if (!window.define) {
    const modules = {};
    window.__modules = modules;
    const modulePromises = {};

    const thisScriptSource = document.currentScript.getAttribute('src');
    const srcDir = thisScriptSource.substring(0, thisScriptSource.lastIndexOf('/'));

    const load = (id) => {
        if (modules[id]) return modules[id];
        if (modulePromises[id]) return modulePromises[id];
        return modulePromises[id] = new Promise((resolve, reject) => {
            const script = document.createElement('script');
            script.src = srcDir + '/' + id + '.js';
            script.onload = () => modules[id].then(resolve);
            script.onerror = err => reject(new Error('failed to load ' + id));
            script.dataset.id = id;
            document.head.append(script);
        });
    };

    const require = (ids, callback) => {
        Promise.all(ids.map(load)).then(items => {
            if (items.length === 1) callback(items[0]);
            else callback(items);
        });
    };
    window.require = require;

    require.context = (dir, useSubdirs) => {
        if ((dir === "../../images/emoji" || dir === "../images/emoji") && !useSubdirs) {
            const data = {"chunks.png":"f59b84127fa7b6c48b6c.png","eggbug-classic.png":"41454e429d62b5cb7963.png","eggbug.png":"17aa2d48956926005de9.png","sixty.png":"9a6014af31fb1ca65a1f.png","unyeah.png":"5cf84d596a2c422967de.png","yeah.png":"014b0a8cc35206ef151d.png"};
            const f = (n) => data[n];
            f.keys = () => Object.keys(data);
            return f;
        } else if ((dir === "../../images/plus-emoji" || dir === "../images/plus-emoji") && !useSubdirs) {
            const data = {"eggbug-asleep.png":"ebbf360236a95b62bdfc.png","eggbug-devious.png":"c4f3f2c6b9ffb85934e7.png","eggbug-heart-sob.png":"b59709333449a01e3e0a.png","eggbug-nervous.png":"d2753b632211c395538e.png","eggbug-pensive.png":"ae53a8b5de7c919100e6.png","eggbug-pleading.png":"11c5493261064ffa82c0.png","eggbug-relieved.png":"3633c116f0941d94d237.png","eggbug-shocked.png":"b25a9fdf230219087003.png","eggbug-smile-hearts.png":"d7ec7f057e6fb15a94cc.png","eggbug-sob.png":"9559ff8058a895328d76.png","eggbug-tuesday.png":"90058099e741e483208a.png","eggbug-uwu.png":"228d3a13bd5f7796b434.png","eggbug-wink.png":"3bc3a1c5272e2ceb8712.png","host-aww.png":"9bb403f3822c6457baf6.png","host-cry.png":"530f8cf75eac87716702.png","host-evil.png":"cb9a5640d7ef7b361a1a.png","host-frown.png":"99c7fbf98de865cc9726.png","host-joy.png":"53635f5fe850274b1a7d.png","host-love.png":"c45b6d8f9de20f725b98.png","host-nervous.png":"e5d55348f39c65a20148.png","host-plead.png":"fa883e2377fea8945237.png","host-shock.png":"bfa6d6316fd95ae76803.png","host-stare.png":"a09d966cd188c9ebaa4c.png"};
            const f = (n) => data[n];
            f.keys = () => Object.keys(data);
            return f;
        }
        throw new Error('not supported: require.context for ' + dir);
    };

    window.define = (imports, exec) => {
        if (typeof imports === 'function') {
            exec = imports;
            imports = [];
        }
        const id = document.currentScript.dataset.id
            ?? './' + document.currentScript.getAttribute('src').split('/').pop().replace(/\.js$/i, '');
        if (modules[id]) return;
        const exports = {};
        modules[id] = Promise.resolve().then(function() {
            const imported = [];
            for (const id of imports) {
                if (id === 'require') imported.push(Promise.resolve(require));
                else if (id === 'exports') imported.push(Promise.resolve(exports));
                else imported.push(load(id));
            }
            return Promise.all(imported);
        }).then(function(imported) {
            const result = exec.apply(window, imported);
            if (!('default' in exports)) exports.default = result;
            return exports;
        });
    };

    window.process = { env: { NODE_ENV: 'production' } };
}

define(['require', 'exports'], (function (require, exports) { 'use strict';

	function _mergeNamespaces(n, m) {
		m.forEach(function (e) {
			e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
				if (k !== 'default' && !(k in n)) {
					var d = Object.getOwnPropertyDescriptor(e, k);
					Object.defineProperty(n, k, d.get ? d : {
						enumerable: true,
						get: function () { return e[k]; }
					});
				}
			});
		});
		return Object.freeze(n);
	}

	var nothing = /*#__PURE__*/Object.freeze({
		__proto__: null
	});

	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

	function getDefaultExportFromCjs (x) {
		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
	}

	function getAugmentedNamespace(n) {
	  if (n.__esModule) return n;
	  var f = n.default;
		if (typeof f == "function") {
			var a = function a () {
				if (this instanceof a) {
	        return Reflect.construct(f, arguments, this.constructor);
				}
				return f.apply(this, arguments);
			};
			a.prototype = f.prototype;
	  } else a = {};
	  Object.defineProperty(a, '__esModule', {value: true});
		Object.keys(n).forEach(function (k) {
			var d = Object.getOwnPropertyDescriptor(n, k);
			Object.defineProperty(a, k, d.get ? d : {
				enumerable: true,
				get: function () {
					return n[k];
				}
			});
		});
		return a;
	}

	var axios$3 = {exports: {}};

	var bind$4 = function bind(fn, thisArg) {
	  return function wrap() {
	    var args = new Array(arguments.length);
	    for (var i = 0; i < args.length; i++) {
	      args[i] = arguments[i];
	    }
	    return fn.apply(thisArg, args);
	  };
	};

	var bind$3 = bind$4;

	// utils is a library of generic helper functions non-specific to axios

	var toString$2 = Object.prototype.toString;

	/**
	 * Determine if a value is an Array
	 *
	 * @param {Object} val The value to test
	 * @returns {boolean} True if value is an Array, otherwise false
	 */
	function isArray$2(val) {
	  return toString$2.call(val) === '[object Array]';
	}

	/**
	 * Determine if a value is undefined
	 *
	 * @param {Object} val The value to test
	 * @returns {boolean} True if the value is undefined, otherwise false
	 */
	function isUndefined$2(val) {
	  return typeof val === 'undefined';
	}

	/**
	 * Determine if a value is a Buffer
	 *
	 * @param {Object} val The value to test
	 * @returns {boolean} True if value is a Buffer, otherwise false
	 */
	function isBuffer$2(val) {
	  return val !== null && !isUndefined$2(val) && val.constructor !== null && !isUndefined$2(val.constructor)
	    && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);
	}

	/**
	 * Determine if a value is an ArrayBuffer
	 *
	 * @param {Object} val The value to test
	 * @returns {boolean} True if value is an ArrayBuffer, otherwise false
	 */
	function isArrayBuffer(val) {
	  return toString$2.call(val) === '[object ArrayBuffer]';
	}

	/**
	 * Determine if a value is a FormData
	 *
	 * @param {Object} val The value to test
	 * @returns {boolean} True if value is an FormData, otherwise false
	 */
	function isFormData(val) {
	  return (typeof FormData !== 'undefined') && (val instanceof FormData);
	}

	/**
	 * Determine if a value is a view on an ArrayBuffer
	 *
	 * @param {Object} val The value to test
	 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
	 */
	function isArrayBufferView(val) {
	  var result;
	  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
	    result = ArrayBuffer.isView(val);
	  } else {
	    result = (val) && (val.buffer) && (val.buffer instanceof ArrayBuffer);
	  }
	  return result;
	}

	/**
	 * Determine if a value is a String
	 *
	 * @param {Object} val The value to test
	 * @returns {boolean} True if value is a String, otherwise false
	 */
	function isString$3(val) {
	  return typeof val === 'string';
	}

	/**
	 * Determine if a value is a Number
	 *
	 * @param {Object} val The value to test
	 * @returns {boolean} True if value is a Number, otherwise false
	 */
	function isNumber$1(val) {
	  return typeof val === 'number';
	}

	/**
	 * Determine if a value is an Object
	 *
	 * @param {Object} val The value to test
	 * @returns {boolean} True if value is an Object, otherwise false
	 */
	function isObject$3(val) {
	  return val !== null && typeof val === 'object';
	}

	/**
	 * Determine if a value is a plain Object
	 *
	 * @param {Object} val The value to test
	 * @return {boolean} True if value is a plain Object, otherwise false
	 */
	function isPlainObject$5(val) {
	  if (toString$2.call(val) !== '[object Object]') {
	    return false;
	  }

	  var prototype = Object.getPrototypeOf(val);
	  return prototype === null || prototype === Object.prototype;
	}

	/**
	 * Determine if a value is a Date
	 *
	 * @param {Object} val The value to test
	 * @returns {boolean} True if value is a Date, otherwise false
	 */
	function isDate$1(val) {
	  return toString$2.call(val) === '[object Date]';
	}

	/**
	 * Determine if a value is a File
	 *
	 * @param {Object} val The value to test
	 * @returns {boolean} True if value is a File, otherwise false
	 */
	function isFile$1(val) {
	  return toString$2.call(val) === '[object File]';
	}

	/**
	 * Determine if a value is a Blob
	 *
	 * @param {Object} val The value to test
	 * @returns {boolean} True if value is a Blob, otherwise false
	 */
	function isBlob(val) {
	  return toString$2.call(val) === '[object Blob]';
	}

	/**
	 * Determine if a value is a Function
	 *
	 * @param {Object} val The value to test
	 * @returns {boolean} True if value is a Function, otherwise false
	 */
	function isFunction$2(val) {
	  return toString$2.call(val) === '[object Function]';
	}

	/**
	 * Determine if a value is a Stream
	 *
	 * @param {Object} val The value to test
	 * @returns {boolean} True if value is a Stream, otherwise false
	 */
	function isStream(val) {
	  return isObject$3(val) && isFunction$2(val.pipe);
	}

	/**
	 * Determine if a value is a URLSearchParams object
	 *
	 * @param {Object} val The value to test
	 * @returns {boolean} True if value is a URLSearchParams object, otherwise false
	 */
	function isURLSearchParams(val) {
	  return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams;
	}

	/**
	 * Trim excess whitespace off the beginning and end of a string
	 *
	 * @param {String} str The String to trim
	 * @returns {String} The String freed of excess whitespace
	 */
	function trim$1(str) {
	  return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '');
	}

	/**
	 * Determine if we're running in a standard browser environment
	 *
	 * This allows axios to run in a web worker, and react-native.
	 * Both environments support XMLHttpRequest, but not fully standard globals.
	 *
	 * web workers:
	 *  typeof window -> undefined
	 *  typeof document -> undefined
	 *
	 * react-native:
	 *  navigator.product -> 'ReactNative'
	 * nativescript
	 *  navigator.product -> 'NativeScript' or 'NS'
	 */
	function isStandardBrowserEnv() {
	  if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||
	                                           navigator.product === 'NativeScript' ||
	                                           navigator.product === 'NS')) {
	    return false;
	  }
	  return (
	    typeof window !== 'undefined' &&
	    typeof document !== 'undefined'
	  );
	}

	/**
	 * Iterate over an Array or an Object invoking a function for each item.
	 *
	 * If `obj` is an Array callback will be called passing
	 * the value, index, and complete array for each item.
	 *
	 * If 'obj' is an Object callback will be called passing
	 * the value, key, and complete object for each property.
	 *
	 * @param {Object|Array} obj The object to iterate
	 * @param {Function} fn The callback to invoke for each item
	 */
	function forEach(obj, fn) {
	  // Don't bother if no value provided
	  if (obj === null || typeof obj === 'undefined') {
	    return;
	  }

	  // Force an array if not already something iterable
	  if (typeof obj !== 'object') {
	    /*eslint no-param-reassign:0*/
	    obj = [obj];
	  }

	  if (isArray$2(obj)) {
	    // Iterate over array values
	    for (var i = 0, l = obj.length; i < l; i++) {
	      fn.call(null, obj[i], i, obj);
	    }
	  } else {
	    // Iterate over object keys
	    for (var key in obj) {
	      if (Object.prototype.hasOwnProperty.call(obj, key)) {
	        fn.call(null, obj[key], key, obj);
	      }
	    }
	  }
	}

	/**
	 * Accepts varargs expecting each argument to be an object, then
	 * immutably merges the properties of each object and returns result.
	 *
	 * When multiple objects contain the same key the later object in
	 * the arguments list will take precedence.
	 *
	 * Example:
	 *
	 * ```js
	 * var result = merge({foo: 123}, {foo: 456});
	 * console.log(result.foo); // outputs 456
	 * ```
	 *
	 * @param {Object} obj1 Object to merge
	 * @returns {Object} Result of all merge properties
	 */
	function merge$4(/* obj1, obj2, obj3, ... */) {
	  var result = {};
	  function assignValue(val, key) {
	    if (isPlainObject$5(result[key]) && isPlainObject$5(val)) {
	      result[key] = merge$4(result[key], val);
	    } else if (isPlainObject$5(val)) {
	      result[key] = merge$4({}, val);
	    } else if (isArray$2(val)) {
	      result[key] = val.slice();
	    } else {
	      result[key] = val;
	    }
	  }

	  for (var i = 0, l = arguments.length; i < l; i++) {
	    forEach(arguments[i], assignValue);
	  }
	  return result;
	}

	/**
	 * Extends object a by mutably adding to it the properties of object b.
	 *
	 * @param {Object} a The object to be extended
	 * @param {Object} b The object to copy properties from
	 * @param {Object} thisArg The object to bind function to
	 * @return {Object} The resulting value of object a
	 */
	function extend$2(a, b, thisArg) {
	  forEach(b, function assignValue(val, key) {
	    if (thisArg && typeof val === 'function') {
	      a[key] = bind$3(val, thisArg);
	    } else {
	      a[key] = val;
	    }
	  });
	  return a;
	}

	/**
	 * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
	 *
	 * @param {string} content with BOM
	 * @return {string} content value without BOM
	 */
	function stripBOM(content) {
	  if (content.charCodeAt(0) === 0xFEFF) {
	    content = content.slice(1);
	  }
	  return content;
	}

	var utils$8 = {
	  isArray: isArray$2,
	  isArrayBuffer: isArrayBuffer,
	  isBuffer: isBuffer$2,
	  isFormData: isFormData,
	  isArrayBufferView: isArrayBufferView,
	  isString: isString$3,
	  isNumber: isNumber$1,
	  isObject: isObject$3,
	  isPlainObject: isPlainObject$5,
	  isUndefined: isUndefined$2,
	  isDate: isDate$1,
	  isFile: isFile$1,
	  isBlob: isBlob,
	  isFunction: isFunction$2,
	  isStream: isStream,
	  isURLSearchParams: isURLSearchParams,
	  isStandardBrowserEnv: isStandardBrowserEnv,
	  forEach: forEach,
	  merge: merge$4,
	  extend: extend$2,
	  trim: trim$1,
	  stripBOM: stripBOM
	};

	var utils$7 = utils$8;

	function encode$4(val) {
	  return encodeURIComponent(val).
	    replace(/%3A/gi, ':').
	    replace(/%24/g, '$').
	    replace(/%2C/gi, ',').
	    replace(/%20/g, '+').
	    replace(/%5B/gi, '[').
	    replace(/%5D/gi, ']');
	}

	/**
	 * Build a URL by appending params to the end
	 *
	 * @param {string} url The base of the url (e.g., http://www.google.com)
	 * @param {object} [params] The params to be appended
	 * @returns {string} The formatted url
	 */
	var buildURL$1 = function buildURL(url, params, paramsSerializer) {
	  /*eslint no-param-reassign:0*/
	  if (!params) {
	    return url;
	  }

	  var serializedParams;
	  if (paramsSerializer) {
	    serializedParams = paramsSerializer(params);
	  } else if (utils$7.isURLSearchParams(params)) {
	    serializedParams = params.toString();
	  } else {
	    var parts = [];

	    utils$7.forEach(params, function serialize(val, key) {
	      if (val === null || typeof val === 'undefined') {
	        return;
	      }

	      if (utils$7.isArray(val)) {
	        key = key + '[]';
	      } else {
	        val = [val];
	      }

	      utils$7.forEach(val, function parseValue(v) {
	        if (utils$7.isDate(v)) {
	          v = v.toISOString();
	        } else if (utils$7.isObject(v)) {
	          v = JSON.stringify(v);
	        }
	        parts.push(encode$4(key) + '=' + encode$4(v));
	      });
	    });

	    serializedParams = parts.join('&');
	  }

	  if (serializedParams) {
	    var hashmarkIndex = url.indexOf('#');
	    if (hashmarkIndex !== -1) {
	      url = url.slice(0, hashmarkIndex);
	    }

	    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
	  }

	  return url;
	};

	var utils$6 = utils$8;

	function InterceptorManager$1() {
	  this.handlers = [];
	}

	/**
	 * Add a new interceptor to the stack
	 *
	 * @param {Function} fulfilled The function to handle `then` for a `Promise`
	 * @param {Function} rejected The function to handle `reject` for a `Promise`
	 *
	 * @return {Number} An ID used to remove interceptor later
	 */
	InterceptorManager$1.prototype.use = function use(fulfilled, rejected, options) {
	  this.handlers.push({
	    fulfilled: fulfilled,
	    rejected: rejected,
	    synchronous: options ? options.synchronous : false,
	    runWhen: options ? options.runWhen : null
	  });
	  return this.handlers.length - 1;
	};

	/**
	 * Remove an interceptor from the stack
	 *
	 * @param {Number} id The ID that was returned by `use`
	 */
	InterceptorManager$1.prototype.eject = function eject(id) {
	  if (this.handlers[id]) {
	    this.handlers[id] = null;
	  }
	};

	/**
	 * Iterate over all the registered interceptors
	 *
	 * This method is particularly useful for skipping over any
	 * interceptors that may have become `null` calling `eject`.
	 *
	 * @param {Function} fn The function to call for each interceptor
	 */
	InterceptorManager$1.prototype.forEach = function forEach(fn) {
	  utils$6.forEach(this.handlers, function forEachHandler(h) {
	    if (h !== null) {
	      fn(h);
	    }
	  });
	};

	var InterceptorManager_1 = InterceptorManager$1;

	var utils$5 = utils$8;

	var normalizeHeaderName = function normalizeHeaderName(headers, normalizedName) {
	  utils$5.forEach(headers, function processHeader(value, name) {
	    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
	      headers[normalizedName] = value;
	      delete headers[name];
	    }
	  });
	};

	/**
	 * Update an Error with the specified config, error code, and response.
	 *
	 * @param {Error} error The error to update.
	 * @param {Object} config The config.
	 * @param {string} [code] The error code (for example, 'ECONNABORTED').
	 * @param {Object} [request] The request.
	 * @param {Object} [response] The response.
	 * @returns {Error} The error.
	 */
	var enhanceError = function enhanceError(error, config, code, request, response) {
	  error.config = config;
	  if (code) {
	    error.code = code;
	  }

	  error.request = request;
	  error.response = response;
	  error.isAxiosError = true;

	  error.toJSON = function toJSON() {
	    return {
	      // Standard
	      message: this.message,
	      name: this.name,
	      // Microsoft
	      description: this.description,
	      number: this.number,
	      // Mozilla
	      fileName: this.fileName,
	      lineNumber: this.lineNumber,
	      columnNumber: this.columnNumber,
	      stack: this.stack,
	      // Axios
	      config: this.config,
	      code: this.code,
	      status: this.response && this.response.status ? this.response.status : null
	    };
	  };
	  return error;
	};

	var createError;
	var hasRequiredCreateError;

	function requireCreateError () {
		if (hasRequiredCreateError) return createError;
		hasRequiredCreateError = 1;

		var enhanceError$1 = enhanceError;

		/**
		 * Create an Error with the specified message, config, error code, request and response.
		 *
		 * @param {string} message The error message.
		 * @param {Object} config The config.
		 * @param {string} [code] The error code (for example, 'ECONNABORTED').
		 * @param {Object} [request] The request.
		 * @param {Object} [response] The response.
		 * @returns {Error} The created error.
		 */
		createError = function createError(message, config, code, request, response) {
		  var error = new Error(message);
		  return enhanceError$1(error, config, code, request, response);
		};
		return createError;
	}

	var settle;
	var hasRequiredSettle;

	function requireSettle () {
		if (hasRequiredSettle) return settle;
		hasRequiredSettle = 1;

		var createError = requireCreateError();

		/**
		 * Resolve or reject a Promise based on response status.
		 *
		 * @param {Function} resolve A function that resolves the promise.
		 * @param {Function} reject A function that rejects the promise.
		 * @param {object} response The response.
		 */
		settle = function settle(resolve, reject, response) {
		  var validateStatus = response.config.validateStatus;
		  if (!response.status || !validateStatus || validateStatus(response.status)) {
		    resolve(response);
		  } else {
		    reject(createError(
		      'Request failed with status code ' + response.status,
		      response.config,
		      null,
		      response.request,
		      response
		    ));
		  }
		};
		return settle;
	}

	var cookies;
	var hasRequiredCookies;

	function requireCookies () {
		if (hasRequiredCookies) return cookies;
		hasRequiredCookies = 1;

		var utils = utils$8;

		cookies = (
		  utils.isStandardBrowserEnv() ?

		  // Standard browser envs support document.cookie
		    (function standardBrowserEnv() {
		      return {
		        write: function write(name, value, expires, path, domain, secure) {
		          var cookie = [];
		          cookie.push(name + '=' + encodeURIComponent(value));

		          if (utils.isNumber(expires)) {
		            cookie.push('expires=' + new Date(expires).toGMTString());
		          }

		          if (utils.isString(path)) {
		            cookie.push('path=' + path);
		          }

		          if (utils.isString(domain)) {
		            cookie.push('domain=' + domain);
		          }

		          if (secure === true) {
		            cookie.push('secure');
		          }

		          document.cookie = cookie.join('; ');
		        },

		        read: function read(name) {
		          var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
		          return (match ? decodeURIComponent(match[3]) : null);
		        },

		        remove: function remove(name) {
		          this.write(name, '', Date.now() - 86400000);
		        }
		      };
		    })() :

		  // Non standard browser env (web workers, react-native) lack needed support.
		    (function nonStandardBrowserEnv() {
		      return {
		        write: function write() {},
		        read: function read() { return null; },
		        remove: function remove() {}
		      };
		    })()
		);
		return cookies;
	}

	var isAbsoluteURL;
	var hasRequiredIsAbsoluteURL;

	function requireIsAbsoluteURL () {
		if (hasRequiredIsAbsoluteURL) return isAbsoluteURL;
		hasRequiredIsAbsoluteURL = 1;

		/**
		 * Determines whether the specified URL is absolute
		 *
		 * @param {string} url The URL to test
		 * @returns {boolean} True if the specified URL is absolute, otherwise false
		 */
		isAbsoluteURL = function isAbsoluteURL(url) {
		  // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
		  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
		  // by any combination of letters, digits, plus, period, or hyphen.
		  return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
		};
		return isAbsoluteURL;
	}

	var combineURLs;
	var hasRequiredCombineURLs;

	function requireCombineURLs () {
		if (hasRequiredCombineURLs) return combineURLs;
		hasRequiredCombineURLs = 1;

		/**
		 * Creates a new URL by combining the specified URLs
		 *
		 * @param {string} baseURL The base URL
		 * @param {string} relativeURL The relative URL
		 * @returns {string} The combined URL
		 */
		combineURLs = function combineURLs(baseURL, relativeURL) {
		  return relativeURL
		    ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
		    : baseURL;
		};
		return combineURLs;
	}

	var buildFullPath;
	var hasRequiredBuildFullPath;

	function requireBuildFullPath () {
		if (hasRequiredBuildFullPath) return buildFullPath;
		hasRequiredBuildFullPath = 1;

		var isAbsoluteURL = requireIsAbsoluteURL();
		var combineURLs = requireCombineURLs();

		/**
		 * Creates a new URL by combining the baseURL with the requestedURL,
		 * only when the requestedURL is not already an absolute URL.
		 * If the requestURL is absolute, this function returns the requestedURL untouched.
		 *
		 * @param {string} baseURL The base URL
		 * @param {string} requestedURL Absolute or relative URL to combine
		 * @returns {string} The combined full path
		 */
		buildFullPath = function buildFullPath(baseURL, requestedURL) {
		  if (baseURL && !isAbsoluteURL(requestedURL)) {
		    return combineURLs(baseURL, requestedURL);
		  }
		  return requestedURL;
		};
		return buildFullPath;
	}

	var parseHeaders;
	var hasRequiredParseHeaders;

	function requireParseHeaders () {
		if (hasRequiredParseHeaders) return parseHeaders;
		hasRequiredParseHeaders = 1;

		var utils = utils$8;

		// Headers whose duplicates are ignored by node
		// c.f. https://nodejs.org/api/http.html#http_message_headers
		var ignoreDuplicateOf = [
		  'age', 'authorization', 'content-length', 'content-type', 'etag',
		  'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
		  'last-modified', 'location', 'max-forwards', 'proxy-authorization',
		  'referer', 'retry-after', 'user-agent'
		];

		/**
		 * Parse headers into an object
		 *
		 * ```
		 * Date: Wed, 27 Aug 2014 08:58:49 GMT
		 * Content-Type: application/json
		 * Connection: keep-alive
		 * Transfer-Encoding: chunked
		 * ```
		 *
		 * @param {String} headers Headers needing to be parsed
		 * @returns {Object} Headers parsed into an object
		 */
		parseHeaders = function parseHeaders(headers) {
		  var parsed = {};
		  var key;
		  var val;
		  var i;

		  if (!headers) { return parsed; }

		  utils.forEach(headers.split('\n'), function parser(line) {
		    i = line.indexOf(':');
		    key = utils.trim(line.substr(0, i)).toLowerCase();
		    val = utils.trim(line.substr(i + 1));

		    if (key) {
		      if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
		        return;
		      }
		      if (key === 'set-cookie') {
		        parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
		      } else {
		        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
		      }
		    }
		  });

		  return parsed;
		};
		return parseHeaders;
	}

	var isURLSameOrigin;
	var hasRequiredIsURLSameOrigin;

	function requireIsURLSameOrigin () {
		if (hasRequiredIsURLSameOrigin) return isURLSameOrigin;
		hasRequiredIsURLSameOrigin = 1;

		var utils = utils$8;

		isURLSameOrigin = (
		  utils.isStandardBrowserEnv() ?

		  // Standard browser envs have full support of the APIs needed to test
		  // whether the request URL is of the same origin as current location.
		    (function standardBrowserEnv() {
		      var msie = /(msie|trident)/i.test(navigator.userAgent);
		      var urlParsingNode = document.createElement('a');
		      var originURL;

		      /**
		    * Parse a URL to discover it's components
		    *
		    * @param {String} url The URL to be parsed
		    * @returns {Object}
		    */
		      function resolveURL(url) {
		        var href = url;

		        if (msie) {
		        // IE needs attribute set twice to normalize properties
		          urlParsingNode.setAttribute('href', href);
		          href = urlParsingNode.href;
		        }

		        urlParsingNode.setAttribute('href', href);

		        // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
		        return {
		          href: urlParsingNode.href,
		          protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
		          host: urlParsingNode.host,
		          search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
		          hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
		          hostname: urlParsingNode.hostname,
		          port: urlParsingNode.port,
		          pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
		            urlParsingNode.pathname :
		            '/' + urlParsingNode.pathname
		        };
		      }

		      originURL = resolveURL(window.location.href);

		      /**
		    * Determine if a URL shares the same origin as the current location
		    *
		    * @param {String} requestURL The URL to test
		    * @returns {boolean} True if URL shares the same origin, otherwise false
		    */
		      return function isURLSameOrigin(requestURL) {
		        var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
		        return (parsed.protocol === originURL.protocol &&
		            parsed.host === originURL.host);
		      };
		    })() :

		  // Non standard browser envs (web workers, react-native) lack needed support.
		    (function nonStandardBrowserEnv() {
		      return function isURLSameOrigin() {
		        return true;
		      };
		    })()
		);
		return isURLSameOrigin;
	}

	var Cancel_1;
	var hasRequiredCancel;

	function requireCancel () {
		if (hasRequiredCancel) return Cancel_1;
		hasRequiredCancel = 1;

		/**
		 * A `Cancel` is an object that is thrown when an operation is canceled.
		 *
		 * @class
		 * @param {string=} message The message.
		 */
		function Cancel(message) {
		  this.message = message;
		}

		Cancel.prototype.toString = function toString() {
		  return 'Cancel' + (this.message ? ': ' + this.message : '');
		};

		Cancel.prototype.__CANCEL__ = true;

		Cancel_1 = Cancel;
		return Cancel_1;
	}

	var xhr;
	var hasRequiredXhr;

	function requireXhr () {
		if (hasRequiredXhr) return xhr;
		hasRequiredXhr = 1;

		var utils = utils$8;
		var settle = requireSettle();
		var cookies = requireCookies();
		var buildURL = buildURL$1;
		var buildFullPath = requireBuildFullPath();
		var parseHeaders = requireParseHeaders();
		var isURLSameOrigin = requireIsURLSameOrigin();
		var createError = requireCreateError();
		var defaults = requireDefaults();
		var Cancel = requireCancel();

		xhr = function xhrAdapter(config) {
		  return new Promise(function dispatchXhrRequest(resolve, reject) {
		    var requestData = config.data;
		    var requestHeaders = config.headers;
		    var responseType = config.responseType;
		    var onCanceled;
		    function done() {
		      if (config.cancelToken) {
		        config.cancelToken.unsubscribe(onCanceled);
		      }

		      if (config.signal) {
		        config.signal.removeEventListener('abort', onCanceled);
		      }
		    }

		    if (utils.isFormData(requestData)) {
		      delete requestHeaders['Content-Type']; // Let the browser set it
		    }

		    var request = new XMLHttpRequest();

		    // HTTP basic authentication
		    if (config.auth) {
		      var username = config.auth.username || '';
		      var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';
		      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
		    }

		    var fullPath = buildFullPath(config.baseURL, config.url);
		    request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);

		    // Set the request timeout in MS
		    request.timeout = config.timeout;

		    function onloadend() {
		      if (!request) {
		        return;
		      }
		      // Prepare the response
		      var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
		      var responseData = !responseType || responseType === 'text' ||  responseType === 'json' ?
		        request.responseText : request.response;
		      var response = {
		        data: responseData,
		        status: request.status,
		        statusText: request.statusText,
		        headers: responseHeaders,
		        config: config,
		        request: request
		      };

		      settle(function _resolve(value) {
		        resolve(value);
		        done();
		      }, function _reject(err) {
		        reject(err);
		        done();
		      }, response);

		      // Clean up request
		      request = null;
		    }

		    if ('onloadend' in request) {
		      // Use onloadend if available
		      request.onloadend = onloadend;
		    } else {
		      // Listen for ready state to emulate onloadend
		      request.onreadystatechange = function handleLoad() {
		        if (!request || request.readyState !== 4) {
		          return;
		        }

		        // The request errored out and we didn't get a response, this will be
		        // handled by onerror instead
		        // With one exception: request that using file: protocol, most browsers
		        // will return status as 0 even though it's a successful request
		        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
		          return;
		        }
		        // readystate handler is calling before onerror or ontimeout handlers,
		        // so we should call onloadend on the next 'tick'
		        setTimeout(onloadend);
		      };
		    }

		    // Handle browser request cancellation (as opposed to a manual cancellation)
		    request.onabort = function handleAbort() {
		      if (!request) {
		        return;
		      }

		      reject(createError('Request aborted', config, 'ECONNABORTED', request));

		      // Clean up request
		      request = null;
		    };

		    // Handle low level network errors
		    request.onerror = function handleError() {
		      // Real errors are hidden from us by the browser
		      // onerror should only fire if it's a network error
		      reject(createError('Network Error', config, null, request));

		      // Clean up request
		      request = null;
		    };

		    // Handle timeout
		    request.ontimeout = function handleTimeout() {
		      var timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded';
		      var transitional = config.transitional || defaults.transitional;
		      if (config.timeoutErrorMessage) {
		        timeoutErrorMessage = config.timeoutErrorMessage;
		      }
		      reject(createError(
		        timeoutErrorMessage,
		        config,
		        transitional.clarifyTimeoutError ? 'ETIMEDOUT' : 'ECONNABORTED',
		        request));

		      // Clean up request
		      request = null;
		    };

		    // Add xsrf header
		    // This is only done if running in a standard browser environment.
		    // Specifically not if we're in a web worker, or react-native.
		    if (utils.isStandardBrowserEnv()) {
		      // Add xsrf header
		      var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ?
		        cookies.read(config.xsrfCookieName) :
		        undefined;

		      if (xsrfValue) {
		        requestHeaders[config.xsrfHeaderName] = xsrfValue;
		      }
		    }

		    // Add headers to the request
		    if ('setRequestHeader' in request) {
		      utils.forEach(requestHeaders, function setRequestHeader(val, key) {
		        if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
		          // Remove Content-Type if data is undefined
		          delete requestHeaders[key];
		        } else {
		          // Otherwise add header to the request
		          request.setRequestHeader(key, val);
		        }
		      });
		    }

		    // Add withCredentials to request if needed
		    if (!utils.isUndefined(config.withCredentials)) {
		      request.withCredentials = !!config.withCredentials;
		    }

		    // Add responseType to request if needed
		    if (responseType && responseType !== 'json') {
		      request.responseType = config.responseType;
		    }

		    // Handle progress if needed
		    if (typeof config.onDownloadProgress === 'function') {
		      request.addEventListener('progress', config.onDownloadProgress);
		    }

		    // Not all browsers support upload events
		    if (typeof config.onUploadProgress === 'function' && request.upload) {
		      request.upload.addEventListener('progress', config.onUploadProgress);
		    }

		    if (config.cancelToken || config.signal) {
		      // Handle cancellation
		      // eslint-disable-next-line func-names
		      onCanceled = function(cancel) {
		        if (!request) {
		          return;
		        }
		        reject(!cancel || (cancel && cancel.type) ? new Cancel('canceled') : cancel);
		        request.abort();
		        request = null;
		      };

		      config.cancelToken && config.cancelToken.subscribe(onCanceled);
		      if (config.signal) {
		        config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);
		      }
		    }

		    if (!requestData) {
		      requestData = null;
		    }

		    // Send the request
		    request.send(requestData);
		  });
		};
		return xhr;
	}

	var http = null;

	var http$1 = /*#__PURE__*/Object.freeze({
		__proto__: null,
		default: http
	});

	var require$$4$1 = /*@__PURE__*/getAugmentedNamespace(http$1);

	var defaults_1;
	var hasRequiredDefaults;

	function requireDefaults () {
		if (hasRequiredDefaults) return defaults_1;
		hasRequiredDefaults = 1;

		var utils = utils$8;
		var normalizeHeaderName$1 = normalizeHeaderName;
		var enhanceError$1 = enhanceError;

		var DEFAULT_CONTENT_TYPE = {
		  'Content-Type': 'application/x-www-form-urlencoded'
		};

		function setContentTypeIfUnset(headers, value) {
		  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
		    headers['Content-Type'] = value;
		  }
		}

		function getDefaultAdapter() {
		  var adapter;
		  if (typeof XMLHttpRequest !== 'undefined') {
		    // For browsers use XHR adapter
		    adapter = requireXhr();
		  } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {
		    // For node use HTTP adapter
		    adapter = require$$4$1;
		  }
		  return adapter;
		}

		function stringifySafely(rawValue, parser, encoder) {
		  if (utils.isString(rawValue)) {
		    try {
		      (parser || JSON.parse)(rawValue);
		      return utils.trim(rawValue);
		    } catch (e) {
		      if (e.name !== 'SyntaxError') {
		        throw e;
		      }
		    }
		  }

		  return (0, JSON.stringify)(rawValue);
		}

		var defaults = {

		  transitional: {
		    silentJSONParsing: true,
		    forcedJSONParsing: true,
		    clarifyTimeoutError: false
		  },

		  adapter: getDefaultAdapter(),

		  transformRequest: [function transformRequest(data, headers) {
		    normalizeHeaderName$1(headers, 'Accept');
		    normalizeHeaderName$1(headers, 'Content-Type');

		    if (utils.isFormData(data) ||
		      utils.isArrayBuffer(data) ||
		      utils.isBuffer(data) ||
		      utils.isStream(data) ||
		      utils.isFile(data) ||
		      utils.isBlob(data)
		    ) {
		      return data;
		    }
		    if (utils.isArrayBufferView(data)) {
		      return data.buffer;
		    }
		    if (utils.isURLSearchParams(data)) {
		      setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
		      return data.toString();
		    }
		    if (utils.isObject(data) || (headers && headers['Content-Type'] === 'application/json')) {
		      setContentTypeIfUnset(headers, 'application/json');
		      return stringifySafely(data);
		    }
		    return data;
		  }],

		  transformResponse: [function transformResponse(data) {
		    var transitional = this.transitional || defaults.transitional;
		    var silentJSONParsing = transitional && transitional.silentJSONParsing;
		    var forcedJSONParsing = transitional && transitional.forcedJSONParsing;
		    var strictJSONParsing = !silentJSONParsing && this.responseType === 'json';

		    if (strictJSONParsing || (forcedJSONParsing && utils.isString(data) && data.length)) {
		      try {
		        return JSON.parse(data);
		      } catch (e) {
		        if (strictJSONParsing) {
		          if (e.name === 'SyntaxError') {
		            throw enhanceError$1(e, this, 'E_JSON_PARSE');
		          }
		          throw e;
		        }
		      }
		    }

		    return data;
		  }],

		  /**
		   * A timeout in milliseconds to abort a request. If set to 0 (default) a
		   * timeout is not created.
		   */
		  timeout: 0,

		  xsrfCookieName: 'XSRF-TOKEN',
		  xsrfHeaderName: 'X-XSRF-TOKEN',

		  maxContentLength: -1,
		  maxBodyLength: -1,

		  validateStatus: function validateStatus(status) {
		    return status >= 200 && status < 300;
		  },

		  headers: {
		    common: {
		      'Accept': 'application/json, text/plain, */*'
		    }
		  }
		};

		utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
		  defaults.headers[method] = {};
		});

		utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
		  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
		});

		defaults_1 = defaults;
		return defaults_1;
	}

	var utils$4 = utils$8;
	var defaults$2 = requireDefaults();

	/**
	 * Transform the data for a request or a response
	 *
	 * @param {Object|String} data The data to be transformed
	 * @param {Array} headers The headers for the request or response
	 * @param {Array|Function} fns A single function or Array of functions
	 * @returns {*} The resulting transformed data
	 */
	var transformData$1 = function transformData(data, headers, fns) {
	  var context = this || defaults$2;
	  /*eslint no-param-reassign:0*/
	  utils$4.forEach(fns, function transform(fn) {
	    data = fn.call(context, data, headers);
	  });

	  return data;
	};

	var isCancel$1;
	var hasRequiredIsCancel;

	function requireIsCancel () {
		if (hasRequiredIsCancel) return isCancel$1;
		hasRequiredIsCancel = 1;

		isCancel$1 = function isCancel(value) {
		  return !!(value && value.__CANCEL__);
		};
		return isCancel$1;
	}

	var utils$3 = utils$8;
	var transformData = transformData$1;
	var isCancel = requireIsCancel();
	var defaults$1 = requireDefaults();
	var Cancel = requireCancel();

	/**
	 * Throws a `Cancel` if cancellation has been requested.
	 */
	function throwIfCancellationRequested(config) {
	  if (config.cancelToken) {
	    config.cancelToken.throwIfRequested();
	  }

	  if (config.signal && config.signal.aborted) {
	    throw new Cancel('canceled');
	  }
	}

	/**
	 * Dispatch a request to the server using the configured adapter.
	 *
	 * @param {object} config The config that is to be used for the request
	 * @returns {Promise} The Promise to be fulfilled
	 */
	var dispatchRequest$1 = function dispatchRequest(config) {
	  throwIfCancellationRequested(config);

	  // Ensure headers exist
	  config.headers = config.headers || {};

	  // Transform request data
	  config.data = transformData.call(
	    config,
	    config.data,
	    config.headers,
	    config.transformRequest
	  );

	  // Flatten headers
	  config.headers = utils$3.merge(
	    config.headers.common || {},
	    config.headers[config.method] || {},
	    config.headers
	  );

	  utils$3.forEach(
	    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
	    function cleanHeaderConfig(method) {
	      delete config.headers[method];
	    }
	  );

	  var adapter = config.adapter || defaults$1.adapter;

	  return adapter(config).then(function onAdapterResolution(response) {
	    throwIfCancellationRequested(config);

	    // Transform response data
	    response.data = transformData.call(
	      config,
	      response.data,
	      response.headers,
	      config.transformResponse
	    );

	    return response;
	  }, function onAdapterRejection(reason) {
	    if (!isCancel(reason)) {
	      throwIfCancellationRequested(config);

	      // Transform response data
	      if (reason && reason.response) {
	        reason.response.data = transformData.call(
	          config,
	          reason.response.data,
	          reason.response.headers,
	          config.transformResponse
	        );
	      }
	    }

	    return Promise.reject(reason);
	  });
	};

	var utils$2 = utils$8;

	/**
	 * Config-specific merge-function which creates a new config-object
	 * by merging two configuration objects together.
	 *
	 * @param {Object} config1
	 * @param {Object} config2
	 * @returns {Object} New object resulting from merging config2 to config1
	 */
	var mergeConfig$2 = function mergeConfig(config1, config2) {
	  // eslint-disable-next-line no-param-reassign
	  config2 = config2 || {};
	  var config = {};

	  function getMergedValue(target, source) {
	    if (utils$2.isPlainObject(target) && utils$2.isPlainObject(source)) {
	      return utils$2.merge(target, source);
	    } else if (utils$2.isPlainObject(source)) {
	      return utils$2.merge({}, source);
	    } else if (utils$2.isArray(source)) {
	      return source.slice();
	    }
	    return source;
	  }

	  // eslint-disable-next-line consistent-return
	  function mergeDeepProperties(prop) {
	    if (!utils$2.isUndefined(config2[prop])) {
	      return getMergedValue(config1[prop], config2[prop]);
	    } else if (!utils$2.isUndefined(config1[prop])) {
	      return getMergedValue(undefined, config1[prop]);
	    }
	  }

	  // eslint-disable-next-line consistent-return
	  function valueFromConfig2(prop) {
	    if (!utils$2.isUndefined(config2[prop])) {
	      return getMergedValue(undefined, config2[prop]);
	    }
	  }

	  // eslint-disable-next-line consistent-return
	  function defaultToConfig2(prop) {
	    if (!utils$2.isUndefined(config2[prop])) {
	      return getMergedValue(undefined, config2[prop]);
	    } else if (!utils$2.isUndefined(config1[prop])) {
	      return getMergedValue(undefined, config1[prop]);
	    }
	  }

	  // eslint-disable-next-line consistent-return
	  function mergeDirectKeys(prop) {
	    if (prop in config2) {
	      return getMergedValue(config1[prop], config2[prop]);
	    } else if (prop in config1) {
	      return getMergedValue(undefined, config1[prop]);
	    }
	  }

	  var mergeMap = {
	    'url': valueFromConfig2,
	    'method': valueFromConfig2,
	    'data': valueFromConfig2,
	    'baseURL': defaultToConfig2,
	    'transformRequest': defaultToConfig2,
	    'transformResponse': defaultToConfig2,
	    'paramsSerializer': defaultToConfig2,
	    'timeout': defaultToConfig2,
	    'timeoutMessage': defaultToConfig2,
	    'withCredentials': defaultToConfig2,
	    'adapter': defaultToConfig2,
	    'responseType': defaultToConfig2,
	    'xsrfCookieName': defaultToConfig2,
	    'xsrfHeaderName': defaultToConfig2,
	    'onUploadProgress': defaultToConfig2,
	    'onDownloadProgress': defaultToConfig2,
	    'decompress': defaultToConfig2,
	    'maxContentLength': defaultToConfig2,
	    'maxBodyLength': defaultToConfig2,
	    'transport': defaultToConfig2,
	    'httpAgent': defaultToConfig2,
	    'httpsAgent': defaultToConfig2,
	    'cancelToken': defaultToConfig2,
	    'socketPath': defaultToConfig2,
	    'responseEncoding': defaultToConfig2,
	    'validateStatus': mergeDirectKeys
	  };

	  utils$2.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
	    var merge = mergeMap[prop] || mergeDeepProperties;
	    var configValue = merge(prop);
	    (utils$2.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
	  });

	  return config;
	};

	var data$2;
	var hasRequiredData;

	function requireData () {
		if (hasRequiredData) return data$2;
		hasRequiredData = 1;
		data$2 = {
		  "version": "0.24.0"
		};
		return data$2;
	}

	var VERSION$1 = requireData().version;

	var validators$1 = {};

	// eslint-disable-next-line func-names
	['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach(function(type, i) {
	  validators$1[type] = function validator(thing) {
	    return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;
	  };
	});

	var deprecatedWarnings = {};

	/**
	 * Transitional option validator
	 * @param {function|boolean?} validator - set to false if the transitional option has been removed
	 * @param {string?} version - deprecated version / removed since version
	 * @param {string?} message - some message with additional info
	 * @returns {function}
	 */
	validators$1.transitional = function transitional(validator, version, message) {
	  function formatMessage(opt, desc) {
	    return '[Axios v' + VERSION$1 + '] Transitional option \'' + opt + '\'' + desc + (message ? '. ' + message : '');
	  }

	  // eslint-disable-next-line func-names
	  return function(value, opt, opts) {
	    if (validator === false) {
	      throw new Error(formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')));
	    }

	    if (version && !deprecatedWarnings[opt]) {
	      deprecatedWarnings[opt] = true;
	      // eslint-disable-next-line no-console
	      console.warn(
	        formatMessage(
	          opt,
	          ' has been deprecated since v' + version + ' and will be removed in the near future'
	        )
	      );
	    }

	    return validator ? validator(value, opt, opts) : true;
	  };
	};

	/**
	 * Assert object's properties type
	 * @param {object} options
	 * @param {object} schema
	 * @param {boolean?} allowUnknown
	 */

	function assertOptions(options, schema, allowUnknown) {
	  if (typeof options !== 'object') {
	    throw new TypeError('options must be an object');
	  }
	  var keys = Object.keys(options);
	  var i = keys.length;
	  while (i-- > 0) {
	    var opt = keys[i];
	    var validator = schema[opt];
	    if (validator) {
	      var value = options[opt];
	      var result = value === undefined || validator(value, opt, options);
	      if (result !== true) {
	        throw new TypeError('option ' + opt + ' must be ' + result);
	      }
	      continue;
	    }
	    if (allowUnknown !== true) {
	      throw Error('Unknown option ' + opt);
	    }
	  }
	}

	var validator$1 = {
	  assertOptions: assertOptions,
	  validators: validators$1
	};

	var utils$1 = utils$8;
	var buildURL = buildURL$1;
	var InterceptorManager = InterceptorManager_1;
	var dispatchRequest = dispatchRequest$1;
	var mergeConfig$1 = mergeConfig$2;
	var validator = validator$1;

	var validators = validator.validators;
	/**
	 * Create a new instance of Axios
	 *
	 * @param {Object} instanceConfig The default config for the instance
	 */
	function Axios$1(instanceConfig) {
	  this.defaults = instanceConfig;
	  this.interceptors = {
	    request: new InterceptorManager(),
	    response: new InterceptorManager()
	  };
	}

	/**
	 * Dispatch a request
	 *
	 * @param {Object} config The config specific for this request (merged with this.defaults)
	 */
	Axios$1.prototype.request = function request(config) {
	  /*eslint no-param-reassign:0*/
	  // Allow for axios('example/url'[, config]) a la fetch API
	  if (typeof config === 'string') {
	    config = arguments[1] || {};
	    config.url = arguments[0];
	  } else {
	    config = config || {};
	  }

	  config = mergeConfig$1(this.defaults, config);

	  // Set config.method
	  if (config.method) {
	    config.method = config.method.toLowerCase();
	  } else if (this.defaults.method) {
	    config.method = this.defaults.method.toLowerCase();
	  } else {
	    config.method = 'get';
	  }

	  var transitional = config.transitional;

	  if (transitional !== undefined) {
	    validator.assertOptions(transitional, {
	      silentJSONParsing: validators.transitional(validators.boolean),
	      forcedJSONParsing: validators.transitional(validators.boolean),
	      clarifyTimeoutError: validators.transitional(validators.boolean)
	    }, false);
	  }

	  // filter out skipped interceptors
	  var requestInterceptorChain = [];
	  var synchronousRequestInterceptors = true;
	  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
	    if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {
	      return;
	    }

	    synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;

	    requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
	  });

	  var responseInterceptorChain = [];
	  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
	    responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
	  });

	  var promise;

	  if (!synchronousRequestInterceptors) {
	    var chain = [dispatchRequest, undefined];

	    Array.prototype.unshift.apply(chain, requestInterceptorChain);
	    chain = chain.concat(responseInterceptorChain);

	    promise = Promise.resolve(config);
	    while (chain.length) {
	      promise = promise.then(chain.shift(), chain.shift());
	    }

	    return promise;
	  }


	  var newConfig = config;
	  while (requestInterceptorChain.length) {
	    var onFulfilled = requestInterceptorChain.shift();
	    var onRejected = requestInterceptorChain.shift();
	    try {
	      newConfig = onFulfilled(newConfig);
	    } catch (error) {
	      onRejected(error);
	      break;
	    }
	  }

	  try {
	    promise = dispatchRequest(newConfig);
	  } catch (error) {
	    return Promise.reject(error);
	  }

	  while (responseInterceptorChain.length) {
	    promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
	  }

	  return promise;
	};

	Axios$1.prototype.getUri = function getUri(config) {
	  config = mergeConfig$1(this.defaults, config);
	  return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, '');
	};

	// Provide aliases for supported request methods
	utils$1.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
	  /*eslint func-names:0*/
	  Axios$1.prototype[method] = function(url, config) {
	    return this.request(mergeConfig$1(config || {}, {
	      method: method,
	      url: url,
	      data: (config || {}).data
	    }));
	  };
	});

	utils$1.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
	  /*eslint func-names:0*/
	  Axios$1.prototype[method] = function(url, data, config) {
	    return this.request(mergeConfig$1(config || {}, {
	      method: method,
	      url: url,
	      data: data
	    }));
	  };
	});

	var Axios_1 = Axios$1;

	var CancelToken_1;
	var hasRequiredCancelToken;

	function requireCancelToken () {
		if (hasRequiredCancelToken) return CancelToken_1;
		hasRequiredCancelToken = 1;

		var Cancel = requireCancel();

		/**
		 * A `CancelToken` is an object that can be used to request cancellation of an operation.
		 *
		 * @class
		 * @param {Function} executor The executor function.
		 */
		function CancelToken(executor) {
		  if (typeof executor !== 'function') {
		    throw new TypeError('executor must be a function.');
		  }

		  var resolvePromise;

		  this.promise = new Promise(function promiseExecutor(resolve) {
		    resolvePromise = resolve;
		  });

		  var token = this;

		  // eslint-disable-next-line func-names
		  this.promise.then(function(cancel) {
		    if (!token._listeners) return;

		    var i;
		    var l = token._listeners.length;

		    for (i = 0; i < l; i++) {
		      token._listeners[i](cancel);
		    }
		    token._listeners = null;
		  });

		  // eslint-disable-next-line func-names
		  this.promise.then = function(onfulfilled) {
		    var _resolve;
		    // eslint-disable-next-line func-names
		    var promise = new Promise(function(resolve) {
		      token.subscribe(resolve);
		      _resolve = resolve;
		    }).then(onfulfilled);

		    promise.cancel = function reject() {
		      token.unsubscribe(_resolve);
		    };

		    return promise;
		  };

		  executor(function cancel(message) {
		    if (token.reason) {
		      // Cancellation has already been requested
		      return;
		    }

		    token.reason = new Cancel(message);
		    resolvePromise(token.reason);
		  });
		}

		/**
		 * Throws a `Cancel` if cancellation has been requested.
		 */
		CancelToken.prototype.throwIfRequested = function throwIfRequested() {
		  if (this.reason) {
		    throw this.reason;
		  }
		};

		/**
		 * Subscribe to the cancel signal
		 */

		CancelToken.prototype.subscribe = function subscribe(listener) {
		  if (this.reason) {
		    listener(this.reason);
		    return;
		  }

		  if (this._listeners) {
		    this._listeners.push(listener);
		  } else {
		    this._listeners = [listener];
		  }
		};

		/**
		 * Unsubscribe from the cancel signal
		 */

		CancelToken.prototype.unsubscribe = function unsubscribe(listener) {
		  if (!this._listeners) {
		    return;
		  }
		  var index = this._listeners.indexOf(listener);
		  if (index !== -1) {
		    this._listeners.splice(index, 1);
		  }
		};

		/**
		 * Returns an object that contains a new `CancelToken` and a function that, when called,
		 * cancels the `CancelToken`.
		 */
		CancelToken.source = function source() {
		  var cancel;
		  var token = new CancelToken(function executor(c) {
		    cancel = c;
		  });
		  return {
		    token: token,
		    cancel: cancel
		  };
		};

		CancelToken_1 = CancelToken;
		return CancelToken_1;
	}

	var spread;
	var hasRequiredSpread;

	function requireSpread () {
		if (hasRequiredSpread) return spread;
		hasRequiredSpread = 1;

		/**
		 * Syntactic sugar for invoking a function and expanding an array for arguments.
		 *
		 * Common use case would be to use `Function.prototype.apply`.
		 *
		 *  ```js
		 *  function f(x, y, z) {}
		 *  var args = [1, 2, 3];
		 *  f.apply(null, args);
		 *  ```
		 *
		 * With `spread` this example can be re-written.
		 *
		 *  ```js
		 *  spread(function(x, y, z) {})([1, 2, 3]);
		 *  ```
		 *
		 * @param {Function} callback
		 * @returns {Function}
		 */
		spread = function spread(callback) {
		  return function wrap(arr) {
		    return callback.apply(null, arr);
		  };
		};
		return spread;
	}

	var isAxiosError;
	var hasRequiredIsAxiosError;

	function requireIsAxiosError () {
		if (hasRequiredIsAxiosError) return isAxiosError;
		hasRequiredIsAxiosError = 1;

		/**
		 * Determines whether the payload is an error thrown by Axios
		 *
		 * @param {*} payload The value to test
		 * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
		 */
		isAxiosError = function isAxiosError(payload) {
		  return (typeof payload === 'object') && (payload.isAxiosError === true);
		};
		return isAxiosError;
	}

	var utils = utils$8;
	var bind$2 = bind$4;
	var Axios = Axios_1;
	var mergeConfig = mergeConfig$2;
	var defaults = requireDefaults();

	/**
	 * Create an instance of Axios
	 *
	 * @param {Object} defaultConfig The default config for the instance
	 * @return {Axios} A new instance of Axios
	 */
	function createInstance(defaultConfig) {
	  var context = new Axios(defaultConfig);
	  var instance = bind$2(Axios.prototype.request, context);

	  // Copy axios.prototype to instance
	  utils.extend(instance, Axios.prototype, context);

	  // Copy context to instance
	  utils.extend(instance, context);

	  // Factory for creating new instances
	  instance.create = function create(instanceConfig) {
	    return createInstance(mergeConfig(defaultConfig, instanceConfig));
	  };

	  return instance;
	}

	// Create the default instance to be exported
	var axios$2 = createInstance(defaults);

	// Expose Axios class to allow class inheritance
	axios$2.Axios = Axios;

	// Expose Cancel & CancelToken
	axios$2.Cancel = requireCancel();
	axios$2.CancelToken = requireCancelToken();
	axios$2.isCancel = requireIsCancel();
	axios$2.VERSION = requireData().version;

	// Expose all/spread
	axios$2.all = function all(promises) {
	  return Promise.all(promises);
	};
	axios$2.spread = requireSpread();

	// Expose isAxiosError
	axios$2.isAxiosError = requireIsAxiosError();

	axios$3.exports = axios$2;

	// Allow use of default import syntax in TypeScript
	axios$3.exports.default = axios$2;

	var axiosExports = axios$3.exports;

	var axios = axiosExports;

	var axios$1 = /*@__PURE__*/getDefaultExportFromCjs(axios);

	var react$1 = {exports: {}};

	var react_production_min = {};

	var l$g=Symbol.for("react.element"),n$g=Symbol.for("react.portal"),p$h=Symbol.for("react.fragment"),q$a=Symbol.for("react.strict_mode"),r$c=Symbol.for("react.profiler"),t$f=Symbol.for("react.provider"),u$h=Symbol.for("react.context"),v$a=Symbol.for("react.forward_ref"),w$b=Symbol.for("react.suspense"),x$7=Symbol.for("react.memo"),y$b=Symbol.for("react.lazy"),z$8=Symbol.iterator;function A$9(a){if(null===a||"object"!==typeof a)return null;a=z$8&&a[z$8]||a["@@iterator"];return "function"===typeof a?a:null}
	var B$6={isMounted:function(){return !1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},C$5=Object.assign,D$a={};function E$7(a,b,e){this.props=a;this.context=b;this.refs=D$a;this.updater=e||B$6;}E$7.prototype.isReactComponent={};
	E$7.prototype.setState=function(a,b){if("object"!==typeof a&&"function"!==typeof a&&null!=a)throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");this.updater.enqueueSetState(this,a,b,"setState");};E$7.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,"forceUpdate");};function F$b(){}F$b.prototype=E$7.prototype;function G$6(a,b,e){this.props=a;this.context=b;this.refs=D$a;this.updater=e||B$6;}var H$a=G$6.prototype=new F$b;
	H$a.constructor=G$6;C$5(H$a,E$7.prototype);H$a.isPureReactComponent=!0;var I$a=Array.isArray,J$5=Object.prototype.hasOwnProperty,K$3={current:null},L$6={key:!0,ref:!0,__self:!0,__source:!0};
	function M$c(a,b,e){var d,c={},k=null,h=null;if(null!=b)for(d in void 0!==b.ref&&(h=b.ref),void 0!==b.key&&(k=""+b.key),b)J$5.call(b,d)&&!L$6.hasOwnProperty(d)&&(c[d]=b[d]);var g=arguments.length-2;if(1===g)c.children=e;else if(1<g){for(var f=Array(g),m=0;m<g;m++)f[m]=arguments[m+2];c.children=f;}if(a&&a.defaultProps)for(d in g=a.defaultProps,g)void 0===c[d]&&(c[d]=g[d]);return {$$typeof:l$g,type:a,key:k,ref:h,props:c,_owner:K$3.current}}
	function N$5(a,b){return {$$typeof:l$g,type:a.type,key:b,ref:a.ref,props:a.props,_owner:a._owner}}function O$9(a){return "object"===typeof a&&null!==a&&a.$$typeof===l$g}function escape$2(a){var b={"=":"=0",":":"=2"};return "$"+a.replace(/[=:]/g,function(a){return b[a]})}var P$7=/\/+/g;function Q$7(a,b){return "object"===typeof a&&null!==a&&null!=a.key?escape$2(""+a.key):b.toString(36)}
	function R$6(a,b,e,d,c){var k=typeof a;if("undefined"===k||"boolean"===k)a=null;var h=!1;if(null===a)h=!0;else switch(k){case "string":case "number":h=!0;break;case "object":switch(a.$$typeof){case l$g:case n$g:h=!0;}}if(h)return h=a,c=c(h),a=""===d?"."+Q$7(h,0):d,I$a(c)?(e="",null!=a&&(e=a.replace(P$7,"$&/")+"/"),R$6(c,b,e,"",function(a){return a})):null!=c&&(O$9(c)&&(c=N$5(c,e+(!c.key||h&&h.key===c.key?"":(""+c.key).replace(P$7,"$&/")+"/")+a)),b.push(c)),1;h=0;d=""===d?".":d+":";if(I$a(a))for(var g=0;g<a.length;g++){k=
	a[g];var f=d+Q$7(k,g);h+=R$6(k,b,e,f,c);}else if(f=A$9(a),"function"===typeof f)for(a=f.call(a),g=0;!(k=a.next()).done;)k=k.value,f=d+Q$7(k,g++),h+=R$6(k,b,e,f,c);else if("object"===k)throw b=String(a),Error("Objects are not valid as a React child (found: "+("[object Object]"===b?"object with keys {"+Object.keys(a).join(", ")+"}":b)+"). If you meant to render a collection of children, use an array instead.");return h}
	function S$d(a,b,e){if(null==a)return a;var d=[],c=0;R$6(a,d,"","",function(a){return b.call(e,a,c++)});return d}function T$8(a){if(-1===a._status){var b=a._result;b=b();b.then(function(b){if(0===a._status||-1===a._status)a._status=1,a._result=b;},function(b){if(0===a._status||-1===a._status)a._status=2,a._result=b;});-1===a._status&&(a._status=0,a._result=b);}if(1===a._status)return a._result.default;throw a._result;}
	var U$7={current:null},V$7={transition:null},W$6={ReactCurrentDispatcher:U$7,ReactCurrentBatchConfig:V$7,ReactCurrentOwner:K$3};react_production_min.Children={map:S$d,forEach:function(a,b,e){S$d(a,function(){b.apply(this,arguments);},e);},count:function(a){var b=0;S$d(a,function(){b++;});return b},toArray:function(a){return S$d(a,function(a){return a})||[]},only:function(a){if(!O$9(a))throw Error("React.Children.only expected to receive a single React element child.");return a}};react_production_min.Component=E$7;react_production_min.Fragment=p$h;
	react_production_min.Profiler=r$c;react_production_min.PureComponent=G$6;react_production_min.StrictMode=q$a;react_production_min.Suspense=w$b;react_production_min.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=W$6;
	react_production_min.cloneElement=function(a,b,e){if(null===a||void 0===a)throw Error("React.cloneElement(...): The argument must be a React element, but you passed "+a+".");var d=C$5({},a.props),c=a.key,k=a.ref,h=a._owner;if(null!=b){void 0!==b.ref&&(k=b.ref,h=K$3.current);void 0!==b.key&&(c=""+b.key);if(a.type&&a.type.defaultProps)var g=a.type.defaultProps;for(f in b)J$5.call(b,f)&&!L$6.hasOwnProperty(f)&&(d[f]=void 0===b[f]&&void 0!==g?g[f]:b[f]);}var f=arguments.length-2;if(1===f)d.children=e;else if(1<f){g=Array(f);
	for(var m=0;m<f;m++)g[m]=arguments[m+2];d.children=g;}return {$$typeof:l$g,type:a.type,key:c,ref:k,props:d,_owner:h}};react_production_min.createContext=function(a){a={$$typeof:u$h,_currentValue:a,_currentValue2:a,_threadCount:0,Provider:null,Consumer:null,_defaultValue:null,_globalName:null};a.Provider={$$typeof:t$f,_context:a};return a.Consumer=a};react_production_min.createElement=M$c;react_production_min.createFactory=function(a){var b=M$c.bind(null,a);b.type=a;return b};react_production_min.createRef=function(){return {current:null}};
	react_production_min.forwardRef=function(a){return {$$typeof:v$a,render:a}};react_production_min.isValidElement=O$9;react_production_min.lazy=function(a){return {$$typeof:y$b,_payload:{_status:-1,_result:a},_init:T$8}};react_production_min.memo=function(a,b){return {$$typeof:x$7,type:a,compare:void 0===b?null:b}};react_production_min.startTransition=function(a){var b=V$7.transition;V$7.transition={};try{a();}finally{V$7.transition=b;}};react_production_min.unstable_act=function(){throw Error("act(...) is not supported in production builds of React.");};
	react_production_min.useCallback=function(a,b){return U$7.current.useCallback(a,b)};react_production_min.useContext=function(a){return U$7.current.useContext(a)};react_production_min.useDebugValue=function(){};react_production_min.useDeferredValue=function(a){return U$7.current.useDeferredValue(a)};react_production_min.useEffect=function(a,b){return U$7.current.useEffect(a,b)};react_production_min.useId=function(){return U$7.current.useId()};react_production_min.useImperativeHandle=function(a,b,e){return U$7.current.useImperativeHandle(a,b,e)};
	react_production_min.useInsertionEffect=function(a,b){return U$7.current.useInsertionEffect(a,b)};react_production_min.useLayoutEffect=function(a,b){return U$7.current.useLayoutEffect(a,b)};react_production_min.useMemo=function(a,b){return U$7.current.useMemo(a,b)};react_production_min.useReducer=function(a,b,e){return U$7.current.useReducer(a,b,e)};react_production_min.useRef=function(a){return U$7.current.useRef(a)};react_production_min.useState=function(a){return U$7.current.useState(a)};react_production_min.useSyncExternalStore=function(a,b,e){return U$7.current.useSyncExternalStore(a,b,e)};
	react_production_min.useTransition=function(){return U$7.current.useTransition()};react_production_min.version="18.0.0-fc46dba67-20220329";

	{
	  react$1.exports = react_production_min;
	}

	var reactExports = react$1.exports;
	var React$2 = /*@__PURE__*/getDefaultExportFromCjs(reactExports);

	var ReactOriginal = /*#__PURE__*/_mergeNamespaces({
		__proto__: null,
		default: React$2
	}, [reactExports]);

	function _objectWithoutPropertiesLoose$2(source, excluded) {
	  if (source == null) return {};
	  var target = {};
	  var sourceKeys = Object.keys(source);
	  var key, i;
	  for (i = 0; i < sourceKeys.length; i++) {
	    key = sourceKeys[i];
	    if (excluded.indexOf(key) >= 0) continue;
	    target[key] = source[key];
	  }
	  return target;
	}

	function _extends$4() {
	  _extends$4 = Object.assign ? Object.assign.bind() : function (target) {
	    for (var i = 1; i < arguments.length; i++) {
	      var source = arguments[i];
	      for (var key in source) {
	        if (Object.prototype.hasOwnProperty.call(source, key)) {
	          target[key] = source[key];
	        }
	      }
	    }
	    return target;
	  };
	  return _extends$4.apply(this, arguments);
	}

	function _assertThisInitialized(self) {
	  if (self === void 0) {
	    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
	  }
	  return self;
	}

	function _setPrototypeOf$1(o, p) {
	  _setPrototypeOf$1 = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
	    o.__proto__ = p;
	    return o;
	  };
	  return _setPrototypeOf$1(o, p);
	}

	function _inheritsLoose$1(subClass, superClass) {
	  subClass.prototype = Object.create(superClass.prototype);
	  subClass.prototype.constructor = subClass;
	  _setPrototypeOf$1(subClass, superClass);
	}

	var reactIs$1 = {exports: {}};

	var reactIs_production_min = {};

	var b$4=60103,c$d=60106,d$d=60107,e$9=60108,f$c=60114,g$5=60109,h$d=60110,k$7=60112,l$f=60113,m$9=60120,n$f=60115,p$g=60116,q$9=60121,r$b=60122,u$g=60117,v$9=60129,w$a=60131;
	if("function"===typeof Symbol&&Symbol.for){var x$6=Symbol.for;b$4=x$6("react.element");c$d=x$6("react.portal");d$d=x$6("react.fragment");e$9=x$6("react.strict_mode");f$c=x$6("react.profiler");g$5=x$6("react.provider");h$d=x$6("react.context");k$7=x$6("react.forward_ref");l$f=x$6("react.suspense");m$9=x$6("react.suspense_list");n$f=x$6("react.memo");p$g=x$6("react.lazy");q$9=x$6("react.block");r$b=x$6("react.server.block");u$g=x$6("react.fundamental");v$9=x$6("react.debug_trace_mode");w$a=x$6("react.legacy_hidden");}
	function y$a(a){if("object"===typeof a&&null!==a){var t=a.$$typeof;switch(t){case b$4:switch(a=a.type,a){case d$d:case f$c:case e$9:case l$f:case m$9:return a;default:switch(a=a&&a.$$typeof,a){case h$d:case k$7:case p$g:case n$f:case g$5:return a;default:return t}}case c$d:return t}}}var z$7=g$5,A$8=b$4,B$5=k$7,C$4=d$d,D$9=p$g,E$6=n$f,F$a=c$d,G$5=f$c,H$9=e$9,I$9=l$f;reactIs_production_min.ContextConsumer=h$d;reactIs_production_min.ContextProvider=z$7;reactIs_production_min.Element=A$8;reactIs_production_min.ForwardRef=B$5;reactIs_production_min.Fragment=C$4;reactIs_production_min.Lazy=D$9;reactIs_production_min.Memo=E$6;reactIs_production_min.Portal=F$a;reactIs_production_min.Profiler=G$5;reactIs_production_min.StrictMode=H$9;
	reactIs_production_min.Suspense=I$9;reactIs_production_min.isAsyncMode=function(){return !1};reactIs_production_min.isConcurrentMode=function(){return !1};reactIs_production_min.isContextConsumer=function(a){return y$a(a)===h$d};reactIs_production_min.isContextProvider=function(a){return y$a(a)===g$5};reactIs_production_min.isElement=function(a){return "object"===typeof a&&null!==a&&a.$$typeof===b$4};reactIs_production_min.isForwardRef=function(a){return y$a(a)===k$7};reactIs_production_min.isFragment=function(a){return y$a(a)===d$d};reactIs_production_min.isLazy=function(a){return y$a(a)===p$g};reactIs_production_min.isMemo=function(a){return y$a(a)===n$f};
	reactIs_production_min.isPortal=function(a){return y$a(a)===c$d};reactIs_production_min.isProfiler=function(a){return y$a(a)===f$c};reactIs_production_min.isStrictMode=function(a){return y$a(a)===e$9};reactIs_production_min.isSuspense=function(a){return y$a(a)===l$f};reactIs_production_min.isValidElementType=function(a){return "string"===typeof a||"function"===typeof a||a===d$d||a===f$c||a===v$9||a===e$9||a===l$f||a===m$9||a===w$a||"object"===typeof a&&null!==a&&(a.$$typeof===p$g||a.$$typeof===n$f||a.$$typeof===g$5||a.$$typeof===h$d||a.$$typeof===k$7||a.$$typeof===u$g||a.$$typeof===q$9||a[0]===r$b)?!0:!1};
	reactIs_production_min.typeOf=y$a;

	{
	  reactIs$1.exports = reactIs_production_min;
	}

	var reactIsExports = reactIs$1.exports;

	var reactIs = reactIsExports;

	/**
	 * Copyright 2015, Yahoo! Inc.
	 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
	 */
	var REACT_STATICS = {
	  childContextTypes: true,
	  contextType: true,
	  contextTypes: true,
	  defaultProps: true,
	  displayName: true,
	  getDefaultProps: true,
	  getDerivedStateFromError: true,
	  getDerivedStateFromProps: true,
	  mixins: true,
	  propTypes: true,
	  type: true
	};
	var KNOWN_STATICS = {
	  name: true,
	  length: true,
	  prototype: true,
	  caller: true,
	  callee: true,
	  arguments: true,
	  arity: true
	};
	var FORWARD_REF_STATICS = {
	  '$$typeof': true,
	  render: true,
	  defaultProps: true,
	  displayName: true,
	  propTypes: true
	};
	var MEMO_STATICS = {
	  '$$typeof': true,
	  compare: true,
	  defaultProps: true,
	  displayName: true,
	  propTypes: true,
	  type: true
	};
	var TYPE_STATICS = {};
	TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
	TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;

	function getStatics(component) {
	  // React v16.11 and below
	  if (reactIs.isMemo(component)) {
	    return MEMO_STATICS;
	  } // React v16.12 and above


	  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;
	}

	var defineProperty$1 = Object.defineProperty;
	var getOwnPropertyNames = Object.getOwnPropertyNames;
	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
	var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
	var getPrototypeOf$1 = Object.getPrototypeOf;
	var objectPrototype = Object.prototype;
	function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
	  if (typeof sourceComponent !== 'string') {
	    // don't hoist over string (html) components
	    if (objectPrototype) {
	      var inheritedComponent = getPrototypeOf$1(sourceComponent);

	      if (inheritedComponent && inheritedComponent !== objectPrototype) {
	        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
	      }
	    }

	    var keys = getOwnPropertyNames(sourceComponent);

	    if (getOwnPropertySymbols) {
	      keys = keys.concat(getOwnPropertySymbols(sourceComponent));
	    }

	    var targetStatics = getStatics(targetComponent);
	    var sourceStatics = getStatics(sourceComponent);

	    for (var i = 0; i < keys.length; ++i) {
	      var key = keys[i];

	      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
	        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);

	        try {
	          // Avoid failures from read-only properties
	          defineProperty$1(targetComponent, key, descriptor);
	        } catch (e) {}
	      }
	    }
	  }

	  return targetComponent;
	}

	var hoistNonReactStatics_cjs = hoistNonReactStatics;

	var hoistNonReactStatics$1 = /*@__PURE__*/getDefaultExportFromCjs(hoistNonReactStatics_cjs);

	/* eslint-disable import/prefer-default-export */
	function invariant$5(condition, message) {
	  if (condition) return;
	  var error = new Error("loadable: " + message);
	  error.framesToPop = 1;
	  error.name = 'Invariant Violation';
	  throw error;
	}

	var Context$1 = /*#__PURE__*/
	React$2.createContext();

	var LOADABLE_SHARED = {
	  initialChunks: {}
	};

	var STATUS_PENDING = 'PENDING';
	var STATUS_RESOLVED = 'RESOLVED';
	var STATUS_REJECTED = 'REJECTED';

	function resolveConstructor(ctor) {
	  if (typeof ctor === 'function') {
	    return {
	      requireAsync: ctor,
	      resolve: function resolve() {
	        return undefined;
	      },
	      chunkName: function chunkName() {
	        return undefined;
	      }
	    };
	  }

	  return ctor;
	}

	var withChunkExtractor = function withChunkExtractor(Component) {
	  var LoadableWithChunkExtractor = function LoadableWithChunkExtractor(props) {
	    return React$2.createElement(Context$1.Consumer, null, function (extractor) {
	      return React$2.createElement(Component, Object.assign({
	        __chunkExtractor: extractor
	      }, props));
	    });
	  };

	  if (Component.displayName) {
	    LoadableWithChunkExtractor.displayName = Component.displayName + "WithChunkExtractor";
	  }

	  return LoadableWithChunkExtractor;
	};

	var identity$2 = function identity(v) {
	  return v;
	};

	function createLoadable(_ref) {
	  var _ref$defaultResolveCo = _ref.defaultResolveComponent,
	      defaultResolveComponent = _ref$defaultResolveCo === void 0 ? identity$2 : _ref$defaultResolveCo,
	      _render = _ref.render,
	      onLoad = _ref.onLoad;

	  function loadable(loadableConstructor, options) {
	    if (options === void 0) {
	      options = {};
	    }

	    var ctor = resolveConstructor(loadableConstructor);
	    var cache = {};
	    /**
	     * Cachekey represents the component to be loaded
	     * if key changes - component has to be reloaded
	     * @param props
	     * @returns {null|Component}
	     */

	    function _getCacheKey(props) {
	      if (options.cacheKey) {
	        return options.cacheKey(props);
	      }

	      if (ctor.resolve) {
	        return ctor.resolve(props);
	      }

	      return 'static';
	    }
	    /**
	     * Resolves loaded `module` to a specific `Component
	     * @param module
	     * @param props
	     * @param Loadable
	     * @returns Component
	     */


	    function resolve(module, props, Loadable) {
	      var Component = options.resolveComponent ? options.resolveComponent(module, props) : defaultResolveComponent(module); // FIXME: suppressed due to https://github.com/gregberge/loadable-components/issues/990
	      // if (options.resolveComponent && !ReactIs.isValidElementType(Component)) {
	      //   throw new Error(
	      //     `resolveComponent returned something that is not a React component!`,
	      //   )
	      // }

	      hoistNonReactStatics$1(Loadable, Component, {
	        preload: true
	      });
	      return Component;
	    }

	    var cachedLoad = function cachedLoad(props) {
	      var cacheKey = _getCacheKey(props);

	      var promise = cache[cacheKey];

	      if (!promise || promise.status === STATUS_REJECTED) {
	        promise = ctor.requireAsync(props);
	        promise.status = STATUS_PENDING;
	        cache[cacheKey] = promise;
	        promise.then(function () {
	          promise.status = STATUS_RESOLVED;
	        }, function (error) {
	          console.error('loadable-components: failed to asynchronously load component', {
	            fileName: ctor.resolve(props),
	            chunkName: ctor.chunkName(props),
	            error: error ? error.message : error
	          });
	          promise.status = STATUS_REJECTED;
	        });
	      }

	      return promise;
	    };

	    var InnerLoadable =
	    /*#__PURE__*/
	    function (_React$Component) {
	      _inheritsLoose$1(InnerLoadable, _React$Component);

	      InnerLoadable.getDerivedStateFromProps = function getDerivedStateFromProps(props, state) {
	        var cacheKey = _getCacheKey(props);

	        return _extends$4({}, state, {
	          cacheKey: cacheKey,
	          // change of a key triggers loading state automatically
	          loading: state.loading || state.cacheKey !== cacheKey
	        });
	      };

	      function InnerLoadable(props) {
	        var _this;

	        _this = _React$Component.call(this, props) || this;
	        _this.state = {
	          result: null,
	          error: null,
	          loading: true,
	          cacheKey: _getCacheKey(props)
	        };
	        invariant$5(!props.__chunkExtractor || ctor.requireSync, 'SSR requires `@loadable/babel-plugin`, please install it'); // Server-side

	        if (props.__chunkExtractor) {
	          // This module has been marked with no SSR
	          if (options.ssr === false) {
	            return _assertThisInitialized(_this);
	          } // We run load function, we assume that it won't fail and that it
	          // triggers a synchronous loading of the module


	          ctor.requireAsync(props)["catch"](function () {
	            return null;
	          }); // So we can require now the module synchronously

	          _this.loadSync();

	          props.__chunkExtractor.addChunk(ctor.chunkName(props));

	          return _assertThisInitialized(_this);
	        } // Client-side with `isReady` method present (SSR probably)
	        // If module is already loaded, we use a synchronous loading
	        // Only perform this synchronous loading if the component has not
	        // been marked with no SSR, else we risk hydration mismatches


	        if (options.ssr !== false && ( // is ready - was loaded in this session
	        ctor.isReady && ctor.isReady(props) || // is ready - was loaded during SSR process
	        ctor.chunkName && LOADABLE_SHARED.initialChunks[ctor.chunkName(props)])) {
	          _this.loadSync();
	        }

	        return _this;
	      }

	      var _proto = InnerLoadable.prototype;

	      _proto.componentDidMount = function componentDidMount() {
	        this.mounted = true; // retrieve loading promise from a global cache

	        var cachedPromise = this.getCache(); // if promise exists, but rejected - clear cache

	        if (cachedPromise && cachedPromise.status === STATUS_REJECTED) {
	          this.setCache();
	        } // component might be resolved synchronously in the constructor


	        if (this.state.loading) {
	          this.loadAsync();
	        }
	      };

	      _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {
	        // Component has to be reloaded on cacheKey change
	        if (prevState.cacheKey !== this.state.cacheKey) {
	          this.loadAsync();
	        }
	      };

	      _proto.componentWillUnmount = function componentWillUnmount() {
	        this.mounted = false;
	      };

	      _proto.safeSetState = function safeSetState(nextState, callback) {
	        if (this.mounted) {
	          this.setState(nextState, callback);
	        }
	      }
	      /**
	       * returns a cache key for the current props
	       * @returns {Component|string}
	       */
	      ;

	      _proto.getCacheKey = function getCacheKey() {
	        return _getCacheKey(this.props);
	      }
	      /**
	       * access the persistent cache
	       */
	      ;

	      _proto.getCache = function getCache() {
	        return cache[this.getCacheKey()];
	      }
	      /**
	       * sets the cache value. If called without value sets it as undefined
	       */
	      ;

	      _proto.setCache = function setCache(value) {
	        if (value === void 0) {
	          value = undefined;
	        }

	        cache[this.getCacheKey()] = value;
	      };

	      _proto.triggerOnLoad = function triggerOnLoad() {
	        var _this2 = this;

	        if (onLoad) {
	          setTimeout(function () {
	            onLoad(_this2.state.result, _this2.props);
	          });
	        }
	      }
	      /**
	       * Synchronously loads component
	       * target module is expected to already exists in the module cache
	       * or be capable to resolve synchronously (webpack target=node)
	       */
	      ;

	      _proto.loadSync = function loadSync() {
	        // load sync is expecting component to be in the "loading" state already
	        // sounds weird, but loading=true is the initial state of InnerLoadable
	        if (!this.state.loading) return;

	        try {
	          var loadedModule = ctor.requireSync(this.props);
	          var result = resolve(loadedModule, this.props, Loadable);
	          this.state.result = result;
	          this.state.loading = false;
	        } catch (error) {
	          console.error('loadable-components: failed to synchronously load component, which expected to be available', {
	            fileName: ctor.resolve(this.props),
	            chunkName: ctor.chunkName(this.props),
	            error: error ? error.message : error
	          });
	          this.state.error = error;
	        }
	      }
	      /**
	       * Asynchronously loads a component.
	       */
	      ;

	      _proto.loadAsync = function loadAsync() {
	        var _this3 = this;

	        var promise = this.resolveAsync();
	        promise.then(function (loadedModule) {
	          var result = resolve(loadedModule, _this3.props, Loadable);

	          _this3.safeSetState({
	            result: result,
	            loading: false
	          }, function () {
	            return _this3.triggerOnLoad();
	          });
	        })["catch"](function (error) {
	          return _this3.safeSetState({
	            error: error,
	            loading: false
	          });
	        });
	        return promise;
	      }
	      /**
	       * Asynchronously resolves(not loads) a component.
	       * Note - this function does not change the state
	       */
	      ;

	      _proto.resolveAsync = function resolveAsync() {
	        var _this$props = this.props;
	            _this$props.__chunkExtractor;
	            _this$props.forwardedRef;
	            var props = _objectWithoutPropertiesLoose$2(_this$props, ["__chunkExtractor", "forwardedRef"]);

	        return cachedLoad(props);
	      };

	      _proto.render = function render() {
	        var _this$props2 = this.props,
	            forwardedRef = _this$props2.forwardedRef,
	            propFallback = _this$props2.fallback;
	            _this$props2.__chunkExtractor;
	            var props = _objectWithoutPropertiesLoose$2(_this$props2, ["forwardedRef", "fallback", "__chunkExtractor"]);

	        var _this$state = this.state,
	            error = _this$state.error,
	            loading = _this$state.loading,
	            result = _this$state.result;

	        if (options.suspense) {
	          var cachedPromise = this.getCache() || this.loadAsync();

	          if (cachedPromise.status === STATUS_PENDING) {
	            throw this.loadAsync();
	          }
	        }

	        if (error) {
	          throw error;
	        }

	        var fallback = propFallback || options.fallback || null;

	        if (loading) {
	          return fallback;
	        }

	        return _render({
	          fallback: fallback,
	          result: result,
	          options: options,
	          props: _extends$4({}, props, {
	            ref: forwardedRef
	          })
	        });
	      };

	      return InnerLoadable;
	    }(React$2.Component);

	    var EnhancedInnerLoadable = withChunkExtractor(InnerLoadable);
	    var Loadable = React$2.forwardRef(function (props, ref) {
	      return React$2.createElement(EnhancedInnerLoadable, Object.assign({
	        forwardedRef: ref
	      }, props));
	    });
	    Loadable.displayName = 'Loadable'; // In future, preload could use `<link rel="preload">`

	    Loadable.preload = function (props) {
	      Loadable.load(props);
	    };

	    Loadable.load = function (props) {
	      return cachedLoad(props);
	    };

	    return Loadable;
	  }

	  function lazy(ctor, options) {
	    return loadable(ctor, _extends$4({}, options, {
	      suspense: true
	    }));
	  }

	  return {
	    loadable: loadable,
	    lazy: lazy
	  };
	}

	function defaultResolveComponent(loadedModule) {
	  // eslint-disable-next-line no-underscore-dangle
	  return loadedModule.__esModule ? loadedModule["default"] : loadedModule["default"] || loadedModule;
	}

	/* eslint-disable no-use-before-define, react/no-multi-comp */

	var _createLoadable =
	/*#__PURE__*/
	createLoadable({
	  defaultResolveComponent: defaultResolveComponent,
	  render: function render(_ref) {
	    var Component = _ref.result,
	        props = _ref.props;
	    return React$2.createElement(Component, props);
	  }
	}),
	    loadable = _createLoadable.loadable,
	    lazy = _createLoadable.lazy;

	/* eslint-disable no-use-before-define, react/no-multi-comp */

	var _createLoadable$1 =
	/*#__PURE__*/
	createLoadable({
	  onLoad: function onLoad(result, props) {
	    if (result && props.forwardedRef) {
	      if (typeof props.forwardedRef === 'function') {
	        props.forwardedRef(result);
	      } else {
	        props.forwardedRef.current = result;
	      }
	    }
	  },
	  render: function render(_ref) {
	    var result = _ref.result,
	        props = _ref.props;

	    if (props.children) {
	      return props.children(result);
	    }

	    return null;
	  }
	}),
	    loadable$1 = _createLoadable$1.loadable,
	    lazy$1 = _createLoadable$1.lazy;

	/* eslint-disable no-underscore-dangle */
	var loadable$2 = loadable;
	loadable$2.lib = loadable$1;
	var lazy$2 = lazy;
	lazy$2.lib = lazy$1;

	var ClientStateID; (function (ClientStateID) {
	    const COHOST_LOADER_STATE = "__COHOST_LOADER_STATE__"; ClientStateID["COHOST_LOADER_STATE"] = COHOST_LOADER_STATE;
	    const COHOST_LAYOUT = "__COHOST_LAYOUT__"; ClientStateID["COHOST_LAYOUT"] = COHOST_LAYOUT;
	    const SITE_CONFIG = "site-config"; ClientStateID["SITE_CONFIG"] = SITE_CONFIG;
	    const USER_INFO = "user-info"; ClientStateID["USER_INFO"] = USER_INFO;
	    const INITIAL_I18N_STORE = "initialI18nStore"; ClientStateID["INITIAL_I18N_STORE"] = INITIAL_I18N_STORE;
	    const INITIAL_LANGUAGE = "initialLanguage"; ClientStateID["INITIAL_LANGUAGE"] = INITIAL_LANGUAGE;
	    const FLASHES = "flashes"; ClientStateID["FLASHES"] = FLASHES;
	    const ROLLBAR_CONFIG = "rollbar-config"; ClientStateID["ROLLBAR_CONFIG"] = ROLLBAR_CONFIG;
	    const UNLEASH_BOOTSTRAP = "unleash-bootstrap"; ClientStateID["UNLEASH_BOOTSTRAP"] = UNLEASH_BOOTSTRAP;
	    const ENV_VARS = "env-vars"; ClientStateID["ENV_VARS"] = ENV_VARS;
	    const TRPC_DEHYRDATED_STATE = "trpc-dehydrated-state"; ClientStateID["TRPC_DEHYRDATED_STATE"] = TRPC_DEHYRDATED_STATE;
	    const INITIAL_MUTABLE_STORE = "initial-mutable-store"; ClientStateID["INITIAL_MUTABLE_STORE"] = INITIAL_MUTABLE_STORE;
	})(ClientStateID || (ClientStateID = {}));

	var ClientStateID$1 = ClientStateID;

	class EnvVars {
	    store = {};

	    setEnv(newEnv) {
	        this.store = { ...newEnv };
	    }

	     getEnvVal(key) {
	        if (typeof window === "undefined") {
	            // node
	            return process.env[key];
	        } else {
	            return this.store[key];
	        }
	    }

	    get HOME_URL() { return new URL("../..", location.href).toString() } _doNothing() {
	        let defaultVal = "";
	        // on the client, we already know what our URL is so we can make a Guess
	        // in case this gets called early somehow.
	        if (
	            typeof window !== "undefined" &&
	            typeof window.location !== "undefined"
	        ) {
	            defaultVal = window.location.origin;
	        }
	        return this.getEnvVal("HOME_URL") || defaultVal;
	    }

	    get VERSION() {
	        return this.getEnvVal("VERSION") || "";
	    }
	}

	const env = new EnvVars();

	var client = {};

	var reactDom = {exports: {}};

	var reactDom_production_min = {};

	var scheduler = {exports: {}};

	var scheduler_production_min = {};

	/**
	 * @license React
	 * scheduler.production.min.js
	 *
	 * Copyright (c) Facebook, Inc. and its affiliates.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */

	(function (exports) {
	function f(a,b){var c=a.length;a.push(b);a:for(;0<c;){var d=c-1>>>1,e=a[d];if(0<g(e,b))a[d]=b,a[c]=e,c=d;else break a}}function h(a){return 0===a.length?null:a[0]}function k(a){if(0===a.length)return null;var b=a[0],c=a.pop();if(c!==b){a[0]=c;a:for(var d=0,e=a.length,w=e>>>1;d<w;){var m=2*(d+1)-1,C=a[m],n=m+1,x=a[n];if(0>g(C,c))n<e&&0>g(x,C)?(a[d]=x,a[n]=c,d=n):(a[d]=C,a[m]=c,d=m);else if(n<e&&0>g(x,c))a[d]=x,a[n]=c,d=n;else break a}}return b}
		function g(a,b){var c=a.sortIndex-b.sortIndex;return 0!==c?c:a.id-b.id}if("object"===typeof performance&&"function"===typeof performance.now){var l=performance;exports.unstable_now=function(){return l.now()};}else {var p=Date,q=p.now();exports.unstable_now=function(){return p.now()-q};}var r=[],t=[],u=1,v=null,y=3,z=!1,A=!1,B=!1,D="function"===typeof setTimeout?setTimeout:null,E="function"===typeof clearTimeout?clearTimeout:null,F="undefined"!==typeof setImmediate?setImmediate:null;
		"undefined"!==typeof navigator&&void 0!==navigator.scheduling&&void 0!==navigator.scheduling.isInputPending&&navigator.scheduling.isInputPending.bind(navigator.scheduling);function G(a){for(var b=h(t);null!==b;){if(null===b.callback)k(t);else if(b.startTime<=a)k(t),b.sortIndex=b.expirationTime,f(r,b);else break;b=h(t);}}function H(a){B=!1;G(a);if(!A)if(null!==h(r))A=!0,I(J);else {var b=h(t);null!==b&&K(H,b.startTime-a);}}
		function J(a,b){A=!1;B&&(B=!1,E(L),L=-1);z=!0;var c=y;try{G(b);for(v=h(r);null!==v&&(!(v.expirationTime>b)||a&&!M());){var d=v.callback;if("function"===typeof d){v.callback=null;y=v.priorityLevel;var e=d(v.expirationTime<=b);b=exports.unstable_now();"function"===typeof e?v.callback=e:v===h(r)&&k(r);G(b);}else k(r);v=h(r);}if(null!==v)var w=!0;else {var m=h(t);null!==m&&K(H,m.startTime-b);w=!1;}return w}finally{v=null,y=c,z=!1;}}var N=!1,O=null,L=-1,P=5,Q=-1;
		function M(){return exports.unstable_now()-Q<P?!1:!0}function R(){if(null!==O){var a=exports.unstable_now();Q=a;var b=!0;try{b=O(!0,a);}finally{b?S():(N=!1,O=null);}}else N=!1;}var S;if("function"===typeof F)S=function(){F(R);};else if("undefined"!==typeof MessageChannel){var T=new MessageChannel,U=T.port2;T.port1.onmessage=R;S=function(){U.postMessage(null);};}else S=function(){D(R,0);};function I(a){O=a;N||(N=!0,S());}function K(a,b){L=D(function(){a(exports.unstable_now());},b);}
		exports.unstable_IdlePriority=5;exports.unstable_ImmediatePriority=1;exports.unstable_LowPriority=4;exports.unstable_NormalPriority=3;exports.unstable_Profiling=null;exports.unstable_UserBlockingPriority=2;exports.unstable_cancelCallback=function(a){a.callback=null;};exports.unstable_continueExecution=function(){A||z||(A=!0,I(J));};
		exports.unstable_forceFrameRate=function(a){0>a||125<a?console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"):P=0<a?Math.floor(1E3/a):5;};exports.unstable_getCurrentPriorityLevel=function(){return y};exports.unstable_getFirstCallbackNode=function(){return h(r)};exports.unstable_next=function(a){switch(y){case 1:case 2:case 3:var b=3;break;default:b=y;}var c=y;y=b;try{return a()}finally{y=c;}};exports.unstable_pauseExecution=function(){};
		exports.unstable_requestPaint=function(){};exports.unstable_runWithPriority=function(a,b){switch(a){case 1:case 2:case 3:case 4:case 5:break;default:a=3;}var c=y;y=a;try{return b()}finally{y=c;}};
		exports.unstable_scheduleCallback=function(a,b,c){var d=exports.unstable_now();"object"===typeof c&&null!==c?(c=c.delay,c="number"===typeof c&&0<c?d+c:d):c=d;switch(a){case 1:var e=-1;break;case 2:e=250;break;case 5:e=1073741823;break;case 4:e=1E4;break;default:e=5E3;}e=c+e;a={id:u++,callback:b,priorityLevel:a,startTime:c,expirationTime:e,sortIndex:-1};c>d?(a.sortIndex=c,f(t,a),null===h(r)&&a===h(t)&&(B?(E(L),L=-1):B=!0,K(H,c-d))):(a.sortIndex=e,f(r,a),A||z||(A=!0,I(J)));return a};
		exports.unstable_shouldYield=M;exports.unstable_wrapCallback=function(a){var b=y;return function(){var c=y;y=b;try{return a.apply(this,arguments)}finally{y=c;}}}; 
	} (scheduler_production_min));

	{
	  scheduler.exports = scheduler_production_min;
	}

	var schedulerExports = scheduler.exports;

	var aa$3=reactExports,ba$3=schedulerExports;function p$f(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return "Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}var ca$3=new Set,da$3={};function ea$3(a,b){fa$3(a,b);fa$3(a+"Capture",b);}
	function fa$3(a,b){da$3[a]=b;for(a=0;a<b.length;a++)ca$3.add(b[a]);}
	var ha$3=!("undefined"===typeof window||"undefined"===typeof window.document||"undefined"===typeof window.document.createElement),ia$3=Object.prototype.hasOwnProperty,ja$3=/^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,ka$3=
	{},la$3={};function ma$3(a){if(ia$3.call(la$3,a))return !0;if(ia$3.call(ka$3,a))return !1;if(ja$3.test(a))return la$3[a]=!0;ka$3[a]=!0;return !1}function na$3(a,b,c,d){if(null!==c&&0===c.type)return !1;switch(typeof b){case "function":case "symbol":return !0;case "boolean":if(d)return !1;if(null!==c)return !c.acceptsBooleans;a=a.toLowerCase().slice(0,5);return "data-"!==a&&"aria-"!==a;default:return !1}}
	function oa$3(a,b,c,d){if(null===b||"undefined"===typeof b||na$3(a,b,c,d))return !0;if(d)return !1;if(null!==c)switch(c.type){case 3:return !b;case 4:return !1===b;case 5:return isNaN(b);case 6:return isNaN(b)||1>b}return !1}function q$8(a,b,c,d,e,f,g){this.acceptsBooleans=2===b||3===b||4===b;this.attributeName=d;this.attributeNamespace=e;this.mustUseProperty=c;this.propertyName=a;this.type=b;this.sanitizeURL=f;this.removeEmptyString=g;}var z$6={};
	"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(a){z$6[a]=new q$8(a,0,!1,a,null,!1,!1);});[["acceptCharset","accept-charset"],["className","class"],["htmlFor","for"],["httpEquiv","http-equiv"]].forEach(function(a){var b=a[0];z$6[b]=new q$8(b,1,!1,a[1],null,!1,!1);});["contentEditable","draggable","spellCheck","value"].forEach(function(a){z$6[a]=new q$8(a,2,!1,a.toLowerCase(),null,!1,!1);});
	["autoReverse","externalResourcesRequired","focusable","preserveAlpha"].forEach(function(a){z$6[a]=new q$8(a,2,!1,a,null,!1,!1);});"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(a){z$6[a]=new q$8(a,3,!1,a.toLowerCase(),null,!1,!1);});
	["checked","multiple","muted","selected"].forEach(function(a){z$6[a]=new q$8(a,3,!0,a,null,!1,!1);});["capture","download"].forEach(function(a){z$6[a]=new q$8(a,4,!1,a,null,!1,!1);});["cols","rows","size","span"].forEach(function(a){z$6[a]=new q$8(a,6,!1,a,null,!1,!1);});["rowSpan","start"].forEach(function(a){z$6[a]=new q$8(a,5,!1,a.toLowerCase(),null,!1,!1);});var pa$3=/[\-:]([a-z])/g;function qa$3(a){return a[1].toUpperCase()}
	"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(a){var b=a.replace(pa$3,
	qa$3);z$6[b]=new q$8(b,1,!1,a,null,!1,!1);});"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a){var b=a.replace(pa$3,qa$3);z$6[b]=new q$8(b,1,!1,a,"http://www.w3.org/1999/xlink",!1,!1);});["xml:base","xml:lang","xml:space"].forEach(function(a){var b=a.replace(pa$3,qa$3);z$6[b]=new q$8(b,1,!1,a,"http://www.w3.org/XML/1998/namespace",!1,!1);});["tabIndex","crossOrigin"].forEach(function(a){z$6[a]=new q$8(a,1,!1,a.toLowerCase(),null,!1,!1);});
	z$6.xlinkHref=new q$8("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!1);["src","href","action","formAction"].forEach(function(a){z$6[a]=new q$8(a,1,!1,a.toLowerCase(),null,!0,!0);});
	function ra$3(a,b,c,d){var e=z$6.hasOwnProperty(b)?z$6[b]:null;if(null!==e?0!==e.type:d||!(2<b.length)||"o"!==b[0]&&"O"!==b[0]||"n"!==b[1]&&"N"!==b[1])oa$3(b,c,e,d)&&(c=null),d||null===e?ma$3(b)&&(null===c?a.removeAttribute(b):a.setAttribute(b,""+c)):e.mustUseProperty?a[e.propertyName]=null===c?3===e.type?!1:"":c:(b=e.attributeName,d=e.attributeNamespace,null===c?a.removeAttribute(b):(e=e.type,c=3===e||4===e&&!0===c?"":""+c,d?a.setAttributeNS(d,b,c):a.setAttribute(b,c)));}
	var sa$3=aa$3.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,ta$3=Symbol.for("react.element"),ua$3=Symbol.for("react.portal"),va$3=Symbol.for("react.fragment"),wa$3=Symbol.for("react.strict_mode"),xa$3=Symbol.for("react.profiler"),ya$3=Symbol.for("react.provider"),Aa$3=Symbol.for("react.context"),Ba$3=Symbol.for("react.forward_ref"),Ca$3=Symbol.for("react.suspense"),Da$3=Symbol.for("react.suspense_list"),Ea$3=Symbol.for("react.memo"),Fa$3=Symbol.for("react.lazy");var Ga$3=Symbol.for("react.offscreen");var Ha$3=Symbol.iterator;function Ia$3(a){if(null===a||"object"!==typeof a)return null;a=Ha$3&&a[Ha$3]||a["@@iterator"];return "function"===typeof a?a:null}var A$7=Object.assign,Ja$3;function Ka$3(a){if(void 0===Ja$3)try{throw Error();}catch(c){var b=c.stack.trim().match(/\n( *(at )?)/);Ja$3=b&&b[1]||"";}return "\n"+Ja$3+a}var La$3=!1;
	function Ma$3(a,b){if(!a||La$3)return "";La$3=!0;var c=Error.prepareStackTrace;Error.prepareStackTrace=void 0;try{if(b)if(b=function(){throw Error();},Object.defineProperty(b.prototype,"props",{set:function(){throw Error();}}),"object"===typeof Reflect&&Reflect.construct){try{Reflect.construct(b,[]);}catch(l){var d=l;}Reflect.construct(a,[],b);}else {try{b.call();}catch(l){d=l;}a.call(b.prototype);}else {try{throw Error();}catch(l){d=l;}a();}}catch(l){if(l&&d&&"string"===typeof l.stack){for(var e=l.stack.split("\n"),
	f=d.stack.split("\n"),g=e.length-1,h=f.length-1;1<=g&&0<=h&&e[g]!==f[h];)h--;for(;1<=g&&0<=h;g--,h--)if(e[g]!==f[h]){if(1!==g||1!==h){do if(g--,h--,0>h||e[g]!==f[h]){var k="\n"+e[g].replace(" at new "," at ");a.displayName&&k.includes("<anonymous>")&&(k=k.replace("<anonymous>",a.displayName));return k}while(1<=g&&0<=h)}break}}}finally{La$3=!1,Error.prepareStackTrace=c;}return (a=a?a.displayName||a.name:"")?Ka$3(a):""}
	function Na$3(a){switch(a.tag){case 5:return Ka$3(a.type);case 16:return Ka$3("Lazy");case 13:return Ka$3("Suspense");case 19:return Ka$3("SuspenseList");case 0:case 2:case 15:return a=Ma$3(a.type,!1),a;case 11:return a=Ma$3(a.type.render,!1),a;case 1:return a=Ma$3(a.type,!0),a;default:return ""}}
	function Oa$3(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case va$3:return "Fragment";case ua$3:return "Portal";case xa$3:return "Profiler";case wa$3:return "StrictMode";case Ca$3:return "Suspense";case Da$3:return "SuspenseList"}if("object"===typeof a)switch(a.$$typeof){case Aa$3:return (a.displayName||"Context")+".Consumer";case ya$3:return (a._context.displayName||"Context")+".Provider";case Ba$3:var b=a.render;a=a.displayName;a||(a=b.displayName||
	b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case Ea$3:return b=a.displayName||null,null!==b?b:Oa$3(a.type)||"Memo";case Fa$3:b=a._payload;a=a._init;try{return Oa$3(a(b))}catch(c){}}return null}
	function Pa$3(a){var b=a.type;switch(a.tag){case 24:return "Cache";case 9:return (b.displayName||"Context")+".Consumer";case 10:return (b._context.displayName||"Context")+".Provider";case 18:return "DehydratedFragment";case 11:return a=b.render,a=a.displayName||a.name||"",b.displayName||(""!==a?"ForwardRef("+a+")":"ForwardRef");case 7:return "Fragment";case 5:return b;case 4:return "Portal";case 3:return "Root";case 6:return "Text";case 16:return Oa$3(b);case 8:return b===wa$3?"StrictMode":"Mode";case 22:return "Offscreen";
	case 12:return "Profiler";case 21:return "Scope";case 13:return "Suspense";case 19:return "SuspenseList";case 25:return "TracingMarker";case 1:case 0:case 17:case 2:case 14:case 15:if("function"===typeof b)return b.displayName||b.name||null;if("string"===typeof b)return b}return null}function Qa$3(a){switch(typeof a){case "boolean":case "number":case "string":case "undefined":return a;case "object":return a;default:return ""}}
	function Ra$3(a){var b=a.type;return (a=a.nodeName)&&"input"===a.toLowerCase()&&("checkbox"===b||"radio"===b)}
	function Sa$3(a){var b=Ra$3(a)?"checked":"value",c=Object.getOwnPropertyDescriptor(a.constructor.prototype,b),d=""+a[b];if(!a.hasOwnProperty(b)&&"undefined"!==typeof c&&"function"===typeof c.get&&"function"===typeof c.set){var e=c.get,f=c.set;Object.defineProperty(a,b,{configurable:!0,get:function(){return e.call(this)},set:function(a){d=""+a;f.call(this,a);}});Object.defineProperty(a,b,{enumerable:c.enumerable});return {getValue:function(){return d},setValue:function(a){d=""+a;},stopTracking:function(){a._valueTracker=
	null;delete a[b];}}}}function Ta$3(a){a._valueTracker||(a._valueTracker=Sa$3(a));}function Ua$3(a){if(!a)return !1;var b=a._valueTracker;if(!b)return !0;var c=b.getValue();var d="";a&&(d=Ra$3(a)?a.checked?"true":"false":a.value);a=d;return a!==c?(b.setValue(a),!0):!1}function Va$3(a){a=a||("undefined"!==typeof document?document:void 0);if("undefined"===typeof a)return null;try{return a.activeElement||a.body}catch(b){return a.body}}
	function Wa$3(a,b){var c=b.checked;return A$7({},b,{defaultChecked:void 0,defaultValue:void 0,value:void 0,checked:null!=c?c:a._wrapperState.initialChecked})}function Xa$3(a,b){var c=null==b.defaultValue?"":b.defaultValue,d=null!=b.checked?b.checked:b.defaultChecked;c=Qa$3(null!=b.value?b.value:c);a._wrapperState={initialChecked:d,initialValue:c,controlled:"checkbox"===b.type||"radio"===b.type?null!=b.checked:null!=b.value};}function Ya$3(a,b){b=b.checked;null!=b&&ra$3(a,"checked",b,!1);}
	function Za$3(a,b){Ya$3(a,b);var c=Qa$3(b.value),d=b.type;if(null!=c)if("number"===d){if(0===c&&""===a.value||a.value!=c)a.value=""+c;}else a.value!==""+c&&(a.value=""+c);else if("submit"===d||"reset"===d){a.removeAttribute("value");return}b.hasOwnProperty("value")?$a$3(a,b.type,c):b.hasOwnProperty("defaultValue")&&$a$3(a,b.type,Qa$3(b.defaultValue));null==b.checked&&null!=b.defaultChecked&&(a.defaultChecked=!!b.defaultChecked);}
	function ab$2(a,b,c){if(b.hasOwnProperty("value")||b.hasOwnProperty("defaultValue")){var d=b.type;if(!("submit"!==d&&"reset"!==d||void 0!==b.value&&null!==b.value))return;b=""+a._wrapperState.initialValue;c||b===a.value||(a.value=b);a.defaultValue=b;}c=a.name;""!==c&&(a.name="");a.defaultChecked=!!a._wrapperState.initialChecked;""!==c&&(a.name=c);}
	function $a$3(a,b,c){if("number"!==b||Va$3(a.ownerDocument)!==a)null==c?a.defaultValue=""+a._wrapperState.initialValue:a.defaultValue!==""+c&&(a.defaultValue=""+c);}var bb$3=Array.isArray;
	function cb$2(a,b,c,d){a=a.options;if(b){b={};for(var e=0;e<c.length;e++)b["$"+c[e]]=!0;for(c=0;c<a.length;c++)e=b.hasOwnProperty("$"+a[c].value),a[c].selected!==e&&(a[c].selected=e),e&&d&&(a[c].defaultSelected=!0);}else {c=""+Qa$3(c);b=null;for(e=0;e<a.length;e++){if(a[e].value===c){a[e].selected=!0;d&&(a[e].defaultSelected=!0);return}null!==b||a[e].disabled||(b=a[e]);}null!==b&&(b.selected=!0);}}
	function db$3(a,b){if(null!=b.dangerouslySetInnerHTML)throw Error(p$f(91));return A$7({},b,{value:void 0,defaultValue:void 0,children:""+a._wrapperState.initialValue})}function eb$2(a,b){var c=b.value;if(null==c){c=b.children;b=b.defaultValue;if(null!=c){if(null!=b)throw Error(p$f(92));if(bb$3(c)){if(1<c.length)throw Error(p$f(93));c=c[0];}b=c;}null==b&&(b="");c=b;}a._wrapperState={initialValue:Qa$3(c)};}
	function fb$3(a,b){var c=Qa$3(b.value),d=Qa$3(b.defaultValue);null!=c&&(c=""+c,c!==a.value&&(a.value=c),null==b.defaultValue&&a.defaultValue!==c&&(a.defaultValue=c));null!=d&&(a.defaultValue=""+d);}function gb$3(a){var b=a.textContent;b===a._wrapperState.initialValue&&""!==b&&null!==b&&(a.value=b);}function hb$2(a){switch(a){case "svg":return "http://www.w3.org/2000/svg";case "math":return "http://www.w3.org/1998/Math/MathML";default:return "http://www.w3.org/1999/xhtml"}}
	function ib$2(a,b){return null==a||"http://www.w3.org/1999/xhtml"===a?hb$2(b):"http://www.w3.org/2000/svg"===a&&"foreignObject"===b?"http://www.w3.org/1999/xhtml":a}
	var jb$2,kb$3=function(a){return "undefined"!==typeof MSApp&&MSApp.execUnsafeLocalFunction?function(b,c,d,e){MSApp.execUnsafeLocalFunction(function(){return a(b,c,d,e)});}:a}(function(a,b){if("http://www.w3.org/2000/svg"!==a.namespaceURI||"innerHTML"in a)a.innerHTML=b;else {jb$2=jb$2||document.createElement("div");jb$2.innerHTML="<svg>"+b.valueOf().toString()+"</svg>";for(b=jb$2.firstChild;a.firstChild;)a.removeChild(a.firstChild);for(;b.firstChild;)a.appendChild(b.firstChild);}});
	function lb$2(a,b){if(b){var c=a.firstChild;if(c&&c===a.lastChild&&3===c.nodeType){c.nodeValue=b;return}}a.textContent=b;}
	var mb$2={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,
	zoom:!0,fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},nb$2=["Webkit","ms","Moz","O"];Object.keys(mb$2).forEach(function(a){nb$2.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);mb$2[b]=mb$2[a];});});function ob$2(a,b,c){return null==b||"boolean"===typeof b||""===b?"":c||"number"!==typeof b||0===b||mb$2.hasOwnProperty(a)&&mb$2[a]?(""+b).trim():b+"px"}
	function pb$2(a,b){a=a.style;for(var c in b)if(b.hasOwnProperty(c)){var d=0===c.indexOf("--"),e=ob$2(c,b[c],d);"float"===c&&(c="cssFloat");d?a.setProperty(c,e):a[c]=e;}}var qb$2=A$7({menuitem:!0},{area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0});
	function rb$2(a,b){if(b){if(qb$2[a]&&(null!=b.children||null!=b.dangerouslySetInnerHTML))throw Error(p$f(137,a));if(null!=b.dangerouslySetInnerHTML){if(null!=b.children)throw Error(p$f(60));if("object"!==typeof b.dangerouslySetInnerHTML||!("__html"in b.dangerouslySetInnerHTML))throw Error(p$f(61));}if(null!=b.style&&"object"!==typeof b.style)throw Error(p$f(62));}}
	function sb$2(a,b){if(-1===a.indexOf("-"))return "string"===typeof b.is;switch(a){case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":return !1;default:return !0}}var tb$2=null;function ub$2(a){a=a.target||a.srcElement||window;a.correspondingUseElement&&(a=a.correspondingUseElement);return 3===a.nodeType?a.parentNode:a}var vb$3=null,wb$3=null,xb$3=null;
	function yb$3(a){if(a=zb$2(a)){if("function"!==typeof vb$3)throw Error(p$f(280));var b=a.stateNode;b&&(b=Ab$3(b),vb$3(a.stateNode,a.type,b));}}function Bb$2(a){wb$3?xb$3?xb$3.push(a):xb$3=[a]:wb$3=a;}function Cb$3(){if(wb$3){var a=wb$3,b=xb$3;xb$3=wb$3=null;yb$3(a);if(b)for(a=0;a<b.length;a++)yb$3(b[a]);}}function Db$2(a,b){return a(b)}function Eb$2(){}var Fb$2=!1;function Gb$2(a,b,c){if(Fb$2)return a(b,c);Fb$2=!0;try{return Db$2(a,b,c)}finally{if(Fb$2=!1,null!==wb$3||null!==xb$3)Eb$2(),Cb$3();}}
	function Hb$2(a,b){var c=a.stateNode;if(null===c)return null;var d=Ab$3(c);if(null===d)return null;c=d[b];a:switch(b){case "onClick":case "onClickCapture":case "onDoubleClick":case "onDoubleClickCapture":case "onMouseDown":case "onMouseDownCapture":case "onMouseMove":case "onMouseMoveCapture":case "onMouseUp":case "onMouseUpCapture":case "onMouseEnter":(d=!d.disabled)||(a=a.type,d=!("button"===a||"input"===a||"select"===a||"textarea"===a));a=!d;break a;default:a=!1;}if(a)return null;if(c&&"function"!==
	typeof c)throw Error(p$f(231,b,typeof c));return c}var Ib$2=!1;if(ha$3)try{var Jb$2={};Object.defineProperty(Jb$2,"passive",{get:function(){Ib$2=!0;}});window.addEventListener("test",Jb$2,Jb$2);window.removeEventListener("test",Jb$2,Jb$2);}catch(a){Ib$2=!1;}function Kb$2(a,b,c,d,e,f,g,h,k){var l=Array.prototype.slice.call(arguments,3);try{b.apply(c,l);}catch(m){this.onError(m);}}var Lb$2=!1,Mb$2=null,Nb$1=!1,Ob$1=null,Pb$1={onError:function(a){Lb$2=!0;Mb$2=a;}};function Qb$1(a,b,c,d,e,f,g,h,k){Lb$2=!1;Mb$2=null;Kb$2.apply(Pb$1,arguments);}
	function Rb$1(a,b,c,d,e,f,g,h,k){Qb$1.apply(this,arguments);if(Lb$2){if(Lb$2){var l=Mb$2;Lb$2=!1;Mb$2=null;}else throw Error(p$f(198));Nb$1||(Nb$1=!0,Ob$1=l);}}function Sb$2(a){var b=a,c=a;if(a.alternate)for(;b.return;)b=b.return;else {a=b;do b=a,0!==(b.flags&4098)&&(c=b.return),a=b.return;while(a)}return 3===b.tag?c:null}function Tb$1(a){if(13===a.tag){var b=a.memoizedState;null===b&&(a=a.alternate,null!==a&&(b=a.memoizedState));if(null!==b)return b.dehydrated}return null}function Ub$1(a){if(Sb$2(a)!==a)throw Error(p$f(188));}
	function Vb$1(a){var b=a.alternate;if(!b){b=Sb$2(a);if(null===b)throw Error(p$f(188));return b!==a?null:a}for(var c=a,d=b;;){var e=c.return;if(null===e)break;var f=e.alternate;if(null===f){d=e.return;if(null!==d){c=d;continue}break}if(e.child===f.child){for(f=e.child;f;){if(f===c)return Ub$1(e),a;if(f===d)return Ub$1(e),b;f=f.sibling;}throw Error(p$f(188));}if(c.return!==d.return)c=e,d=f;else {for(var g=!1,h=e.child;h;){if(h===c){g=!0;c=e;d=f;break}if(h===d){g=!0;d=e;c=f;break}h=h.sibling;}if(!g){for(h=f.child;h;){if(h===
	c){g=!0;c=f;d=e;break}if(h===d){g=!0;d=f;c=e;break}h=h.sibling;}if(!g)throw Error(p$f(189));}}if(c.alternate!==d)throw Error(p$f(190));}if(3!==c.tag)throw Error(p$f(188));return c.stateNode.current===c?a:b}function Wb$1(a){a=Vb$1(a);return null!==a?Xb$1(a):null}function Xb$1(a){if(5===a.tag||6===a.tag)return a;for(a=a.child;null!==a;){var b=Xb$1(a);if(null!==b)return b;a=a.sibling;}return null}
	var Yb$1=ba$3.unstable_scheduleCallback,Zb$1=ba$3.unstable_cancelCallback,$b$1=ba$3.unstable_shouldYield,ac$2=ba$3.unstable_requestPaint,D$8=ba$3.unstable_now,bc$2=ba$3.unstable_getCurrentPriorityLevel,cc$2=ba$3.unstable_ImmediatePriority,dc$2=ba$3.unstable_UserBlockingPriority,ec$2=ba$3.unstable_NormalPriority,fc$2=ba$3.unstable_LowPriority,gc$2=ba$3.unstable_IdlePriority,hc$2=null,ic$2=null;function jc$2(a){if(ic$2&&"function"===typeof ic$2.onCommitFiberRoot)try{ic$2.onCommitFiberRoot(hc$2,a,void 0,128===(a.current.flags&128));}catch(b){}}
	var lc$2=Math.clz32?Math.clz32:kc$2,mc$2=Math.log,nc$1=Math.LN2;function kc$2(a){a>>>=0;return 0===a?32:31-(mc$2(a)/nc$1|0)|0}var oc$2=64,pc$2=4194304;
	function qc$2(a){switch(a&-a){case 1:return 1;case 2:return 2;case 4:return 4;case 8:return 8;case 16:return 16;case 32:return 32;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return a&4194240;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return a&130023424;case 134217728:return 134217728;case 268435456:return 268435456;case 536870912:return 536870912;case 1073741824:return 1073741824;
	default:return a}}function rc$2(a,b){var c=a.pendingLanes;if(0===c)return 0;var d=0,e=a.suspendedLanes,f=a.pingedLanes,g=c&268435455;if(0!==g){var h=g&~e;0!==h?d=qc$2(h):(f&=g,0!==f&&(d=qc$2(f)));}else g=c&~e,0!==g?d=qc$2(g):0!==f&&(d=qc$2(f));if(0===d)return 0;if(0!==b&&b!==d&&0===(b&e)&&(e=d&-d,f=b&-b,e>=f||16===e&&0!==(f&4194240)))return b;0!==(d&4)&&(d|=c&16);b=a.entangledLanes;if(0!==b)for(a=a.entanglements,b&=d;0<b;)c=31-lc$2(b),e=1<<c,d|=a[c],b&=~e;return d}
	function sc$2(a,b){switch(a){case 1:case 2:case 4:return b+250;case 8:case 16:case 32:case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:return b+5E3;case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:return -1;case 134217728:case 268435456:case 536870912:case 1073741824:return -1;default:return -1}}
	function tc$2(a,b){for(var c=a.suspendedLanes,d=a.pingedLanes,e=a.expirationTimes,f=a.pendingLanes;0<f;){var g=31-lc$2(f),h=1<<g,k=e[g];if(-1===k){if(0===(h&c)||0!==(h&d))e[g]=sc$2(h,b);}else k<=b&&(a.expiredLanes|=h);f&=~h;}}function uc$2(a){a=a.pendingLanes&-1073741825;return 0!==a?a:a&1073741824?1073741824:0}function vc$2(a){for(var b=[],c=0;31>c;c++)b.push(a);return b}function wc$2(a,b,c){a.pendingLanes|=b;536870912!==b&&(a.suspendedLanes=0,a.pingedLanes=0);a=a.eventTimes;b=31-lc$2(b);a[b]=c;}
	function xc$2(a,b){var c=a.pendingLanes&~b;a.pendingLanes=b;a.suspendedLanes=0;a.pingedLanes=0;a.expiredLanes&=b;a.mutableReadLanes&=b;a.entangledLanes&=b;b=a.entanglements;var d=a.eventTimes;for(a=a.expirationTimes;0<c;){var e=31-lc$2(c),f=1<<e;b[e]=0;d[e]=-1;a[e]=-1;c&=~f;}}function yc$2(a,b){var c=a.entangledLanes|=b;for(a=a.entanglements;c;){var d=31-lc$2(c),e=1<<d;e&b|a[d]&b&&(a[d]|=b);c&=~e;}}var E$5=0;function zc$2(a){a&=-a;return 1<a?4<a?0!==(a&268435455)?16:536870912:4:1}
	var Ac$2,Bc$2,Cc$2,Dc$2,Ec$2,Fc$2=!1,Gc$2=[],Hc$2=null,Ic$2=null,Jc$2=null,Kc$2=new Map,Lc$2=new Map,Mc$2=[],Nc$2="mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(" ");
	function Oc$2(a,b){switch(a){case "focusin":case "focusout":Hc$2=null;break;case "dragenter":case "dragleave":Ic$2=null;break;case "mouseover":case "mouseout":Jc$2=null;break;case "pointerover":case "pointerout":Kc$2.delete(b.pointerId);break;case "gotpointercapture":case "lostpointercapture":Lc$2.delete(b.pointerId);}}
	function Pc$2(a,b,c,d,e,f){if(null===a||a.nativeEvent!==f)return a={blockedOn:b,domEventName:c,eventSystemFlags:d,nativeEvent:f,targetContainers:[e]},null!==b&&(b=zb$2(b),null!==b&&Bc$2(b)),a;a.eventSystemFlags|=d;b=a.targetContainers;null!==e&&-1===b.indexOf(e)&&b.push(e);return a}
	function Qc$2(a,b,c,d,e){switch(b){case "focusin":return Hc$2=Pc$2(Hc$2,a,b,c,d,e),!0;case "dragenter":return Ic$2=Pc$2(Ic$2,a,b,c,d,e),!0;case "mouseover":return Jc$2=Pc$2(Jc$2,a,b,c,d,e),!0;case "pointerover":var f=e.pointerId;Kc$2.set(f,Pc$2(Kc$2.get(f)||null,a,b,c,d,e));return !0;case "gotpointercapture":return f=e.pointerId,Lc$2.set(f,Pc$2(Lc$2.get(f)||null,a,b,c,d,e)),!0}return !1}
	function Rc$2(a){var b=Sc$2(a.target);if(null!==b){var c=Sb$2(b);if(null!==c)if(b=c.tag,13===b){if(b=Tb$1(c),null!==b){a.blockedOn=b;Ec$2(a.priority,function(){Cc$2(c);});return}}else if(3===b&&c.stateNode.current.memoizedState.isDehydrated){a.blockedOn=3===c.tag?c.stateNode.containerInfo:null;return}}a.blockedOn=null;}
	function Tc$2(a){if(null!==a.blockedOn)return !1;for(var b=a.targetContainers;0<b.length;){var c=Uc$2(a.domEventName,a.eventSystemFlags,b[0],a.nativeEvent);if(null===c){c=a.nativeEvent;var d=new c.constructor(c.type,c);tb$2=d;c.target.dispatchEvent(d);tb$2=null;}else return b=zb$2(c),null!==b&&Bc$2(b),a.blockedOn=c,!1;b.shift();}return !0}function Vc$2(a,b,c){Tc$2(a)&&c.delete(b);}function Wc$2(){Fc$2=!1;null!==Hc$2&&Tc$2(Hc$2)&&(Hc$2=null);null!==Ic$2&&Tc$2(Ic$2)&&(Ic$2=null);null!==Jc$2&&Tc$2(Jc$2)&&(Jc$2=null);Kc$2.forEach(Vc$2);Lc$2.forEach(Vc$2);}
	function Xc$2(a,b){a.blockedOn===b&&(a.blockedOn=null,Fc$2||(Fc$2=!0,ba$3.unstable_scheduleCallback(ba$3.unstable_NormalPriority,Wc$2)));}
	function Yc$1(a){function b(b){return Xc$2(b,a)}if(0<Gc$2.length){Xc$2(Gc$2[0],a);for(var c=1;c<Gc$2.length;c++){var d=Gc$2[c];d.blockedOn===a&&(d.blockedOn=null);}}null!==Hc$2&&Xc$2(Hc$2,a);null!==Ic$2&&Xc$2(Ic$2,a);null!==Jc$2&&Xc$2(Jc$2,a);Kc$2.forEach(b);Lc$2.forEach(b);for(c=0;c<Mc$2.length;c++)d=Mc$2[c],d.blockedOn===a&&(d.blockedOn=null);for(;0<Mc$2.length&&(c=Mc$2[0],null===c.blockedOn);)Rc$2(c),null===c.blockedOn&&Mc$2.shift();}var Zc$1=sa$3.ReactCurrentBatchConfig;
	function $c$1(a,b,c,d){var e=E$5,f=Zc$1.transition;Zc$1.transition=null;try{E$5=1,ad(a,b,c,d);}finally{E$5=e,Zc$1.transition=f;}}function bd(a,b,c,d){var e=E$5,f=Zc$1.transition;Zc$1.transition=null;try{E$5=4,ad(a,b,c,d);}finally{E$5=e,Zc$1.transition=f;}}
	function ad(a,b,c,d){var e=Uc$2(a,b,c,d);if(null===e)cd(a,b,d,dd$1,c),Oc$2(a,d);else if(Qc$2(e,a,b,c,d))d.stopPropagation();else if(Oc$2(a,d),b&4&&-1<Nc$2.indexOf(a)){for(;null!==e;){var f=zb$2(e);null!==f&&Ac$2(f);f=Uc$2(a,b,c,d);null===f&&cd(a,b,d,dd$1,c);if(f===e)break;e=f;}null!==e&&d.stopPropagation();}else cd(a,b,d,null,c);}var dd$1=null;
	function Uc$2(a,b,c,d){dd$1=null;a=ub$2(d);a=Sc$2(a);if(null!==a)if(b=Sb$2(a),null===b)a=null;else if(c=b.tag,13===c){a=Tb$1(b);if(null!==a)return a;a=null;}else if(3===c){if(b.stateNode.current.memoizedState.isDehydrated)return 3===b.tag?b.stateNode.containerInfo:null;a=null;}else b!==a&&(a=null);dd$1=a;return null}
	function ed(a){switch(a){case "cancel":case "click":case "close":case "contextmenu":case "copy":case "cut":case "auxclick":case "dblclick":case "dragend":case "dragstart":case "drop":case "focusin":case "focusout":case "input":case "invalid":case "keydown":case "keypress":case "keyup":case "mousedown":case "mouseup":case "paste":case "pause":case "play":case "pointercancel":case "pointerdown":case "pointerup":case "ratechange":case "reset":case "resize":case "seeked":case "submit":case "touchcancel":case "touchend":case "touchstart":case "volumechange":case "change":case "selectionchange":case "textInput":case "compositionstart":case "compositionend":case "compositionupdate":case "beforeblur":case "afterblur":case "beforeinput":case "blur":case "fullscreenchange":case "focus":case "hashchange":case "popstate":case "select":case "selectstart":return 1;case "drag":case "dragenter":case "dragexit":case "dragleave":case "dragover":case "mousemove":case "mouseout":case "mouseover":case "pointermove":case "pointerout":case "pointerover":case "scroll":case "toggle":case "touchmove":case "wheel":case "mouseenter":case "mouseleave":case "pointerenter":case "pointerleave":return 4;
	case "message":switch(bc$2()){case cc$2:return 1;case dc$2:return 4;case ec$2:case fc$2:return 16;case gc$2:return 536870912;default:return 16}default:return 16}}var fd=null,gd=null,hd=null;function id$1(){if(hd)return hd;var a,b=gd,c=b.length,d,e="value"in fd?fd.value:fd.textContent,f=e.length;for(a=0;a<c&&b[a]===e[a];a++);var g=c-a;for(d=1;d<=g&&b[c-d]===e[f-d];d++);return hd=e.slice(a,1<d?1-d:void 0)}
	function jd(a){var b=a.keyCode;"charCode"in a?(a=a.charCode,0===a&&13===b&&(a=13)):a=b;10===a&&(a=13);return 32<=a||13===a?a:0}function kd(){return !0}function ld(){return !1}
	function md(a){function b(b,d,e,f,g){this._reactName=b;this._targetInst=e;this.type=d;this.nativeEvent=f;this.target=g;this.currentTarget=null;for(var c in a)a.hasOwnProperty(c)&&(b=a[c],this[c]=b?b(f):f[c]);this.isDefaultPrevented=(null!=f.defaultPrevented?f.defaultPrevented:!1===f.returnValue)?kd:ld;this.isPropagationStopped=ld;return this}A$7(b.prototype,{preventDefault:function(){this.defaultPrevented=!0;var a=this.nativeEvent;a&&(a.preventDefault?a.preventDefault():"unknown"!==typeof a.returnValue&&
	(a.returnValue=!1),this.isDefaultPrevented=kd);},stopPropagation:function(){var a=this.nativeEvent;a&&(a.stopPropagation?a.stopPropagation():"unknown"!==typeof a.cancelBubble&&(a.cancelBubble=!0),this.isPropagationStopped=kd);},persist:function(){},isPersistent:kd});return b}
	var nd={eventPhase:0,bubbles:0,cancelable:0,timeStamp:function(a){return a.timeStamp||Date.now()},defaultPrevented:0,isTrusted:0},od=md(nd),pd=A$7({},nd,{view:0,detail:0}),qd=md(pd),rd,sd,td,vd=A$7({},pd,{screenX:0,screenY:0,clientX:0,clientY:0,pageX:0,pageY:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,getModifierState:ud,button:0,buttons:0,relatedTarget:function(a){return void 0===a.relatedTarget?a.fromElement===a.srcElement?a.toElement:a.fromElement:a.relatedTarget},movementX:function(a){if("movementX"in
	a)return a.movementX;a!==td&&(td&&"mousemove"===a.type?(rd=a.screenX-td.screenX,sd=a.screenY-td.screenY):sd=rd=0,td=a);return rd},movementY:function(a){return "movementY"in a?a.movementY:sd}}),wd=md(vd),xd=A$7({},vd,{dataTransfer:0}),yd=md(xd),zd=A$7({},pd,{relatedTarget:0}),Ad=md(zd),Bd=A$7({},nd,{animationName:0,elapsedTime:0,pseudoElement:0}),Cd=md(Bd),Dd=A$7({},nd,{clipboardData:function(a){return "clipboardData"in a?a.clipboardData:window.clipboardData}}),Ed=md(Dd),Fd=A$7({},nd,{data:0}),Gd=md(Fd),Hd={Esc:"Escape",
	Spacebar:" ",Left:"ArrowLeft",Up:"ArrowUp",Right:"ArrowRight",Down:"ArrowDown",Del:"Delete",Win:"OS",Menu:"ContextMenu",Apps:"ContextMenu",Scroll:"ScrollLock",MozPrintableKey:"Unidentified"},Id={8:"Backspace",9:"Tab",12:"Clear",13:"Enter",16:"Shift",17:"Control",18:"Alt",19:"Pause",20:"CapsLock",27:"Escape",32:" ",33:"PageUp",34:"PageDown",35:"End",36:"Home",37:"ArrowLeft",38:"ArrowUp",39:"ArrowRight",40:"ArrowDown",45:"Insert",46:"Delete",112:"F1",113:"F2",114:"F3",115:"F4",116:"F5",117:"F6",118:"F7",
	119:"F8",120:"F9",121:"F10",122:"F11",123:"F12",144:"NumLock",145:"ScrollLock",224:"Meta"},Jd={Alt:"altKey",Control:"ctrlKey",Meta:"metaKey",Shift:"shiftKey"};function Kd(a){var b=this.nativeEvent;return b.getModifierState?b.getModifierState(a):(a=Jd[a])?!!b[a]:!1}function ud(){return Kd}
	var Ld=A$7({},pd,{key:function(a){if(a.key){var b=Hd[a.key]||a.key;if("Unidentified"!==b)return b}return "keypress"===a.type?(a=jd(a),13===a?"Enter":String.fromCharCode(a)):"keydown"===a.type||"keyup"===a.type?Id[a.keyCode]||"Unidentified":""},code:0,location:0,ctrlKey:0,shiftKey:0,altKey:0,metaKey:0,repeat:0,locale:0,getModifierState:ud,charCode:function(a){return "keypress"===a.type?jd(a):0},keyCode:function(a){return "keydown"===a.type||"keyup"===a.type?a.keyCode:0},which:function(a){return "keypress"===
	a.type?jd(a):"keydown"===a.type||"keyup"===a.type?a.keyCode:0}}),Md=md(Ld),Nd=A$7({},vd,{pointerId:0,width:0,height:0,pressure:0,tangentialPressure:0,tiltX:0,tiltY:0,twist:0,pointerType:0,isPrimary:0}),Od=md(Nd),Pd=A$7({},pd,{touches:0,targetTouches:0,changedTouches:0,altKey:0,metaKey:0,ctrlKey:0,shiftKey:0,getModifierState:ud}),Qd=md(Pd),Rd=A$7({},nd,{propertyName:0,elapsedTime:0,pseudoElement:0}),Sd=md(Rd),Td=A$7({},vd,{deltaX:function(a){return "deltaX"in a?a.deltaX:"wheelDeltaX"in a?-a.wheelDeltaX:0},
	deltaY:function(a){return "deltaY"in a?a.deltaY:"wheelDeltaY"in a?-a.wheelDeltaY:"wheelDelta"in a?-a.wheelDelta:0},deltaZ:0,deltaMode:0}),Ud=md(Td),Vd=[9,13,27,32],Wd=ha$3&&"CompositionEvent"in window,Xd=null;ha$3&&"documentMode"in document&&(Xd=document.documentMode);var Yd=ha$3&&"TextEvent"in window&&!Xd,Zd=ha$3&&(!Wd||Xd&&8<Xd&&11>=Xd),$d=String.fromCharCode(32),ae$1=!1;
	function be$4(a,b){switch(a){case "keyup":return -1!==Vd.indexOf(b.keyCode);case "keydown":return 229!==b.keyCode;case "keypress":case "mousedown":case "focusout":return !0;default:return !1}}function ce$3(a){a=a.detail;return "object"===typeof a&&"data"in a?a.data:null}var de$4=!1;function ee$4(a,b){switch(a){case "compositionend":return ce$3(b);case "keypress":if(32!==b.which)return null;ae$1=!0;return $d;case "textInput":return a=b.data,a===$d&&ae$1?null:a;default:return null}}
	function fe$3(a,b){if(de$4)return "compositionend"===a||!Wd&&be$4(a,b)?(a=id$1(),hd=gd=fd=null,de$4=!1,a):null;switch(a){case "paste":return null;case "keypress":if(!(b.ctrlKey||b.altKey||b.metaKey)||b.ctrlKey&&b.altKey){if(b.char&&1<b.char.length)return b.char;if(b.which)return String.fromCharCode(b.which)}return null;case "compositionend":return Zd&&"ko"!==b.locale?null:b.data;default:return null}}
	var ge$4={color:!0,date:!0,datetime:!0,"datetime-local":!0,email:!0,month:!0,number:!0,password:!0,range:!0,search:!0,tel:!0,text:!0,time:!0,url:!0,week:!0};function he$7(a){var b=a&&a.nodeName&&a.nodeName.toLowerCase();return "input"===b?!!ge$4[a.type]:"textarea"===b?!0:!1}function ie$3(a,b,c,d){Bb$2(d);b=je$4(b,"onChange");0<b.length&&(c=new od("onChange","change",null,c,d),a.push({event:c,listeners:b}));}var ke$2=null,le$4=null;function me$3(a){ne$5(a,0);}function oe$3(a){var b=pe$4(a);if(Ua$3(b))return a}
	function qe$2(a,b){if("change"===a)return b}var re$5=!1;if(ha$3){var se$4;if(ha$3){var te$3="oninput"in document;if(!te$3){var ue$4=document.createElement("div");ue$4.setAttribute("oninput","return;");te$3="function"===typeof ue$4.oninput;}se$4=te$3;}else se$4=!1;re$5=se$4&&(!document.documentMode||9<document.documentMode);}function ve$5(){ke$2&&(ke$2.detachEvent("onpropertychange",we$3),le$4=ke$2=null);}function we$3(a){if("value"===a.propertyName&&oe$3(le$4)){var b=[];ie$3(b,le$4,a,ub$2(a));Gb$2(me$3,b);}}
	function xe$6(a,b,c){"focusin"===a?(ve$5(),ke$2=b,le$4=c,ke$2.attachEvent("onpropertychange",we$3)):"focusout"===a&&ve$5();}function ye$5(a){if("selectionchange"===a||"keyup"===a||"keydown"===a)return oe$3(le$4)}function ze$2(a,b){if("click"===a)return oe$3(b)}function Ae$4(a,b){if("input"===a||"change"===a)return oe$3(b)}function Be$4(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var Ce$2="function"===typeof Object.is?Object.is:Be$4;
	function De$4(a,b){if(Ce$2(a,b))return !0;if("object"!==typeof a||null===a||"object"!==typeof b||null===b)return !1;var c=Object.keys(a),d=Object.keys(b);if(c.length!==d.length)return !1;for(d=0;d<c.length;d++){var e=c[d];if(!ia$3.call(b,e)||!Ce$2(a[e],b[e]))return !1}return !0}function Ee$5(a){for(;a&&a.firstChild;)a=a.firstChild;return a}
	function Fe$4(a,b){var c=Ee$5(a);a=0;for(var d;c;){if(3===c.nodeType){d=a+c.textContent.length;if(a<=b&&d>=b)return {node:c,offset:b-a};a=d;}a:{for(;c;){if(c.nextSibling){c=c.nextSibling;break a}c=c.parentNode;}c=void 0;}c=Ee$5(c);}}function Ge$4(a,b){return a&&b?a===b?!0:a&&3===a.nodeType?!1:b&&3===b.nodeType?Ge$4(a,b.parentNode):"contains"in a?a.contains(b):a.compareDocumentPosition?!!(a.compareDocumentPosition(b)&16):!1:!1}
	function He$5(){for(var a=window,b=Va$3();b instanceof a.HTMLIFrameElement;){try{var c="string"===typeof b.contentWindow.location.href;}catch(d){c=!1;}if(c)a=b.contentWindow;else break;b=Va$3(a.document);}return b}function Ie$6(a){var b=a&&a.nodeName&&a.nodeName.toLowerCase();return b&&("input"===b&&("text"===a.type||"search"===a.type||"tel"===a.type||"url"===a.type||"password"===a.type)||"textarea"===b||"true"===a.contentEditable)}
	function Je$4(a){var b=He$5(),c=a.focusedElem,d=a.selectionRange;if(b!==c&&c&&c.ownerDocument&&Ge$4(c.ownerDocument.documentElement,c)){if(null!==d&&Ie$6(c))if(b=d.start,a=d.end,void 0===a&&(a=b),"selectionStart"in c)c.selectionStart=b,c.selectionEnd=Math.min(a,c.value.length);else if(a=(b=c.ownerDocument||document)&&b.defaultView||window,a.getSelection){a=a.getSelection();var e=c.textContent.length,f=Math.min(d.start,e);d=void 0===d.end?f:Math.min(d.end,e);!a.extend&&f>d&&(e=d,d=f,f=e);e=Fe$4(c,f);var g=Fe$4(c,
	d);e&&g&&(1!==a.rangeCount||a.anchorNode!==e.node||a.anchorOffset!==e.offset||a.focusNode!==g.node||a.focusOffset!==g.offset)&&(b=b.createRange(),b.setStart(e.node,e.offset),a.removeAllRanges(),f>d?(a.addRange(b),a.extend(g.node,g.offset)):(b.setEnd(g.node,g.offset),a.addRange(b)));}b=[];for(a=c;a=a.parentNode;)1===a.nodeType&&b.push({element:a,left:a.scrollLeft,top:a.scrollTop});"function"===typeof c.focus&&c.focus();for(c=0;c<b.length;c++)a=b[c],a.element.scrollLeft=a.left,a.element.scrollTop=a.top;}}
	var Ke$4=ha$3&&"documentMode"in document&&11>=document.documentMode,Le$2=null,Me$5=null,Ne$5=null,Oe$1=!1;
	function Pe$4(a,b,c){var d=c.window===c?c.document:9===c.nodeType?c:c.ownerDocument;Oe$1||null==Le$2||Le$2!==Va$3(d)||(d=Le$2,"selectionStart"in d&&Ie$6(d)?d={start:d.selectionStart,end:d.selectionEnd}:(d=(d.ownerDocument&&d.ownerDocument.defaultView||window).getSelection(),d={anchorNode:d.anchorNode,anchorOffset:d.anchorOffset,focusNode:d.focusNode,focusOffset:d.focusOffset}),Ne$5&&De$4(Ne$5,d)||(Ne$5=d,d=je$4(Me$5,"onSelect"),0<d.length&&(b=new od("onSelect","select",null,b,c),a.push({event:b,listeners:d}),b.target=Le$2)));}
	function Qe$2(a,b){var c={};c[a.toLowerCase()]=b.toLowerCase();c["Webkit"+a]="webkit"+b;c["Moz"+a]="moz"+b;return c}var Re$6={animationend:Qe$2("Animation","AnimationEnd"),animationiteration:Qe$2("Animation","AnimationIteration"),animationstart:Qe$2("Animation","AnimationStart"),transitionend:Qe$2("Transition","TransitionEnd")},Se$6={},Te$4={};
	ha$3&&(Te$4=document.createElement("div").style,"AnimationEvent"in window||(delete Re$6.animationend.animation,delete Re$6.animationiteration.animation,delete Re$6.animationstart.animation),"TransitionEvent"in window||delete Re$6.transitionend.transition);function Ue$3(a){if(Se$6[a])return Se$6[a];if(!Re$6[a])return a;var b=Re$6[a],c;for(c in b)if(b.hasOwnProperty(c)&&c in Te$4)return Se$6[a]=b[c];return a}var Ve$4=Ue$3("animationend"),We$4=Ue$3("animationiteration"),Xe$4=Ue$3("animationstart"),Ye$3=Ue$3("transitionend"),Ze$2=new Map,$e$4="abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" ");
	function af(a,b){Ze$2.set(a,b);ea$3(b,[a]);}for(var bf=0;bf<$e$4.length;bf++){var cf=$e$4[bf],df=cf.toLowerCase(),ef=cf[0].toUpperCase()+cf.slice(1);af(df,"on"+ef);}af(Ve$4,"onAnimationEnd");af(We$4,"onAnimationIteration");af(Xe$4,"onAnimationStart");af("dblclick","onDoubleClick");af("focusin","onFocus");af("focusout","onBlur");af(Ye$3,"onTransitionEnd");fa$3("onMouseEnter",["mouseout","mouseover"]);fa$3("onMouseLeave",["mouseout","mouseover"]);fa$3("onPointerEnter",["pointerout","pointerover"]);
	fa$3("onPointerLeave",["pointerout","pointerover"]);ea$3("onChange","change click focusin focusout input keydown keyup selectionchange".split(" "));ea$3("onSelect","focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(" "));ea$3("onBeforeInput",["compositionend","keypress","textInput","paste"]);ea$3("onCompositionEnd","compositionend focusout keydown keypress keyup mousedown".split(" "));ea$3("onCompositionStart","compositionstart focusout keydown keypress keyup mousedown".split(" "));
	ea$3("onCompositionUpdate","compositionupdate focusout keydown keypress keyup mousedown".split(" "));var ff="abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(" "),gf=new Set("cancel close invalid load scroll toggle".split(" ").concat(ff));
	function hf(a,b,c){var d=a.type||"unknown-event";a.currentTarget=c;Rb$1(d,b,void 0,a);a.currentTarget=null;}
	function ne$5(a,b){b=0!==(b&4);for(var c=0;c<a.length;c++){var d=a[c],e=d.event;d=d.listeners;a:{var f=void 0;if(b)for(var g=d.length-1;0<=g;g--){var h=d[g],k=h.instance,l=h.currentTarget;h=h.listener;if(k!==f&&e.isPropagationStopped())break a;hf(e,h,l);f=k;}else for(g=0;g<d.length;g++){h=d[g];k=h.instance;l=h.currentTarget;h=h.listener;if(k!==f&&e.isPropagationStopped())break a;hf(e,h,l);f=k;}}}if(Nb$1)throw a=Ob$1,Nb$1=!1,Ob$1=null,a;}
	function F$9(a,b){var c=b[jf];void 0===c&&(c=b[jf]=new Set);var d=a+"__bubble";c.has(d)||(kf(b,a,2,!1),c.add(d));}function lf(a,b,c){var d=0;b&&(d|=4);kf(c,a,d,b);}var mf="_reactListening"+Math.random().toString(36).slice(2);function nf(a){if(!a[mf]){a[mf]=!0;ca$3.forEach(function(b){"selectionchange"!==b&&(gf.has(b)||lf(b,!1,a),lf(b,!0,a));});var b=9===a.nodeType?a:a.ownerDocument;null===b||b[mf]||(b[mf]=!0,lf("selectionchange",!1,b));}}
	function kf(a,b,c,d){switch(ed(b)){case 1:var e=$c$1;break;case 4:e=bd;break;default:e=ad;}c=e.bind(null,b,c,a);e=void 0;!Ib$2||"touchstart"!==b&&"touchmove"!==b&&"wheel"!==b||(e=!0);d?void 0!==e?a.addEventListener(b,c,{capture:!0,passive:e}):a.addEventListener(b,c,!0):void 0!==e?a.addEventListener(b,c,{passive:e}):a.addEventListener(b,c,!1);}
	function cd(a,b,c,d,e){var f=d;if(0===(b&1)&&0===(b&2)&&null!==d)a:for(;;){if(null===d)return;var g=d.tag;if(3===g||4===g){var h=d.stateNode.containerInfo;if(h===e||8===h.nodeType&&h.parentNode===e)break;if(4===g)for(g=d.return;null!==g;){var k=g.tag;if(3===k||4===k)if(k=g.stateNode.containerInfo,k===e||8===k.nodeType&&k.parentNode===e)return;g=g.return;}for(;null!==h;){g=Sc$2(h);if(null===g)return;k=g.tag;if(5===k||6===k){d=f=g;continue a}h=h.parentNode;}}d=d.return;}Gb$2(function(){var d=f,e=ub$2(c),g=[];
	a:{var h=Ze$2.get(a);if(void 0!==h){var k=od,n=a;switch(a){case "keypress":if(0===jd(c))break a;case "keydown":case "keyup":k=Md;break;case "focusin":n="focus";k=Ad;break;case "focusout":n="blur";k=Ad;break;case "beforeblur":case "afterblur":k=Ad;break;case "click":if(2===c.button)break a;case "auxclick":case "dblclick":case "mousedown":case "mousemove":case "mouseup":case "mouseout":case "mouseover":case "contextmenu":k=wd;break;case "drag":case "dragend":case "dragenter":case "dragexit":case "dragleave":case "dragover":case "dragstart":case "drop":k=
	yd;break;case "touchcancel":case "touchend":case "touchmove":case "touchstart":k=Qd;break;case Ve$4:case We$4:case Xe$4:k=Cd;break;case Ye$3:k=Sd;break;case "scroll":k=qd;break;case "wheel":k=Ud;break;case "copy":case "cut":case "paste":k=Ed;break;case "gotpointercapture":case "lostpointercapture":case "pointercancel":case "pointerdown":case "pointermove":case "pointerout":case "pointerover":case "pointerup":k=Od;}var v=0!==(b&4),C=!v&&"scroll"===a,t=v?null!==h?h+"Capture":null:h;v=[];for(var r=d,x;null!==
	r;){x=r;var B=x.stateNode;5===x.tag&&null!==B&&(x=B,null!==t&&(B=Hb$2(r,t),null!=B&&v.push(of(r,B,x))));if(C)break;r=r.return;}0<v.length&&(h=new k(h,n,null,c,e),g.push({event:h,listeners:v}));}}if(0===(b&7)){a:{h="mouseover"===a||"pointerover"===a;k="mouseout"===a||"pointerout"===a;if(h&&c!==tb$2&&(n=c.relatedTarget||c.fromElement)&&(Sc$2(n)||n[pf]))break a;if(k||h){h=e.window===e?e:(h=e.ownerDocument)?h.defaultView||h.parentWindow:window;if(k){if(n=c.relatedTarget||c.toElement,k=d,n=n?Sc$2(n):null,null!==
	n&&(C=Sb$2(n),n!==C||5!==n.tag&&6!==n.tag))n=null;}else k=null,n=d;if(k!==n){v=wd;B="onMouseLeave";t="onMouseEnter";r="mouse";if("pointerout"===a||"pointerover"===a)v=Od,B="onPointerLeave",t="onPointerEnter",r="pointer";C=null==k?h:pe$4(k);x=null==n?h:pe$4(n);h=new v(B,r+"leave",k,c,e);h.target=C;h.relatedTarget=x;B=null;Sc$2(e)===d&&(v=new v(t,r+"enter",n,c,e),v.target=x,v.relatedTarget=C,B=v);C=B;if(k&&n)b:{v=k;t=n;r=0;for(x=v;x;x=qf(x))r++;x=0;for(B=t;B;B=qf(B))x++;for(;0<r-x;)v=qf(v),r--;for(;0<x-r;)t=
	qf(t),x--;for(;r--;){if(v===t||null!==t&&v===t.alternate)break b;v=qf(v);t=qf(t);}v=null;}else v=null;null!==k&&rf(g,h,k,v,!1);null!==n&&null!==C&&rf(g,C,n,v,!0);}}}a:{h=d?pe$4(d):window;k=h.nodeName&&h.nodeName.toLowerCase();if("select"===k||"input"===k&&"file"===h.type)var O=qe$2;else if(he$7(h))if(re$5)O=Ae$4;else {O=ye$5;var T=xe$6;}else (k=h.nodeName)&&"input"===k.toLowerCase()&&("checkbox"===h.type||"radio"===h.type)&&(O=ze$2);if(O&&(O=O(a,d))){ie$3(g,O,c,e);break a}T&&T(a,h,d);"focusout"===a&&(T=h._wrapperState)&&
	T.controlled&&"number"===h.type&&$a$3(h,"number",h.value);}T=d?pe$4(d):window;switch(a){case "focusin":if(he$7(T)||"true"===T.contentEditable)Le$2=T,Me$5=d,Ne$5=null;break;case "focusout":Ne$5=Me$5=Le$2=null;break;case "mousedown":Oe$1=!0;break;case "contextmenu":case "mouseup":case "dragend":Oe$1=!1;Pe$4(g,c,e);break;case "selectionchange":if(Ke$4)break;case "keydown":case "keyup":Pe$4(g,c,e);}var za;if(Wd)b:{switch(a){case "compositionstart":var L="onCompositionStart";break b;case "compositionend":L="onCompositionEnd";break b;
	case "compositionupdate":L="onCompositionUpdate";break b}L=void 0;}else de$4?be$4(a,c)&&(L="onCompositionEnd"):"keydown"===a&&229===c.keyCode&&(L="onCompositionStart");L&&(Zd&&"ko"!==c.locale&&(de$4||"onCompositionStart"!==L?"onCompositionEnd"===L&&de$4&&(za=id$1()):(fd=e,gd="value"in fd?fd.value:fd.textContent,de$4=!0)),T=je$4(d,L),0<T.length&&(L=new Gd(L,a,null,c,e),g.push({event:L,listeners:T}),za?L.data=za:(za=ce$3(c),null!==za&&(L.data=za))));if(za=Yd?ee$4(a,c):fe$3(a,c))d=je$4(d,"onBeforeInput"),0<d.length&&(e=new Gd("onBeforeInput",
	"beforeinput",null,c,e),g.push({event:e,listeners:d}),e.data=za);}ne$5(g,b);});}function of(a,b,c){return {instance:a,listener:b,currentTarget:c}}function je$4(a,b){for(var c=b+"Capture",d=[];null!==a;){var e=a,f=e.stateNode;5===e.tag&&null!==f&&(e=f,f=Hb$2(a,c),null!=f&&d.unshift(of(a,f,e)),f=Hb$2(a,b),null!=f&&d.push(of(a,f,e)));a=a.return;}return d}function qf(a){if(null===a)return null;do a=a.return;while(a&&5!==a.tag);return a?a:null}
	function rf(a,b,c,d,e){for(var f=b._reactName,g=[];null!==c&&c!==d;){var h=c,k=h.alternate,l=h.stateNode;if(null!==k&&k===d)break;5===h.tag&&null!==l&&(h=l,e?(k=Hb$2(c,f),null!=k&&g.unshift(of(c,k,h))):e||(k=Hb$2(c,f),null!=k&&g.push(of(c,k,h))));c=c.return;}0!==g.length&&a.push({event:b,listeners:g});}var sf=/\r\n?/g,tf=/\u0000|\uFFFD/g;function uf(a){return ("string"===typeof a?a:""+a).replace(sf,"\n").replace(tf,"")}function vf(a,b,c){b=uf(b);if(uf(a)!==b&&c)throw Error(p$f(425));}function wf(){}
	var xf=null;function yf(a,b){return "textarea"===a||"noscript"===a||"string"===typeof b.children||"number"===typeof b.children||"object"===typeof b.dangerouslySetInnerHTML&&null!==b.dangerouslySetInnerHTML&&null!=b.dangerouslySetInnerHTML.__html}
	var zf="function"===typeof setTimeout?setTimeout:void 0,Af="function"===typeof clearTimeout?clearTimeout:void 0,Bf="function"===typeof Promise?Promise:void 0,Df="function"===typeof queueMicrotask?queueMicrotask:"undefined"!==typeof Bf?function(a){return Bf.resolve(null).then(a).catch(Cf)}:zf;function Cf(a){setTimeout(function(){throw a;});}
	function Ef(a,b){var c=b,d=0;do{var e=c.nextSibling;a.removeChild(c);if(e&&8===e.nodeType)if(c=e.data,"/$"===c){if(0===d){a.removeChild(e);Yc$1(b);return}d--;}else "$"!==c&&"$?"!==c&&"$!"!==c||d++;c=e;}while(c);Yc$1(b);}function Ff(a){for(;null!=a;a=a.nextSibling){var b=a.nodeType;if(1===b||3===b)break;if(8===b){b=a.data;if("$"===b||"$!"===b||"$?"===b)break;if("/$"===b)return null}}return a}
	function Gf(a){a=a.previousSibling;for(var b=0;a;){if(8===a.nodeType){var c=a.data;if("$"===c||"$!"===c||"$?"===c){if(0===b)return a;b--;}else "/$"===c&&b++;}a=a.previousSibling;}return null}var Hf=Math.random().toString(36).slice(2),If="__reactFiber$"+Hf,Jf="__reactProps$"+Hf,pf="__reactContainer$"+Hf,jf="__reactEvents$"+Hf,Kf="__reactListeners$"+Hf,Lf="__reactHandles$"+Hf;
	function Sc$2(a){var b=a[If];if(b)return b;for(var c=a.parentNode;c;){if(b=c[pf]||c[If]){c=b.alternate;if(null!==b.child||null!==c&&null!==c.child)for(a=Gf(a);null!==a;){if(c=a[If])return c;a=Gf(a);}return b}a=c;c=a.parentNode;}return null}function zb$2(a){a=a[If]||a[pf];return !a||5!==a.tag&&6!==a.tag&&13!==a.tag&&3!==a.tag?null:a}function pe$4(a){if(5===a.tag||6===a.tag)return a.stateNode;throw Error(p$f(33));}function Ab$3(a){return a[Jf]||null}var Mf=[],Nf=-1;function Of(a){return {current:a}}
	function G$4(a){0>Nf||(a.current=Mf[Nf],Mf[Nf]=null,Nf--);}function H$8(a,b){Nf++;Mf[Nf]=a.current;a.current=b;}var Pf={},I$8=Of(Pf),Qf=Of(!1),Rf=Pf;function Sf(a,b){var c=a.type.contextTypes;if(!c)return Pf;var d=a.stateNode;if(d&&d.__reactInternalMemoizedUnmaskedChildContext===b)return d.__reactInternalMemoizedMaskedChildContext;var e={},f;for(f in c)e[f]=b[f];d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=b,a.__reactInternalMemoizedMaskedChildContext=e);return e}
	function Tf(a){a=a.childContextTypes;return null!==a&&void 0!==a}function Uf(){G$4(Qf);G$4(I$8);}function Vf(a,b,c){if(I$8.current!==Pf)throw Error(p$f(168));H$8(I$8,b);H$8(Qf,c);}function Wf(a,b,c){var d=a.stateNode;b=b.childContextTypes;if("function"!==typeof d.getChildContext)return c;d=d.getChildContext();for(var e in d)if(!(e in b))throw Error(p$f(108,Pa$3(a)||"Unknown",e));return A$7({},c,d)}
	function Xf(a){a=(a=a.stateNode)&&a.__reactInternalMemoizedMergedChildContext||Pf;Rf=I$8.current;H$8(I$8,a);H$8(Qf,Qf.current);return !0}function Yf(a,b,c){var d=a.stateNode;if(!d)throw Error(p$f(169));c?(a=Wf(a,b,Rf),d.__reactInternalMemoizedMergedChildContext=a,G$4(Qf),G$4(I$8),H$8(I$8,a)):G$4(Qf);H$8(Qf,c);}var Zf=null,$f=!1,ag=!1;function bg(a){null===Zf?Zf=[a]:Zf.push(a);}function cg(a){$f=!0;bg(a);}
	function dg(){if(!ag&&null!==Zf){ag=!0;var a=0,b=E$5;try{var c=Zf;for(E$5=1;a<c.length;a++){var d=c[a];do d=d(!0);while(null!==d)}Zf=null;$f=!1;}catch(e){throw null!==Zf&&(Zf=Zf.slice(a+1)),Yb$1(cc$2,dg),e;}finally{E$5=b,ag=!1;}}return null}var eg=sa$3.ReactCurrentBatchConfig;function fg(a,b){if(a&&a.defaultProps){b=A$7({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}var gg=Of(null),hg=null,ig=null,jg=null;function kg(){jg=ig=hg=null;}
	function lg(a){var b=gg.current;G$4(gg);a._currentValue=b;}function mg(a,b,c){for(;null!==a;){var d=a.alternate;(a.childLanes&b)!==b?(a.childLanes|=b,null!==d&&(d.childLanes|=b)):null!==d&&(d.childLanes&b)!==b&&(d.childLanes|=b);if(a===c)break;a=a.return;}}function ng(a,b){hg=a;jg=ig=null;a=a.dependencies;null!==a&&null!==a.firstContext&&(0!==(a.lanes&b)&&(og=!0),a.firstContext=null);}
	function pg(a){var b=a._currentValue;if(jg!==a)if(a={context:a,memoizedValue:b,next:null},null===ig){if(null===hg)throw Error(p$f(308));ig=a;hg.dependencies={lanes:0,firstContext:a};}else ig=ig.next=a;return b}var qg=null,rg=!1;function sg(a){a.updateQueue={baseState:a.memoizedState,firstBaseUpdate:null,lastBaseUpdate:null,shared:{pending:null,interleaved:null,lanes:0},effects:null};}
	function tg(a,b){a=a.updateQueue;b.updateQueue===a&&(b.updateQueue={baseState:a.baseState,firstBaseUpdate:a.firstBaseUpdate,lastBaseUpdate:a.lastBaseUpdate,shared:a.shared,effects:a.effects});}function ug(a,b){return {eventTime:a,lane:b,tag:0,payload:null,callback:null,next:null}}
	function vg(a,b){var c=a.updateQueue;null!==c&&(c=c.shared,null!==J$4&&0!==(a.mode&1)&&0===(K$2&2)?(a=c.interleaved,null===a?(b.next=b,null===qg?qg=[c]:qg.push(c)):(b.next=a.next,a.next=b),c.interleaved=b):(a=c.pending,null===a?b.next=b:(b.next=a.next,a.next=b),c.pending=b));}function wg(a,b,c){b=b.updateQueue;if(null!==b&&(b=b.shared,0!==(c&4194240))){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;yc$2(a,c);}}
	function xg(a,b){var c=a.updateQueue,d=a.alternate;if(null!==d&&(d=d.updateQueue,c===d)){var e=null,f=null;c=c.firstBaseUpdate;if(null!==c){do{var g={eventTime:c.eventTime,lane:c.lane,tag:c.tag,payload:c.payload,callback:c.callback,next:null};null===f?e=f=g:f=f.next=g;c=c.next;}while(null!==c);null===f?e=f=b:f=f.next=b;}else e=f=b;c={baseState:d.baseState,firstBaseUpdate:e,lastBaseUpdate:f,shared:d.shared,effects:d.effects};a.updateQueue=c;return}a=c.lastBaseUpdate;null===a?c.firstBaseUpdate=b:a.next=
	b;c.lastBaseUpdate=b;}
	function yg(a,b,c,d){var e=a.updateQueue;rg=!1;var f=e.firstBaseUpdate,g=e.lastBaseUpdate,h=e.shared.pending;if(null!==h){e.shared.pending=null;var k=h,l=k.next;k.next=null;null===g?f=l:g.next=l;g=k;var m=a.alternate;null!==m&&(m=m.updateQueue,h=m.lastBaseUpdate,h!==g&&(null===h?m.firstBaseUpdate=l:h.next=l,m.lastBaseUpdate=k));}if(null!==f){var w=e.baseState;g=0;m=l=k=null;h=f;do{var u=h.lane,y=h.eventTime;if((d&u)===u){null!==m&&(m=m.next={eventTime:y,lane:0,tag:h.tag,payload:h.payload,callback:h.callback,
	next:null});a:{var n=a,v=h;u=b;y=c;switch(v.tag){case 1:n=v.payload;if("function"===typeof n){w=n.call(y,w,u);break a}w=n;break a;case 3:n.flags=n.flags&-65537|128;case 0:n=v.payload;u="function"===typeof n?n.call(y,w,u):n;if(null===u||void 0===u)break a;w=A$7({},w,u);break a;case 2:rg=!0;}}null!==h.callback&&0!==h.lane&&(a.flags|=64,u=e.effects,null===u?e.effects=[h]:u.push(h));}else y={eventTime:y,lane:u,tag:h.tag,payload:h.payload,callback:h.callback,next:null},null===m?(l=m=y,k=w):m=m.next=y,g|=u;
	h=h.next;if(null===h)if(h=e.shared.pending,null===h)break;else u=h,h=u.next,u.next=null,e.lastBaseUpdate=u,e.shared.pending=null;}while(1);null===m&&(k=w);e.baseState=k;e.firstBaseUpdate=l;e.lastBaseUpdate=m;b=e.shared.interleaved;if(null!==b){e=b;do g|=e.lane,e=e.next;while(e!==b)}else null===f&&(e.shared.lanes=0);zg|=g;a.lanes=g;a.memoizedState=w;}}
	function Ag(a,b,c){a=b.effects;b.effects=null;if(null!==a)for(b=0;b<a.length;b++){var d=a[b],e=d.callback;if(null!==e){d.callback=null;d=c;if("function"!==typeof e)throw Error(p$f(191,e));e.call(d);}}}var Bg=(new aa$3.Component).refs;function Cg(a,b,c,d){b=a.memoizedState;c=c(d,b);c=null===c||void 0===c?b:A$7({},b,c);a.memoizedState=c;0===a.lanes&&(a.updateQueue.baseState=c);}
	var Fg={isMounted:function(a){return (a=a._reactInternals)?Sb$2(a)===a:!1},enqueueSetState:function(a,b,c){a=a._reactInternals;var d=M$b(),e=Dg(a),f=ug(d,e);f.payload=b;void 0!==c&&null!==c&&(f.callback=c);vg(a,f);b=Eg(a,e,d);null!==b&&wg(b,a,e);},enqueueReplaceState:function(a,b,c){a=a._reactInternals;var d=M$b(),e=Dg(a),f=ug(d,e);f.tag=1;f.payload=b;void 0!==c&&null!==c&&(f.callback=c);vg(a,f);b=Eg(a,e,d);null!==b&&wg(b,a,e);},enqueueForceUpdate:function(a,b){a=a._reactInternals;var c=M$b(),d=Dg(a),e=ug(c,
	d);e.tag=2;void 0!==b&&null!==b&&(e.callback=b);vg(a,e);b=Eg(a,d,c);null!==b&&wg(b,a,d);}};function Gg(a,b,c,d,e,f,g){a=a.stateNode;return "function"===typeof a.shouldComponentUpdate?a.shouldComponentUpdate(d,f,g):b.prototype&&b.prototype.isPureReactComponent?!De$4(c,d)||!De$4(e,f):!0}
	function Hg(a,b,c){var d=!1,e=Pf;var f=b.contextType;"object"===typeof f&&null!==f?f=pg(f):(e=Tf(b)?Rf:I$8.current,d=b.contextTypes,f=(d=null!==d&&void 0!==d)?Sf(a,e):Pf);b=new b(c,f);a.memoizedState=null!==b.state&&void 0!==b.state?b.state:null;b.updater=Fg;a.stateNode=b;b._reactInternals=a;d&&(a=a.stateNode,a.__reactInternalMemoizedUnmaskedChildContext=e,a.__reactInternalMemoizedMaskedChildContext=f);return b}
	function Ig(a,b,c,d){a=b.state;"function"===typeof b.componentWillReceiveProps&&b.componentWillReceiveProps(c,d);"function"===typeof b.UNSAFE_componentWillReceiveProps&&b.UNSAFE_componentWillReceiveProps(c,d);b.state!==a&&Fg.enqueueReplaceState(b,b.state,null);}
	function Jg(a,b,c,d){var e=a.stateNode;e.props=c;e.state=a.memoizedState;e.refs=Bg;sg(a);var f=b.contextType;"object"===typeof f&&null!==f?e.context=pg(f):(f=Tf(b)?Rf:I$8.current,e.context=Sf(a,f));e.state=a.memoizedState;f=b.getDerivedStateFromProps;"function"===typeof f&&(Cg(a,b,f,c),e.state=a.memoizedState);"function"===typeof b.getDerivedStateFromProps||"function"===typeof e.getSnapshotBeforeUpdate||"function"!==typeof e.UNSAFE_componentWillMount&&"function"!==typeof e.componentWillMount||(b=e.state,
	"function"===typeof e.componentWillMount&&e.componentWillMount(),"function"===typeof e.UNSAFE_componentWillMount&&e.UNSAFE_componentWillMount(),b!==e.state&&Fg.enqueueReplaceState(e,e.state,null),yg(a,c,e,d),e.state=a.memoizedState);"function"===typeof e.componentDidMount&&(a.flags|=4194308);}var Kg=[],Lg=0,Mg=null,Ng=0,Og=[],Pg=0,Qg=null,Rg=1,Sg="";function Tg(a,b){Kg[Lg++]=Ng;Kg[Lg++]=Mg;Mg=a;Ng=b;}
	function Ug(a,b,c){Og[Pg++]=Rg;Og[Pg++]=Sg;Og[Pg++]=Qg;Qg=a;var d=Rg;a=Sg;var e=32-lc$2(d)-1;d&=~(1<<e);c+=1;var f=32-lc$2(b)+e;if(30<f){var g=e-e%5;f=(d&(1<<g)-1).toString(32);d>>=g;e-=g;Rg=1<<32-lc$2(b)+e|c<<e|d;Sg=f+a;}else Rg=1<<f|c<<e|d,Sg=a;}function Vg(a){null!==a.return&&(Tg(a,1),Ug(a,1,0));}function Wg(a){for(;a===Mg;)Mg=Kg[--Lg],Kg[Lg]=null,Ng=Kg[--Lg],Kg[Lg]=null;for(;a===Qg;)Qg=Og[--Pg],Og[Pg]=null,Sg=Og[--Pg],Og[Pg]=null,Rg=Og[--Pg],Og[Pg]=null;}var Xg=null,Yg=null,N$4=!1,Zg=null;
	function $g(a,b){var c=ah$1(5,null,null,0);c.elementType="DELETED";c.stateNode=b;c.return=a;b=a.deletions;null===b?(a.deletions=[c],a.flags|=16):b.push(c);}
	function bh$1(a,b){switch(a.tag){case 5:var c=a.type;b=1!==b.nodeType||c.toLowerCase()!==b.nodeName.toLowerCase()?null:b;return null!==b?(a.stateNode=b,Xg=a,Yg=Ff(b.firstChild),!0):!1;case 6:return b=""===a.pendingProps||3!==b.nodeType?null:b,null!==b?(a.stateNode=b,Xg=a,Yg=null,!0):!1;case 13:return b=8!==b.nodeType?null:b,null!==b?(c=null!==Qg?{id:Rg,overflow:Sg}:null,a.memoizedState={dehydrated:b,treeContext:c,retryLane:1073741824},c=ah$1(18,null,null,0),c.stateNode=b,c.return=a,a.child=c,Xg=a,Yg=
	null,!0):!1;default:return !1}}function ch$1(a){return 0!==(a.mode&1)&&0===(a.flags&128)}function dh$1(a){if(N$4){var b=Yg;if(b){var c=b;if(!bh$1(a,b)){if(ch$1(a))throw Error(p$f(418));b=Ff(c.nextSibling);var d=Xg;b&&bh$1(a,b)?$g(d,c):(a.flags=a.flags&-4097|2,N$4=!1,Xg=a);}}else {if(ch$1(a))throw Error(p$f(418));a.flags=a.flags&-4097|2;N$4=!1;Xg=a;}}}function eh$1(a){for(a=a.return;null!==a&&5!==a.tag&&3!==a.tag&&13!==a.tag;)a=a.return;Xg=a;}
	function fh$1(a){if(a!==Xg)return !1;if(!N$4)return eh$1(a),N$4=!0,!1;var b;(b=3!==a.tag)&&!(b=5!==a.tag)&&(b=a.type,b="head"!==b&&"body"!==b&&!yf(a.type,a.memoizedProps));if(b&&(b=Yg)){if(ch$1(a)){for(a=Yg;a;)a=Ff(a.nextSibling);throw Error(p$f(418));}for(;b;)$g(a,b),b=Ff(b.nextSibling);}eh$1(a);if(13===a.tag){a=a.memoizedState;a=null!==a?a.dehydrated:null;if(!a)throw Error(p$f(317));a:{a=a.nextSibling;for(b=0;a;){if(8===a.nodeType){var c=a.data;if("/$"===c){if(0===b){Yg=Ff(a.nextSibling);break a}b--;}else "$"!==c&&
	"$!"!==c&&"$?"!==c||b++;}a=a.nextSibling;}Yg=null;}}else Yg=Xg?Ff(a.stateNode.nextSibling):null;return !0}function gh$1(){Yg=Xg=null;N$4=!1;}function hh$1(a){null===Zg?Zg=[a]:Zg.push(a);}
	function ih$1(a,b,c){a=c.ref;if(null!==a&&"function"!==typeof a&&"object"!==typeof a){if(c._owner){c=c._owner;if(c){if(1!==c.tag)throw Error(p$f(309));var d=c.stateNode;}if(!d)throw Error(p$f(147,a));var e=d,f=""+a;if(null!==b&&null!==b.ref&&"function"===typeof b.ref&&b.ref._stringRef===f)return b.ref;b=function(a){var b=e.refs;b===Bg&&(b=e.refs={});null===a?delete b[f]:b[f]=a;};b._stringRef=f;return b}if("string"!==typeof a)throw Error(p$f(284));if(!c._owner)throw Error(p$f(290,a));}return a}
	function jh$1(a,b){a=Object.prototype.toString.call(b);throw Error(p$f(31,"[object Object]"===a?"object with keys {"+Object.keys(b).join(", ")+"}":a));}function kh$1(a){var b=a._init;return b(a._payload)}
	function lh$1(a){function b(b,c){if(a){var d=b.deletions;null===d?(b.deletions=[c],b.flags|=16):d.push(c);}}function c(c,d){if(!a)return null;for(;null!==d;)b(c,d),d=d.sibling;return null}function d(a,b){for(a=new Map;null!==b;)null!==b.key?a.set(b.key,b):a.set(b.index,b),b=b.sibling;return a}function e(a,b){a=mh$1(a,b);a.index=0;a.sibling=null;return a}function f(b,c,d){b.index=d;if(!a)return b.flags|=1048576,c;d=b.alternate;if(null!==d)return d=d.index,d<c?(b.flags|=2,c):d;b.flags|=2;return c}function g(b){a&&
	null===b.alternate&&(b.flags|=2);return b}function h(a,b,c,d){if(null===b||6!==b.tag)return b=nh$1(c,a.mode,d),b.return=a,b;b=e(b,c);b.return=a;return b}function k(a,b,c,d){var f=c.type;if(f===va$3)return m(a,b,c.props.children,d,c.key);if(null!==b&&(b.elementType===f||"object"===typeof f&&null!==f&&f.$$typeof===Fa$3&&kh$1(f)===b.type))return d=e(b,c.props),d.ref=ih$1(a,b,c),d.return=a,d;d=oh$1(c.type,c.key,c.props,null,a.mode,d);d.ref=ih$1(a,b,c);d.return=a;return d}function l(a,b,c,d){if(null===b||4!==b.tag||
	b.stateNode.containerInfo!==c.containerInfo||b.stateNode.implementation!==c.implementation)return b=ph$1(c,a.mode,d),b.return=a,b;b=e(b,c.children||[]);b.return=a;return b}function m(a,b,c,d,f){if(null===b||7!==b.tag)return b=qh$1(c,a.mode,d,f),b.return=a,b;b=e(b,c);b.return=a;return b}function w(a,b,c){if("string"===typeof b&&""!==b||"number"===typeof b)return b=nh$1(""+b,a.mode,c),b.return=a,b;if("object"===typeof b&&null!==b){switch(b.$$typeof){case ta$3:return c=oh$1(b.type,b.key,b.props,null,a.mode,c),
	c.ref=ih$1(a,null,b),c.return=a,c;case ua$3:return b=ph$1(b,a.mode,c),b.return=a,b;case Fa$3:var d=b._init;return w(a,d(b._payload),c)}if(bb$3(b)||Ia$3(b))return b=qh$1(b,a.mode,c,null),b.return=a,b;jh$1(a,b);}return null}function u(a,b,c,d){var e=null!==b?b.key:null;if("string"===typeof c&&""!==c||"number"===typeof c)return null!==e?null:h(a,b,""+c,d);if("object"===typeof c&&null!==c){switch(c.$$typeof){case ta$3:return c.key===e?k(a,b,c,d):null;case ua$3:return c.key===e?l(a,b,c,d):null;case Fa$3:return e=c._init,u(a,
	b,e(c._payload),d)}if(bb$3(c)||Ia$3(c))return null!==e?null:m(a,b,c,d,null);jh$1(a,c);}return null}function y(a,b,c,d,e){if("string"===typeof d&&""!==d||"number"===typeof d)return a=a.get(c)||null,h(b,a,""+d,e);if("object"===typeof d&&null!==d){switch(d.$$typeof){case ta$3:return a=a.get(null===d.key?c:d.key)||null,k(b,a,d,e);case ua$3:return a=a.get(null===d.key?c:d.key)||null,l(b,a,d,e);case Fa$3:var f=d._init;return y(a,b,c,f(d._payload),e)}if(bb$3(d)||Ia$3(d))return a=a.get(c)||null,m(b,a,d,e,null);jh$1(b,d);}return null}
	function n(e,g,h,k){for(var l=null,n=null,m=g,r=g=0,x=null;null!==m&&r<h.length;r++){m.index>r?(x=m,m=null):x=m.sibling;var t=u(e,m,h[r],k);if(null===t){null===m&&(m=x);break}a&&m&&null===t.alternate&&b(e,m);g=f(t,g,r);null===n?l=t:n.sibling=t;n=t;m=x;}if(r===h.length)return c(e,m),N$4&&Tg(e,r),l;if(null===m){for(;r<h.length;r++)m=w(e,h[r],k),null!==m&&(g=f(m,g,r),null===n?l=m:n.sibling=m,n=m);N$4&&Tg(e,r);return l}for(m=d(e,m);r<h.length;r++)x=y(m,e,r,h[r],k),null!==x&&(a&&null!==x.alternate&&m.delete(null===
	x.key?r:x.key),g=f(x,g,r),null===n?l=x:n.sibling=x,n=x);a&&m.forEach(function(a){return b(e,a)});N$4&&Tg(e,r);return l}function v(e,g,h,k){var l=Ia$3(h);if("function"!==typeof l)throw Error(p$f(150));h=l.call(h);if(null==h)throw Error(p$f(151));for(var m=l=null,n=g,r=g=0,x=null,t=h.next();null!==n&&!t.done;r++,t=h.next()){n.index>r?(x=n,n=null):x=n.sibling;var v=u(e,n,t.value,k);if(null===v){null===n&&(n=x);break}a&&n&&null===v.alternate&&b(e,n);g=f(v,g,r);null===m?l=v:m.sibling=v;m=v;n=x;}if(t.done)return c(e,
	n),N$4&&Tg(e,r),l;if(null===n){for(;!t.done;r++,t=h.next())t=w(e,t.value,k),null!==t&&(g=f(t,g,r),null===m?l=t:m.sibling=t,m=t);N$4&&Tg(e,r);return l}for(n=d(e,n);!t.done;r++,t=h.next())t=y(n,e,r,t.value,k),null!==t&&(a&&null!==t.alternate&&n.delete(null===t.key?r:t.key),g=f(t,g,r),null===m?l=t:m.sibling=t,m=t);a&&n.forEach(function(a){return b(e,a)});N$4&&Tg(e,r);return l}function C(a,d,f,h){"object"===typeof f&&null!==f&&f.type===va$3&&null===f.key&&(f=f.props.children);if("object"===typeof f&&null!==f){switch(f.$$typeof){case ta$3:a:{for(var k=
	f.key,l=d;null!==l;){if(l.key===k){k=f.type;if(k===va$3){if(7===l.tag){c(a,l.sibling);d=e(l,f.props.children);d.return=a;a=d;break a}}else if(l.elementType===k||"object"===typeof k&&null!==k&&k.$$typeof===Fa$3&&kh$1(k)===l.type){c(a,l.sibling);d=e(l,f.props);d.ref=ih$1(a,l,f);d.return=a;a=d;break a}c(a,l);break}else b(a,l);l=l.sibling;}f.type===va$3?(d=qh$1(f.props.children,a.mode,h,f.key),d.return=a,a=d):(h=oh$1(f.type,f.key,f.props,null,a.mode,h),h.ref=ih$1(a,d,f),h.return=a,a=h);}return g(a);case ua$3:a:{for(l=f.key;null!==
	d;){if(d.key===l)if(4===d.tag&&d.stateNode.containerInfo===f.containerInfo&&d.stateNode.implementation===f.implementation){c(a,d.sibling);d=e(d,f.children||[]);d.return=a;a=d;break a}else {c(a,d);break}else b(a,d);d=d.sibling;}d=ph$1(f,a.mode,h);d.return=a;a=d;}return g(a);case Fa$3:return l=f._init,C(a,d,l(f._payload),h)}if(bb$3(f))return n(a,d,f,h);if(Ia$3(f))return v(a,d,f,h);jh$1(a,f);}return "string"===typeof f&&""!==f||"number"===typeof f?(f=""+f,null!==d&&6===d.tag?(c(a,d.sibling),d=e(d,f),d.return=a,a=d):
	(c(a,d),d=nh$1(f,a.mode,h),d.return=a,a=d),g(a)):c(a,d)}return C}var rh$1=lh$1(!0),sh$1=lh$1(!1),th$1={},uh$1=Of(th$1),vh$1=Of(th$1),wh$1=Of(th$1);function xh$1(a){if(a===th$1)throw Error(p$f(174));return a}function yh$1(a,b){H$8(wh$1,b);H$8(vh$1,a);H$8(uh$1,th$1);a=b.nodeType;switch(a){case 9:case 11:b=(b=b.documentElement)?b.namespaceURI:ib$2(null,"");break;default:a=8===a?b.parentNode:b,b=a.namespaceURI||null,a=a.tagName,b=ib$2(b,a);}G$4(uh$1);H$8(uh$1,b);}function zh$1(){G$4(uh$1);G$4(vh$1);G$4(wh$1);}
	function Ah$1(a){xh$1(wh$1.current);var b=xh$1(uh$1.current);var c=ib$2(b,a.type);b!==c&&(H$8(vh$1,a),H$8(uh$1,c));}function Bh$1(a){vh$1.current===a&&(G$4(uh$1),G$4(vh$1));}var P$6=Of(0);
	function Ch$1(a){for(var b=a;null!==b;){if(13===b.tag){var c=b.memoizedState;if(null!==c&&(c=c.dehydrated,null===c||"$?"===c.data||"$!"===c.data))return b}else if(19===b.tag&&void 0!==b.memoizedProps.revealOrder){if(0!==(b.flags&128))return b}else if(null!==b.child){b.child.return=b;b=b.child;continue}if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return null;b=b.return;}b.sibling.return=b.return;b=b.sibling;}return null}var Dh$1=[];
	function Eh$1(){for(var a=0;a<Dh$1.length;a++)Dh$1[a]._workInProgressVersionPrimary=null;Dh$1.length=0;}var Fh$1=sa$3.ReactCurrentDispatcher,Gh=sa$3.ReactCurrentBatchConfig,Hh$1=0,Q$6=null,R$5=null,S$c=null,Ih$1=!1,Jh=!1,Kh=0,Lh$1=0;function U$6(){throw Error(p$f(321));}function Mh$1(a,b){if(null===b)return !1;for(var c=0;c<b.length&&c<a.length;c++)if(!Ce$2(a[c],b[c]))return !1;return !0}
	function Nh$1(a,b,c,d,e,f){Hh$1=f;Q$6=b;b.memoizedState=null;b.updateQueue=null;b.lanes=0;Fh$1.current=null===a||null===a.memoizedState?Oh$1:Ph$1;a=c(d,e);if(Jh){f=0;do{Jh=!1;Kh=0;if(25<=f)throw Error(p$f(301));f+=1;S$c=R$5=null;b.updateQueue=null;Fh$1.current=Qh;a=c(d,e);}while(Jh)}Fh$1.current=Rh$1;b=null!==R$5&&null!==R$5.next;Hh$1=0;S$c=R$5=Q$6=null;Ih$1=!1;if(b)throw Error(p$f(300));return a}function Sh$1(){var a=0!==Kh;Kh=0;return a}
	function Th$1(){var a={memoizedState:null,baseState:null,baseQueue:null,queue:null,next:null};null===S$c?Q$6.memoizedState=S$c=a:S$c=S$c.next=a;return S$c}function Uh$1(){if(null===R$5){var a=Q$6.alternate;a=null!==a?a.memoizedState:null;}else a=R$5.next;var b=null===S$c?Q$6.memoizedState:S$c.next;if(null!==b)S$c=b,R$5=a;else {if(null===a)throw Error(p$f(310));R$5=a;a={memoizedState:R$5.memoizedState,baseState:R$5.baseState,baseQueue:R$5.baseQueue,queue:R$5.queue,next:null};null===S$c?Q$6.memoizedState=S$c=a:S$c=S$c.next=a;}return S$c}
	function Vh(a,b){return "function"===typeof b?b(a):b}
	function Wh$1(a){var b=Uh$1(),c=b.queue;if(null===c)throw Error(p$f(311));c.lastRenderedReducer=a;var d=R$5,e=d.baseQueue,f=c.pending;if(null!==f){if(null!==e){var g=e.next;e.next=f.next;f.next=g;}d.baseQueue=e=f;c.pending=null;}if(null!==e){f=e.next;d=d.baseState;var h=g=null,k=null,l=f;do{var m=l.lane;if((Hh$1&m)===m)null!==k&&(k=k.next={lane:0,action:l.action,hasEagerState:l.hasEagerState,eagerState:l.eagerState,next:null}),d=l.hasEagerState?l.eagerState:a(d,l.action);else {var w={lane:m,action:l.action,hasEagerState:l.hasEagerState,
	eagerState:l.eagerState,next:null};null===k?(h=k=w,g=d):k=k.next=w;Q$6.lanes|=m;zg|=m;}l=l.next;}while(null!==l&&l!==f);null===k?g=d:k.next=h;Ce$2(d,b.memoizedState)||(og=!0);b.memoizedState=d;b.baseState=g;b.baseQueue=k;c.lastRenderedState=d;}a=c.interleaved;if(null!==a){e=a;do f=e.lane,Q$6.lanes|=f,zg|=f,e=e.next;while(e!==a)}else null===e&&(c.lanes=0);return [b.memoizedState,c.dispatch]}
	function Xh(a){var b=Uh$1(),c=b.queue;if(null===c)throw Error(p$f(311));c.lastRenderedReducer=a;var d=c.dispatch,e=c.pending,f=b.memoizedState;if(null!==e){c.pending=null;var g=e=e.next;do f=a(f,g.action),g=g.next;while(g!==e);Ce$2(f,b.memoizedState)||(og=!0);b.memoizedState=f;null===b.baseQueue&&(b.baseState=f);c.lastRenderedState=f;}return [f,d]}function Yh$1(){}
	function Zh(a,b){var c=Q$6,d=Uh$1(),e=b(),f=!Ce$2(d.memoizedState,e);f&&(d.memoizedState=e,og=!0);d=d.queue;$h(ai.bind(null,c,d,a),[a]);if(d.getSnapshot!==b||f||null!==S$c&&S$c.memoizedState.tag&1){c.flags|=2048;bi$1(9,ci.bind(null,c,d,e,b),void 0,null);if(null===J$4)throw Error(p$f(349));0!==(Hh$1&30)||di(c,b,e);}return e}function di(a,b,c){a.flags|=16384;a={getSnapshot:b,value:c};b=Q$6.updateQueue;null===b?(b={lastEffect:null,stores:null},Q$6.updateQueue=b,b.stores=[a]):(c=b.stores,null===c?b.stores=[a]:c.push(a));}
	function ci(a,b,c,d){b.value=c;b.getSnapshot=d;ei(b)&&Eg(a,1,-1);}function ai(a,b,c){return c(function(){ei(b)&&Eg(a,1,-1);})}function ei(a){var b=a.getSnapshot;a=a.value;try{var c=b();return !Ce$2(a,c)}catch(d){return !0}}function fi$1(a){var b=Th$1();"function"===typeof a&&(a=a());b.memoizedState=b.baseState=a;a={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:Vh,lastRenderedState:a};b.queue=a;a=a.dispatch=gi$1.bind(null,Q$6,a);return [b.memoizedState,a]}
	function bi$1(a,b,c,d){a={tag:a,create:b,destroy:c,deps:d,next:null};b=Q$6.updateQueue;null===b?(b={lastEffect:null,stores:null},Q$6.updateQueue=b,b.lastEffect=a.next=a):(c=b.lastEffect,null===c?b.lastEffect=a.next=a:(d=c.next,c.next=a,a.next=d,b.lastEffect=a));return a}function hi(){return Uh$1().memoizedState}function ii(a,b,c,d){var e=Th$1();Q$6.flags|=a;e.memoizedState=bi$1(1|b,c,void 0,void 0===d?null:d);}
	function ji$1(a,b,c,d){var e=Uh$1();d=void 0===d?null:d;var f=void 0;if(null!==R$5){var g=R$5.memoizedState;f=g.destroy;if(null!==d&&Mh$1(d,g.deps)){e.memoizedState=bi$1(b,c,f,d);return}}Q$6.flags|=a;e.memoizedState=bi$1(1|b,c,f,d);}function ki$1(a,b){return ii(8390656,8,a,b)}function $h(a,b){return ji$1(2048,8,a,b)}function li$1(a,b){return ji$1(4,2,a,b)}function mi(a,b){return ji$1(4,4,a,b)}
	function ni(a,b){if("function"===typeof b)return a=a(),b(a),function(){b(null);};if(null!==b&&void 0!==b)return a=a(),b.current=a,function(){b.current=null;}}function oi$1(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;return ji$1(4,4,ni.bind(null,b,a),c)}function pi$1(){}function qi$1(a,b){var c=Uh$1();b=void 0===b?null:b;var d=c.memoizedState;if(null!==d&&null!==b&&Mh$1(b,d[1]))return d[0];c.memoizedState=[a,b];return a}
	function ri(a,b){var c=Uh$1();b=void 0===b?null:b;var d=c.memoizedState;if(null!==d&&null!==b&&Mh$1(b,d[1]))return d[0];a=a();c.memoizedState=[a,b];return a}function si(a,b){var c=E$5;E$5=0!==c&&4>c?c:4;a(!0);var d=Gh.transition;Gh.transition={};try{a(!1),b();}finally{E$5=c,Gh.transition=d;}}function ti(){return Uh$1().memoizedState}function ui(a,b,c){var d=Dg(a);c={lane:d,action:c,hasEagerState:!1,eagerState:null,next:null};vi$1(a)?wi$1(b,c):(xi$1(a,b,c),c=M$b(),a=Eg(a,d,c),null!==a&&yi$1(a,b,d));}
	function gi$1(a,b,c){var d=Dg(a),e={lane:d,action:c,hasEagerState:!1,eagerState:null,next:null};if(vi$1(a))wi$1(b,e);else {xi$1(a,b,e);var f=a.alternate;if(0===a.lanes&&(null===f||0===f.lanes)&&(f=b.lastRenderedReducer,null!==f))try{var g=b.lastRenderedState,h=f(g,c);e.hasEagerState=!0;e.eagerState=h;if(Ce$2(h,g))return}catch(k){}finally{}c=M$b();a=Eg(a,d,c);null!==a&&yi$1(a,b,d);}}function vi$1(a){var b=a.alternate;return a===Q$6||null!==b&&b===Q$6}
	function wi$1(a,b){Jh=Ih$1=!0;var c=a.pending;null===c?b.next=b:(b.next=c.next,c.next=b);a.pending=b;}function xi$1(a,b,c){null!==J$4&&0!==(a.mode&1)&&0===(K$2&2)?(a=b.interleaved,null===a?(c.next=c,null===qg?qg=[b]:qg.push(b)):(c.next=a.next,a.next=c),b.interleaved=c):(a=b.pending,null===a?c.next=c:(c.next=a.next,a.next=c),b.pending=c);}function yi$1(a,b,c){if(0!==(c&4194240)){var d=b.lanes;d&=a.pendingLanes;c|=d;b.lanes=c;yc$2(a,c);}}
	var Rh$1={readContext:pg,useCallback:U$6,useContext:U$6,useEffect:U$6,useImperativeHandle:U$6,useInsertionEffect:U$6,useLayoutEffect:U$6,useMemo:U$6,useReducer:U$6,useRef:U$6,useState:U$6,useDebugValue:U$6,useDeferredValue:U$6,useTransition:U$6,useMutableSource:U$6,useSyncExternalStore:U$6,useId:U$6,unstable_isNewReconciler:!1},Oh$1={readContext:pg,useCallback:function(a,b){Th$1().memoizedState=[a,void 0===b?null:b];return a},useContext:pg,useEffect:ki$1,useImperativeHandle:function(a,b,c){c=null!==c&&void 0!==c?c.concat([a]):null;return ii(4194308,
	4,ni.bind(null,b,a),c)},useLayoutEffect:function(a,b){return ii(4194308,4,a,b)},useInsertionEffect:function(a,b){return ii(4,2,a,b)},useMemo:function(a,b){var c=Th$1();b=void 0===b?null:b;a=a();c.memoizedState=[a,b];return a},useReducer:function(a,b,c){var d=Th$1();b=void 0!==c?c(b):b;d.memoizedState=d.baseState=b;a={pending:null,interleaved:null,lanes:0,dispatch:null,lastRenderedReducer:a,lastRenderedState:b};d.queue=a;a=a.dispatch=ui.bind(null,Q$6,a);return [d.memoizedState,a]},useRef:function(a){var b=
	Th$1();a={current:a};return b.memoizedState=a},useState:fi$1,useDebugValue:pi$1,useDeferredValue:function(a){var b=fi$1(a),c=b[0],d=b[1];ki$1(function(){var b=Gh.transition;Gh.transition={};try{d(a);}finally{Gh.transition=b;}},[a]);return c},useTransition:function(){var a=fi$1(!1),b=a[0];a=si.bind(null,a[1]);Th$1().memoizedState=a;return [b,a]},useMutableSource:function(){},useSyncExternalStore:function(a,b,c){var d=Q$6,e=Th$1();if(N$4){if(void 0===c)throw Error(p$f(407));c=c();}else {c=b();if(null===J$4)throw Error(p$f(349));
	0!==(Hh$1&30)||di(d,b,c);}e.memoizedState=c;var f={value:c,getSnapshot:b};e.queue=f;ki$1(ai.bind(null,d,f,a),[a]);d.flags|=2048;bi$1(9,ci.bind(null,d,f,c,b),void 0,null);return c},useId:function(){var a=Th$1(),b=J$4.identifierPrefix;if(N$4){var c=Sg;var d=Rg;c=(d&~(1<<32-lc$2(d)-1)).toString(32)+c;b=":"+b+"R"+c;c=Kh++;0<c&&(b+="H"+c.toString(32));b+=":";}else c=Lh$1++,b=":"+b+"r"+c.toString(32)+":";return a.memoizedState=b},unstable_isNewReconciler:!1},Ph$1={readContext:pg,useCallback:qi$1,useContext:pg,useEffect:$h,useImperativeHandle:oi$1,
	useInsertionEffect:li$1,useLayoutEffect:mi,useMemo:ri,useReducer:Wh$1,useRef:hi,useState:function(){return Wh$1(Vh)},useDebugValue:pi$1,useDeferredValue:function(a){var b=Wh$1(Vh),c=b[0],d=b[1];$h(function(){var b=Gh.transition;Gh.transition={};try{d(a);}finally{Gh.transition=b;}},[a]);return c},useTransition:function(){var a=Wh$1(Vh)[0],b=Uh$1().memoizedState;return [a,b]},useMutableSource:Yh$1,useSyncExternalStore:Zh,useId:ti,unstable_isNewReconciler:!1},Qh={readContext:pg,useCallback:qi$1,useContext:pg,useEffect:$h,
	useImperativeHandle:oi$1,useInsertionEffect:li$1,useLayoutEffect:mi,useMemo:ri,useReducer:Xh,useRef:hi,useState:function(){return Xh(Vh)},useDebugValue:pi$1,useDeferredValue:function(a){var b=Xh(Vh),c=b[0],d=b[1];$h(function(){var b=Gh.transition;Gh.transition={};try{d(a);}finally{Gh.transition=b;}},[a]);return c},useTransition:function(){var a=Xh(Vh)[0],b=Uh$1().memoizedState;return [a,b]},useMutableSource:Yh$1,useSyncExternalStore:Zh,useId:ti,unstable_isNewReconciler:!1};
	function zi$1(a,b){try{var c="",d=b;do c+=Na$3(d),d=d.return;while(d);var e=c;}catch(f){e="\nError generating stack: "+f.message+"\n"+f.stack;}return {value:a,source:b,stack:e}}function Ai$1(a,b){try{console.error(b.value);}catch(c){setTimeout(function(){throw c;});}}var Bi$1="function"===typeof WeakMap?WeakMap:Map;function Ci$1(a,b,c){c=ug(-1,c);c.tag=3;c.payload={element:null};var d=b.value;c.callback=function(){Di$1||(Di$1=!0,Ei$1=d);Ai$1(a,b);};return c}
	function Fi$1(a,b,c){c=ug(-1,c);c.tag=3;var d=a.type.getDerivedStateFromError;if("function"===typeof d){var e=b.value;c.payload=function(){return d(e)};c.callback=function(){Ai$1(a,b);};}var f=a.stateNode;null!==f&&"function"===typeof f.componentDidCatch&&(c.callback=function(){Ai$1(a,b);"function"!==typeof d&&(null===Gi$1?Gi$1=new Set([this]):Gi$1.add(this));var c=b.stack;this.componentDidCatch(b.value,{componentStack:null!==c?c:""});});return c}
	function Hi$1(a,b,c){var d=a.pingCache;if(null===d){d=a.pingCache=new Bi$1;var e=new Set;d.set(b,e);}else e=d.get(b),void 0===e&&(e=new Set,d.set(b,e));e.has(c)||(e.add(c),a=Ii$1.bind(null,a,b,c),b.then(a,a));}function Ji$1(a){do{var b;if(b=13===a.tag)b=a.memoizedState,b=null!==b?null!==b.dehydrated?!0:!1:!0;if(b)return a;a=a.return;}while(null!==a);return null}
	function Ki$1(a,b,c,d,e){if(0===(a.mode&1))return a===b?a.flags|=65536:(a.flags|=128,c.flags|=131072,c.flags&=-52805,1===c.tag&&(null===c.alternate?c.tag=17:(b=ug(-1,1),b.tag=2,vg(c,b))),c.lanes|=1),a;a.flags|=65536;a.lanes=e;return a}var Li$1,Mi$1,Ni$1,Oi$1;
	Li$1=function(a,b){for(var c=b.child;null!==c;){if(5===c.tag||6===c.tag)a.appendChild(c.stateNode);else if(4!==c.tag&&null!==c.child){c.child.return=c;c=c.child;continue}if(c===b)break;for(;null===c.sibling;){if(null===c.return||c.return===b)return;c=c.return;}c.sibling.return=c.return;c=c.sibling;}};Mi$1=function(){};
	Ni$1=function(a,b,c,d){var e=a.memoizedProps;if(e!==d){a=b.stateNode;xh$1(uh$1.current);var f=null;switch(c){case "input":e=Wa$3(a,e);d=Wa$3(a,d);f=[];break;case "select":e=A$7({},e,{value:void 0});d=A$7({},d,{value:void 0});f=[];break;case "textarea":e=db$3(a,e);d=db$3(a,d);f=[];break;default:"function"!==typeof e.onClick&&"function"===typeof d.onClick&&(a.onclick=wf);}rb$2(c,d);var g;c=null;for(l in e)if(!d.hasOwnProperty(l)&&e.hasOwnProperty(l)&&null!=e[l])if("style"===l){var h=e[l];for(g in h)h.hasOwnProperty(g)&&
	(c||(c={}),c[g]="");}else "dangerouslySetInnerHTML"!==l&&"children"!==l&&"suppressContentEditableWarning"!==l&&"suppressHydrationWarning"!==l&&"autoFocus"!==l&&(da$3.hasOwnProperty(l)?f||(f=[]):(f=f||[]).push(l,null));for(l in d){var k=d[l];h=null!=e?e[l]:void 0;if(d.hasOwnProperty(l)&&k!==h&&(null!=k||null!=h))if("style"===l)if(h){for(g in h)!h.hasOwnProperty(g)||k&&k.hasOwnProperty(g)||(c||(c={}),c[g]="");for(g in k)k.hasOwnProperty(g)&&h[g]!==k[g]&&(c||(c={}),c[g]=k[g]);}else c||(f||(f=[]),f.push(l,
	c)),c=k;else "dangerouslySetInnerHTML"===l?(k=k?k.__html:void 0,h=h?h.__html:void 0,null!=k&&h!==k&&(f=f||[]).push(l,k)):"children"===l?"string"!==typeof k&&"number"!==typeof k||(f=f||[]).push(l,""+k):"suppressContentEditableWarning"!==l&&"suppressHydrationWarning"!==l&&(da$3.hasOwnProperty(l)?(null!=k&&"onScroll"===l&&F$9("scroll",a),f||h===k||(f=[])):(f=f||[]).push(l,k));}c&&(f=f||[]).push("style",c);var l=f;if(b.updateQueue=l)b.flags|=4;}};Oi$1=function(a,b,c,d){c!==d&&(b.flags|=4);};
	function Pi$1(a,b){if(!N$4)switch(a.tailMode){case "hidden":b=a.tail;for(var c=null;null!==b;)null!==b.alternate&&(c=b),b=b.sibling;null===c?a.tail=null:c.sibling=null;break;case "collapsed":c=a.tail;for(var d=null;null!==c;)null!==c.alternate&&(d=c),c=c.sibling;null===d?b||null===a.tail?a.tail=null:a.tail.sibling=null:d.sibling=null;}}
	function V$6(a){var b=null!==a.alternate&&a.alternate.child===a.child,c=0,d=0;if(b)for(var e=a.child;null!==e;)c|=e.lanes|e.childLanes,d|=e.subtreeFlags&14680064,d|=e.flags&14680064,e.return=a,e=e.sibling;else for(e=a.child;null!==e;)c|=e.lanes|e.childLanes,d|=e.subtreeFlags,d|=e.flags,e.return=a,e=e.sibling;a.subtreeFlags|=d;a.childLanes=c;return b}
	function Qi$1(a,b,c){var d=b.pendingProps;Wg(b);switch(b.tag){case 2:case 16:case 15:case 0:case 11:case 7:case 8:case 12:case 9:case 14:return V$6(b),null;case 1:return Tf(b.type)&&Uf(),V$6(b),null;case 3:d=b.stateNode;zh$1();G$4(Qf);G$4(I$8);Eh$1();d.pendingContext&&(d.context=d.pendingContext,d.pendingContext=null);if(null===a||null===a.child)fh$1(b)?b.flags|=4:null===a||a.memoizedState.isDehydrated&&0===(b.flags&256)||(b.flags|=1024,null!==Zg&&(Ri$1(Zg),Zg=null));Mi$1(a,b);V$6(b);return null;case 5:Bh$1(b);var e=xh$1(wh$1.current);
	c=b.type;if(null!==a&&null!=b.stateNode)Ni$1(a,b,c,d,e),a.ref!==b.ref&&(b.flags|=512,b.flags|=2097152);else {if(!d){if(null===b.stateNode)throw Error(p$f(166));V$6(b);return null}a=xh$1(uh$1.current);if(fh$1(b)){d=b.stateNode;c=b.type;var f=b.memoizedProps;d[If]=b;d[Jf]=f;a=0!==(b.mode&1);switch(c){case "dialog":F$9("cancel",d);F$9("close",d);break;case "iframe":case "object":case "embed":F$9("load",d);break;case "video":case "audio":for(e=0;e<ff.length;e++)F$9(ff[e],d);break;case "source":F$9("error",d);break;case "img":case "image":case "link":F$9("error",
	d);F$9("load",d);break;case "details":F$9("toggle",d);break;case "input":Xa$3(d,f);F$9("invalid",d);break;case "select":d._wrapperState={wasMultiple:!!f.multiple};F$9("invalid",d);break;case "textarea":eb$2(d,f),F$9("invalid",d);}rb$2(c,f);e=null;for(var g in f)if(f.hasOwnProperty(g)){var h=f[g];"children"===g?"string"===typeof h?d.textContent!==h&&(vf(d.textContent,h,a),e=["children",h]):"number"===typeof h&&d.textContent!==""+h&&(vf(d.textContent,h,a),e=["children",""+h]):da$3.hasOwnProperty(g)&&null!=h&&"onScroll"===
	g&&F$9("scroll",d);}switch(c){case "input":Ta$3(d);ab$2(d,f,!0);break;case "textarea":Ta$3(d);gb$3(d);break;case "select":case "option":break;default:"function"===typeof f.onClick&&(d.onclick=wf);}d=e;b.updateQueue=d;null!==d&&(b.flags|=4);}else {g=9===e.nodeType?e:e.ownerDocument;"http://www.w3.org/1999/xhtml"===a&&(a=hb$2(c));"http://www.w3.org/1999/xhtml"===a?"script"===c?(a=g.createElement("div"),a.innerHTML="<script>\x3c/script>",a=a.removeChild(a.firstChild)):"string"===typeof d.is?a=g.createElement(c,{is:d.is}):
	(a=g.createElement(c),"select"===c&&(g=a,d.multiple?g.multiple=!0:d.size&&(g.size=d.size))):a=g.createElementNS(a,c);a[If]=b;a[Jf]=d;Li$1(a,b,!1,!1);b.stateNode=a;a:{g=sb$2(c,d);switch(c){case "dialog":F$9("cancel",a);F$9("close",a);e=d;break;case "iframe":case "object":case "embed":F$9("load",a);e=d;break;case "video":case "audio":for(e=0;e<ff.length;e++)F$9(ff[e],a);e=d;break;case "source":F$9("error",a);e=d;break;case "img":case "image":case "link":F$9("error",a);F$9("load",a);e=d;break;case "details":F$9("toggle",
	a);e=d;break;case "input":Xa$3(a,d);e=Wa$3(a,d);F$9("invalid",a);break;case "option":e=d;break;case "select":a._wrapperState={wasMultiple:!!d.multiple};e=A$7({},d,{value:void 0});F$9("invalid",a);break;case "textarea":eb$2(a,d);e=db$3(a,d);F$9("invalid",a);break;default:e=d;}rb$2(c,e);h=e;for(f in h)if(h.hasOwnProperty(f)){var k=h[f];"style"===f?pb$2(a,k):"dangerouslySetInnerHTML"===f?(k=k?k.__html:void 0,null!=k&&kb$3(a,k)):"children"===f?"string"===typeof k?("textarea"!==c||""!==k)&&lb$2(a,k):"number"===typeof k&&lb$2(a,
	""+k):"suppressContentEditableWarning"!==f&&"suppressHydrationWarning"!==f&&"autoFocus"!==f&&(da$3.hasOwnProperty(f)?null!=k&&"onScroll"===f&&F$9("scroll",a):null!=k&&ra$3(a,f,k,g));}switch(c){case "input":Ta$3(a);ab$2(a,d,!1);break;case "textarea":Ta$3(a);gb$3(a);break;case "option":null!=d.value&&a.setAttribute("value",""+Qa$3(d.value));break;case "select":a.multiple=!!d.multiple;f=d.value;null!=f?cb$2(a,!!d.multiple,f,!1):null!=d.defaultValue&&cb$2(a,!!d.multiple,d.defaultValue,!0);break;default:"function"===typeof e.onClick&&
	(a.onclick=wf);}switch(c){case "button":case "input":case "select":case "textarea":d=!!d.autoFocus;break a;case "img":d=!0;break a;default:d=!1;}}d&&(b.flags|=4);}null!==b.ref&&(b.flags|=512,b.flags|=2097152);}V$6(b);return null;case 6:if(a&&null!=b.stateNode)Oi$1(a,b,a.memoizedProps,d);else {if("string"!==typeof d&&null===b.stateNode)throw Error(p$f(166));c=xh$1(wh$1.current);xh$1(uh$1.current);if(fh$1(b)){d=b.stateNode;c=b.memoizedProps;d[If]=b;if(f=d.nodeValue!==c)if(a=Xg,null!==a)switch(g=0!==(a.mode&1),a.tag){case 3:vf(d.nodeValue,
	c,g);break;case 5:!0!==a.memoizedProps[void 0]&&vf(d.nodeValue,c,g);}f&&(b.flags|=4);}else d=(9===c.nodeType?c:c.ownerDocument).createTextNode(d),d[If]=b,b.stateNode=d;}V$6(b);return null;case 13:G$4(P$6);d=b.memoizedState;if(N$4&&null!==Yg&&0!==(b.mode&1)&&0===(b.flags&128)){for(d=Yg;d;)d=Ff(d.nextSibling);gh$1();b.flags|=98560;return b}if(null!==d&&null!==d.dehydrated){d=fh$1(b);if(null===a){if(!d)throw Error(p$f(318));d=b.memoizedState;d=null!==d?d.dehydrated:null;if(!d)throw Error(p$f(317));d[If]=b;}else gh$1(),0===
	(b.flags&128)&&(b.memoizedState=null),b.flags|=4;V$6(b);return null}null!==Zg&&(Ri$1(Zg),Zg=null);if(0!==(b.flags&128))return b.lanes=c,b;d=null!==d;c=!1;null===a?fh$1(b):c=null!==a.memoizedState;d&&!c&&(b.child.flags|=8192,0!==(b.mode&1)&&(null===a||0!==(P$6.current&1)?0===W$5&&(W$5=3):Si$1()));null!==b.updateQueue&&(b.flags|=4);V$6(b);return null;case 4:return zh$1(),Mi$1(a,b),null===a&&nf(b.stateNode.containerInfo),V$6(b),null;case 10:return lg(b.type._context),V$6(b),null;case 17:return Tf(b.type)&&Uf(),V$6(b),null;case 19:G$4(P$6);
	f=b.memoizedState;if(null===f)return V$6(b),null;d=0!==(b.flags&128);g=f.rendering;if(null===g)if(d)Pi$1(f,!1);else {if(0!==W$5||null!==a&&0!==(a.flags&128))for(a=b.child;null!==a;){g=Ch$1(a);if(null!==g){b.flags|=128;Pi$1(f,!1);d=g.updateQueue;null!==d&&(b.updateQueue=d,b.flags|=4);b.subtreeFlags=0;d=c;for(c=b.child;null!==c;)f=c,a=d,f.flags&=14680066,g=f.alternate,null===g?(f.childLanes=0,f.lanes=a,f.child=null,f.subtreeFlags=0,f.memoizedProps=null,f.memoizedState=null,f.updateQueue=null,f.dependencies=null,
	f.stateNode=null):(f.childLanes=g.childLanes,f.lanes=g.lanes,f.child=g.child,f.subtreeFlags=0,f.deletions=null,f.memoizedProps=g.memoizedProps,f.memoizedState=g.memoizedState,f.updateQueue=g.updateQueue,f.type=g.type,a=g.dependencies,f.dependencies=null===a?null:{lanes:a.lanes,firstContext:a.firstContext}),c=c.sibling;H$8(P$6,P$6.current&1|2);return b.child}a=a.sibling;}null!==f.tail&&D$8()>Ti$1&&(b.flags|=128,d=!0,Pi$1(f,!1),b.lanes=4194304);}else {if(!d)if(a=Ch$1(g),null!==a){if(b.flags|=128,d=!0,c=a.updateQueue,
	null!==c&&(b.updateQueue=c,b.flags|=4),Pi$1(f,!0),null===f.tail&&"hidden"===f.tailMode&&!g.alternate&&!N$4)return V$6(b),null}else 2*D$8()-f.renderingStartTime>Ti$1&&1073741824!==c&&(b.flags|=128,d=!0,Pi$1(f,!1),b.lanes=4194304);f.isBackwards?(g.sibling=b.child,b.child=g):(c=f.last,null!==c?c.sibling=g:b.child=g,f.last=g);}if(null!==f.tail)return b=f.tail,f.rendering=b,f.tail=b.sibling,f.renderingStartTime=D$8(),b.sibling=null,c=P$6.current,H$8(P$6,d?c&1|2:c&1),b;V$6(b);return null;case 22:case 23:return Ui$1(),d=null!==
	b.memoizedState,null!==a&&null!==a.memoizedState!==d&&(b.flags|=8192),d&&0!==(b.mode&1)?0!==(Vi$1&1073741824)&&(V$6(b),b.subtreeFlags&6&&(b.flags|=8192)):V$6(b),null;case 24:return null;case 25:return null}throw Error(p$f(156,b.tag));}var Wi$1=sa$3.ReactCurrentOwner,og=!1;function Xi$1(a,b,c,d){b.child=null===a?sh$1(b,null,c,d):rh$1(b,a.child,c,d);}
	function Yi$1(a,b,c,d,e){c=c.render;var f=b.ref;ng(b,e);d=Nh$1(a,b,c,d,f,e);c=Sh$1();if(null!==a&&!og)return b.updateQueue=a.updateQueue,b.flags&=-2053,a.lanes&=~e,Zi$1(a,b,e);N$4&&c&&Vg(b);b.flags|=1;Xi$1(a,b,d,e);return b.child}
	function $i$1(a,b,c,d,e){if(null===a){var f=c.type;if("function"===typeof f&&!aj(f)&&void 0===f.defaultProps&&null===c.compare&&void 0===c.defaultProps)return b.tag=15,b.type=f,bj(a,b,f,d,e);a=oh$1(c.type,null,d,b,b.mode,e);a.ref=b.ref;a.return=b;return b.child=a}f=a.child;if(0===(a.lanes&e)){var g=f.memoizedProps;c=c.compare;c=null!==c?c:De$4;if(c(g,d)&&a.ref===b.ref)return Zi$1(a,b,e)}b.flags|=1;a=mh$1(f,d);a.ref=b.ref;a.return=b;return b.child=a}
	function bj(a,b,c,d,e){if(null!==a&&De$4(a.memoizedProps,d)&&a.ref===b.ref)if(og=!1,0!==(a.lanes&e))0!==(a.flags&131072)&&(og=!0);else return b.lanes=a.lanes,Zi$1(a,b,e);return cj(a,b,c,d,e)}
	function dj(a,b,c){var d=b.pendingProps,e=d.children,f=null!==a?a.memoizedState:null;if("hidden"===d.mode)if(0===(b.mode&1))b.memoizedState={baseLanes:0,cachePool:null},H$8(ej,Vi$1),Vi$1|=c;else if(0!==(c&1073741824))b.memoizedState={baseLanes:0,cachePool:null},d=null!==f?f.baseLanes:c,H$8(ej,Vi$1),Vi$1|=d;else return a=null!==f?f.baseLanes|c:c,b.lanes=b.childLanes=1073741824,b.memoizedState={baseLanes:a,cachePool:null},b.updateQueue=null,H$8(ej,Vi$1),Vi$1|=a,null;else null!==f?(d=f.baseLanes|c,b.memoizedState=null):
	d=c,H$8(ej,Vi$1),Vi$1|=d;Xi$1(a,b,e,c);return b.child}function fj(a,b){var c=b.ref;if(null===a&&null!==c||null!==a&&a.ref!==c)b.flags|=512,b.flags|=2097152;}function cj(a,b,c,d,e){var f=Tf(c)?Rf:I$8.current;f=Sf(b,f);ng(b,e);c=Nh$1(a,b,c,d,f,e);d=Sh$1();if(null!==a&&!og)return b.updateQueue=a.updateQueue,b.flags&=-2053,a.lanes&=~e,Zi$1(a,b,e);N$4&&d&&Vg(b);b.flags|=1;Xi$1(a,b,c,e);return b.child}
	function gj(a,b,c,d,e){if(Tf(c)){var f=!0;Xf(b);}else f=!1;ng(b,e);if(null===b.stateNode)null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2),Hg(b,c,d),Jg(b,c,d,e),d=!0;else if(null===a){var g=b.stateNode,h=b.memoizedProps;g.props=h;var k=g.context,l=c.contextType;"object"===typeof l&&null!==l?l=pg(l):(l=Tf(c)?Rf:I$8.current,l=Sf(b,l));var m=c.getDerivedStateFromProps,w="function"===typeof m||"function"===typeof g.getSnapshotBeforeUpdate;w||"function"!==typeof g.UNSAFE_componentWillReceiveProps&&
	"function"!==typeof g.componentWillReceiveProps||(h!==d||k!==l)&&Ig(b,g,d,l);rg=!1;var u=b.memoizedState;g.state=u;yg(b,d,g,e);k=b.memoizedState;h!==d||u!==k||Qf.current||rg?("function"===typeof m&&(Cg(b,c,m,d),k=b.memoizedState),(h=rg||Gg(b,c,h,d,u,k,l))?(w||"function"!==typeof g.UNSAFE_componentWillMount&&"function"!==typeof g.componentWillMount||("function"===typeof g.componentWillMount&&g.componentWillMount(),"function"===typeof g.UNSAFE_componentWillMount&&g.UNSAFE_componentWillMount()),"function"===
	typeof g.componentDidMount&&(b.flags|=4194308)):("function"===typeof g.componentDidMount&&(b.flags|=4194308),b.memoizedProps=d,b.memoizedState=k),g.props=d,g.state=k,g.context=l,d=h):("function"===typeof g.componentDidMount&&(b.flags|=4194308),d=!1);}else {g=b.stateNode;tg(a,b);h=b.memoizedProps;l=b.type===b.elementType?h:fg(b.type,h);g.props=l;w=b.pendingProps;u=g.context;k=c.contextType;"object"===typeof k&&null!==k?k=pg(k):(k=Tf(c)?Rf:I$8.current,k=Sf(b,k));var y=c.getDerivedStateFromProps;(m="function"===
	typeof y||"function"===typeof g.getSnapshotBeforeUpdate)||"function"!==typeof g.UNSAFE_componentWillReceiveProps&&"function"!==typeof g.componentWillReceiveProps||(h!==w||u!==k)&&Ig(b,g,d,k);rg=!1;u=b.memoizedState;g.state=u;yg(b,d,g,e);var n=b.memoizedState;h!==w||u!==n||Qf.current||rg?("function"===typeof y&&(Cg(b,c,y,d),n=b.memoizedState),(l=rg||Gg(b,c,l,d,u,n,k)||!1)?(m||"function"!==typeof g.UNSAFE_componentWillUpdate&&"function"!==typeof g.componentWillUpdate||("function"===typeof g.componentWillUpdate&&
	g.componentWillUpdate(d,n,k),"function"===typeof g.UNSAFE_componentWillUpdate&&g.UNSAFE_componentWillUpdate(d,n,k)),"function"===typeof g.componentDidUpdate&&(b.flags|=4),"function"===typeof g.getSnapshotBeforeUpdate&&(b.flags|=1024)):("function"!==typeof g.componentDidUpdate||h===a.memoizedProps&&u===a.memoizedState||(b.flags|=4),"function"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&u===a.memoizedState||(b.flags|=1024),b.memoizedProps=d,b.memoizedState=n),g.props=d,g.state=n,g.context=
	k,d=l):("function"!==typeof g.componentDidUpdate||h===a.memoizedProps&&u===a.memoizedState||(b.flags|=4),"function"!==typeof g.getSnapshotBeforeUpdate||h===a.memoizedProps&&u===a.memoizedState||(b.flags|=1024),d=!1);}return hj(a,b,c,d,f,e)}
	function hj(a,b,c,d,e,f){fj(a,b);var g=0!==(b.flags&128);if(!d&&!g)return e&&Yf(b,c,!1),Zi$1(a,b,f);d=b.stateNode;Wi$1.current=b;var h=g&&"function"!==typeof c.getDerivedStateFromError?null:d.render();b.flags|=1;null!==a&&g?(b.child=rh$1(b,a.child,null,f),b.child=rh$1(b,null,h,f)):Xi$1(a,b,h,f);b.memoizedState=d.state;e&&Yf(b,c,!0);return b.child}function ij(a){var b=a.stateNode;b.pendingContext?Vf(a,b.pendingContext,b.pendingContext!==b.context):b.context&&Vf(a,b.context,!1);yh$1(a,b.containerInfo);}
	function jj(a,b,c,d,e){gh$1();hh$1(e);b.flags|=256;Xi$1(a,b,c,d);return b.child}var kj={dehydrated:null,treeContext:null,retryLane:0};function lj(a){return {baseLanes:a,cachePool:null}}
	function mj(a,b,c){var d=b.pendingProps,e=P$6.current,f=!1,g=0!==(b.flags&128),h;(h=g)||(h=null!==a&&null===a.memoizedState?!1:0!==(e&2));if(h)f=!0,b.flags&=-129;else if(null===a||null!==a.memoizedState)e|=1;H$8(P$6,e&1);if(null===a){dh$1(b);a=b.memoizedState;if(null!==a&&(a=a.dehydrated,null!==a))return 0===(b.mode&1)?b.lanes=1:"$!"===a.data?b.lanes=8:b.lanes=1073741824,null;e=d.children;a=d.fallback;return f?(d=b.mode,f=b.child,e={mode:"hidden",children:e},0===(d&1)&&null!==f?(f.childLanes=0,f.pendingProps=
	e):f=nj(e,d,0,null),a=qh$1(a,d,c,null),f.return=b,a.return=b,f.sibling=a,b.child=f,b.child.memoizedState=lj(c),b.memoizedState=kj,a):oj(b,e)}e=a.memoizedState;if(null!==e){h=e.dehydrated;if(null!==h){if(g){if(b.flags&256)return b.flags&=-257,pj(a,b,c,Error(p$f(422)));if(null!==b.memoizedState)return b.child=a.child,b.flags|=128,null;f=d.fallback;e=b.mode;d=nj({mode:"visible",children:d.children},e,0,null);f=qh$1(f,e,c,null);f.flags|=2;d.return=b;f.return=b;d.sibling=f;b.child=d;0!==(b.mode&1)&&rh$1(b,a.child,
	null,c);b.child.memoizedState=lj(c);b.memoizedState=kj;return f}if(0===(b.mode&1))b=pj(a,b,c,null);else if("$!"===h.data)b=pj(a,b,c,Error(p$f(419)));else if(d=0!==(c&a.childLanes),og||d){d=J$4;if(null!==d){switch(c&-c){case 4:f=2;break;case 16:f=8;break;case 64:case 128:case 256:case 512:case 1024:case 2048:case 4096:case 8192:case 16384:case 32768:case 65536:case 131072:case 262144:case 524288:case 1048576:case 2097152:case 4194304:case 8388608:case 16777216:case 33554432:case 67108864:f=32;break;case 536870912:f=
	268435456;break;default:f=0;}d=0!==(f&(d.suspendedLanes|c))?0:f;0!==d&&d!==e.retryLane&&(e.retryLane=d,Eg(a,d,-1));}Si$1();b=pj(a,b,c,Error(p$f(421)));}else "$?"===h.data?(b.flags|=128,b.child=a.child,b=qj.bind(null,a),h._reactRetry=b,b=null):(c=e.treeContext,Yg=Ff(h.nextSibling),Xg=b,N$4=!0,Zg=null,null!==c&&(Og[Pg++]=Rg,Og[Pg++]=Sg,Og[Pg++]=Qg,Rg=c.id,Sg=c.overflow,Qg=b),b=oj(b,b.pendingProps.children),b.flags|=4096);return b}if(f)return d=rj(a,b,d.children,d.fallback,c),f=b.child,e=a.child.memoizedState,
	f.memoizedState=null===e?lj(c):{baseLanes:e.baseLanes|c,cachePool:null},f.childLanes=a.childLanes&~c,b.memoizedState=kj,d;c=sj(a,b,d.children,c);b.memoizedState=null;return c}if(f)return d=rj(a,b,d.children,d.fallback,c),f=b.child,e=a.child.memoizedState,f.memoizedState=null===e?lj(c):{baseLanes:e.baseLanes|c,cachePool:null},f.childLanes=a.childLanes&~c,b.memoizedState=kj,d;c=sj(a,b,d.children,c);b.memoizedState=null;return c}
	function oj(a,b){b=nj({mode:"visible",children:b},a.mode,0,null);b.return=a;return a.child=b}function sj(a,b,c,d){var e=a.child;a=e.sibling;c=mh$1(e,{mode:"visible",children:c});0===(b.mode&1)&&(c.lanes=d);c.return=b;c.sibling=null;null!==a&&(d=b.deletions,null===d?(b.deletions=[a],b.flags|=16):d.push(a));return b.child=c}
	function rj(a,b,c,d,e){var f=b.mode;a=a.child;var g=a.sibling,h={mode:"hidden",children:c};0===(f&1)&&b.child!==a?(c=b.child,c.childLanes=0,c.pendingProps=h,b.deletions=null):(c=mh$1(a,h),c.subtreeFlags=a.subtreeFlags&14680064);null!==g?d=mh$1(g,d):(d=qh$1(d,f,e,null),d.flags|=2);d.return=b;c.return=b;c.sibling=d;b.child=c;return d}function pj(a,b,c,d){null!==d&&hh$1(d);rh$1(b,a.child,null,c);a=oj(b,b.pendingProps.children);a.flags|=2;b.memoizedState=null;return a}
	function tj(a,b,c){a.lanes|=b;var d=a.alternate;null!==d&&(d.lanes|=b);mg(a.return,b,c);}function uj(a,b,c,d,e){var f=a.memoizedState;null===f?a.memoizedState={isBackwards:b,rendering:null,renderingStartTime:0,last:d,tail:c,tailMode:e}:(f.isBackwards=b,f.rendering=null,f.renderingStartTime=0,f.last=d,f.tail=c,f.tailMode=e);}
	function vj(a,b,c){var d=b.pendingProps,e=d.revealOrder,f=d.tail;Xi$1(a,b,d.children,c);d=P$6.current;if(0!==(d&2))d=d&1|2,b.flags|=128;else {if(null!==a&&0!==(a.flags&128))a:for(a=b.child;null!==a;){if(13===a.tag)null!==a.memoizedState&&tj(a,c,b);else if(19===a.tag)tj(a,c,b);else if(null!==a.child){a.child.return=a;a=a.child;continue}if(a===b)break a;for(;null===a.sibling;){if(null===a.return||a.return===b)break a;a=a.return;}a.sibling.return=a.return;a=a.sibling;}d&=1;}H$8(P$6,d);if(0===(b.mode&1))b.memoizedState=
	null;else switch(e){case "forwards":c=b.child;for(e=null;null!==c;)a=c.alternate,null!==a&&null===Ch$1(a)&&(e=c),c=c.sibling;c=e;null===c?(e=b.child,b.child=null):(e=c.sibling,c.sibling=null);uj(b,!1,e,c,f);break;case "backwards":c=null;e=b.child;for(b.child=null;null!==e;){a=e.alternate;if(null!==a&&null===Ch$1(a)){b.child=e;break}a=e.sibling;e.sibling=c;c=e;e=a;}uj(b,!0,c,null,f);break;case "together":uj(b,!1,null,null,void 0);break;default:b.memoizedState=null;}return b.child}
	function Zi$1(a,b,c){null!==a&&(b.dependencies=a.dependencies);zg|=b.lanes;if(0===(c&b.childLanes))return null;if(null!==a&&b.child!==a.child)throw Error(p$f(153));if(null!==b.child){a=b.child;c=mh$1(a,a.pendingProps);b.child=c;for(c.return=b;null!==a.sibling;)a=a.sibling,c=c.sibling=mh$1(a,a.pendingProps),c.return=b;c.sibling=null;}return b.child}
	function wj(a,b,c){switch(b.tag){case 3:ij(b);gh$1();break;case 5:Ah$1(b);break;case 1:Tf(b.type)&&Xf(b);break;case 4:yh$1(b,b.stateNode.containerInfo);break;case 10:var d=b.type._context,e=b.memoizedProps.value;H$8(gg,d._currentValue);d._currentValue=e;break;case 13:d=b.memoizedState;if(null!==d){if(null!==d.dehydrated)return H$8(P$6,P$6.current&1),b.flags|=128,null;if(0!==(c&b.child.childLanes))return mj(a,b,c);H$8(P$6,P$6.current&1);a=Zi$1(a,b,c);return null!==a?a.sibling:null}H$8(P$6,P$6.current&1);break;case 19:d=0!==(c&
	b.childLanes);if(0!==(a.flags&128)){if(d)return vj(a,b,c);b.flags|=128;}e=b.memoizedState;null!==e&&(e.rendering=null,e.tail=null,e.lastEffect=null);H$8(P$6,P$6.current);if(d)break;else return null;case 22:case 23:return b.lanes=0,dj(a,b,c)}return Zi$1(a,b,c)}
	function xj(a,b){Wg(b);switch(b.tag){case 1:return Tf(b.type)&&Uf(),a=b.flags,a&65536?(b.flags=a&-65537|128,b):null;case 3:return zh$1(),G$4(Qf),G$4(I$8),Eh$1(),a=b.flags,0!==(a&65536)&&0===(a&128)?(b.flags=a&-65537|128,b):null;case 5:return Bh$1(b),null;case 13:G$4(P$6);a=b.memoizedState;if(null!==a&&null!==a.dehydrated){if(null===b.alternate)throw Error(p$f(340));gh$1();}a=b.flags;return a&65536?(b.flags=a&-65537|128,b):null;case 19:return G$4(P$6),null;case 4:return zh$1(),null;case 10:return lg(b.type._context),null;case 22:case 23:return Ui$1(),
	null;case 24:return null;default:return null}}var yj=!1,zj=!1,Aj="function"===typeof WeakSet?WeakSet:Set,X$8=null;function Bj(a,b){var c=a.ref;if(null!==c)if("function"===typeof c)try{c(null);}catch(d){Cj(a,b,d);}else c.current=null;}function Dj(a,b,c){try{c();}catch(d){Cj(a,b,d);}}var Ej=!1;
	function Fj(a,b){a=He$5();if(Ie$6(a)){if("selectionStart"in a)var c={start:a.selectionStart,end:a.selectionEnd};else a:{c=(c=a.ownerDocument)&&c.defaultView||window;var d=c.getSelection&&c.getSelection();if(d&&0!==d.rangeCount){c=d.anchorNode;var e=d.anchorOffset,f=d.focusNode;d=d.focusOffset;try{c.nodeType,f.nodeType;}catch(O){c=null;break a}var g=0,h=-1,k=-1,l=0,m=0,w=a,u=null;b:for(;;){for(var y;;){w!==c||0!==e&&3!==w.nodeType||(h=g+e);w!==f||0!==d&&3!==w.nodeType||(k=g+d);3===w.nodeType&&(g+=w.nodeValue.length);
	if(null===(y=w.firstChild))break;u=w;w=y;}for(;;){if(w===a)break b;u===c&&++l===e&&(h=g);u===f&&++m===d&&(k=g);if(null!==(y=w.nextSibling))break;w=u;u=w.parentNode;}w=y;}c=-1===h||-1===k?null:{start:h,end:k};}else c=null;}c=c||{start:0,end:0};}else c=null;xf={focusedElem:a,selectionRange:c};for(X$8=b;null!==X$8;)if(b=X$8,a=b.child,0!==(b.subtreeFlags&1028)&&null!==a)a.return=b,X$8=a;else for(;null!==X$8;){b=X$8;try{var n=b.alternate;if(0!==(b.flags&1024))switch(b.tag){case 0:case 11:case 15:break;case 1:if(null!==
	n){var v=n.memoizedProps,C=n.memoizedState,t=b.stateNode,r=t.getSnapshotBeforeUpdate(b.elementType===b.type?v:fg(b.type,v),C);t.__reactInternalSnapshotBeforeUpdate=r;}break;case 3:var x=b.stateNode.containerInfo;if(1===x.nodeType)x.textContent="";else if(9===x.nodeType){var B=x.body;null!=B&&(B.textContent="");}break;case 5:case 6:case 4:case 17:break;default:throw Error(p$f(163));}}catch(O){Cj(b,b.return,O);}a=b.sibling;if(null!==a){a.return=b.return;X$8=a;break}X$8=b.return;}n=Ej;Ej=!1;return n}
	function Gj(a,b,c){var d=b.updateQueue;d=null!==d?d.lastEffect:null;if(null!==d){var e=d=d.next;do{if((e.tag&a)===a){var f=e.destroy;e.destroy=void 0;void 0!==f&&Dj(b,c,f);}e=e.next;}while(e!==d)}}function Hj(a,b){b=b.updateQueue;b=null!==b?b.lastEffect:null;if(null!==b){var c=b=b.next;do{if((c.tag&a)===a){var d=c.create;c.destroy=d();}c=c.next;}while(c!==b)}}function Ij(a){var b=a.ref;if(null!==b){var c=a.stateNode;switch(a.tag){case 5:a=c;break;default:a=c;}"function"===typeof b?b(a):b.current=a;}}
	function Jj(a,b,c){if(ic$2&&"function"===typeof ic$2.onCommitFiberUnmount)try{ic$2.onCommitFiberUnmount(hc$2,b);}catch(g){}switch(b.tag){case 0:case 11:case 14:case 15:a=b.updateQueue;if(null!==a&&(a=a.lastEffect,null!==a)){var d=a=a.next;do{var e=d,f=e.destroy;e=e.tag;void 0!==f&&(0!==(e&2)?Dj(b,c,f):0!==(e&4)&&Dj(b,c,f));d=d.next;}while(d!==a)}break;case 1:Bj(b,c);a=b.stateNode;if("function"===typeof a.componentWillUnmount)try{a.props=b.memoizedProps,a.state=b.memoizedState,a.componentWillUnmount();}catch(g){Cj(b,
	c,g);}break;case 5:Bj(b,c);break;case 4:Kj(a,b,c);}}function Lj(a){var b=a.alternate;null!==b&&(a.alternate=null,Lj(b));a.child=null;a.deletions=null;a.sibling=null;5===a.tag&&(b=a.stateNode,null!==b&&(delete b[If],delete b[Jf],delete b[jf],delete b[Kf],delete b[Lf]));a.stateNode=null;a.return=null;a.dependencies=null;a.memoizedProps=null;a.memoizedState=null;a.pendingProps=null;a.stateNode=null;a.updateQueue=null;}function Mj(a){return 5===a.tag||3===a.tag||4===a.tag}
	function Nj(a){a:for(;;){for(;null===a.sibling;){if(null===a.return||Mj(a.return))return null;a=a.return;}a.sibling.return=a.return;for(a=a.sibling;5!==a.tag&&6!==a.tag&&18!==a.tag;){if(a.flags&2)continue a;if(null===a.child||4===a.tag)continue a;else a.child.return=a,a=a.child;}if(!(a.flags&2))return a.stateNode}}
	function Oj(a){a:{for(var b=a.return;null!==b;){if(Mj(b))break a;b=b.return;}throw Error(p$f(160));}var c=b;switch(c.tag){case 5:b=c.stateNode;c.flags&32&&(lb$2(b,""),c.flags&=-33);c=Nj(a);Pj(a,c,b);break;case 3:case 4:b=c.stateNode.containerInfo;c=Nj(a);Qj(a,c,b);break;default:throw Error(p$f(161));}}
	function Qj(a,b,c){var d=a.tag;if(5===d||6===d)a=a.stateNode,b?8===c.nodeType?c.parentNode.insertBefore(a,b):c.insertBefore(a,b):(8===c.nodeType?(b=c.parentNode,b.insertBefore(a,c)):(b=c,b.appendChild(a)),c=c._reactRootContainer,null!==c&&void 0!==c||null!==b.onclick||(b.onclick=wf));else if(4!==d&&(a=a.child,null!==a))for(Qj(a,b,c),a=a.sibling;null!==a;)Qj(a,b,c),a=a.sibling;}
	function Pj(a,b,c){var d=a.tag;if(5===d||6===d)a=a.stateNode,b?c.insertBefore(a,b):c.appendChild(a);else if(4!==d&&(a=a.child,null!==a))for(Pj(a,b,c),a=a.sibling;null!==a;)Pj(a,b,c),a=a.sibling;}
	function Kj(a,b,c){for(var d=b,e=!1,f,g;;){if(!e){e=d.return;a:for(;;){if(null===e)throw Error(p$f(160));f=e.stateNode;switch(e.tag){case 5:g=!1;break a;case 3:f=f.containerInfo;g=!0;break a;case 4:f=f.containerInfo;g=!0;break a}e=e.return;}e=!0;}if(5===d.tag||6===d.tag){a:for(var h=a,k=d,l=c,m=k;;)if(Jj(h,m,l),null!==m.child&&4!==m.tag)m.child.return=m,m=m.child;else {if(m===k)break a;for(;null===m.sibling;){if(null===m.return||m.return===k)break a;m=m.return;}m.sibling.return=m.return;m=m.sibling;}g?(h=
	f,k=d.stateNode,8===h.nodeType?h.parentNode.removeChild(k):h.removeChild(k)):f.removeChild(d.stateNode);}else if(18===d.tag)g?(h=f,k=d.stateNode,8===h.nodeType?Ef(h.parentNode,k):1===h.nodeType&&Ef(h,k),Yc$1(h)):Ef(f,d.stateNode);else if(4===d.tag){if(null!==d.child){f=d.stateNode.containerInfo;g=!0;d.child.return=d;d=d.child;continue}}else if(Jj(a,d,c),null!==d.child){d.child.return=d;d=d.child;continue}if(d===b)break;for(;null===d.sibling;){if(null===d.return||d.return===b)return;d=d.return;4===d.tag&&
	(e=!1);}d.sibling.return=d.return;d=d.sibling;}}
	function Rj(a,b){switch(b.tag){case 0:case 11:case 14:case 15:Gj(3,b,b.return);Hj(3,b);Gj(5,b,b.return);return;case 1:return;case 5:var c=b.stateNode;if(null!=c){var d=b.memoizedProps,e=null!==a?a.memoizedProps:d;a=b.type;var f=b.updateQueue;b.updateQueue=null;if(null!==f){"input"===a&&"radio"===d.type&&null!=d.name&&Ya$3(c,d);sb$2(a,e);b=sb$2(a,d);for(e=0;e<f.length;e+=2){var g=f[e],h=f[e+1];"style"===g?pb$2(c,h):"dangerouslySetInnerHTML"===g?kb$3(c,h):"children"===g?lb$2(c,h):ra$3(c,g,h,b);}switch(a){case "input":Za$3(c,
	d);break;case "textarea":fb$3(c,d);break;case "select":a=c._wrapperState.wasMultiple,c._wrapperState.wasMultiple=!!d.multiple,f=d.value,null!=f?cb$2(c,!!d.multiple,f,!1):a!==!!d.multiple&&(null!=d.defaultValue?cb$2(c,!!d.multiple,d.defaultValue,!0):cb$2(c,!!d.multiple,d.multiple?[]:"",!1));}c[Jf]=d;}}return;case 6:if(null===b.stateNode)throw Error(p$f(162));b.stateNode.nodeValue=b.memoizedProps;return;case 3:null!==a&&a.memoizedState.isDehydrated&&Yc$1(b.stateNode.containerInfo);return;case 12:return;case 13:Sj(b);
	return;case 19:Sj(b);return;case 17:return}throw Error(p$f(163));}function Sj(a){var b=a.updateQueue;if(null!==b){a.updateQueue=null;var c=a.stateNode;null===c&&(c=a.stateNode=new Aj);b.forEach(function(b){var d=Tj.bind(null,a,b);c.has(b)||(c.add(b),b.then(d,d));});}}
	function Uj(a,b){for(X$8=b;null!==X$8;){b=X$8;var c=b.deletions;if(null!==c)for(var d=0;d<c.length;d++){var e=c[d];try{Kj(a,e,b);var f=e.alternate;null!==f&&(f.return=null);e.return=null;}catch(L){Cj(e,b,L);}}c=b.child;if(0!==(b.subtreeFlags&12854)&&null!==c)c.return=b,X$8=c;else for(;null!==X$8;){b=X$8;try{var g=b.flags;g&32&&lb$2(b.stateNode,"");if(g&512){var h=b.alternate;if(null!==h){var k=h.ref;null!==k&&("function"===typeof k?k(null):k.current=null);}}if(g&8192)switch(b.tag){case 13:if(null!==b.memoizedState){var l=
	b.alternate;if(null===l||null===l.memoizedState)Vj=D$8();}break;case 22:var m=null!==b.memoizedState,w=b.alternate,u=null!==w&&null!==w.memoizedState;c=b;a:{d=c;e=m;for(var y=null,n=d;;){if(5===n.tag){if(null===y){y=n;var v=n.stateNode;if(e){var C=v.style;"function"===typeof C.setProperty?C.setProperty("display","none","important"):C.display="none";}else {var t=n.stateNode,r=n.memoizedProps.style,x=void 0!==r&&null!==r&&r.hasOwnProperty("display")?r.display:null;t.style.display=ob$2("display",x);}}}else if(6===
	n.tag)null===y&&(n.stateNode.nodeValue=e?"":n.memoizedProps);else if((22!==n.tag&&23!==n.tag||null===n.memoizedState||n===d)&&null!==n.child){n.child.return=n;n=n.child;continue}if(n===d)break;for(;null===n.sibling;){if(null===n.return||n.return===d)break a;y===n&&(y=null);n=n.return;}y===n&&(y=null);n.sibling.return=n.return;n=n.sibling;}}if(m&&!u&&0!==(c.mode&1)){X$8=c;for(var B=c.child;null!==B;){for(c=X$8=B;null!==X$8;){d=X$8;var O=d.child;switch(d.tag){case 0:case 11:case 14:case 15:Gj(4,d,d.return);break;
	case 1:Bj(d,d.return);var T=d.stateNode;if("function"===typeof T.componentWillUnmount){var za=d.return;try{T.props=d.memoizedProps,T.state=d.memoizedState,T.componentWillUnmount();}catch(L){Cj(d,za,L);}}break;case 5:Bj(d,d.return);break;case 22:if(null!==d.memoizedState){Wj(c);continue}}null!==O?(O.return=d,X$8=O):Wj(c);}B=B.sibling;}}}switch(g&4102){case 2:Oj(b);b.flags&=-3;break;case 6:Oj(b);b.flags&=-3;Rj(b.alternate,b);break;case 4096:b.flags&=-4097;break;case 4100:b.flags&=-4097;Rj(b.alternate,b);
	break;case 4:Rj(b.alternate,b);}}catch(L){Cj(b,b.return,L);}c=b.sibling;if(null!==c){c.return=b.return;X$8=c;break}X$8=b.return;}}}function Xj(a,b,c){X$8=a;Yj(a);}
	function Yj(a,b,c){for(var d=0!==(a.mode&1);null!==X$8;){var e=X$8,f=e.child;if(22===e.tag&&d){var g=null!==e.memoizedState||yj;if(!g){var h=e.alternate,k=null!==h&&null!==h.memoizedState||zj;h=yj;var l=zj;yj=g;if((zj=k)&&!l)for(X$8=e;null!==X$8;)g=X$8,k=g.child,22===g.tag&&null!==g.memoizedState?Zj(e):null!==k?(k.return=g,X$8=k):Zj(e);for(;null!==f;)X$8=f,Yj(f),f=f.sibling;X$8=e;yj=h;zj=l;}ak(a);}else 0!==(e.subtreeFlags&8772)&&null!==f?(f.return=e,X$8=f):ak(a);}}
	function ak(a){for(;null!==X$8;){var b=X$8;if(0!==(b.flags&8772)){var c=b.alternate;try{if(0!==(b.flags&8772))switch(b.tag){case 0:case 11:case 15:zj||Hj(5,b);break;case 1:var d=b.stateNode;if(b.flags&4&&!zj)if(null===c)d.componentDidMount();else {var e=b.elementType===b.type?c.memoizedProps:fg(b.type,c.memoizedProps);d.componentDidUpdate(e,c.memoizedState,d.__reactInternalSnapshotBeforeUpdate);}var f=b.updateQueue;null!==f&&Ag(b,f,d);break;case 3:var g=b.updateQueue;if(null!==g){c=null;if(null!==b.child)switch(b.child.tag){case 5:c=
	b.child.stateNode;break;case 1:c=b.child.stateNode;}Ag(b,g,c);}break;case 5:var h=b.stateNode;if(null===c&&b.flags&4){c=h;var k=b.memoizedProps;switch(b.type){case "button":case "input":case "select":case "textarea":k.autoFocus&&c.focus();break;case "img":k.src&&(c.src=k.src);}}break;case 6:break;case 4:break;case 12:break;case 13:if(null===b.memoizedState){var l=b.alternate;if(null!==l){var m=l.memoizedState;if(null!==m){var w=m.dehydrated;null!==w&&Yc$1(w);}}}break;case 19:case 17:case 21:case 22:case 23:break;
	default:throw Error(p$f(163));}zj||b.flags&512&&Ij(b);}catch(u){Cj(b,b.return,u);}}if(b===a){X$8=null;break}c=b.sibling;if(null!==c){c.return=b.return;X$8=c;break}X$8=b.return;}}function Wj(a){for(;null!==X$8;){var b=X$8;if(b===a){X$8=null;break}var c=b.sibling;if(null!==c){c.return=b.return;X$8=c;break}X$8=b.return;}}
	function Zj(a){for(;null!==X$8;){var b=X$8;try{switch(b.tag){case 0:case 11:case 15:var c=b.return;try{Hj(4,b);}catch(k){Cj(b,c,k);}break;case 1:var d=b.stateNode;if("function"===typeof d.componentDidMount){var e=b.return;try{d.componentDidMount();}catch(k){Cj(b,e,k);}}var f=b.return;try{Ij(b);}catch(k){Cj(b,f,k);}break;case 5:var g=b.return;try{Ij(b);}catch(k){Cj(b,g,k);}}}catch(k){Cj(b,b.return,k);}if(b===a){X$8=null;break}var h=b.sibling;if(null!==h){h.return=b.return;X$8=h;break}X$8=b.return;}}
	var bk=Math.ceil,ck=sa$3.ReactCurrentDispatcher,dk=sa$3.ReactCurrentOwner,ek=sa$3.ReactCurrentBatchConfig,K$2=0,J$4=null,Y$7=null,Z$8=0,Vi$1=0,ej=Of(0),W$5=0,fk=null,zg=0,gk=0,hk=0,ik=null,jk=null,Vj=0,Ti$1=Infinity,Di$1=!1,Ei$1=null,Gi$1=null,kk=!1,lk=null,mk=0,nk=0,ok$2=null,pk=-1,qk=0;function M$b(){return 0!==(K$2&6)?D$8():-1!==pk?pk:pk=D$8()}
	function Dg(a){if(0===(a.mode&1))return 1;if(0!==(K$2&2)&&0!==Z$8)return Z$8&-Z$8;if(null!==eg.transition)return 0===qk&&(a=oc$2,oc$2<<=1,0===(oc$2&4194240)&&(oc$2=64),qk=a),qk;a=E$5;if(0!==a)return a;a=window.event;a=void 0===a?16:ed(a.type);return a}function Eg(a,b,c){if(50<nk)throw nk=0,ok$2=null,Error(p$f(185));var d=rk(a,b);if(null===d)return null;wc$2(d,b,c);if(0===(K$2&2)||d!==J$4)d===J$4&&(0===(K$2&2)&&(gk|=b),4===W$5&&sk(d,Z$8)),tk(d,c),1===b&&0===K$2&&0===(a.mode&1)&&(Ti$1=D$8()+500,$f&&dg());return d}
	function rk(a,b){a.lanes|=b;var c=a.alternate;null!==c&&(c.lanes|=b);c=a;for(a=a.return;null!==a;)a.childLanes|=b,c=a.alternate,null!==c&&(c.childLanes|=b),c=a,a=a.return;return 3===c.tag?c.stateNode:null}
	function tk(a,b){var c=a.callbackNode;tc$2(a,b);var d=rc$2(a,a===J$4?Z$8:0);if(0===d)null!==c&&Zb$1(c),a.callbackNode=null,a.callbackPriority=0;else if(b=d&-d,a.callbackPriority!==b){null!=c&&Zb$1(c);if(1===b)0===a.tag?cg(uk.bind(null,a)):bg(uk.bind(null,a)),Df(function(){0===K$2&&dg();}),c=null;else {switch(zc$2(d)){case 1:c=cc$2;break;case 4:c=dc$2;break;case 16:c=ec$2;break;case 536870912:c=gc$2;break;default:c=ec$2;}c=vk(c,wk.bind(null,a));}a.callbackPriority=b;a.callbackNode=c;}}
	function wk(a,b){pk=-1;qk=0;if(0!==(K$2&6))throw Error(p$f(327));var c=a.callbackNode;if(xk()&&a.callbackNode!==c)return null;var d=rc$2(a,a===J$4?Z$8:0);if(0===d)return null;if(0!==(d&30)||0!==(d&a.expiredLanes)||b)b=yk(a,d);else {b=d;var e=K$2;K$2|=2;var f=zk();if(J$4!==a||Z$8!==b)Ti$1=D$8()+500,Ak(a,b);do try{Bk();break}catch(h){Ck(a,h);}while(1);kg();ck.current=f;K$2=e;null!==Y$7?b=0:(J$4=null,Z$8=0,b=W$5);}if(0!==b){2===b&&(e=uc$2(a),0!==e&&(d=e,b=Dk(a,e)));if(1===b)throw c=fk,Ak(a,0),sk(a,d),tk(a,D$8()),c;if(6===b)sk(a,d);else {e=
	a.current.alternate;if(0===(d&30)&&!Ek(e)&&(b=yk(a,d),2===b&&(f=uc$2(a),0!==f&&(d=f,b=Dk(a,f))),1===b))throw c=fk,Ak(a,0),sk(a,d),tk(a,D$8()),c;a.finishedWork=e;a.finishedLanes=d;switch(b){case 0:case 1:throw Error(p$f(345));case 2:Fk(a,jk);break;case 3:sk(a,d);if((d&130023424)===d&&(b=Vj+500-D$8(),10<b)){if(0!==rc$2(a,0))break;e=a.suspendedLanes;if((e&d)!==d){M$b();a.pingedLanes|=a.suspendedLanes&e;break}a.timeoutHandle=zf(Fk.bind(null,a,jk),b);break}Fk(a,jk);break;case 4:sk(a,d);if((d&4194240)===d)break;b=
	a.eventTimes;for(e=-1;0<d;){var g=31-lc$2(d);f=1<<g;g=b[g];g>e&&(e=g);d&=~f;}d=e;d=D$8()-d;d=(120>d?120:480>d?480:1080>d?1080:1920>d?1920:3E3>d?3E3:4320>d?4320:1960*bk(d/1960))-d;if(10<d){a.timeoutHandle=zf(Fk.bind(null,a,jk),d);break}Fk(a,jk);break;case 5:Fk(a,jk);break;default:throw Error(p$f(329));}}}tk(a,D$8());return a.callbackNode===c?wk.bind(null,a):null}function Dk(a,b){var c=ik;a.current.memoizedState.isDehydrated&&(Ak(a,b).flags|=256);a=yk(a,b);2!==a&&(b=jk,jk=c,null!==b&&Ri$1(b));return a}
	function Ri$1(a){null===jk?jk=a:jk.push.apply(jk,a);}function Ek(a){for(var b=a;;){if(b.flags&16384){var c=b.updateQueue;if(null!==c&&(c=c.stores,null!==c))for(var d=0;d<c.length;d++){var e=c[d],f=e.getSnapshot;e=e.value;try{if(!Ce$2(f(),e))return !1}catch(g){return !1}}}c=b.child;if(b.subtreeFlags&16384&&null!==c)c.return=b,b=c;else {if(b===a)break;for(;null===b.sibling;){if(null===b.return||b.return===a)return !0;b=b.return;}b.sibling.return=b.return;b=b.sibling;}}return !0}
	function sk(a,b){b&=~hk;b&=~gk;a.suspendedLanes|=b;a.pingedLanes&=~b;for(a=a.expirationTimes;0<b;){var c=31-lc$2(b),d=1<<c;a[c]=-1;b&=~d;}}function uk(a){if(0!==(K$2&6))throw Error(p$f(327));xk();var b=rc$2(a,0);if(0===(b&1))return tk(a,D$8()),null;var c=yk(a,b);if(0!==a.tag&&2===c){var d=uc$2(a);0!==d&&(b=d,c=Dk(a,d));}if(1===c)throw c=fk,Ak(a,0),sk(a,b),tk(a,D$8()),c;if(6===c)throw Error(p$f(345));a.finishedWork=a.current.alternate;a.finishedLanes=b;Fk(a,jk);tk(a,D$8());return null}
	function Gk(a,b){var c=K$2;K$2|=1;try{return a(b)}finally{K$2=c,0===K$2&&(Ti$1=D$8()+500,$f&&dg());}}function Hk(a){null!==lk&&0===lk.tag&&0===(K$2&6)&&xk();var b=K$2;K$2|=1;var c=ek.transition,d=E$5;try{if(ek.transition=null,E$5=1,a)return a()}finally{E$5=d,ek.transition=c,K$2=b,0===(K$2&6)&&dg();}}function Ui$1(){Vi$1=ej.current;G$4(ej);}
	function Ak(a,b){a.finishedWork=null;a.finishedLanes=0;var c=a.timeoutHandle;-1!==c&&(a.timeoutHandle=-1,Af(c));if(null!==Y$7)for(c=Y$7.return;null!==c;){var d=c;Wg(d);switch(d.tag){case 1:d=d.type.childContextTypes;null!==d&&void 0!==d&&Uf();break;case 3:zh$1();G$4(Qf);G$4(I$8);Eh$1();break;case 5:Bh$1(d);break;case 4:zh$1();break;case 13:G$4(P$6);break;case 19:G$4(P$6);break;case 10:lg(d.type._context);break;case 22:case 23:Ui$1();}c=c.return;}J$4=a;Y$7=a=mh$1(a.current,null);Z$8=Vi$1=b;W$5=0;fk=null;hk=gk=zg=0;jk=ik=null;if(null!==qg){for(b=
	0;b<qg.length;b++)if(c=qg[b],d=c.interleaved,null!==d){c.interleaved=null;var e=d.next,f=c.pending;if(null!==f){var g=f.next;f.next=e;d.next=g;}c.pending=d;}qg=null;}return a}
	function Ck(a,b){do{var c=Y$7;try{kg();Fh$1.current=Rh$1;if(Ih$1){for(var d=Q$6.memoizedState;null!==d;){var e=d.queue;null!==e&&(e.pending=null);d=d.next;}Ih$1=!1;}Hh$1=0;S$c=R$5=Q$6=null;Jh=!1;Kh=0;dk.current=null;if(null===c||null===c.return){W$5=1;fk=b;Y$7=null;break}a:{var f=a,g=c.return,h=c,k=b;b=Z$8;h.flags|=32768;if(null!==k&&"object"===typeof k&&"function"===typeof k.then){var l=k,m=h,w=m.tag;if(0===(m.mode&1)&&(0===w||11===w||15===w)){var u=m.alternate;u?(m.updateQueue=u.updateQueue,m.memoizedState=u.memoizedState,
	m.lanes=u.lanes):(m.updateQueue=null,m.memoizedState=null);}var y=Ji$1(g);if(null!==y){y.flags&=-257;Ki$1(y,g,h,f,b);y.mode&1&&Hi$1(f,l,b);b=y;k=l;var n=b.updateQueue;if(null===n){var v=new Set;v.add(k);b.updateQueue=v;}else n.add(k);break a}else {if(0===(b&1)){Hi$1(f,l,b);Si$1();break a}k=Error(p$f(426));}}else if(N$4&&h.mode&1){var C=Ji$1(g);if(null!==C){0===(C.flags&65536)&&(C.flags|=256);Ki$1(C,g,h,f,b);hh$1(k);break a}}f=k;4!==W$5&&(W$5=2);null===ik?ik=[f]:ik.push(f);k=zi$1(k,h);h=g;do{switch(h.tag){case 3:h.flags|=65536;
	b&=-b;h.lanes|=b;var t=Ci$1(h,k,b);xg(h,t);break a;case 1:f=k;var r=h.type,x=h.stateNode;if(0===(h.flags&128)&&("function"===typeof r.getDerivedStateFromError||null!==x&&"function"===typeof x.componentDidCatch&&(null===Gi$1||!Gi$1.has(x)))){h.flags|=65536;b&=-b;h.lanes|=b;var B=Fi$1(h,f,b);xg(h,B);break a}}h=h.return;}while(null!==h)}Ik(c);}catch(O){b=O;Y$7===c&&null!==c&&(Y$7=c=c.return);continue}break}while(1)}function zk(){var a=ck.current;ck.current=Rh$1;return null===a?Rh$1:a}
	function Si$1(){if(0===W$5||3===W$5||2===W$5)W$5=4;null===J$4||0===(zg&268435455)&&0===(gk&268435455)||sk(J$4,Z$8);}function yk(a,b){var c=K$2;K$2|=2;var d=zk();J$4===a&&Z$8===b||Ak(a,b);do try{Jk();break}catch(e){Ck(a,e);}while(1);kg();K$2=c;ck.current=d;if(null!==Y$7)throw Error(p$f(261));J$4=null;Z$8=0;return W$5}function Jk(){for(;null!==Y$7;)Kk(Y$7);}function Bk(){for(;null!==Y$7&&!$b$1();)Kk(Y$7);}function Kk(a){var b=Lk(a.alternate,a,Vi$1);a.memoizedProps=a.pendingProps;null===b?Ik(a):Y$7=b;dk.current=null;}
	function Ik(a){var b=a;do{var c=b.alternate;a=b.return;if(0===(b.flags&32768)){if(c=Qi$1(c,b,Vi$1),null!==c){Y$7=c;return}}else {c=xj(c,b);if(null!==c){c.flags&=32767;Y$7=c;return}if(null!==a)a.flags|=32768,a.subtreeFlags=0,a.deletions=null;else {W$5=6;Y$7=null;return}}b=b.sibling;if(null!==b){Y$7=b;return}Y$7=b=a;}while(null!==b);0===W$5&&(W$5=5);}function Fk(a,b){var c=E$5,d=ek.transition;try{ek.transition=null,E$5=1,Mk(a,b,c);}finally{ek.transition=d,E$5=c;}return null}
	function Mk(a,b,c){do xk();while(null!==lk);if(0!==(K$2&6))throw Error(p$f(327));var d=a.finishedWork,e=a.finishedLanes;if(null===d)return null;a.finishedWork=null;a.finishedLanes=0;if(d===a.current)throw Error(p$f(177));a.callbackNode=null;a.callbackPriority=0;var f=d.lanes|d.childLanes;xc$2(a,f);a===J$4&&(Y$7=J$4=null,Z$8=0);0===(d.subtreeFlags&2064)&&0===(d.flags&2064)||kk||(kk=!0,vk(ec$2,function(){xk();return null}));f=0!==(d.flags&15990);if(0!==(d.subtreeFlags&15990)||f){f=ek.transition;ek.transition=null;var g=
	E$5;E$5=1;var h=K$2;K$2|=4;dk.current=null;Fj(a,d);Uj(a,d);Je$4(xf);xf=null;a.current=d;Xj(d);ac$2();K$2=h;E$5=g;ek.transition=f;}else a.current=d;kk&&(kk=!1,lk=a,mk=e);f=a.pendingLanes;0===f&&(Gi$1=null);jc$2(d.stateNode);tk(a,D$8());if(null!==b)for(c=a.onRecoverableError,d=0;d<b.length;d++)c(b[d]);if(Di$1)throw Di$1=!1,a=Ei$1,Ei$1=null,a;0!==(mk&1)&&0!==a.tag&&xk();f=a.pendingLanes;0!==(f&1)?a===ok$2?nk++:(nk=0,ok$2=a):nk=0;dg();return null}
	function xk(){if(null!==lk){var a=zc$2(mk),b=ek.transition,c=E$5;try{ek.transition=null;E$5=16>a?16:a;if(null===lk)var d=!1;else {a=lk;lk=null;mk=0;if(0!==(K$2&6))throw Error(p$f(331));var e=K$2;K$2|=4;for(X$8=a.current;null!==X$8;){var f=X$8,g=f.child;if(0!==(X$8.flags&16)){var h=f.deletions;if(null!==h){for(var k=0;k<h.length;k++){var l=h[k];for(X$8=l;null!==X$8;){var m=X$8;switch(m.tag){case 0:case 11:case 15:Gj(8,m,f);}var w=m.child;if(null!==w)w.return=m,X$8=w;else for(;null!==X$8;){m=X$8;var u=m.sibling,y=m.return;Lj(m);if(m===
	l){X$8=null;break}if(null!==u){u.return=y;X$8=u;break}X$8=y;}}}var n=f.alternate;if(null!==n){var v=n.child;if(null!==v){n.child=null;do{var C=v.sibling;v.sibling=null;v=C;}while(null!==v)}}X$8=f;}}if(0!==(f.subtreeFlags&2064)&&null!==g)g.return=f,X$8=g;else b:for(;null!==X$8;){f=X$8;if(0!==(f.flags&2048))switch(f.tag){case 0:case 11:case 15:Gj(9,f,f.return);}var t=f.sibling;if(null!==t){t.return=f.return;X$8=t;break b}X$8=f.return;}}var r=a.current;for(X$8=r;null!==X$8;){g=X$8;var x=g.child;if(0!==(g.subtreeFlags&2064)&&null!==
	x)x.return=g,X$8=x;else b:for(g=r;null!==X$8;){h=X$8;if(0!==(h.flags&2048))try{switch(h.tag){case 0:case 11:case 15:Hj(9,h);}}catch(O){Cj(h,h.return,O);}if(h===g){X$8=null;break b}var B=h.sibling;if(null!==B){B.return=h.return;X$8=B;break b}X$8=h.return;}}K$2=e;dg();if(ic$2&&"function"===typeof ic$2.onPostCommitFiberRoot)try{ic$2.onPostCommitFiberRoot(hc$2,a);}catch(O){}d=!0;}return d}finally{E$5=c,ek.transition=b;}}return !1}function Nk(a,b,c){b=zi$1(c,b);b=Ci$1(a,b,1);vg(a,b);b=M$b();a=rk(a,1);null!==a&&(wc$2(a,1,b),tk(a,b));}
	function Cj(a,b,c){if(3===a.tag)Nk(a,a,c);else for(;null!==b;){if(3===b.tag){Nk(b,a,c);break}else if(1===b.tag){var d=b.stateNode;if("function"===typeof b.type.getDerivedStateFromError||"function"===typeof d.componentDidCatch&&(null===Gi$1||!Gi$1.has(d))){a=zi$1(c,a);a=Fi$1(b,a,1);vg(b,a);a=M$b();b=rk(b,1);null!==b&&(wc$2(b,1,a),tk(b,a));break}}b=b.return;}}
	function Ii$1(a,b,c){var d=a.pingCache;null!==d&&d.delete(b);b=M$b();a.pingedLanes|=a.suspendedLanes&c;J$4===a&&(Z$8&c)===c&&(4===W$5||3===W$5&&(Z$8&130023424)===Z$8&&500>D$8()-Vj?Ak(a,0):hk|=c);tk(a,b);}function Ok(a,b){0===b&&(0===(a.mode&1)?b=1:(b=pc$2,pc$2<<=1,0===(pc$2&130023424)&&(pc$2=4194304)));var c=M$b();a=rk(a,b);null!==a&&(wc$2(a,b,c),tk(a,c));}function qj(a){var b=a.memoizedState,c=0;null!==b&&(c=b.retryLane);Ok(a,c);}
	function Tj(a,b){var c=0;switch(a.tag){case 13:var d=a.stateNode;var e=a.memoizedState;null!==e&&(c=e.retryLane);break;case 19:d=a.stateNode;break;default:throw Error(p$f(314));}null!==d&&d.delete(b);Ok(a,c);}var Lk;
	Lk=function(a,b,c){if(null!==a)if(a.memoizedProps!==b.pendingProps||Qf.current)og=!0;else {if(0===(a.lanes&c)&&0===(b.flags&128))return og=!1,wj(a,b,c);og=0!==(a.flags&131072)?!0:!1;}else og=!1,N$4&&0!==(b.flags&1048576)&&Ug(b,Ng,b.index);b.lanes=0;switch(b.tag){case 2:var d=b.type;null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2);a=b.pendingProps;var e=Sf(b,I$8.current);ng(b,c);e=Nh$1(null,b,d,a,e,c);var f=Sh$1();b.flags|=1;"object"===typeof e&&null!==e&&"function"===typeof e.render&&void 0===e.$$typeof?
	(b.tag=1,b.memoizedState=null,b.updateQueue=null,Tf(d)?(f=!0,Xf(b)):f=!1,b.memoizedState=null!==e.state&&void 0!==e.state?e.state:null,sg(b),e.updater=Fg,b.stateNode=e,e._reactInternals=b,Jg(b,d,a,c),b=hj(null,b,d,!0,f,c)):(b.tag=0,N$4&&f&&Vg(b),Xi$1(null,b,e,c),b=b.child);return b;case 16:d=b.elementType;a:{null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2);a=b.pendingProps;e=d._init;d=e(d._payload);b.type=d;e=b.tag=Pk(d);a=fg(d,a);switch(e){case 0:b=cj(null,b,d,a,c);break a;case 1:b=gj(null,b,
	d,a,c);break a;case 11:b=Yi$1(null,b,d,a,c);break a;case 14:b=$i$1(null,b,d,fg(d.type,a),c);break a}throw Error(p$f(306,d,""));}return b;case 0:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:fg(d,e),cj(a,b,d,e,c);case 1:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:fg(d,e),gj(a,b,d,e,c);case 3:a:{ij(b);if(null===a)throw Error(p$f(387));d=b.pendingProps;f=b.memoizedState;e=f.element;tg(a,b);yg(b,d,null,c);var g=b.memoizedState;d=g.element;if(f.isDehydrated)if(f={element:d,isDehydrated:!1,
	cache:g.cache,transitions:g.transitions},b.updateQueue.baseState=f,b.memoizedState=f,b.flags&256){e=Error(p$f(423));b=jj(a,b,d,c,e);break a}else if(d!==e){e=Error(p$f(424));b=jj(a,b,d,c,e);break a}else for(Yg=Ff(b.stateNode.containerInfo.firstChild),Xg=b,N$4=!0,Zg=null,c=sh$1(b,null,d,c),b.child=c;c;)c.flags=c.flags&-3|4096,c=c.sibling;else {gh$1();if(d===e){b=Zi$1(a,b,c);break a}Xi$1(a,b,d,c);}b=b.child;}return b;case 5:return Ah$1(b),null===a&&dh$1(b),d=b.type,e=b.pendingProps,f=null!==a?a.memoizedProps:null,g=e.children,
	yf(d,e)?g=null:null!==f&&yf(d,f)&&(b.flags|=32),fj(a,b),Xi$1(a,b,g,c),b.child;case 6:return null===a&&dh$1(b),null;case 13:return mj(a,b,c);case 4:return yh$1(b,b.stateNode.containerInfo),d=b.pendingProps,null===a?b.child=rh$1(b,null,d,c):Xi$1(a,b,d,c),b.child;case 11:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:fg(d,e),Yi$1(a,b,d,e,c);case 7:return Xi$1(a,b,b.pendingProps,c),b.child;case 8:return Xi$1(a,b,b.pendingProps.children,c),b.child;case 12:return Xi$1(a,b,b.pendingProps.children,c),b.child;case 10:a:{d=
	b.type._context;e=b.pendingProps;f=b.memoizedProps;g=e.value;H$8(gg,d._currentValue);d._currentValue=g;if(null!==f)if(Ce$2(f.value,g)){if(f.children===e.children&&!Qf.current){b=Zi$1(a,b,c);break a}}else for(f=b.child,null!==f&&(f.return=b);null!==f;){var h=f.dependencies;if(null!==h){g=f.child;for(var k=h.firstContext;null!==k;){if(k.context===d){if(1===f.tag){k=ug(-1,c&-c);k.tag=2;var l=f.updateQueue;if(null!==l){l=l.shared;var m=l.pending;null===m?k.next=k:(k.next=m.next,m.next=k);l.pending=k;}}f.lanes|=
	c;k=f.alternate;null!==k&&(k.lanes|=c);mg(f.return,c,b);h.lanes|=c;break}k=k.next;}}else if(10===f.tag)g=f.type===b.type?null:f.child;else if(18===f.tag){g=f.return;if(null===g)throw Error(p$f(341));g.lanes|=c;h=g.alternate;null!==h&&(h.lanes|=c);mg(g,c,b);g=f.sibling;}else g=f.child;if(null!==g)g.return=f;else for(g=f;null!==g;){if(g===b){g=null;break}f=g.sibling;if(null!==f){f.return=g.return;g=f;break}g=g.return;}f=g;}Xi$1(a,b,e.children,c);b=b.child;}return b;case 9:return e=b.type,d=b.pendingProps.children,
	ng(b,c),e=pg(e),d=d(e),b.flags|=1,Xi$1(a,b,d,c),b.child;case 14:return d=b.type,e=fg(d,b.pendingProps),e=fg(d.type,e),$i$1(a,b,d,e,c);case 15:return bj(a,b,b.type,b.pendingProps,c);case 17:return d=b.type,e=b.pendingProps,e=b.elementType===d?e:fg(d,e),null!==a&&(a.alternate=null,b.alternate=null,b.flags|=2),b.tag=1,Tf(d)?(a=!0,Xf(b)):a=!1,ng(b,c),Hg(b,d,e),Jg(b,d,e,c),hj(null,b,d,!0,a,c);case 19:return vj(a,b,c);case 22:return dj(a,b,c)}throw Error(p$f(156,b.tag));};function vk(a,b){return Yb$1(a,b)}
	function Qk(a,b,c,d){this.tag=a;this.key=c;this.sibling=this.child=this.return=this.stateNode=this.type=this.elementType=null;this.index=0;this.ref=null;this.pendingProps=b;this.dependencies=this.memoizedState=this.updateQueue=this.memoizedProps=null;this.mode=d;this.subtreeFlags=this.flags=0;this.deletions=null;this.childLanes=this.lanes=0;this.alternate=null;}function ah$1(a,b,c,d){return new Qk(a,b,c,d)}function aj(a){a=a.prototype;return !(!a||!a.isReactComponent)}
	function Pk(a){if("function"===typeof a)return aj(a)?1:0;if(void 0!==a&&null!==a){a=a.$$typeof;if(a===Ba$3)return 11;if(a===Ea$3)return 14}return 2}
	function mh$1(a,b){var c=a.alternate;null===c?(c=ah$1(a.tag,b,a.key,a.mode),c.elementType=a.elementType,c.type=a.type,c.stateNode=a.stateNode,c.alternate=a,a.alternate=c):(c.pendingProps=b,c.type=a.type,c.flags=0,c.subtreeFlags=0,c.deletions=null);c.flags=a.flags&14680064;c.childLanes=a.childLanes;c.lanes=a.lanes;c.child=a.child;c.memoizedProps=a.memoizedProps;c.memoizedState=a.memoizedState;c.updateQueue=a.updateQueue;b=a.dependencies;c.dependencies=null===b?null:{lanes:b.lanes,firstContext:b.firstContext};
	c.sibling=a.sibling;c.index=a.index;c.ref=a.ref;return c}
	function oh$1(a,b,c,d,e,f){var g=2;d=a;if("function"===typeof a)aj(a)&&(g=1);else if("string"===typeof a)g=5;else a:switch(a){case va$3:return qh$1(c.children,e,f,b);case wa$3:g=8;e|=8;break;case xa$3:return a=ah$1(12,c,b,e|2),a.elementType=xa$3,a.lanes=f,a;case Ca$3:return a=ah$1(13,c,b,e),a.elementType=Ca$3,a.lanes=f,a;case Da$3:return a=ah$1(19,c,b,e),a.elementType=Da$3,a.lanes=f,a;case Ga$3:return nj(c,e,f,b);default:if("object"===typeof a&&null!==a)switch(a.$$typeof){case ya$3:g=10;break a;case Aa$3:g=9;break a;case Ba$3:g=11;
	break a;case Ea$3:g=14;break a;case Fa$3:g=16;d=null;break a}throw Error(p$f(130,null==a?a:typeof a,""));}b=ah$1(g,c,b,e);b.elementType=a;b.type=d;b.lanes=f;return b}function qh$1(a,b,c,d){a=ah$1(7,a,d,b);a.lanes=c;return a}function nj(a,b,c,d){a=ah$1(22,a,d,b);a.elementType=Ga$3;a.lanes=c;a.stateNode={};return a}function nh$1(a,b,c){a=ah$1(6,a,null,b);a.lanes=c;return a}
	function ph$1(a,b,c){b=ah$1(4,null!==a.children?a.children:[],a.key,b);b.lanes=c;b.stateNode={containerInfo:a.containerInfo,pendingChildren:null,implementation:a.implementation};return b}
	function Rk(a,b,c,d,e){this.tag=b;this.containerInfo=a;this.finishedWork=this.pingCache=this.current=this.pendingChildren=null;this.timeoutHandle=-1;this.callbackNode=this.pendingContext=this.context=null;this.callbackPriority=0;this.eventTimes=vc$2(0);this.expirationTimes=vc$2(-1);this.entangledLanes=this.finishedLanes=this.mutableReadLanes=this.expiredLanes=this.pingedLanes=this.suspendedLanes=this.pendingLanes=0;this.entanglements=vc$2(0);this.identifierPrefix=d;this.onRecoverableError=e;this.mutableSourceEagerHydrationData=
	null;}function Sk(a,b,c,d,e,f,g,h,k){a=new Rk(a,b,c,h,k);1===b?(b=1,!0===f&&(b|=8)):b=0;f=ah$1(3,null,null,b);a.current=f;f.stateNode=a;f.memoizedState={element:d,isDehydrated:c,cache:null,transitions:null};sg(f);return a}function Tk(a,b,c){var d=3<arguments.length&&void 0!==arguments[3]?arguments[3]:null;return {$$typeof:ua$3,key:null==d?null:""+d,children:a,containerInfo:b,implementation:c}}
	function Uk(a){if(!a)return Pf;a=a._reactInternals;a:{if(Sb$2(a)!==a||1!==a.tag)throw Error(p$f(170));var b=a;do{switch(b.tag){case 3:b=b.stateNode.context;break a;case 1:if(Tf(b.type)){b=b.stateNode.__reactInternalMemoizedMergedChildContext;break a}}b=b.return;}while(null!==b);throw Error(p$f(171));}if(1===a.tag){var c=a.type;if(Tf(c))return Wf(a,c,b)}return b}
	function Vk(a,b,c,d,e,f,g,h,k){a=Sk(c,d,!0,a,e,f,g,h,k);a.context=Uk(null);c=a.current;d=M$b();e=Dg(c);f=ug(d,e);f.callback=void 0!==b&&null!==b?b:null;vg(c,f);a.current.lanes=e;wc$2(a,e,d);tk(a,d);return a}function Wk(a,b,c,d){var e=b.current,f=M$b(),g=Dg(e);c=Uk(c);null===b.context?b.context=c:b.pendingContext=c;b=ug(f,g);b.payload={element:a};d=void 0===d?null:d;null!==d&&(b.callback=d);vg(e,b);a=Eg(e,g,f);null!==a&&wg(a,e,g);return g}
	function Xk(a){a=a.current;if(!a.child)return null;switch(a.child.tag){case 5:return a.child.stateNode;default:return a.child.stateNode}}function Yk(a,b){a=a.memoizedState;if(null!==a&&null!==a.dehydrated){var c=a.retryLane;a.retryLane=0!==c&&c<b?c:b;}}function Zk(a,b){Yk(a,b);(a=a.alternate)&&Yk(a,b);}function $k(){return null}var al$1="function"===typeof reportError?reportError:function(a){console.error(a);};function bl$1(a){this._internalRoot=a;}
	cl$1.prototype.render=bl$1.prototype.render=function(a){var b=this._internalRoot;if(null===b)throw Error(p$f(409));Wk(a,b,null,null);};cl$1.prototype.unmount=bl$1.prototype.unmount=function(){var a=this._internalRoot;if(null!==a){this._internalRoot=null;var b=a.containerInfo;Hk(function(){Wk(null,a,null,null);});b[pf]=null;}};function cl$1(a){this._internalRoot=a;}
	cl$1.prototype.unstable_scheduleHydration=function(a){if(a){var b=Dc$2();a={blockedOn:null,target:a,priority:b};for(var c=0;c<Mc$2.length&&0!==b&&b<Mc$2[c].priority;c++);Mc$2.splice(c,0,a);0===c&&Rc$2(a);}};function dl$1(a){return !(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType)}function el(a){return !(!a||1!==a.nodeType&&9!==a.nodeType&&11!==a.nodeType&&(8!==a.nodeType||" react-mount-point-unstable "!==a.nodeValue))}function fl$1(){}
	function gl$1(a,b,c,d,e){if(e){if("function"===typeof d){var f=d;d=function(){var a=Xk(g);f.call(a);};}var g=Vk(b,d,a,0,null,!1,!1,"",fl$1);a._reactRootContainer=g;a[pf]=g.current;nf(8===a.nodeType?a.parentNode:a);Hk();return g}for(;e=a.lastChild;)a.removeChild(e);if("function"===typeof d){var h=d;d=function(){var a=Xk(k);h.call(a);};}var k=Sk(a,0,!1,null,null,!1,!1,"",fl$1);a._reactRootContainer=k;a[pf]=k.current;nf(8===a.nodeType?a.parentNode:a);Hk(function(){Wk(b,k,c,d);});return k}
	function hl$1(a,b,c,d,e){var f=c._reactRootContainer;if(f){var g=f;if("function"===typeof e){var h=e;e=function(){var a=Xk(g);h.call(a);};}Wk(b,g,a,e);}else g=gl$1(c,b,a,e,d);return Xk(g)}Ac$2=function(a){switch(a.tag){case 3:var b=a.stateNode;if(b.current.memoizedState.isDehydrated){var c=qc$2(b.pendingLanes);0!==c&&(yc$2(b,c|1),tk(b,D$8()),0===(K$2&6)&&(Ti$1=D$8()+500,dg()));}break;case 13:var d=M$b();Hk(function(){return Eg(a,1,d)});Zk(a,1);}};Bc$2=function(a){if(13===a.tag){var b=M$b();Eg(a,134217728,b);Zk(a,134217728);}};
	Cc$2=function(a){if(13===a.tag){var b=M$b(),c=Dg(a);Eg(a,c,b);Zk(a,c);}};Dc$2=function(){return E$5};Ec$2=function(a,b){var c=E$5;try{return E$5=a,b()}finally{E$5=c;}};
	vb$3=function(a,b,c){switch(b){case "input":Za$3(a,c);b=c.name;if("radio"===c.type&&null!=b){for(c=a;c.parentNode;)c=c.parentNode;c=c.querySelectorAll("input[name="+JSON.stringify(""+b)+'][type="radio"]');for(b=0;b<c.length;b++){var d=c[b];if(d!==a&&d.form===a.form){var e=Ab$3(d);if(!e)throw Error(p$f(90));Ua$3(d);Za$3(d,e);}}}break;case "textarea":fb$3(a,c);break;case "select":b=c.value,null!=b&&cb$2(a,!!c.multiple,b,!1);}};Db$2=Gk;Eb$2=Hk;
	var il$1={usingClientEntryPoint:!1,Events:[zb$2,pe$4,Ab$3,Bb$2,Cb$3,Gk]},jl$1={findFiberByHostInstance:Sc$2,bundleType:0,version:"18.0.0-fc46dba67-20220329",rendererPackageName:"react-dom"};
	var kl$1={bundleType:jl$1.bundleType,version:jl$1.version,rendererPackageName:jl$1.rendererPackageName,rendererConfig:jl$1.rendererConfig,overrideHookState:null,overrideHookStateDeletePath:null,overrideHookStateRenamePath:null,overrideProps:null,overridePropsDeletePath:null,overridePropsRenamePath:null,setErrorHandler:null,setSuspenseHandler:null,scheduleUpdate:null,currentDispatcherRef:sa$3.ReactCurrentDispatcher,findHostInstanceByFiber:function(a){a=Wb$1(a);return null===a?null:a.stateNode},findFiberByHostInstance:jl$1.findFiberByHostInstance||
	$k,findHostInstancesForRefresh:null,scheduleRefresh:null,scheduleRoot:null,setRefreshHandler:null,getCurrentFiber:null,reconcilerVersion:"18.0.0-fc46dba67-20220329"};if("undefined"!==typeof __REACT_DEVTOOLS_GLOBAL_HOOK__){var ll$1=__REACT_DEVTOOLS_GLOBAL_HOOK__;if(!ll$1.isDisabled&&ll$1.supportsFiber)try{hc$2=ll$1.inject(kl$1),ic$2=ll$1;}catch(a){}}reactDom_production_min.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=il$1;
	reactDom_production_min.createPortal=function(a,b){var c=2<arguments.length&&void 0!==arguments[2]?arguments[2]:null;if(!dl$1(b))throw Error(p$f(200));return Tk(a,b,null,c)};reactDom_production_min.createRoot=function(a,b){if(!dl$1(a))throw Error(p$f(299));var c=!1,d="",e=al$1;null!==b&&void 0!==b&&(!0===b.unstable_strictMode&&(c=!0),void 0!==b.identifierPrefix&&(d=b.identifierPrefix),void 0!==b.onRecoverableError&&(e=b.onRecoverableError));b=Sk(a,1,!1,null,null,c,!1,d,e);a[pf]=b.current;nf(8===a.nodeType?a.parentNode:a);return new bl$1(b)};
	reactDom_production_min.findDOMNode=function(a){if(null==a)return null;if(1===a.nodeType)return a;var b=a._reactInternals;if(void 0===b){if("function"===typeof a.render)throw Error(p$f(188));a=Object.keys(a).join(",");throw Error(p$f(268,a));}a=Wb$1(b);a=null===a?null:a.stateNode;return a};reactDom_production_min.flushSync=function(a){return Hk(a)};reactDom_production_min.hydrate=function(a,b,c){if(!el(b))throw Error(p$f(200));return hl$1(null,a,b,!0,c)};
	reactDom_production_min.hydrateRoot=function(a,b,c){if(!dl$1(a))throw Error(p$f(405));var d=null!=c&&c.hydratedSources||null,e=!1,f="",g=al$1;null!==c&&void 0!==c&&(!0===c.unstable_strictMode&&(e=!0),void 0!==c.identifierPrefix&&(f=c.identifierPrefix),void 0!==c.onRecoverableError&&(g=c.onRecoverableError));b=Vk(b,null,a,1,null!=c?c:null,e,!1,f,g);a[pf]=b.current;nf(a);if(d)for(a=0;a<d.length;a++)c=d[a],e=c._getVersion,e=e(c._source),null==b.mutableSourceEagerHydrationData?b.mutableSourceEagerHydrationData=[c,e]:b.mutableSourceEagerHydrationData.push(c,
	e);return new cl$1(b)};reactDom_production_min.render=function(a,b,c){if(!el(b))throw Error(p$f(200));return hl$1(null,a,b,!1,c)};reactDom_production_min.unmountComponentAtNode=function(a){if(!el(a))throw Error(p$f(40));return a._reactRootContainer?(Hk(function(){hl$1(null,null,a,!1,function(){a._reactRootContainer=null;a[pf]=null;});}),!0):!1};reactDom_production_min.unstable_batchedUpdates=Gk;
	reactDom_production_min.unstable_renderSubtreeIntoContainer=function(a,b,c,d){if(!el(c))throw Error(p$f(200));if(null==a||void 0===a._reactInternals)throw Error(p$f(38));return hl$1(a,b,c,!1,d)};reactDom_production_min.version="18.0.0-fc46dba67-20220329";

	function checkDCE() {
	  /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
	  if (
	    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined' ||
	    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== 'function'
	  ) {
	    return;
	  }
	  try {
	    // Verify that the code above has been dead code eliminated (DCE'd).
	    __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);
	  } catch (err) {
	    // DevTools shouldn't crash React, no matter what.
	    // We should still report in case we break this code.
	    console.error(err);
	  }
	}

	{
	  // DCE check should happen before ReactDOM bundle executes so that
	  // DevTools can report bad minification during injection.
	  checkDCE();
	  reactDom.exports = reactDom_production_min;
	}

	var reactDomExports = reactDom.exports;

	var m$8 = reactDomExports;
	{
	  client.createRoot = m$8.createRoot;
	  client.hydrateRoot = m$8.hydrateRoot;
	}

	/**
	 * @remix-run/router v1.0.0
	 *
	 * Copyright (c) Remix Software Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE.md file in the root directory of this source tree.
	 *
	 * @license MIT
	 */
	function _extends$3() {
	  _extends$3 = Object.assign ? Object.assign.bind() : function (target) {
	    for (var i = 1; i < arguments.length; i++) {
	      var source = arguments[i];

	      for (var key in source) {
	        if (Object.prototype.hasOwnProperty.call(source, key)) {
	          target[key] = source[key];
	        }
	      }
	    }

	    return target;
	  };
	  return _extends$3.apply(this, arguments);
	}

	////////////////////////////////////////////////////////////////////////////////
	//#region Types and Constants
	////////////////////////////////////////////////////////////////////////////////

	/**
	 * Actions represent the type of change to a location value.
	 */
	var Action;

	(function (Action) {
	  /**
	   * A POP indicates a change to an arbitrary index in the history stack, such
	   * as a back or forward navigation. It does not describe the direction of the
	   * navigation, only that the current index changed.
	   *
	   * Note: This is the default action for newly created history objects.
	   */
	  Action["Pop"] = "POP";
	  /**
	   * A PUSH indicates a new entry being added to the history stack, such as when
	   * a link is clicked and a new page loads. When this happens, all subsequent
	   * entries in the stack are lost.
	   */

	  Action["Push"] = "PUSH";
	  /**
	   * A REPLACE indicates the entry at the current index in the history stack
	   * being replaced by a new one.
	   */

	  Action["Replace"] = "REPLACE";
	})(Action || (Action = {}));

	const PopStateEventType = "popstate";
	/**
	 * Browser history stores the location in regular URLs. This is the standard for
	 * most web apps, but it requires some configuration on the server to ensure you
	 * serve the same app at multiple URLs.
	 *
	 * @see https://github.com/remix-run/history/tree/main/docs/api-reference.md#createbrowserhistory
	 */

	function createBrowserHistory(options) {
	  if (options === void 0) {
	    options = {};
	  }

	  function createBrowserLocation(window, globalHistory) {
	    var _globalHistory$state, _globalHistory$state2;

	    let {
	      pathname,
	      search,
	      hash
	    } = window.location;
	    return createLocation$1("", {
	      pathname,
	      search,
	      hash
	    }, // state defaults to `null` because `window.history.state` does
	    ((_globalHistory$state = globalHistory.state) == null ? void 0 : _globalHistory$state.usr) || null, ((_globalHistory$state2 = globalHistory.state) == null ? void 0 : _globalHistory$state2.key) || "default");
	  }

	  function createBrowserHref(window, to) {
	    return typeof to === "string" ? to : createPath(to);
	  }

	  return getUrlBasedHistory(createBrowserLocation, createBrowserHref, null, options);
	}

	function createKey() {
	  return Math.random().toString(36).substr(2, 8);
	}
	/**
	 * For browser-based histories, we combine the state and key into an object
	 */


	function getHistoryState(location) {
	  return {
	    usr: location.state,
	    key: location.key
	  };
	}
	/**
	 * Creates a Location object with a unique key from the given Path
	 */


	function createLocation$1(current, to, state, key) {
	  if (state === void 0) {
	    state = null;
	  }

	  let location = _extends$3({
	    pathname: typeof current === "string" ? current : current.pathname,
	    search: "",
	    hash: ""
	  }, typeof to === "string" ? parsePath(to) : to, {
	    state,
	    // TODO: This could be cleaned up.  push/replace should probably just take
	    // full Locations now and avoid the need to run through this flow at all
	    // But that's a pretty big refactor to the current test suite so going to
	    // keep as is for the time being and just let any incoming keys take precedence
	    key: (to == null ? void 0 : to.key) || key || createKey()
	  });

	  return location;
	}
	/**
	 * Creates a string URL path from the given pathname, search, and hash components.
	 */

	function createPath(_ref) {
	  let {
	    pathname = "/",
	    search = "",
	    hash = ""
	  } = _ref;
	  if (search && search !== "?") pathname += search.charAt(0) === "?" ? search : "?" + search;
	  if (hash && hash !== "#") pathname += hash.charAt(0) === "#" ? hash : "#" + hash;
	  return pathname;
	}
	/**
	 * Parses a string URL path into its separate pathname, search, and hash components.
	 */

	function parsePath(path) {
	  let parsedPath = {};

	  if (path) {
	    let hashIndex = path.indexOf("#");

	    if (hashIndex >= 0) {
	      parsedPath.hash = path.substr(hashIndex);
	      path = path.substr(0, hashIndex);
	    }

	    let searchIndex = path.indexOf("?");

	    if (searchIndex >= 0) {
	      parsedPath.search = path.substr(searchIndex);
	      path = path.substr(0, searchIndex);
	    }

	    if (path) {
	      parsedPath.pathname = path;
	    }
	  }

	  return parsedPath;
	}

	function getUrlBasedHistory(getLocation, createHref, validateLocation, options) {
	  if (options === void 0) {
	    options = {};
	  }

	  let {
	    window = document.defaultView,
	    v5Compat = false
	  } = options;
	  let globalHistory = window.history;
	  let action = Action.Pop;
	  let listener = null;

	  function handlePop() {
	    action = Action.Pop;

	    if (listener) {
	      listener({
	        action,
	        location: history.location
	      });
	    }
	  }

	  function push(to, state) {
	    action = Action.Push;
	    let location = createLocation$1(history.location, to, state);
	    let historyState = getHistoryState(location);
	    let url = history.createHref(location); // try...catch because iOS limits us to 100 pushState calls :/

	    try {
	      globalHistory.pushState(historyState, "", url);
	    } catch (error) {
	      // They are going to lose state here, but there is no real
	      // way to warn them about it since the page will refresh...
	      window.location.assign(url);
	    }

	    if (v5Compat && listener) {
	      listener({
	        action,
	        location
	      });
	    }
	  }

	  function replace(to, state) {
	    action = Action.Replace;
	    let location = createLocation$1(history.location, to, state);
	    let historyState = getHistoryState(location);
	    let url = history.createHref(location);
	    globalHistory.replaceState(historyState, "", url);

	    if (v5Compat && listener) {
	      listener({
	        action,
	        location: location
	      });
	    }
	  }

	  let history = {
	    get action() {
	      return action;
	    },

	    get location() {
	      return getLocation(window, globalHistory);
	    },

	    listen(fn) {
	      if (listener) {
	        throw new Error("A history only accepts one active listener");
	      }

	      window.addEventListener(PopStateEventType, handlePop);
	      listener = fn;
	      return () => {
	        window.removeEventListener(PopStateEventType, handlePop);
	        listener = null;
	      };
	    },

	    createHref(to) {
	      return createHref(window, to);
	    },

	    push,
	    replace,

	    go(n) {
	      return globalHistory.go(n);
	    }

	  };
	  return history;
	} //#endregion

	var ResultType;

	(function (ResultType) {
	  ResultType["data"] = "data";
	  ResultType["deferred"] = "deferred";
	  ResultType["redirect"] = "redirect";
	  ResultType["error"] = "error";
	})(ResultType || (ResultType = {})); // Walk the route tree generating unique IDs where necessary so we are working
	/**
	 * Matches the given routes to a location and returns the match data.
	 *
	 * @see https://reactrouter.com/docs/en/v6/utils/match-routes
	 */

	function matchRoutes(routes, locationArg, basename) {
	  if (basename === void 0) {
	    basename = "/";
	  }

	  let location = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
	  let pathname = stripBasename(location.pathname || "/", basename);

	  if (pathname == null) {
	    return null;
	  }

	  let branches = flattenRoutes(routes);
	  rankRouteBranches(branches);
	  let matches = null;

	  for (let i = 0; matches == null && i < branches.length; ++i) {
	    matches = matchRouteBranch(branches[i], pathname);
	  }

	  return matches;
	}

	function flattenRoutes(routes, branches, parentsMeta, parentPath) {
	  if (branches === void 0) {
	    branches = [];
	  }

	  if (parentsMeta === void 0) {
	    parentsMeta = [];
	  }

	  if (parentPath === void 0) {
	    parentPath = "";
	  }

	  routes.forEach((route, index) => {
	    let meta = {
	      relativePath: route.path || "",
	      caseSensitive: route.caseSensitive === true,
	      childrenIndex: index,
	      route
	    };

	    if (meta.relativePath.startsWith("/")) {
	      invariant$4(meta.relativePath.startsWith(parentPath), "Absolute route path \"" + meta.relativePath + "\" nested under path " + ("\"" + parentPath + "\" is not valid. An absolute child route path ") + "must start with the combined path of all its parent routes.");
	      meta.relativePath = meta.relativePath.slice(parentPath.length);
	    }

	    let path = joinPaths([parentPath, meta.relativePath]);
	    let routesMeta = parentsMeta.concat(meta); // Add the children before adding this route to the array so we traverse the
	    // route tree depth-first and child routes appear before their parents in
	    // the "flattened" version.

	    if (route.children && route.children.length > 0) {
	      invariant$4(route.index !== true, "Index routes must not have child routes. Please remove " + ("all child routes from route path \"" + path + "\"."));
	      flattenRoutes(route.children, branches, routesMeta, path);
	    } // Routes without a path shouldn't ever match by themselves unless they are
	    // index routes, so don't add them to the list of possible branches.


	    if (route.path == null && !route.index) {
	      return;
	    }

	    branches.push({
	      path,
	      score: computeScore(path, route.index),
	      routesMeta
	    });
	  });
	  return branches;
	}

	function rankRouteBranches(branches) {
	  branches.sort((a, b) => a.score !== b.score ? b.score - a.score // Higher score first
	  : compareIndexes(a.routesMeta.map(meta => meta.childrenIndex), b.routesMeta.map(meta => meta.childrenIndex)));
	}

	const paramRe = /^:\w+$/;
	const dynamicSegmentValue = 3;
	const indexRouteValue = 2;
	const emptySegmentValue = 1;
	const staticSegmentValue = 10;
	const splatPenalty = -2;

	const isSplat = s => s === "*";

	function computeScore(path, index) {
	  let segments = path.split("/");
	  let initialScore = segments.length;

	  if (segments.some(isSplat)) {
	    initialScore += splatPenalty;
	  }

	  if (index) {
	    initialScore += indexRouteValue;
	  }

	  return segments.filter(s => !isSplat(s)).reduce((score, segment) => score + (paramRe.test(segment) ? dynamicSegmentValue : segment === "" ? emptySegmentValue : staticSegmentValue), initialScore);
	}

	function compareIndexes(a, b) {
	  let siblings = a.length === b.length && a.slice(0, -1).every((n, i) => n === b[i]);
	  return siblings ? // If two routes are siblings, we should try to match the earlier sibling
	  // first. This allows people to have fine-grained control over the matching
	  // behavior by simply putting routes with identical paths in the order they
	  // want them tried.
	  a[a.length - 1] - b[b.length - 1] : // Otherwise, it doesn't really make sense to rank non-siblings by index,
	  // so they sort equally.
	  0;
	}

	function matchRouteBranch(branch, pathname) {
	  let {
	    routesMeta
	  } = branch;
	  let matchedParams = {};
	  let matchedPathname = "/";
	  let matches = [];

	  for (let i = 0; i < routesMeta.length; ++i) {
	    let meta = routesMeta[i];
	    let end = i === routesMeta.length - 1;
	    let remainingPathname = matchedPathname === "/" ? pathname : pathname.slice(matchedPathname.length) || "/";
	    let match = matchPath({
	      path: meta.relativePath,
	      caseSensitive: meta.caseSensitive,
	      end
	    }, remainingPathname);
	    if (!match) return null;
	    Object.assign(matchedParams, match.params);
	    let route = meta.route;
	    matches.push({
	      // TODO: Can this as be avoided?
	      params: matchedParams,
	      pathname: joinPaths([matchedPathname, match.pathname]),
	      pathnameBase: normalizePathname(joinPaths([matchedPathname, match.pathnameBase])),
	      route
	    });

	    if (match.pathnameBase !== "/") {
	      matchedPathname = joinPaths([matchedPathname, match.pathnameBase]);
	    }
	  }

	  return matches;
	}
	/**
	 * Performs pattern matching on a URL pathname and returns information about
	 * the match.
	 *
	 * @see https://reactrouter.com/docs/en/v6/utils/match-path
	 */

	function matchPath(pattern, pathname) {
	  if (typeof pattern === "string") {
	    pattern = {
	      path: pattern,
	      caseSensitive: false,
	      end: true
	    };
	  }

	  let [matcher, paramNames] = compilePath(pattern.path, pattern.caseSensitive, pattern.end);
	  let match = pathname.match(matcher);
	  if (!match) return null;
	  let matchedPathname = match[0];
	  let pathnameBase = matchedPathname.replace(/(.)\/+$/, "$1");
	  let captureGroups = match.slice(1);
	  let params = paramNames.reduce((memo, paramName, index) => {
	    // We need to compute the pathnameBase here using the raw splat value
	    // instead of using params["*"] later because it will be decoded then
	    if (paramName === "*") {
	      let splatValue = captureGroups[index] || "";
	      pathnameBase = matchedPathname.slice(0, matchedPathname.length - splatValue.length).replace(/(.)\/+$/, "$1");
	    }

	    memo[paramName] = safelyDecodeURIComponent(captureGroups[index] || "", paramName);
	    return memo;
	  }, {});
	  return {
	    params,
	    pathname: matchedPathname,
	    pathnameBase,
	    pattern
	  };
	}

	function compilePath(path, caseSensitive, end) {
	  if (caseSensitive === void 0) {
	    caseSensitive = false;
	  }

	  if (end === void 0) {
	    end = true;
	  }

	  warning(path === "*" || !path.endsWith("*") || path.endsWith("/*"), "Route path \"" + path + "\" will be treated as if it were " + ("\"" + path.replace(/\*$/, "/*") + "\" because the `*` character must ") + "always follow a `/` in the pattern. To get rid of this warning, " + ("please change the route path to \"" + path.replace(/\*$/, "/*") + "\"."));
	  let paramNames = [];
	  let regexpSource = "^" + path.replace(/\/*\*?$/, "") // Ignore trailing / and /*, we'll handle it below
	  .replace(/^\/*/, "/") // Make sure it has a leading /
	  .replace(/[\\.*+^$?{}|()[\]]/g, "\\$&") // Escape special regex chars
	  .replace(/:(\w+)/g, (_, paramName) => {
	    paramNames.push(paramName);
	    return "([^\\/]+)";
	  });

	  if (path.endsWith("*")) {
	    paramNames.push("*");
	    regexpSource += path === "*" || path === "/*" ? "(.*)$" // Already matched the initial /, just match the rest
	    : "(?:\\/(.+)|\\/*)$"; // Don't include the / in params["*"]
	  } else {
	    regexpSource += end ? "\\/*$" // When matching to the end, ignore trailing slashes
	    : // Otherwise, match a word boundary or a proceeding /. The word boundary restricts
	    // parent routes to matching only their own words and nothing more, e.g. parent
	    // route "/home" should not match "/home2".
	    // Additionally, allow paths starting with `.`, `-`, `~`, and url-encoded entities,
	    // but do not consume the character in the matched path so they can match against
	    // nested paths.
	    "(?:(?=[@.~-]|%[0-9A-F]{2})|\\b|\\/|$)";
	  }

	  let matcher = new RegExp(regexpSource, caseSensitive ? undefined : "i");
	  return [matcher, paramNames];
	}

	function safelyDecodeURIComponent(value, paramName) {
	  try {
	    return decodeURIComponent(value);
	  } catch (error) {
	    warning(false, "The value for the URL param \"" + paramName + "\" will not be decoded because" + (" the string \"" + value + "\" is a malformed URL segment. This is probably") + (" due to a bad percent encoding (" + error + ")."));
	    return value;
	  }
	}
	/**
	 * @private
	 */


	function stripBasename(pathname, basename) {
	  if (basename === "/") return pathname;

	  if (!pathname.toLowerCase().startsWith(basename.toLowerCase())) {
	    return null;
	  } // We want to leave trailing slash behavior in the user's control, so if they
	  // specify a basename with a trailing slash, we should support it


	  let startIndex = basename.endsWith("/") ? basename.length - 1 : basename.length;
	  let nextChar = pathname.charAt(startIndex);

	  if (nextChar && nextChar !== "/") {
	    // pathname does not start with basename/
	    return null;
	  }

	  return pathname.slice(startIndex) || "/";
	}
	function invariant$4(value, message) {
	  if (value === false || value === null || typeof value === "undefined") {
	    throw new Error(message);
	  }
	}
	/**
	 * @private
	 */

	function warning(cond, message) {
	  if (!cond) {
	    // eslint-disable-next-line no-console
	    if (typeof console !== "undefined") console.warn(message);

	    try {
	      // Welcome to debugging React Router!
	      //
	      // This error is thrown as a convenience so you can more easily
	      // find the source for a warning that appears in the console by
	      // enabling "pause on exceptions" in your JavaScript debugger.
	      throw new Error(message); // eslint-disable-next-line no-empty
	    } catch (e) {}
	  }
	}
	/**
	 * Returns a resolved path object relative to the given pathname.
	 *
	 * @see https://reactrouter.com/docs/en/v6/utils/resolve-path
	 */

	function resolvePath(to, fromPathname) {
	  if (fromPathname === void 0) {
	    fromPathname = "/";
	  }

	  let {
	    pathname: toPathname,
	    search = "",
	    hash = ""
	  } = typeof to === "string" ? parsePath(to) : to;
	  let pathname = toPathname ? toPathname.startsWith("/") ? toPathname : resolvePathname(toPathname, fromPathname) : fromPathname;
	  return {
	    pathname,
	    search: normalizeSearch(search),
	    hash: normalizeHash(hash)
	  };
	}

	function resolvePathname(relativePath, fromPathname) {
	  let segments = fromPathname.replace(/\/+$/, "").split("/");
	  let relativeSegments = relativePath.split("/");
	  relativeSegments.forEach(segment => {
	    if (segment === "..") {
	      // Keep the root "" segment so the pathname starts at /
	      if (segments.length > 1) segments.pop();
	    } else if (segment !== ".") {
	      segments.push(segment);
	    }
	  });
	  return segments.length > 1 ? segments.join("/") : "/";
	}
	/**
	 * @private
	 */


	function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
	  if (isPathRelative === void 0) {
	    isPathRelative = false;
	  }

	  let to = typeof toArg === "string" ? parsePath(toArg) : _extends$3({}, toArg);
	  let isEmptyPath = toArg === "" || to.pathname === "";
	  let toPathname = isEmptyPath ? "/" : to.pathname;
	  let from; // Routing is relative to the current pathname if explicitly requested.
	  //
	  // If a pathname is explicitly provided in `to`, it should be relative to the
	  // route context. This is explained in `Note on `<Link to>` values` in our
	  // migration guide from v5 as a means of disambiguation between `to` values
	  // that begin with `/` and those that do not. However, this is problematic for
	  // `to` values that do not provide a pathname. `to` can simply be a search or
	  // hash string, in which case we should assume that the navigation is relative
	  // to the current location's pathname and *not* the route pathname.

	  if (isPathRelative || toPathname == null) {
	    from = locationPathname;
	  } else {
	    let routePathnameIndex = routePathnames.length - 1;

	    if (toPathname.startsWith("..")) {
	      let toSegments = toPathname.split("/"); // Each leading .. segment means "go up one route" instead of "go up one
	      // URL segment".  This is a key difference from how <a href> works and a
	      // major reason we call this a "to" value instead of a "href".

	      while (toSegments[0] === "..") {
	        toSegments.shift();
	        routePathnameIndex -= 1;
	      }

	      to.pathname = toSegments.join("/");
	    } // If there are more ".." segments than parent routes, resolve relative to
	    // the root / URL.


	    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
	  }

	  let path = resolvePath(to, from); // Ensure the pathname has a trailing slash if the original "to" had one

	  let hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/"); // Or if this was a link to the current path which has a trailing slash

	  let hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");

	  if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {
	    path.pathname += "/";
	  }

	  return path;
	}
	/**
	 * @private
	 */

	const joinPaths = paths => paths.join("/").replace(/\/\/+/g, "/");
	/**
	 * @private
	 */

	const normalizePathname = pathname => pathname.replace(/\/+$/, "").replace(/^\/*/, "/");
	/**
	 * @private
	 */

	const normalizeSearch = search => !search || search === "?" ? "" : search.startsWith("?") ? search : "?" + search;
	/**
	 * @private
	 */

	const normalizeHash = hash => !hash || hash === "#" ? "" : hash.startsWith("#") ? hash : "#" + hash;
	/**
	 * @private
	 * Utility class we use to hold auto-unwrapped 4xx/5xx Response bodies
	 */

	class ErrorResponse {
	  constructor(status, statusText, data) {
	    this.status = status;
	    this.statusText = statusText || "";
	    this.data = data;
	  }

	}
	/**
	 * Check if the given error is an ErrorResponse generated from a 4xx/5xx
	 * Response throw from an action/loader
	 */

	function isRouteErrorResponse(e) {
	  return e instanceof ErrorResponse;
	}

	/**
	 * React Router v6.4.0
	 *
	 * Copyright (c) Remix Software Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE.md file in the root directory of this source tree.
	 *
	 * @license MIT
	 */

	function _extends$2() {
	  _extends$2 = Object.assign ? Object.assign.bind() : function (target) {
	    for (var i = 1; i < arguments.length; i++) {
	      var source = arguments[i];

	      for (var key in source) {
	        if (Object.prototype.hasOwnProperty.call(source, key)) {
	          target[key] = source[key];
	        }
	      }
	    }

	    return target;
	  };
	  return _extends$2.apply(this, arguments);
	}

	// Contexts for data routers
	const DataStaticRouterContext = /*#__PURE__*/reactExports.createContext(null);

	const DataRouterContext = /*#__PURE__*/reactExports.createContext(null);

	const DataRouterStateContext = /*#__PURE__*/reactExports.createContext(null);

	const NavigationContext = /*#__PURE__*/reactExports.createContext(null);

	const LocationContext = /*#__PURE__*/reactExports.createContext(null);

	const RouteContext = /*#__PURE__*/reactExports.createContext({
	  outlet: null,
	  matches: []
	});

	const RouteErrorContext = /*#__PURE__*/reactExports.createContext(null);

	/**
	 * Returns the full href for the given "to" value. This is useful for building
	 * custom links that are also accessible and preserve right-click behavior.
	 *
	 * @see https://reactrouter.com/docs/en/v6/hooks/use-href
	 */

	function useHref(to, _temp) {
	  let {
	    relative
	  } = {} ;
	  !useInRouterContext() ? invariant$4(false) : void 0;
	  let {
	    basename,
	    navigator
	  } = reactExports.useContext(NavigationContext);
	  let {
	    hash,
	    pathname,
	    search
	  } = useResolvedPath(to, {
	    relative
	  });
	  let joinedPathname = pathname; // If we're operating within a basename, prepend it to the pathname prior
	  // to creating the href.  If this is a root navigation, then just use the raw
	  // basename which allows the basename to have full control over the presence
	  // of a trailing slash on root links

	  if (basename !== "/") {
	    joinedPathname = pathname === "/" ? basename : joinPaths([basename, pathname]);
	  }

	  return navigator.createHref({
	    pathname: joinedPathname,
	    search,
	    hash
	  });
	}
	/**
	 * Returns true if this component is a descendant of a <Router>.
	 *
	 * @see https://reactrouter.com/docs/en/v6/hooks/use-in-router-context
	 */

	function useInRouterContext() {
	  return reactExports.useContext(LocationContext) != null;
	}
	/**
	 * Returns the current location object, which represents the current URL in web
	 * browsers.
	 *
	 * Note: If you're using this it may mean you're doing some of your own
	 * "routing" in your app, and we'd like to know what your use case is. We may
	 * be able to provide something higher-level to better suit your needs.
	 *
	 * @see https://reactrouter.com/docs/en/v6/hooks/use-location
	 */

	function useLocation() {
	  !useInRouterContext() ? invariant$4(false) : void 0;
	  return reactExports.useContext(LocationContext).location;
	}
	/**
	 * Returns true if the URL for the given "to" value matches the current URL.
	 * This is useful for components that need to know "active" state, e.g.
	 * <NavLink>.
	 *
	 * @see https://reactrouter.com/docs/en/v6/hooks/use-match
	 */

	function useMatch(pattern) {
	  !useInRouterContext() ? invariant$4(false) : void 0;
	  let {
	    pathname
	  } = useLocation();
	  return reactExports.useMemo(() => matchPath(pattern, pathname), [pathname, pattern]);
	}
	/**
	 * The interface for the navigate() function returned from useNavigate().
	 */

	/**
	 * When processing relative navigation we want to ignore ancestor routes that
	 * do not contribute to the path, such that index/pathless layout routes don't
	 * interfere.
	 *
	 * For example, when moving a route element into an index route and/or a
	 * pathless layout route, relative link behavior contained within should stay
	 * the same.  Both of the following examples should link back to the root:
	 *
	 *   <Route path="/">
	 *     <Route path="accounts" element={<Link to=".."}>
	 *   </Route>
	 *
	 *   <Route path="/">
	 *     <Route path="accounts">
	 *       <Route element={<AccountsLayout />}>       // <-- Does not contribute
	 *         <Route index element={<Link to=".."} />  // <-- Does not contribute
	 *       </Route
	 *     </Route>
	 *   </Route>
	 */
	function getPathContributingMatches(matches) {
	  return matches.filter((match, index) => index === 0 || !match.route.index && match.pathnameBase !== matches[index - 1].pathnameBase);
	}
	/**
	 * Returns an imperative method for changing the location. Used by <Link>s, but
	 * may also be used by other elements to change the location.
	 *
	 * @see https://reactrouter.com/docs/en/v6/hooks/use-navigate
	 */


	function useNavigate() {
	  !useInRouterContext() ? invariant$4(false) : void 0;
	  let {
	    basename,
	    navigator
	  } = reactExports.useContext(NavigationContext);
	  let {
	    matches
	  } = reactExports.useContext(RouteContext);
	  let {
	    pathname: locationPathname
	  } = useLocation();
	  let routePathnamesJson = JSON.stringify(getPathContributingMatches(matches).map(match => match.pathnameBase));
	  let activeRef = reactExports.useRef(false);
	  reactExports.useEffect(() => {
	    activeRef.current = true;
	  });
	  let navigate = reactExports.useCallback(function (to, options) {
	    if (options === void 0) {
	      options = {};
	    }
	    if (!activeRef.current) return;

	    if (typeof to === "number") {
	      navigator.go(to);
	      return;
	    }

	    let path = resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, options.relative === "path"); // If we're operating within a basename, prepend it to the pathname prior
	    // to handing off to history.  If this is a root navigation, then we
	    // navigate to the raw basename which allows the basename to have full
	    // control over the presence of a trailing slash on root links

	    if (basename !== "/") {
	      path.pathname = path.pathname === "/" ? basename : joinPaths([basename, path.pathname]);
	    }

	    (!!options.replace ? navigator.replace : navigator.push)(path, options.state, options);
	  }, [basename, navigator, routePathnamesJson, locationPathname]);
	  return navigate;
	}
	/**
	 * Returns an object of key/value pairs of the dynamic params from the current
	 * URL that were matched by the route path.
	 *
	 * @see https://reactrouter.com/docs/en/v6/hooks/use-params
	 */

	function useParams() {
	  let {
	    matches
	  } = reactExports.useContext(RouteContext);
	  let routeMatch = matches[matches.length - 1];
	  return routeMatch ? routeMatch.params : {};
	}
	/**
	 * Resolves the pathname of the given `to` value against the current location.
	 *
	 * @see https://reactrouter.com/docs/en/v6/hooks/use-resolved-path
	 */

	function useResolvedPath(to, _temp2) {
	  let {
	    relative
	  } = _temp2 === void 0 ? {} : _temp2;
	  let {
	    matches
	  } = reactExports.useContext(RouteContext);
	  let {
	    pathname: locationPathname
	  } = useLocation();
	  let routePathnamesJson = JSON.stringify(getPathContributingMatches(matches).map(match => match.pathnameBase));
	  return reactExports.useMemo(() => resolveTo(to, JSON.parse(routePathnamesJson), locationPathname, relative === "path"), [to, routePathnamesJson, locationPathname, relative]);
	}
	/**
	 * Returns the element of the route that matched the current location, prepared
	 * with the correct context to render the remainder of the route tree. Route
	 * elements in the tree must render an <Outlet> to render their child route's
	 * element.
	 *
	 * @see https://reactrouter.com/docs/en/v6/hooks/use-routes
	 */

	function useRoutes(routes, locationArg) {
	  !useInRouterContext() ? invariant$4(false) : void 0;
	  let dataRouterStateContext = reactExports.useContext(DataRouterStateContext);
	  let {
	    matches: parentMatches
	  } = reactExports.useContext(RouteContext);
	  let routeMatch = parentMatches[parentMatches.length - 1];
	  let parentParams = routeMatch ? routeMatch.params : {};
	  routeMatch ? routeMatch.pathname : "/";
	  let parentPathnameBase = routeMatch ? routeMatch.pathnameBase : "/";
	  routeMatch && routeMatch.route;

	  let locationFromContext = useLocation();
	  let location;

	  if (locationArg) {
	    var _parsedLocationArg$pa;

	    let parsedLocationArg = typeof locationArg === "string" ? parsePath(locationArg) : locationArg;
	    !(parentPathnameBase === "/" || ((_parsedLocationArg$pa = parsedLocationArg.pathname) == null ? void 0 : _parsedLocationArg$pa.startsWith(parentPathnameBase))) ? invariant$4(false) : void 0;
	    location = parsedLocationArg;
	  } else {
	    location = locationFromContext;
	  }

	  let pathname = location.pathname || "/";
	  let remainingPathname = parentPathnameBase === "/" ? pathname : pathname.slice(parentPathnameBase.length) || "/";
	  let matches = matchRoutes(routes, {
	    pathname: remainingPathname
	  });

	  let renderedMatches = _renderMatches(matches && matches.map(match => Object.assign({}, match, {
	    params: Object.assign({}, parentParams, match.params),
	    pathname: joinPaths([parentPathnameBase, match.pathname]),
	    pathnameBase: match.pathnameBase === "/" ? parentPathnameBase : joinPaths([parentPathnameBase, match.pathnameBase])
	  })), parentMatches, dataRouterStateContext || undefined); // When a user passes in a `locationArg`, the associated routes need to
	  // be wrapped in a new `LocationContext.Provider` in order for `useLocation`
	  // to use the scoped location instead of the global location.


	  if (locationArg) {
	    return /*#__PURE__*/reactExports.createElement(LocationContext.Provider, {
	      value: {
	        location: _extends$2({
	          pathname: "/",
	          search: "",
	          hash: "",
	          state: null,
	          key: "default"
	        }, location),
	        navigationType: Action.Pop
	      }
	    }, renderedMatches);
	  }

	  return renderedMatches;
	}

	function DefaultErrorElement() {
	  let error = useRouteError();
	  let message = isRouteErrorResponse(error) ? error.status + " " + error.statusText : error instanceof Error ? error.message : JSON.stringify(error);
	  let stack = error instanceof Error ? error.stack : null;
	  let lightgrey = "rgba(200,200,200, 0.5)";
	  let preStyles = {
	    padding: "0.5rem",
	    backgroundColor: lightgrey
	  };
	  let codeStyles = {
	    padding: "2px 4px",
	    backgroundColor: lightgrey
	  };
	  return /*#__PURE__*/reactExports.createElement(reactExports.Fragment, null, /*#__PURE__*/reactExports.createElement("h2", null, "Unhandled Thrown Error!"), /*#__PURE__*/reactExports.createElement("h3", {
	    style: {
	      fontStyle: "italic"
	    }
	  }, message), stack ? /*#__PURE__*/reactExports.createElement("pre", {
	    style: preStyles
	  }, stack) : null, /*#__PURE__*/reactExports.createElement("p", null, "\uD83D\uDCBF Hey developer \uD83D\uDC4B"), /*#__PURE__*/reactExports.createElement("p", null, "You can provide a way better UX than this when your app throws errors by providing your own\xA0", /*#__PURE__*/reactExports.createElement("code", {
	    style: codeStyles
	  }, "errorElement"), " props on\xA0", /*#__PURE__*/reactExports.createElement("code", {
	    style: codeStyles
	  }, "<Route>")));
	}

	class RenderErrorBoundary extends reactExports.Component {
	  constructor(props) {
	    super(props);
	    this.state = {
	      location: props.location,
	      error: props.error
	    };
	  }

	  static getDerivedStateFromError(error) {
	    return {
	      error: error
	    };
	  }

	  static getDerivedStateFromProps(props, state) {
	    // When we get into an error state, the user will likely click "back" to the
	    // previous page that didn't have an error. Because this wraps the entire
	    // application, that will have no effect--the error page continues to display.
	    // This gives us a mechanism to recover from the error when the location changes.
	    //
	    // Whether we're in an error state or not, we update the location in state
	    // so that when we are in an error state, it gets reset when a new location
	    // comes in and the user recovers from the error.
	    if (state.location !== props.location) {
	      return {
	        error: props.error,
	        location: props.location
	      };
	    } // If we're not changing locations, preserve the location but still surface
	    // any new errors that may come through. We retain the existing error, we do
	    // this because the error provided from the app state may be cleared without
	    // the location changing.


	    return {
	      error: props.error || state.error,
	      location: state.location
	    };
	  }

	  componentDidCatch(error, errorInfo) {
	    console.error("React Router caught the following error during render", error, errorInfo);
	  }

	  render() {
	    return this.state.error ? /*#__PURE__*/reactExports.createElement(RouteErrorContext.Provider, {
	      value: this.state.error,
	      children: this.props.component
	    }) : this.props.children;
	  }

	}

	function RenderedRoute(_ref) {
	  let {
	    routeContext,
	    match,
	    children
	  } = _ref;
	  let dataStaticRouterContext = reactExports.useContext(DataStaticRouterContext); // Track how deep we got in our render pass to emulate SSR componentDidCatch
	  // in a DataStaticRouter

	  if (dataStaticRouterContext && match.route.errorElement) {
	    dataStaticRouterContext._deepestRenderedBoundaryId = match.route.id;
	  }

	  return /*#__PURE__*/reactExports.createElement(RouteContext.Provider, {
	    value: routeContext
	  }, children);
	}

	function _renderMatches(matches, parentMatches, dataRouterState) {
	  if (parentMatches === void 0) {
	    parentMatches = [];
	  }

	  if (matches == null) {
	    if (dataRouterState != null && dataRouterState.errors) {
	      // Don't bail if we have data router errors so we can render them in the
	      // boundary.  Use the pre-matched (or shimmed) matches
	      matches = dataRouterState.matches;
	    } else {
	      return null;
	    }
	  }

	  let renderedMatches = matches; // If we have data errors, trim matches to the highest error boundary

	  let errors = dataRouterState == null ? void 0 : dataRouterState.errors;

	  if (errors != null) {
	    let errorIndex = renderedMatches.findIndex(m => m.route.id && (errors == null ? void 0 : errors[m.route.id]));
	    !(errorIndex >= 0) ? invariant$4(false) : void 0;
	    renderedMatches = renderedMatches.slice(0, Math.min(renderedMatches.length, errorIndex + 1));
	  }

	  return renderedMatches.reduceRight((outlet, match, index) => {
	    let error = match.route.id ? errors == null ? void 0 : errors[match.route.id] : null; // Only data routers handle errors

	    let errorElement = dataRouterState ? match.route.errorElement || /*#__PURE__*/reactExports.createElement(DefaultErrorElement, null) : null;

	    let getChildren = () => /*#__PURE__*/reactExports.createElement(RenderedRoute, {
	      match: match,
	      routeContext: {
	        outlet,
	        matches: parentMatches.concat(renderedMatches.slice(0, index + 1))
	      }
	    }, error ? errorElement : match.route.element !== undefined ? match.route.element : outlet); // Only wrap in an error boundary within data router usages when we have an
	    // errorElement on this route.  Otherwise let it bubble up to an ancestor
	    // errorElement


	    return dataRouterState && (match.route.errorElement || index === 0) ? /*#__PURE__*/reactExports.createElement(RenderErrorBoundary, {
	      location: dataRouterState.location,
	      component: errorElement,
	      error: error,
	      children: getChildren()
	    }) : getChildren();
	  }, null);
	}
	var DataRouterHook;

	(function (DataRouterHook) {
	  DataRouterHook["UseLoaderData"] = "useLoaderData";
	  DataRouterHook["UseActionData"] = "useActionData";
	  DataRouterHook["UseRouteError"] = "useRouteError";
	  DataRouterHook["UseNavigation"] = "useNavigation";
	  DataRouterHook["UseRouteLoaderData"] = "useRouteLoaderData";
	  DataRouterHook["UseMatches"] = "useMatches";
	  DataRouterHook["UseRevalidator"] = "useRevalidator";
	})(DataRouterHook || (DataRouterHook = {}));

	function useDataRouterState(hookName) {
	  let state = reactExports.useContext(DataRouterStateContext);
	  !state ? invariant$4(false) : void 0;
	  return state;
	}
	/**
	 * Returns the nearest ancestor Route error, which could be a loader/action
	 * error or a render error.  This is intended to be called from your
	 * errorElement to display a proper error message.
	 */

	function useRouteError() {
	  var _state$errors;

	  let error = reactExports.useContext(RouteErrorContext);
	  let state = useDataRouterState(DataRouterHook.UseRouteError);
	  let route = reactExports.useContext(RouteContext);
	  let thisRoute = route.matches[route.matches.length - 1]; // If this was a render error, we put it in a RouteError context inside
	  // of RenderErrorBoundary

	  if (error) {
	    return error;
	  }

	  !route ? invariant$4(false) : void 0;
	  !thisRoute.route.id ? invariant$4(false) : void 0; // Otherwise look for errors from our data router state

	  return (_state$errors = state.errors) == null ? void 0 : _state$errors[thisRoute.route.id];
	}

	/**
	 * Declares an element that should be rendered at a certain URL path.
	 *
	 * @see https://reactrouter.com/docs/en/v6/components/route
	 */
	function Route(_props) {
	  invariant$4(false) ;
	}

	/**
	 * Provides location context for the rest of the app.
	 *
	 * Note: You usually won't render a <Router> directly. Instead, you'll render a
	 * router that is more specific to your environment such as a <BrowserRouter>
	 * in web browsers or a <StaticRouter> for server rendering.
	 *
	 * @see https://reactrouter.com/docs/en/v6/routers/router
	 */
	function Router(_ref4) {
	  let {
	    basename: basenameProp = "/",
	    children = null,
	    location: locationProp,
	    navigationType = Action.Pop,
	    navigator,
	    static: staticProp = false
	  } = _ref4;
	  !!useInRouterContext() ? invariant$4(false) : void 0; // Preserve trailing slashes on basename, so we can let the user control
	  // the enforcement of trailing slashes throughout the app

	  let basename = basenameProp.replace(/^\/*/, "/");
	  let navigationContext = reactExports.useMemo(() => ({
	    basename,
	    navigator,
	    static: staticProp
	  }), [basename, navigator, staticProp]);

	  if (typeof locationProp === "string") {
	    locationProp = parsePath(locationProp);
	  }

	  let {
	    pathname = "/",
	    search = "",
	    hash = "",
	    state = null,
	    key = "default"
	  } = locationProp;
	  let location = reactExports.useMemo(() => {
	    let trailingPathname = stripBasename(pathname, basename);

	    if (trailingPathname == null) {
	      return null;
	    }

	    return {
	      pathname: trailingPathname,
	      search,
	      hash,
	      state,
	      key
	    };
	  }, [basename, pathname, search, hash, state, key]);

	  if (location == null) {
	    return null;
	  }

	  return /*#__PURE__*/reactExports.createElement(NavigationContext.Provider, {
	    value: navigationContext
	  }, /*#__PURE__*/reactExports.createElement(LocationContext.Provider, {
	    children: children,
	    value: {
	      location,
	      navigationType
	    }
	  }));
	}

	/**
	 * A container for a nested tree of <Route> elements that renders the branch
	 * that best matches the current location.
	 *
	 * @see https://reactrouter.com/docs/en/v6/components/routes
	 */
	function Routes(_ref5) {
	  let {
	    children,
	    location
	  } = _ref5;
	  let dataRouterContext = reactExports.useContext(DataRouterContext); // When in a DataRouterContext _without_ children, we use the router routes
	  // directly.  If we have children, then we're in a descendant tree and we
	  // need to use child routes.

	  let routes = dataRouterContext && !children ? dataRouterContext.router.routes : createRoutesFromChildren(children);
	  return useRoutes(routes, location);
	}
	var AwaitRenderStatus;

	(function (AwaitRenderStatus) {
	  AwaitRenderStatus[AwaitRenderStatus["pending"] = 0] = "pending";
	  AwaitRenderStatus[AwaitRenderStatus["success"] = 1] = "success";
	  AwaitRenderStatus[AwaitRenderStatus["error"] = 2] = "error";
	})(AwaitRenderStatus || (AwaitRenderStatus = {}));

	new Promise(() => {});
	// UTILS
	///////////////////////////////////////////////////////////////////////////////

	/**
	 * Creates a route config from a React "children" object, which is usually
	 * either a `<Route>` element or an array of them. Used internally by
	 * `<Routes>` to create a route config from its children.
	 *
	 * @see https://reactrouter.com/docs/en/v6/utils/create-routes-from-children
	 */


	function createRoutesFromChildren(children, parentPath) {
	  if (parentPath === void 0) {
	    parentPath = [];
	  }

	  let routes = [];
	  reactExports.Children.forEach(children, (element, index) => {
	    if (! /*#__PURE__*/reactExports.isValidElement(element)) {
	      // Ignore non-elements. This allows people to more easily inline
	      // conditionals in their route config.
	      return;
	    }

	    if (element.type === reactExports.Fragment) {
	      // Transparently support React.Fragment and its children.
	      routes.push.apply(routes, createRoutesFromChildren(element.props.children, parentPath));
	      return;
	    }

	    !(element.type === Route) ? invariant$4(false) : void 0;
	    let treePath = [...parentPath, index];
	    let route = {
	      id: element.props.id || treePath.join("-"),
	      caseSensitive: element.props.caseSensitive,
	      element: element.props.element,
	      index: element.props.index,
	      path: element.props.path,
	      loader: element.props.loader,
	      action: element.props.action,
	      errorElement: element.props.errorElement,
	      hasErrorBoundary: element.props.errorElement != null,
	      shouldRevalidate: element.props.shouldRevalidate,
	      handle: element.props.handle
	    };

	    if (element.props.children) {
	      route.children = createRoutesFromChildren(element.props.children, treePath);
	    }

	    routes.push(route);
	  });
	  return routes;
	}

	/**
	 * React Router DOM v6.4.0
	 *
	 * Copyright (c) Remix Software Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE.md file in the root directory of this source tree.
	 *
	 * @license MIT
	 */
	/**
	 * Creates a URLSearchParams object using the given initializer.
	 *
	 * This is identical to `new URLSearchParams(init)` except it also
	 * supports arrays as values in the object form of the initializer
	 * instead of just strings. This is convenient when you need multiple
	 * values for a given key, but don't want to use an array initializer.
	 *
	 * For example, instead of:
	 *
	 *   let searchParams = new URLSearchParams([
	 *     ['sort', 'name'],
	 *     ['sort', 'price']
	 *   ]);
	 *
	 * you can do:
	 *
	 *   let searchParams = createSearchParams({
	 *     sort: ['name', 'price']
	 *   });
	 */

	function createSearchParams(init) {
	  if (init === void 0) {
	    init = "";
	  }

	  return new URLSearchParams(typeof init === "string" || Array.isArray(init) || init instanceof URLSearchParams ? init : Object.keys(init).reduce((memo, key) => {
	    let value = init[key];
	    return memo.concat(Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]);
	  }, []));
	}
	function getSearchParamsForLocation(locationSearch, defaultSearchParams) {
	  let searchParams = createSearchParams(locationSearch);

	  for (let key of defaultSearchParams.keys()) {
	    if (!searchParams.has(key)) {
	      defaultSearchParams.getAll(key).forEach(value => {
	        searchParams.append(key, value);
	      });
	    }
	  }

	  return searchParams;
	}
	/**
	 * A `<Router>` for use in web browsers. Provides the cleanest URLs.
	 */

	function BrowserRouter(_ref) {
	  let {
	    basename,
	    children,
	    window
	  } = _ref;
	  let historyRef = reactExports.useRef();

	  if (historyRef.current == null) {
	    historyRef.current = createBrowserHistory({
	      window,
	      v5Compat: true
	    });
	  }

	  let history = historyRef.current;
	  let [state, setState] = reactExports.useState({
	    action: history.action,
	    location: history.location
	  });
	  reactExports.useLayoutEffect(() => history.listen(setState), [history]);
	  return /*#__PURE__*/reactExports.createElement(Router, {
	    basename: basename,
	    children: children,
	    location: state.location,
	    navigationType: state.action,
	    navigator: history
	  });
	}
	/**
	 * A convenient wrapper for reading and writing search parameters via the
	 * URLSearchParams interface.
	 */

	function useSearchParams(defaultInit) {
	  let defaultSearchParamsRef = reactExports.useRef(createSearchParams(defaultInit));
	  let location = useLocation();
	  let searchParams = reactExports.useMemo(() => getSearchParamsForLocation(location.search, defaultSearchParamsRef.current), [location.search]);
	  let navigate = useNavigate();
	  let setSearchParams = reactExports.useCallback((nextInit, navigateOptions) => {
	    const newSearchParams = createSearchParams(typeof nextInit === "function" ? nextInit(searchParams) : nextInit);
	    navigate("?" + newSearchParams, navigateOptions);
	  }, [navigate, searchParams]);
	  return [searchParams, setSearchParams];
	}

	var missingAttachment = "edcc39b1702e4bd4b95e.svg";

	/**
	 * Tokenize input string.
	 */
	function lexer$1(str) {
	    var tokens = [];
	    var i = 0;
	    while (i < str.length) {
	        var char = str[i];
	        if (char === "*" || char === "+" || char === "?") {
	            tokens.push({ type: "MODIFIER", index: i, value: str[i++] });
	            continue;
	        }
	        if (char === "\\") {
	            tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[i++] });
	            continue;
	        }
	        if (char === "{") {
	            tokens.push({ type: "OPEN", index: i, value: str[i++] });
	            continue;
	        }
	        if (char === "}") {
	            tokens.push({ type: "CLOSE", index: i, value: str[i++] });
	            continue;
	        }
	        if (char === ":") {
	            var name = "";
	            var j = i + 1;
	            while (j < str.length) {
	                var code = str.charCodeAt(j);
	                if (
	                // `0-9`
	                (code >= 48 && code <= 57) ||
	                    // `A-Z`
	                    (code >= 65 && code <= 90) ||
	                    // `a-z`
	                    (code >= 97 && code <= 122) ||
	                    // `_`
	                    code === 95) {
	                    name += str[j++];
	                    continue;
	                }
	                break;
	            }
	            if (!name)
	                throw new TypeError("Missing parameter name at " + i);
	            tokens.push({ type: "NAME", index: i, value: name });
	            i = j;
	            continue;
	        }
	        if (char === "(") {
	            var count = 1;
	            var pattern = "";
	            var j = i + 1;
	            if (str[j] === "?") {
	                throw new TypeError("Pattern cannot start with \"?\" at " + j);
	            }
	            while (j < str.length) {
	                if (str[j] === "\\") {
	                    pattern += str[j++] + str[j++];
	                    continue;
	                }
	                if (str[j] === ")") {
	                    count--;
	                    if (count === 0) {
	                        j++;
	                        break;
	                    }
	                }
	                else if (str[j] === "(") {
	                    count++;
	                    if (str[j + 1] !== "?") {
	                        throw new TypeError("Capturing groups are not allowed at " + j);
	                    }
	                }
	                pattern += str[j++];
	            }
	            if (count)
	                throw new TypeError("Unbalanced pattern at " + i);
	            if (!pattern)
	                throw new TypeError("Missing pattern at " + i);
	            tokens.push({ type: "PATTERN", index: i, value: pattern });
	            i = j;
	            continue;
	        }
	        tokens.push({ type: "CHAR", index: i, value: str[i++] });
	    }
	    tokens.push({ type: "END", index: i, value: "" });
	    return tokens;
	}
	/**
	 * Parse a string for the raw tokens.
	 */
	function parse$7(str, options) {
	    if (options === void 0) { options = {}; }
	    var tokens = lexer$1(str);
	    var _a = options.prefixes, prefixes = _a === void 0 ? "./" : _a;
	    var defaultPattern = "[^" + escapeString(options.delimiter || "/#?") + "]+?";
	    var result = [];
	    var key = 0;
	    var i = 0;
	    var path = "";
	    var tryConsume = function (type) {
	        if (i < tokens.length && tokens[i].type === type)
	            return tokens[i++].value;
	    };
	    var mustConsume = function (type) {
	        var value = tryConsume(type);
	        if (value !== undefined)
	            return value;
	        var _a = tokens[i], nextType = _a.type, index = _a.index;
	        throw new TypeError("Unexpected " + nextType + " at " + index + ", expected " + type);
	    };
	    var consumeText = function () {
	        var result = "";
	        var value;
	        // tslint:disable-next-line
	        while ((value = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR"))) {
	            result += value;
	        }
	        return result;
	    };
	    while (i < tokens.length) {
	        var char = tryConsume("CHAR");
	        var name = tryConsume("NAME");
	        var pattern = tryConsume("PATTERN");
	        if (name || pattern) {
	            var prefix = char || "";
	            if (prefixes.indexOf(prefix) === -1) {
	                path += prefix;
	                prefix = "";
	            }
	            if (path) {
	                result.push(path);
	                path = "";
	            }
	            result.push({
	                name: name || key++,
	                prefix: prefix,
	                suffix: "",
	                pattern: pattern || defaultPattern,
	                modifier: tryConsume("MODIFIER") || ""
	            });
	            continue;
	        }
	        var value = char || tryConsume("ESCAPED_CHAR");
	        if (value) {
	            path += value;
	            continue;
	        }
	        if (path) {
	            result.push(path);
	            path = "";
	        }
	        var open = tryConsume("OPEN");
	        if (open) {
	            var prefix = consumeText();
	            var name_1 = tryConsume("NAME") || "";
	            var pattern_1 = tryConsume("PATTERN") || "";
	            var suffix = consumeText();
	            mustConsume("CLOSE");
	            result.push({
	                name: name_1 || (pattern_1 ? key++ : ""),
	                pattern: name_1 && !pattern_1 ? defaultPattern : pattern_1,
	                prefix: prefix,
	                suffix: suffix,
	                modifier: tryConsume("MODIFIER") || ""
	            });
	            continue;
	        }
	        mustConsume("END");
	    }
	    return result;
	}
	/**
	 * Compile a string to a template function for the path.
	 */
	function compile$1(str, options) {
	    return tokensToFunction(parse$7(str, options), options);
	}
	/**
	 * Expose a method for transforming tokens into the path function.
	 */
	function tokensToFunction(tokens, options) {
	    if (options === void 0) { options = {}; }
	    var reFlags = flags(options);
	    var _a = options.encode, encode = _a === void 0 ? function (x) { return x; } : _a, _b = options.validate, validate = _b === void 0 ? true : _b;
	    // Compile all the tokens into regexps.
	    var matches = tokens.map(function (token) {
	        if (typeof token === "object") {
	            return new RegExp("^(?:" + token.pattern + ")$", reFlags);
	        }
	    });
	    return function (data) {
	        var path = "";
	        for (var i = 0; i < tokens.length; i++) {
	            var token = tokens[i];
	            if (typeof token === "string") {
	                path += token;
	                continue;
	            }
	            var value = data ? data[token.name] : undefined;
	            var optional = token.modifier === "?" || token.modifier === "*";
	            var repeat = token.modifier === "*" || token.modifier === "+";
	            if (Array.isArray(value)) {
	                if (!repeat) {
	                    throw new TypeError("Expected \"" + token.name + "\" to not repeat, but got an array");
	                }
	                if (value.length === 0) {
	                    if (optional)
	                        continue;
	                    throw new TypeError("Expected \"" + token.name + "\" to not be empty");
	                }
	                for (var j = 0; j < value.length; j++) {
	                    var segment = encode(value[j], token);
	                    if (validate && !matches[i].test(segment)) {
	                        throw new TypeError("Expected all \"" + token.name + "\" to match \"" + token.pattern + "\", but got \"" + segment + "\"");
	                    }
	                    path += token.prefix + segment + token.suffix;
	                }
	                continue;
	            }
	            if (typeof value === "string" || typeof value === "number") {
	                var segment = encode(String(value), token);
	                if (validate && !matches[i].test(segment)) {
	                    throw new TypeError("Expected \"" + token.name + "\" to match \"" + token.pattern + "\", but got \"" + segment + "\"");
	                }
	                path += token.prefix + segment + token.suffix;
	                continue;
	            }
	            if (optional)
	                continue;
	            var typeOfMessage = repeat ? "an array" : "a string";
	            throw new TypeError("Expected \"" + token.name + "\" to be " + typeOfMessage);
	        }
	        return path;
	    };
	}
	/**
	 * Escape a regular expression string.
	 */
	function escapeString(str) {
	    return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
	}
	/**
	 * Get the flags for a regexp from the options.
	 */
	function flags(options) {
	    return options && options.sensitive ? "" : "i";
	}

	/**
	 * Check if we're required to add a port number.
	 *
	 * @see https://url.spec.whatwg.org/#default-port
	 * @param {Number|String} port Port number we need to check
	 * @param {String} protocol Protocol we need to check against.
	 * @returns {Boolean} Is it a default port for the given protocol
	 * @api private
	 */
	var requiresPort = function required(port, protocol) {
	  protocol = protocol.split(':')[0];
	  port = +port;

	  if (!port) return false;

	  switch (protocol) {
	    case 'http':
	    case 'ws':
	    return port !== 80;

	    case 'https':
	    case 'wss':
	    return port !== 443;

	    case 'ftp':
	    return port !== 21;

	    case 'gopher':
	    return port !== 70;

	    case 'file':
	    return false;
	  }

	  return port !== 0;
	};

	var querystringify$1 = {};

	var has$2 = Object.prototype.hasOwnProperty
	  , undef;

	/**
	 * Decode a URI encoded string.
	 *
	 * @param {String} input The URI encoded string.
	 * @returns {String|Null} The decoded string.
	 * @api private
	 */
	function decode$2(input) {
	  try {
	    return decodeURIComponent(input.replace(/\+/g, ' '));
	  } catch (e) {
	    return null;
	  }
	}

	/**
	 * Attempts to encode a given input.
	 *
	 * @param {String} input The string that needs to be encoded.
	 * @returns {String|Null} The encoded string.
	 * @api private
	 */
	function encode$3(input) {
	  try {
	    return encodeURIComponent(input);
	  } catch (e) {
	    return null;
	  }
	}

	/**
	 * Simple query string parser.
	 *
	 * @param {String} query The query string that needs to be parsed.
	 * @returns {Object}
	 * @api public
	 */
	function querystring(query) {
	  var parser = /([^=?#&]+)=?([^&]*)/g
	    , result = {}
	    , part;

	  while (part = parser.exec(query)) {
	    var key = decode$2(part[1])
	      , value = decode$2(part[2]);

	    //
	    // Prevent overriding of existing properties. This ensures that build-in
	    // methods like `toString` or __proto__ are not overriden by malicious
	    // querystrings.
	    //
	    // In the case if failed decoding, we want to omit the key/value pairs
	    // from the result.
	    //
	    if (key === null || value === null || key in result) continue;
	    result[key] = value;
	  }

	  return result;
	}

	/**
	 * Transform a query string to an object.
	 *
	 * @param {Object} obj Object that should be transformed.
	 * @param {String} prefix Optional prefix.
	 * @returns {String}
	 * @api public
	 */
	function querystringify(obj, prefix) {
	  prefix = prefix || '';

	  var pairs = []
	    , value
	    , key;

	  //
	  // Optionally prefix with a '?' if needed
	  //
	  if ('string' !== typeof prefix) prefix = '?';

	  for (key in obj) {
	    if (has$2.call(obj, key)) {
	      value = obj[key];

	      //
	      // Edge cases where we actually want to encode the value to an empty
	      // string instead of the stringified value.
	      //
	      if (!value && (value === null || value === undef || isNaN(value))) {
	        value = '';
	      }

	      key = encode$3(key);
	      value = encode$3(value);

	      //
	      // If we failed to encode the strings, we should bail out as we don't
	      // want to add invalid strings to the query.
	      //
	      if (key === null || value === null) continue;
	      pairs.push(key +'='+ value);
	    }
	  }

	  return pairs.length ? prefix + pairs.join('&') : '';
	}

	//
	// Expose the module.
	//
	querystringify$1.stringify = querystringify;
	querystringify$1.parse = querystring;

	var required = requiresPort
	  , qs$1 = querystringify$1
	  , slashes = /^[A-Za-z][A-Za-z0-9+-.]*:\/\//
	  , protocolre = /^([a-z][a-z0-9.+-]*:)?(\/\/)?([\\/]+)?([\S\s]*)/i
	  , windowsDriveLetter = /^[a-zA-Z]:/
	  , whitespace$2 = '[\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF]'
	  , left = new RegExp('^'+ whitespace$2 +'+');

	/**
	 * Trim a given string.
	 *
	 * @param {String} str String to trim.
	 * @public
	 */
	function trimLeft(str) {
	  return (str ? str : '').toString().replace(left, '');
	}

	/**
	 * These are the parse rules for the URL parser, it informs the parser
	 * about:
	 *
	 * 0. The char it Needs to parse, if it's a string it should be done using
	 *    indexOf, RegExp using exec and NaN means set as current value.
	 * 1. The property we should set when parsing this value.
	 * 2. Indication if it's backwards or forward parsing, when set as number it's
	 *    the value of extra chars that should be split off.
	 * 3. Inherit from location if non existing in the parser.
	 * 4. `toLowerCase` the resulting value.
	 */
	var rules = [
	  ['#', 'hash'],                        // Extract from the back.
	  ['?', 'query'],                       // Extract from the back.
	  function sanitize(address, url) {     // Sanitize what is left of the address
	    return isSpecial$1(url.protocol) ? address.replace(/\\/g, '/') : address;
	  },
	  ['/', 'pathname'],                    // Extract from the back.
	  ['@', 'auth', 1],                     // Extract from the front.
	  [NaN, 'host', undefined, 1, 1],       // Set left over value.
	  [/:(\d+)$/, 'port', undefined, 1],    // RegExp the back.
	  [NaN, 'hostname', undefined, 1, 1]    // Set left over.
	];

	/**
	 * These properties should not be copied or inherited from. This is only needed
	 * for all non blob URL's as a blob URL does not include a hash, only the
	 * origin.
	 *
	 * @type {Object}
	 * @private
	 */
	var ignore$1 = { hash: 1, query: 1 };

	/**
	 * The location object differs when your code is loaded through a normal page,
	 * Worker or through a worker using a blob. And with the blobble begins the
	 * trouble as the location object will contain the URL of the blob, not the
	 * location of the page where our code is loaded in. The actual origin is
	 * encoded in the `pathname` so we can thankfully generate a good "default"
	 * location from it so we can generate proper relative URL's again.
	 *
	 * @param {Object|String} loc Optional default location object.
	 * @returns {Object} lolcation object.
	 * @public
	 */
	function lolcation(loc) {
	  var globalVar;

	  if (typeof window !== 'undefined') globalVar = window;
	  else if (typeof commonjsGlobal !== 'undefined') globalVar = commonjsGlobal;
	  else if (typeof self !== 'undefined') globalVar = self;
	  else globalVar = {};

	  var location = globalVar.location || {};
	  loc = loc || location;

	  var finaldestination = {}
	    , type = typeof loc
	    , key;

	  if ('blob:' === loc.protocol) {
	    finaldestination = new Url(unescape(loc.pathname), {});
	  } else if ('string' === type) {
	    finaldestination = new Url(loc, {});
	    for (key in ignore$1) delete finaldestination[key];
	  } else if ('object' === type) {
	    for (key in loc) {
	      if (key in ignore$1) continue;
	      finaldestination[key] = loc[key];
	    }

	    if (finaldestination.slashes === undefined) {
	      finaldestination.slashes = slashes.test(loc.href);
	    }
	  }

	  return finaldestination;
	}

	/**
	 * Check whether a protocol scheme is special.
	 *
	 * @param {String} The protocol scheme of the URL
	 * @return {Boolean} `true` if the protocol scheme is special, else `false`
	 * @private
	 */
	function isSpecial$1(scheme) {
	  return (
	    scheme === 'file:' ||
	    scheme === 'ftp:' ||
	    scheme === 'http:' ||
	    scheme === 'https:' ||
	    scheme === 'ws:' ||
	    scheme === 'wss:'
	  );
	}

	/**
	 * @typedef ProtocolExtract
	 * @type Object
	 * @property {String} protocol Protocol matched in the URL, in lowercase.
	 * @property {Boolean} slashes `true` if protocol is followed by "//", else `false`.
	 * @property {String} rest Rest of the URL that is not part of the protocol.
	 */

	/**
	 * Extract protocol information from a URL with/without double slash ("//").
	 *
	 * @param {String} address URL we want to extract from.
	 * @param {Object} location
	 * @return {ProtocolExtract} Extracted information.
	 * @private
	 */
	function extractProtocol(address, location) {
	  address = trimLeft(address);
	  location = location || {};

	  var match = protocolre.exec(address);
	  var protocol = match[1] ? match[1].toLowerCase() : '';
	  var forwardSlashes = !!match[2];
	  var otherSlashes = !!match[3];
	  var slashesCount = 0;
	  var rest;

	  if (forwardSlashes) {
	    if (otherSlashes) {
	      rest = match[2] + match[3] + match[4];
	      slashesCount = match[2].length + match[3].length;
	    } else {
	      rest = match[2] + match[4];
	      slashesCount = match[2].length;
	    }
	  } else {
	    if (otherSlashes) {
	      rest = match[3] + match[4];
	      slashesCount = match[3].length;
	    } else {
	      rest = match[4];
	    }
	  }

	  if (protocol === 'file:') {
	    if (slashesCount >= 2) {
	      rest = rest.slice(2);
	    }
	  } else if (isSpecial$1(protocol)) {
	    rest = match[4];
	  } else if (protocol) {
	    if (forwardSlashes) {
	      rest = rest.slice(2);
	    }
	  } else if (slashesCount >= 2 && isSpecial$1(location.protocol)) {
	    rest = match[4];
	  }

	  return {
	    protocol: protocol,
	    slashes: forwardSlashes || isSpecial$1(protocol),
	    slashesCount: slashesCount,
	    rest: rest
	  };
	}

	/**
	 * Resolve a relative URL pathname against a base URL pathname.
	 *
	 * @param {String} relative Pathname of the relative URL.
	 * @param {String} base Pathname of the base URL.
	 * @return {String} Resolved pathname.
	 * @private
	 */
	function resolve(relative, base) {
	  if (relative === '') return base;

	  var path = (base || '/').split('/').slice(0, -1).concat(relative.split('/'))
	    , i = path.length
	    , last = path[i - 1]
	    , unshift = false
	    , up = 0;

	  while (i--) {
	    if (path[i] === '.') {
	      path.splice(i, 1);
	    } else if (path[i] === '..') {
	      path.splice(i, 1);
	      up++;
	    } else if (up) {
	      if (i === 0) unshift = true;
	      path.splice(i, 1);
	      up--;
	    }
	  }

	  if (unshift) path.unshift('');
	  if (last === '.' || last === '..') path.push('');

	  return path.join('/');
	}

	/**
	 * The actual URL instance. Instead of returning an object we've opted-in to
	 * create an actual constructor as it's much more memory efficient and
	 * faster and it pleases my OCD.
	 *
	 * It is worth noting that we should not use `URL` as class name to prevent
	 * clashes with the global URL instance that got introduced in browsers.
	 *
	 * @constructor
	 * @param {String} address URL we want to parse.
	 * @param {Object|String} [location] Location defaults for relative paths.
	 * @param {Boolean|Function} [parser] Parser for the query string.
	 * @private
	 */
	function Url(address, location, parser) {
	  address = trimLeft(address);

	  if (!(this instanceof Url)) {
	    return new Url(address, location, parser);
	  }

	  var relative, extracted, parse, instruction, index, key
	    , instructions = rules.slice()
	    , type = typeof location
	    , url = this
	    , i = 0;

	  //
	  // The following if statements allows this module two have compatibility with
	  // 2 different API:
	  //
	  // 1. Node.js's `url.parse` api which accepts a URL, boolean as arguments
	  //    where the boolean indicates that the query string should also be parsed.
	  //
	  // 2. The `URL` interface of the browser which accepts a URL, object as
	  //    arguments. The supplied object will be used as default values / fall-back
	  //    for relative paths.
	  //
	  if ('object' !== type && 'string' !== type) {
	    parser = location;
	    location = null;
	  }

	  if (parser && 'function' !== typeof parser) parser = qs$1.parse;

	  location = lolcation(location);

	  //
	  // Extract protocol information before running the instructions.
	  //
	  extracted = extractProtocol(address || '', location);
	  relative = !extracted.protocol && !extracted.slashes;
	  url.slashes = extracted.slashes || relative && location.slashes;
	  url.protocol = extracted.protocol || location.protocol || '';
	  address = extracted.rest;

	  //
	  // When the authority component is absent the URL starts with a path
	  // component.
	  //
	  if (
	    extracted.protocol === 'file:' && (
	      extracted.slashesCount !== 2 || windowsDriveLetter.test(address)) ||
	    (!extracted.slashes &&
	      (extracted.protocol ||
	        extracted.slashesCount < 2 ||
	        !isSpecial$1(url.protocol)))
	  ) {
	    instructions[3] = [/(.*)/, 'pathname'];
	  }

	  for (; i < instructions.length; i++) {
	    instruction = instructions[i];

	    if (typeof instruction === 'function') {
	      address = instruction(address, url);
	      continue;
	    }

	    parse = instruction[0];
	    key = instruction[1];

	    if (parse !== parse) {
	      url[key] = address;
	    } else if ('string' === typeof parse) {
	      if (~(index = address.indexOf(parse))) {
	        if ('number' === typeof instruction[2]) {
	          url[key] = address.slice(0, index);
	          address = address.slice(index + instruction[2]);
	        } else {
	          url[key] = address.slice(index);
	          address = address.slice(0, index);
	        }
	      }
	    } else if ((index = parse.exec(address))) {
	      url[key] = index[1];
	      address = address.slice(0, index.index);
	    }

	    url[key] = url[key] || (
	      relative && instruction[3] ? location[key] || '' : ''
	    );

	    //
	    // Hostname, host and protocol should be lowercased so they can be used to
	    // create a proper `origin`.
	    //
	    if (instruction[4]) url[key] = url[key].toLowerCase();
	  }

	  //
	  // Also parse the supplied query string in to an object. If we're supplied
	  // with a custom parser as function use that instead of the default build-in
	  // parser.
	  //
	  if (parser) url.query = parser(url.query);

	  //
	  // If the URL is relative, resolve the pathname against the base URL.
	  //
	  if (
	      relative
	    && location.slashes
	    && url.pathname.charAt(0) !== '/'
	    && (url.pathname !== '' || location.pathname !== '')
	  ) {
	    url.pathname = resolve(url.pathname, location.pathname);
	  }

	  //
	  // Default to a / for pathname if none exists. This normalizes the URL
	  // to always have a /
	  //
	  if (url.pathname.charAt(0) !== '/' && isSpecial$1(url.protocol)) {
	    url.pathname = '/' + url.pathname;
	  }

	  //
	  // We should not add port numbers if they are already the default port number
	  // for a given protocol. As the host also contains the port number we're going
	  // override it with the hostname which contains no port number.
	  //
	  if (!required(url.port, url.protocol)) {
	    url.host = url.hostname;
	    url.port = '';
	  }

	  //
	  // Parse down the `auth` for the username and password.
	  //
	  url.username = url.password = '';
	  if (url.auth) {
	    instruction = url.auth.split(':');
	    url.username = instruction[0] || '';
	    url.password = instruction[1] || '';
	  }

	  url.origin = url.protocol !== 'file:' && isSpecial$1(url.protocol) && url.host
	    ? url.protocol +'//'+ url.host
	    : 'null';

	  //
	  // The href is just the compiled result.
	  //
	  url.href = url.toString();
	}

	/**
	 * This is convenience method for changing properties in the URL instance to
	 * insure that they all propagate correctly.
	 *
	 * @param {String} part          Property we need to adjust.
	 * @param {Mixed} value          The newly assigned value.
	 * @param {Boolean|Function} fn  When setting the query, it will be the function
	 *                               used to parse the query.
	 *                               When setting the protocol, double slash will be
	 *                               removed from the final url if it is true.
	 * @returns {URL} URL instance for chaining.
	 * @public
	 */
	function set$2(part, value, fn) {
	  var url = this;

	  switch (part) {
	    case 'query':
	      if ('string' === typeof value && value.length) {
	        value = (fn || qs$1.parse)(value);
	      }

	      url[part] = value;
	      break;

	    case 'port':
	      url[part] = value;

	      if (!required(value, url.protocol)) {
	        url.host = url.hostname;
	        url[part] = '';
	      } else if (value) {
	        url.host = url.hostname +':'+ value;
	      }

	      break;

	    case 'hostname':
	      url[part] = value;

	      if (url.port) value += ':'+ url.port;
	      url.host = value;
	      break;

	    case 'host':
	      url[part] = value;

	      if (/:\d+$/.test(value)) {
	        value = value.split(':');
	        url.port = value.pop();
	        url.hostname = value.join(':');
	      } else {
	        url.hostname = value;
	        url.port = '';
	      }

	      break;

	    case 'protocol':
	      url.protocol = value.toLowerCase();
	      url.slashes = !fn;
	      break;

	    case 'pathname':
	    case 'hash':
	      if (value) {
	        var char = part === 'pathname' ? '/' : '#';
	        url[part] = value.charAt(0) !== char ? char + value : value;
	      } else {
	        url[part] = value;
	      }
	      break;

	    default:
	      url[part] = value;
	  }

	  for (var i = 0; i < rules.length; i++) {
	    var ins = rules[i];

	    if (ins[4]) url[ins[1]] = url[ins[1]].toLowerCase();
	  }

	  url.origin = url.protocol !== 'file:' && isSpecial$1(url.protocol) && url.host
	    ? url.protocol +'//'+ url.host
	    : 'null';

	  url.href = url.toString();

	  return url;
	}

	/**
	 * Transform the properties back in to a valid and full URL string.
	 *
	 * @param {Function} stringify Optional query stringify function.
	 * @returns {String} Compiled version of the URL.
	 * @public
	 */
	function toString$1(stringify) {
	  if (!stringify || 'function' !== typeof stringify) stringify = qs$1.stringify;

	  var query
	    , url = this
	    , protocol = url.protocol;

	  if (protocol && protocol.charAt(protocol.length - 1) !== ':') protocol += ':';

	  var result = protocol + (url.slashes || isSpecial$1(url.protocol) ? '//' : '');

	  if (url.username) {
	    result += url.username;
	    if (url.password) result += ':'+ url.password;
	    result += '@';
	  }

	  result += url.host + url.pathname;

	  query = 'object' === typeof url.query ? stringify(url.query) : url.query;
	  if (query) result += '?' !== query.charAt(0) ? '?'+ query : query;

	  if (url.hash) result += url.hash;

	  return result;
	}

	Url.prototype = { set: set$2, toString: toString$1 };

	//
	// Expose the URL parser and some additional properties that might be useful for
	// others or testing.
	//
	Url.extractProtocol = extractProtocol;
	Url.location = lolcation;
	Url.trimLeft = trimLeft;
	Url.qs = qs$1;

	var urlParse = Url;

	var urlParse$1 = /*@__PURE__*/getDefaultExportFromCjs(urlParse);

	function vhostUrlForProject(projectName) {
	    const baseHost = urlParse$1(env.HOME_URL).hostname;
	    const basePort = urlParse$1(env.HOME_URL).port;

	    if (basePort) {
	        return new URL(`https://${projectName}.${baseHost}:${basePort}`);
	    } else {
	        return new URL(`https://${projectName}.${baseHost}`);
	    }
	}

	function mainDomain(
	    path,
	    args
	) {
	    return new URL(compile$1(path)(args), env.HOME_URL);
	}

	function apiV1(
	    path,
	    args
	) {
	    return new URL(
	        `.${compile$1(path)(args)}`,
	        new URL("/api/v1/", env.HOME_URL)
	    );
	}

	function relationshipAction(
	    path,
	    args
	) {
	    return new URL(
	        `.${compile$1(path)(args)}`,
	        new URL("/rc/relationships/", env.HOME_URL)
	    );
	}

	function projectSubdomain(
	    path,
	    args
	) {
	    return new URL(
	        compile$1(path)(args),
	        vhostUrlForProject(args.projectHandle)
	    );
	}











	const patterns = {
	    public: {
	        home: "/",
	        dashboard: "/rc/dashboard",
	        welcome: "/rc/welcome",
	        login: "/rc/login",
	        logout: "/rc/logout",
	        signup: "/rc/signup",
	        createProject: "/rc/project/create",
	        switchProject: "/rc/project/switch",
	        settingsMain: "/rc/user/settings",
	        silencedPosts: "/rc/user/silenced-posts",
	        verifyEmail: "/rc/verify_email",
	        cancelVerifyEmail: "/rc/cancel_verify_email",
	        resetPassword: "/rc/reset_password",
	        staticContent: "/rc/content/:slug",
	        search: "/rc/search",
	        composePost: "/rc/post/compose",
	        redirectToAttachment: "/rc/attachment-redirect/:attachmentId",
	        apiV1: {
	            createProject: "/project",
	            getProject: "/project/:projectHandle",
	            updateProject: "/versions",
	            getFollowingState: "/project/:projectHandle/following",
	            getProjectPosts: "/project/:projectHandle/posts",
	            createPost: "/project/:projectHandle/posts",
	            updatePost: "/project/:projectHandle/posts/:postId",
	            getCommentsForPost: "/project_post/:postId/comments",
	            // hit by eggbug.rs
	            startAttachment:
	                "/project/:projectHandle/posts/:postId/attach/start",
	            // hit by eggbug.rs
	            finishAttachment:
	                "/project/:projectHandle/posts/:postId/attach/finish/:attachmentId",
	            redirectToAttachment: "/attachments/:attachmentId",
	            changePostState: "/project/:projectHandle/posts/:postId/:operation",
	            listEditedProjects: "/projects/edited",
	            createComment: "/comments",
	            editDeleteComment: "/comments/:commentId",
	            register: "/register",
	            changePassword: "/change-password",
	            requestPasswordReset: "/reset-password",
	            /** @deprecated */
	            login: "/login",
	            /** @deprecated */
	            logout: "/logout",
	            checkEmail: "/register/check-email",
	            projects: {
	                followers: "/projects/followers",
	            },
	            moderation: {
	                changeSettings: "/moderation/settings",
	                grantOrRevokePermission: "/moderation/permission",
	            },
	            notifications: {
	                list: "/notifications/list",
	            },
	            reporting: {
	                listReasons: "/reporting/reasons",
	                reportPost: "/reporting/report-post",
	            },
	            trpc: "/trpc",
	        },
	        unleashProxy: "/api/unleash-proxy",
	        relationshipAction:
	            "/:fromEntityType-:fromEntityId/to-:toEntityType-:toEntityId/:operation",
	        tags: "/rc/tagged/:tagSlug",
	        bookmarkedTagFeed: "/rc/bookmarks",
	        likedPosts: "/rc/liked-posts",
	        project: {
	            home: "/",
	            mainAppProfile: "/:projectHandle",
	            profileEdit: "/rc/project/edit",
	            followers: "/rc/project/followers",
	            following: "/rc/project/following",
	            notifications: "/rc/project/notifications",
	            followRequests: "/:projectHandle/follow-requests",
	            composePost: "/:projectHandle/post/compose",
	            editPost: "/:projectHandle/post/:filename/edit",
	            singlePost: {
	                published: "/:projectHandle/post/:filename",
	                unpublished: "/:projectHandle/post/:filename/:draftNonce",
	            },
	            unpublishedPosts: "/rc/posts/unpublished",
	            subdomainTags: "/tagged/:tagSlug",
	            tags: "/:projectHandle/tagged/:tagSlug",
	            rss: {
	                publicRss: "/:projectHandle/rss/public.rss",
	                publicAtom: "/:projectHandle/rss/public.atom",
	                publicJson: "/:projectHandle/rss/public.json",
	            },
	            defaultAvatar: "/rc/default-avatar/:projectId.png",
	            settings: "/rc/project/settings",
	            ask: "/:projectHandle/ask",
	            inbox: "/rc/project/inbox",
	        },
	        invites: {
	            manage: "/rc/moderation/invites/manage",
	            activate: "/rc/activate",
	            create: "/rc/moderation/invites/create",
	        },
	        moderation: {
	            home: "/rc/moderation",
	            manageArtistAlleyListing:
	                "/rc/moderation/manage-artist-alley-listing",
	            manageAsk: "/rc/moderation/manage-ask",
	            managePage: "/rc/moderation/manage-project",
	            managePost: "/rc/moderation/manage-post",
	            manageUser: "/rc/moderation/manage-user",
	            cacheMaintenance: "/rc/moderation/cache-maintenance",
	            bulkActivate: "/rc/moderation/bulk-activate",
	            createOAuthClient: "/rc/moderation/create-oauth-client",
	            artistAlleyPendingQueue: "/rc/moderation/artist-alley/pending",
	            tagOntology: {
	                manageTags: "/rc/moderation/tag-ontology/manage-tags",
	                pendingRequests: "/rc/moderation/tag-ontology/pending-requests",
	            },
	        },
	        subscriptions: {
	            createCheckoutSession: "/rc/subscriptions/create-checkout-session", // POST
	            createPortalSession: "/rc/subscriptions/create-portal-session", // POST,
	            success: "/rc/subscriptions/success",
	            cancelled: "/rc/subscriptions/cancelled",
	        },
	        artistAlley: {
	            home: "/rc/artist-alley",
	            success: "/rc/artist-alley/success/:sessionId",
	            cancelled: "/rc/artist-alley/cancelled/:sessionId",
	            create: "/rc/artist-alley/create",
	            ownerManage: "/rc/artist-alley/manage-listings",
	        },
	    },
	} ;

	const sitemap = {
	    public: {
	        home: (args


	) => {
	            const url = mainDomain(patterns.public.home, {});

	            const params = new URLSearchParams();

	            if (args?.refTimestamp !== undefined) {
	                params.set("refTimestamp", args.refTimestamp.toString());
	            }

	            if (args?.skipPosts !== undefined) {
	                params.set("skipPosts", args.skipPosts.toString());
	            }

	            url.search = params.toString();

	            return url;
	        },
	        dashboard: (args


	) => {
	            const url = mainDomain(patterns.public.dashboard, {});

	            const params = new URLSearchParams();

	            if (args?.refTimestamp !== undefined) {
	                params.set("refTimestamp", args.refTimestamp.toString());
	            }

	            if (args?.skipPosts !== undefined) {
	                params.set("skipPosts", args.skipPosts.toString());
	            }

	            url.search = params.toString();

	            return url;
	        },
	        welcome: () => mainDomain(patterns.public.welcome, {}),
	        login: (args) => {
	            const url = mainDomain(patterns.public.login, {});

	            if (args?.originalUrl) {
	                const searchParams = new URLSearchParams();
	                searchParams.set("originalUrl", args.originalUrl);
	                url.search = searchParams.toString();
	            }
	            return url;
	        },
	        logout: () => mainDomain(patterns.public.logout, {}),
	        signup: () => mainDomain(patterns.public.signup, {}),
	        createProject: () => mainDomain(patterns.public.createProject, {}),
	        switchProject: () => mainDomain(patterns.public.switchProject, {}),
	        userSettings: () => mainDomain(patterns.public.settingsMain, {}),
	        silencedPosts: (args) => {
	            const url = mainDomain(patterns.public.silencedPosts, {});
	            const params = new URLSearchParams();

	            if (args?.beforeTime !== undefined) {
	                params.set("beforeTime", args.beforeTime.toString());
	            }

	            if (args?.afterTime !== undefined) {
	                params.set("afterTime", args.afterTime.toString());
	            }

	            url.search = params.toString();
	            return url;
	        },
	        verifyEmail: ({ userId, nonce }) => {
	            const url = mainDomain(patterns.public.verifyEmail, {});
	            url.search = new URLSearchParams({
	                userId: userId.toString(),
	                nonce,
	            }).toString();
	            return url;
	        },
	        cancelVerifyEmail: ({
	            userId,
	            nonce,
	        }


	) => {
	            const url = mainDomain(patterns.public.cancelVerifyEmail, {});
	            url.search = new URLSearchParams({
	                userId: userId.toString(),
	                nonce,
	            }).toString();
	            return url;
	        },
	        redirectToAttachment: (args) =>
	            mainDomain(patterns.public.redirectToAttachment, args),
	        resetPassword: ({
	            email,
	            nonce,
	        }


	) => {
	            const url = mainDomain(patterns.public.resetPassword, {});
	            if (email && nonce) {
	                url.search = new URLSearchParams({
	                    email,
	                    nonce,
	                }).toString();
	            }
	            return url;
	        },
	        staticContent: (args) =>
	            mainDomain(patterns.public.staticContent, args),
	        static: {
	            staticAsset: (args) => {
	                let path = args.path;
	                return `../../static/${path}`;            },
	        },
	        apiV1: {
	            createProject: () => apiV1(patterns.public.apiV1.createProject, {}),
	            getProject: (args) =>
	                apiV1(patterns.public.apiV1.getProject, args),
	            updateProject: () => apiV1(patterns.public.apiV1.updateProject, {}),
	            getFollowingState: (args) =>
	                apiV1(patterns.public.apiV1.getFollowingState, args),
	            updatePost: (args


	) => apiV1(patterns.public.apiV1.updatePost, args),
	            startAttachment: (args


	) => apiV1(patterns.public.apiV1.startAttachment, args),
	            finishAttachment: (args



	) => apiV1(patterns.public.apiV1.finishAttachment, args),
	            listEditedProjects: () =>
	                apiV1(patterns.public.apiV1.listEditedProjects, {}),
	            createComment: () => apiV1(patterns.public.apiV1.createComment, {}),
	            editDeleteComment: (args) =>
	                apiV1(patterns.public.apiV1.editDeleteComment, args),
	            register: () => apiV1(patterns.public.apiV1.register, {}),
	            changePassword: () =>
	                apiV1(patterns.public.apiV1.changePassword, {}),
	            requestPasswordReset: () =>
	                apiV1(patterns.public.apiV1.requestPasswordReset, {}),
	            /** @deprecated */
	            login: () => apiV1(patterns.public.apiV1.login, {}),
	            /** @deprecated */
	            logout: () => apiV1(patterns.public.apiV1.logout, {}),
	            checkEmail: () => apiV1(patterns.public.apiV1.checkEmail, {}),
	            projects: {
	                followers: ({
	                    offset = 0,
	                    limit = 10,
	                }


	) => {
	                    const url = apiV1(
	                        patterns.public.apiV1.projects.followers,
	                        {}
	                    );
	                    url.search = new URLSearchParams({
	                        offset: offset.toString(),
	                        limit: limit.toString(),
	                    }).toString();
	                    return url;
	                },
	            },
	            moderation: {
	                changeSettings: () =>
	                    apiV1(patterns.public.apiV1.moderation.changeSettings, {}),
	                grantOrRevokePermission: () =>
	                    apiV1(
	                        patterns.public.apiV1.moderation
	                            .grantOrRevokePermission,
	                        {}
	                    ),
	            },
	            reporting: {
	                listReasons: () =>
	                    apiV1(patterns.public.apiV1.reporting.listReasons, {}),
	                reportPost: () =>
	                    apiV1(patterns.public.apiV1.reporting.reportPost, {}),
	            },
	            trpc: () => apiV1(patterns.public.apiV1.trpc, {}),
	        },
	        unleashProxy: () => mainDomain(patterns.public.unleashProxy, {}),
	        relationshipAction: (
	            args






























	        ) => relationshipAction(patterns.public.relationshipAction, args),
	        tags: (
	            args



	        ) => {
	            const url = mainDomain(patterns.public.tags, {
	                tagSlug: encodeURIComponent(args.tagSlug),
	            });

	            const params = new URLSearchParams();

	            if (args?.show18PlusPosts !== undefined) {
	                params.set("show18PlusPosts", args.show18PlusPosts.toString());
	            }

	            if (args?.refTimestamp !== undefined) {
	                params.set("refTimestamp", args.refTimestamp.toString());
	            }

	            if (args?.skipPosts !== undefined) {
	                params.set("skipPosts", args.skipPosts.toString());
	            }

	            url.search = params.toString();

	            return url;
	        },
	        bookmarkedTagFeed: (
	            args
	        ) => {
	            const url = mainDomain(patterns.public.bookmarkedTagFeed, {});

	            const params = new URLSearchParams();

	            if (args?.show18PlusPosts !== undefined) {
	                params.set("show18PlusPosts", args.show18PlusPosts.toString());
	            }

	            if (args?.beforeTime !== undefined) {
	                params.set("beforeTime", args.beforeTime.toString());
	            }

	            if (args?.afterTime !== undefined) {
	                params.set("afterTime", args.afterTime.toString());
	            }

	            url.search = params.toString();

	            return url;
	        },
	        likedPosts: (args) => {
	            const url = mainDomain(patterns.public.likedPosts, {});

	            const params = new URLSearchParams();

	            if (args?.refTimestamp !== undefined) {
	                params.set("refTimestamp", args.refTimestamp.toString());
	            }

	            if (args?.skipPosts !== undefined) {
	                params.set("skipPosts", args.skipPosts.toString());
	            }

	            url.search = params.toString();

	            return url;
	        },
	        composePost: (args


	) => {
	            const url = mainDomain(patterns.public.composePost, args);

	            const params = new URLSearchParams();

	            if (args?.shareOfPostId !== undefined) {
	                params.set("shareOfPostId", args.shareOfPostId.toString());
	            }

	            if (args?.responseToAskId !== undefined) {
	                params.set("responseToAskId", args.responseToAskId.toString());
	            }

	            url.search = params.toString();

	            return url;
	        },
	        project: {
	            home: (args) =>
	                projectSubdomain(patterns.public.project.home, args),
	            mainAppProfile: (args) =>
	                mainDomain(patterns.public.project.mainAppProfile, args),
	            profileEdit: () =>
	                mainDomain(patterns.public.project.profileEdit, {}),
	            followers: () => mainDomain(patterns.public.project.followers, {}),
	            following: () => mainDomain(patterns.public.project.following, {}),
	            notifications: () =>
	                mainDomain(patterns.public.project.notifications, {}),
	            followRequests: (args) =>
	                mainDomain(patterns.public.project.followRequests, args),
	            composePost: (args



	) => {
	                const url = mainDomain(
	                    patterns.public.project.composePost,
	                    args
	                );

	                const params = new URLSearchParams();

	                if (args?.shareOfPostId !== undefined) {
	                    params.set("shareOfPostId", args.shareOfPostId.toString());
	                }

	                if (args?.responseToAskId !== undefined) {
	                    params.set(
	                        "responseToAskId",
	                        args.responseToAskId.toString()
	                    );
	                }

	                url.search = params.toString();

	                return url;
	            },
	            editPost: (args


	) => mainDomain(patterns.public.project.editPost, args),
	            singlePost: {
	                published: (args



	) => {
	                    const url = mainDomain(
	                        patterns.public.project.singlePost.published,
	                        args
	                    );
	                    if (args.commentId) {
	                        url.hash = `comment-${args.commentId}`;
	                    }
	                    return url;
	                },
	                unpublished: (args



	) =>
	                    mainDomain(
	                        patterns.public.project.singlePost.unpublished,
	                        args
	                    ),
	            },
	            unpublishedPosts: (args) => {
	                const url = mainDomain(
	                    patterns.public.project.unpublishedPosts,
	                    {}
	                );

	                const params = new URLSearchParams();

	                if (args?.refTimestamp !== undefined) {
	                    params.set("refTimestamp", args.refTimestamp.toString());
	                }

	                if (args?.skipPosts !== undefined) {
	                    params.set("skipPosts", args.skipPosts.toString());
	                }

	                url.search = params.toString();

	                return url;
	            },
	            ask: (args) =>
	                mainDomain(patterns.public.project.ask, args),
	            inbox: () => mainDomain(patterns.public.project.inbox, {}),
	            rss: {
	                publicRss: (args


	) => {
	                    const url = mainDomain(
	                        patterns.public.project.rss.publicRss,
	                        args
	                    );

	                    if (args.page !== undefined) {
	                        const params = new URLSearchParams({
	                            page: args.page.toString(),
	                        });

	                        url.search = `?${params.toString()}`;
	                    }

	                    return url;
	                },
	                publicAtom: (args


	) => {
	                    const url = mainDomain(
	                        patterns.public.project.rss.publicAtom,
	                        args
	                    );

	                    if (args.page !== undefined) {
	                        const params = new URLSearchParams({
	                            page: args.page.toString(),
	                        });

	                        url.search = `?${params.toString()}`;
	                    }

	                    return url;
	                },
	                publicJson: (args


	) => {
	                    const url = mainDomain(
	                        patterns.public.project.rss.publicJson,
	                        args
	                    );

	                    if (args.page !== undefined) {
	                        const params = new URLSearchParams({
	                            page: args.page.toString(),
	                        });

	                        url.search = `?${params.toString()}`;
	                    }

	                    return url;
	                },
	            },
	            tags: (
	                args



	            ) => {
	                const url = mainDomain(patterns.public.project.tags, {
	                    tagSlug: encodeURIComponent(args.tagSlug),
	                    projectHandle: args.projectHandle,
	                });

	                const params = new URLSearchParams();

	                if (args?.refTimestamp !== undefined) {
	                    params.set("refTimestamp", args.refTimestamp.toString());
	                }

	                if (args?.skipPosts !== undefined) {
	                    params.set("skipPosts", args.skipPosts.toString());
	                }

	                url.search = params.toString();

	                return url;
	            },
	            defaultAvatar: (args) =>
	                mainDomain(patterns.public.project.defaultAvatar, args),
	            settings: () => mainDomain(patterns.public.project.settings, {}),
	        },
	        invites: {
	            manage: () => mainDomain(patterns.public.invites.manage, {}),
	            activate: (args) => {
	                const url = mainDomain(patterns.public.invites.activate, args);

	                const params = new URLSearchParams({
	                    inviteId: args.inviteId,
	                });

	                url.search = `?${params.toString()}`;

	                return url;
	            },
	            create: () => mainDomain(patterns.public.invites.create, {}),
	        },
	        moderation: {
	            home: () => mainDomain(patterns.public.moderation.home, {}),
	            manageUser: (args) => {
	                const url = mainDomain(
	                    patterns.public.moderation.manageUser,
	                    args
	                );

	                const params = new URLSearchParams();

	                if (args.userId) {
	                    params.set("userId", args.userId.toString());
	                } else if (args.email) {
	                    params.set("email", args.email);
	                }

	                url.search = `?${params.toString()}`;

	                return url;
	            },
	            managePost: (args) => {
	                const url = mainDomain(
	                    patterns.public.moderation.managePost,
	                    args
	                );

	                const params = new URLSearchParams({
	                    postId: args.postId.toString(),
	                });

	                url.search = `?${params.toString()}`;

	                return url;
	            },
	            manageProject: (args) => {
	                const url = mainDomain(
	                    patterns.public.moderation.managePage,
	                    {}
	                );

	                if (args.projectHandle) {
	                    const params = new URLSearchParams({
	                        handle: args.projectHandle,
	                    });
	                    url.search = `?${params.toString()}`;
	                }
	                return url;
	            },
	            manageArtistAlleyListing: (args) => {
	                const url = mainDomain(
	                    patterns.public.moderation.manageArtistAlleyListing,
	                    {}
	                );

	                const params = new URLSearchParams({
	                    adId: args.adId,
	                });
	                url.search = `?${params.toString()}`;

	                return url;
	            },
	            cacheMaintenance: () =>
	                mainDomain(patterns.public.moderation.cacheMaintenance, {}),
	            bulkActivate: () =>
	                mainDomain(patterns.public.moderation.bulkActivate, {}),
	            createOAuthClient: () =>
	                mainDomain(patterns.public.moderation.createOAuthClient, {}),
	            manageAsk: (args) => {
	                const url = mainDomain(
	                    patterns.public.moderation.manageAsk,
	                    {}
	                );

	                if (args.askId) {
	                    const params = new URLSearchParams({
	                        askId: args.askId,
	                    });
	                    url.search = `?${params.toString()}`;
	                }
	                return url;
	            },
	            artistAlleyPendingQueue: () =>
	                mainDomain(
	                    patterns.public.moderation.artistAlleyPendingQueue,
	                    {}
	                ),
	            tagOntology: {
	                manageTags: () =>
	                    mainDomain(
	                        patterns.public.moderation.tagOntology.manageTags,
	                        {}
	                    ),
	                pendingRequests: () =>
	                    mainDomain(
	                        patterns.public.moderation.tagOntology.pendingRequests,
	                        {}
	                    ),
	            },
	        },
	        subscriptions: {
	            createCheckoutSession: () =>
	                mainDomain(
	                    patterns.public.subscriptions.createCheckoutSession,
	                    {}
	                ),
	            createPortalSession: () =>
	                mainDomain(
	                    patterns.public.subscriptions.createPortalSession,
	                    {}
	                ),
	            success: (args) => {
	                const url = mainDomain(
	                    patterns.public.subscriptions.success,
	                    {}
	                );

	                const params = new URLSearchParams({
	                    sessionId: args.sessionId,
	                });
	                url.search = `?${params.toString()}`;

	                return url;
	            },
	            cancelled: (args) => {
	                const url = mainDomain(
	                    patterns.public.subscriptions.cancelled,
	                    {}
	                );

	                const params = new URLSearchParams({
	                    sessionId: args.sessionId,
	                });
	                url.search = `?${params.toString()}`;

	                return url;
	            },
	            manage: () => {
	                const url = sitemap.public.userSettings();
	                url.hash = "cohost-plus";
	                return url;
	            },
	        },
	        search: (args = {}) => {
	            const url = mainDomain(patterns.public.search, {});

	            if (args.query) {
	                const params = new URLSearchParams({
	                    q: args.query,
	                });
	                url.search = `?${params.toString()}`;
	            }
	            return url;
	        },
	        artistAlley: {
	            home: () => mainDomain(patterns.public.artistAlley.home, {}),
	            success: (args) => {
	                return mainDomain(patterns.public.artistAlley.success, args);
	            },
	            cancelled: (args) => {
	                return mainDomain(patterns.public.artistAlley.cancelled, args);
	            },
	            create: () => mainDomain(patterns.public.artistAlley.create, {}),
	            ownerManage: () =>
	                mainDomain(patterns.public.artistAlley.ownerManage, {}),
	        },
	    },
	} ;

	class Subscribable {
	  constructor() {
	    this.listeners = [];
	    this.subscribe = this.subscribe.bind(this);
	  }

	  subscribe(listener) {
	    this.listeners.push(listener);
	    this.onSubscribe();
	    return () => {
	      this.listeners = this.listeners.filter(x => x !== listener);
	      this.onUnsubscribe();
	    };
	  }

	  hasListeners() {
	    return this.listeners.length > 0;
	  }

	  onSubscribe() {// Do nothing
	  }

	  onUnsubscribe() {// Do nothing
	  }

	}

	// TYPES
	// UTILS
	const isServer = typeof window === 'undefined' || 'Deno' in window;
	function noop$5() {
	  return undefined;
	}
	function functionalUpdate(updater, input) {
	  return typeof updater === 'function' ? updater(input) : updater;
	}
	function isValidTimeout(value) {
	  return typeof value === 'number' && value >= 0 && value !== Infinity;
	}
	function difference(array1, array2) {
	  return array1.filter(x => array2.indexOf(x) === -1);
	}
	function replaceAt(array, index, value) {
	  const copy = array.slice(0);
	  copy[index] = value;
	  return copy;
	}
	function timeUntilStale(updatedAt, staleTime) {
	  return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
	}
	function parseQueryArgs(arg1, arg2, arg3) {
	  if (!isQueryKey(arg1)) {
	    return arg1;
	  }

	  if (typeof arg2 === 'function') {
	    return { ...arg3,
	      queryKey: arg1,
	      queryFn: arg2
	    };
	  }

	  return { ...arg2,
	    queryKey: arg1
	  };
	}
	function parseMutationArgs(arg1, arg2, arg3) {
	  if (isQueryKey(arg1)) {

	    return { ...arg2,
	      mutationKey: arg1
	    };
	  }

	  if (typeof arg1 === 'function') {
	    return { ...arg2,
	      mutationFn: arg1
	    };
	  }

	  return { ...arg1
	  };
	}
	function parseFilterArgs(arg1, arg2, arg3) {
	  return isQueryKey(arg1) ? [{ ...arg2,
	    queryKey: arg1
	  }, arg3] : [arg1 || {}, arg2];
	}
	function matchQuery(filters, query) {
	  const {
	    type = 'all',
	    exact,
	    fetchStatus,
	    predicate,
	    queryKey,
	    stale
	  } = filters;

	  if (isQueryKey(queryKey)) {
	    if (exact) {
	      if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {
	        return false;
	      }
	    } else if (!partialMatchKey(query.queryKey, queryKey)) {
	      return false;
	    }
	  }

	  if (type !== 'all') {
	    const isActive = query.isActive();

	    if (type === 'active' && !isActive) {
	      return false;
	    }

	    if (type === 'inactive' && isActive) {
	      return false;
	    }
	  }

	  if (typeof stale === 'boolean' && query.isStale() !== stale) {
	    return false;
	  }

	  if (typeof fetchStatus !== 'undefined' && fetchStatus !== query.state.fetchStatus) {
	    return false;
	  }

	  if (predicate && !predicate(query)) {
	    return false;
	  }

	  return true;
	}
	function matchMutation(filters, mutation) {
	  const {
	    exact,
	    fetching,
	    predicate,
	    mutationKey
	  } = filters;

	  if (isQueryKey(mutationKey)) {
	    if (!mutation.options.mutationKey) {
	      return false;
	    }

	    if (exact) {
	      if (hashQueryKey$1(mutation.options.mutationKey) !== hashQueryKey$1(mutationKey)) {
	        return false;
	      }
	    } else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) {
	      return false;
	    }
	  }

	  if (typeof fetching === 'boolean' && mutation.state.status === 'loading' !== fetching) {
	    return false;
	  }

	  if (predicate && !predicate(mutation)) {
	    return false;
	  }

	  return true;
	}
	function hashQueryKeyByOptions(queryKey, options) {
	  const hashFn = (options == null ? void 0 : options.queryKeyHashFn) || hashQueryKey$1;
	  return hashFn(queryKey);
	}
	/**
	 * Default query keys hash function.
	 * Hashes the value into a stable hash.
	 */

	function hashQueryKey$1(queryKey) {
	  return JSON.stringify(queryKey, (_, val) => isPlainObject$4(val) ? Object.keys(val).sort().reduce((result, key) => {
	    result[key] = val[key];
	    return result;
	  }, {}) : val);
	}
	/**
	 * Checks if key `b` partially matches with key `a`.
	 */

	function partialMatchKey(a, b) {
	  return partialDeepEqual(a, b);
	}
	/**
	 * Checks if `b` partially matches with `a`.
	 */

	function partialDeepEqual(a, b) {
	  if (a === b) {
	    return true;
	  }

	  if (typeof a !== typeof b) {
	    return false;
	  }

	  if (a && b && typeof a === 'object' && typeof b === 'object') {
	    return !Object.keys(b).some(key => !partialDeepEqual(a[key], b[key]));
	  }

	  return false;
	}
	/**
	 * This function returns `a` if `b` is deeply equal.
	 * If not, it will replace any deeply equal children of `b` with those of `a`.
	 * This can be used for structural sharing between JSON values for example.
	 */

	function replaceEqualDeep(a, b) {
	  if (a === b) {
	    return a;
	  }

	  const array = isPlainArray(a) && isPlainArray(b);

	  if (array || isPlainObject$4(a) && isPlainObject$4(b)) {
	    const aSize = array ? a.length : Object.keys(a).length;
	    const bItems = array ? b : Object.keys(b);
	    const bSize = bItems.length;
	    const copy = array ? [] : {};
	    let equalItems = 0;

	    for (let i = 0; i < bSize; i++) {
	      const key = array ? i : bItems[i];
	      copy[key] = replaceEqualDeep(a[key], b[key]);

	      if (copy[key] === a[key]) {
	        equalItems++;
	      }
	    }

	    return aSize === bSize && equalItems === aSize ? a : copy;
	  }

	  return b;
	}
	/**
	 * Shallow compare objects. Only works with objects that always have the same properties.
	 */

	function shallowEqualObjects(a, b) {
	  if (a && !b || b && !a) {
	    return false;
	  }

	  for (const key in a) {
	    if (a[key] !== b[key]) {
	      return false;
	    }
	  }

	  return true;
	}
	function isPlainArray(value) {
	  return Array.isArray(value) && value.length === Object.keys(value).length;
	} // Copied from: https://github.com/jonschlinkert/is-plain-object

	function isPlainObject$4(o) {
	  if (!hasObjectPrototype(o)) {
	    return false;
	  } // If has modified constructor


	  const ctor = o.constructor;

	  if (typeof ctor === 'undefined') {
	    return true;
	  } // If has modified prototype


	  const prot = ctor.prototype;

	  if (!hasObjectPrototype(prot)) {
	    return false;
	  } // If constructor does not have an Object-specific method


	  if (!prot.hasOwnProperty('isPrototypeOf')) {
	    return false;
	  } // Most likely a plain Object


	  return true;
	}

	function hasObjectPrototype(o) {
	  return Object.prototype.toString.call(o) === '[object Object]';
	}

	function isQueryKey(value) {
	  return Array.isArray(value);
	}
	function sleep(timeout) {
	  return new Promise(resolve => {
	    setTimeout(resolve, timeout);
	  });
	}
	/**
	 * Schedules a microtask.
	 * This can be useful to schedule state updates after rendering.
	 */

	function scheduleMicrotask(callback) {
	  sleep(0).then(callback);
	}
	function getAbortController$1() {
	  if (typeof AbortController === 'function') {
	    return new AbortController();
	  }

	  return;
	}
	function replaceData(prevData, data, options) {
	  // Use prev data if an isDataEqual function is defined and returns `true`
	  if (options.isDataEqual != null && options.isDataEqual(prevData, data)) {
	    return prevData;
	  } else if (typeof options.structuralSharing === 'function') {
	    return options.structuralSharing(prevData, data);
	  } else if (options.structuralSharing !== false) {
	    // Structurally share data between prev and new data if needed
	    return replaceEqualDeep(prevData, data);
	  }

	  return data;
	}

	class FocusManager extends Subscribable {
	  constructor() {
	    super();

	    this.setup = onFocus => {
	      // addEventListener does not exist in React Native, but window does
	      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
	      if (!isServer && window.addEventListener) {
	        const listener = () => onFocus(); // Listen to visibillitychange and focus


	        window.addEventListener('visibilitychange', listener, false);
	        window.addEventListener('focus', listener, false);
	        return () => {
	          // Be sure to unsubscribe if a new handler is set
	          window.removeEventListener('visibilitychange', listener);
	          window.removeEventListener('focus', listener);
	        };
	      }

	      return;
	    };
	  }

	  onSubscribe() {
	    if (!this.cleanup) {
	      this.setEventListener(this.setup);
	    }
	  }

	  onUnsubscribe() {
	    if (!this.hasListeners()) {
	      var _this$cleanup;

	      (_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);
	      this.cleanup = undefined;
	    }
	  }

	  setEventListener(setup) {
	    var _this$cleanup2;

	    this.setup = setup;
	    (_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);
	    this.cleanup = setup(focused => {
	      if (typeof focused === 'boolean') {
	        this.setFocused(focused);
	      } else {
	        this.onFocus();
	      }
	    });
	  }

	  setFocused(focused) {
	    this.focused = focused;

	    if (focused) {
	      this.onFocus();
	    }
	  }

	  onFocus() {
	    this.listeners.forEach(listener => {
	      listener();
	    });
	  }

	  isFocused() {
	    if (typeof this.focused === 'boolean') {
	      return this.focused;
	    } // document global can be unavailable in react native


	    if (typeof document === 'undefined') {
	      return true;
	    }

	    return [undefined, 'visible', 'prerender'].includes(document.visibilityState);
	  }

	}
	const focusManager = new FocusManager();

	// TYPES
	// FUNCTIONS
	function hydrate(client, dehydratedState, options) {
	  if (typeof dehydratedState !== 'object' || dehydratedState === null) {
	    return;
	  }

	  const mutationCache = client.getMutationCache();
	  const queryCache = client.getQueryCache(); // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition

	  const mutations = dehydratedState.mutations || []; // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition

	  const queries = dehydratedState.queries || [];
	  mutations.forEach(dehydratedMutation => {
	    var _options$defaultOptio;

	    mutationCache.build(client, { ...(options == null ? void 0 : (_options$defaultOptio = options.defaultOptions) == null ? void 0 : _options$defaultOptio.mutations),
	      mutationKey: dehydratedMutation.mutationKey
	    }, dehydratedMutation.state);
	  });
	  queries.forEach(dehydratedQuery => {
	    var _options$defaultOptio2;

	    const query = queryCache.get(dehydratedQuery.queryHash); // Do not hydrate if an existing query exists with newer data

	    if (query) {
	      if (query.state.dataUpdatedAt < dehydratedQuery.state.dataUpdatedAt) {
	        query.setState(dehydratedQuery.state);
	      }

	      return;
	    } // Restore query


	    queryCache.build(client, { ...(options == null ? void 0 : (_options$defaultOptio2 = options.defaultOptions) == null ? void 0 : _options$defaultOptio2.queries),
	      queryKey: dehydratedQuery.queryKey,
	      queryHash: dehydratedQuery.queryHash
	    }, dehydratedQuery.state);
	  });
	}

	function infiniteQueryBehavior() {
	  return {
	    onFetch: context => {
	      context.fetchFn = () => {
	        var _context$fetchOptions, _context$fetchOptions2, _context$fetchOptions3, _context$fetchOptions4, _context$state$data, _context$state$data2;

	        const refetchPage = (_context$fetchOptions = context.fetchOptions) == null ? void 0 : (_context$fetchOptions2 = _context$fetchOptions.meta) == null ? void 0 : _context$fetchOptions2.refetchPage;
	        const fetchMore = (_context$fetchOptions3 = context.fetchOptions) == null ? void 0 : (_context$fetchOptions4 = _context$fetchOptions3.meta) == null ? void 0 : _context$fetchOptions4.fetchMore;
	        const pageParam = fetchMore == null ? void 0 : fetchMore.pageParam;
	        const isFetchingNextPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'forward';
	        const isFetchingPreviousPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'backward';
	        const oldPages = ((_context$state$data = context.state.data) == null ? void 0 : _context$state$data.pages) || [];
	        const oldPageParams = ((_context$state$data2 = context.state.data) == null ? void 0 : _context$state$data2.pageParams) || [];
	        let newPageParams = oldPageParams;
	        let cancelled = false;

	        const addSignalProperty = object => {
	          Object.defineProperty(object, 'signal', {
	            enumerable: true,
	            get: () => {
	              var _context$signal;

	              if ((_context$signal = context.signal) != null && _context$signal.aborted) {
	                cancelled = true;
	              } else {
	                var _context$signal2;

	                (_context$signal2 = context.signal) == null ? void 0 : _context$signal2.addEventListener('abort', () => {
	                  cancelled = true;
	                });
	              }

	              return context.signal;
	            }
	          });
	        }; // Get query function


	        const queryFn = context.options.queryFn || (() => Promise.reject('Missing queryFn'));

	        const buildNewPages = (pages, param, page, previous) => {
	          newPageParams = previous ? [param, ...newPageParams] : [...newPageParams, param];
	          return previous ? [page, ...pages] : [...pages, page];
	        }; // Create function to fetch a page


	        const fetchPage = (pages, manual, param, previous) => {
	          if (cancelled) {
	            return Promise.reject('Cancelled');
	          }

	          if (typeof param === 'undefined' && !manual && pages.length) {
	            return Promise.resolve(pages);
	          }

	          const queryFnContext = {
	            queryKey: context.queryKey,
	            pageParam: param,
	            meta: context.options.meta
	          };
	          addSignalProperty(queryFnContext);
	          const queryFnResult = queryFn(queryFnContext);
	          const promise = Promise.resolve(queryFnResult).then(page => buildNewPages(pages, param, page, previous));
	          return promise;
	        };

	        let promise; // Fetch first page?

	        if (!oldPages.length) {
	          promise = fetchPage([]);
	        } // Fetch next page?
	        else if (isFetchingNextPage) {
	          const manual = typeof pageParam !== 'undefined';
	          const param = manual ? pageParam : getNextPageParam(context.options, oldPages);
	          promise = fetchPage(oldPages, manual, param);
	        } // Fetch previous page?
	        else if (isFetchingPreviousPage) {
	          const manual = typeof pageParam !== 'undefined';
	          const param = manual ? pageParam : getPreviousPageParam(context.options, oldPages);
	          promise = fetchPage(oldPages, manual, param, true);
	        } // Refetch pages
	        else {
	          newPageParams = [];
	          const manual = typeof context.options.getNextPageParam === 'undefined';
	          const shouldFetchFirstPage = refetchPage && oldPages[0] ? refetchPage(oldPages[0], 0, oldPages) : true; // Fetch first page

	          promise = shouldFetchFirstPage ? fetchPage([], manual, oldPageParams[0]) : Promise.resolve(buildNewPages([], oldPageParams[0], oldPages[0])); // Fetch remaining pages

	          for (let i = 1; i < oldPages.length; i++) {
	            promise = promise.then(pages => {
	              const shouldFetchNextPage = refetchPage && oldPages[i] ? refetchPage(oldPages[i], i, oldPages) : true;

	              if (shouldFetchNextPage) {
	                const param = manual ? oldPageParams[i] : getNextPageParam(context.options, pages);
	                return fetchPage(pages, manual, param);
	              }

	              return Promise.resolve(buildNewPages(pages, oldPageParams[i], oldPages[i]));
	            });
	          }
	        }

	        const finalPromise = promise.then(pages => ({
	          pages,
	          pageParams: newPageParams
	        }));
	        return finalPromise;
	      };
	    }
	  };
	}
	function getNextPageParam(options, pages) {
	  return options.getNextPageParam == null ? void 0 : options.getNextPageParam(pages[pages.length - 1], pages);
	}
	function getPreviousPageParam(options, pages) {
	  return options.getPreviousPageParam == null ? void 0 : options.getPreviousPageParam(pages[0], pages);
	}
	/**
	 * Checks if there is a next page.
	 * Returns `undefined` if it cannot be determined.
	 */

	function hasNextPage(options, pages) {
	  if (options.getNextPageParam && Array.isArray(pages)) {
	    const nextPageParam = getNextPageParam(options, pages);
	    return typeof nextPageParam !== 'undefined' && nextPageParam !== null && nextPageParam !== false;
	  }

	  return;
	}
	/**
	 * Checks if there is a previous page.
	 * Returns `undefined` if it cannot be determined.
	 */

	function hasPreviousPage(options, pages) {
	  if (options.getPreviousPageParam && Array.isArray(pages)) {
	    const previousPageParam = getPreviousPageParam(options, pages);
	    return typeof previousPageParam !== 'undefined' && previousPageParam !== null && previousPageParam !== false;
	  }

	  return;
	}

	function createNotifyManager() {
	  let queue = [];
	  let transactions = 0;

	  let notifyFn = callback => {
	    callback();
	  };

	  let batchNotifyFn = callback => {
	    callback();
	  };

	  const batch = callback => {
	    let result;
	    transactions++;

	    try {
	      result = callback();
	    } finally {
	      transactions--;

	      if (!transactions) {
	        flush();
	      }
	    }

	    return result;
	  };

	  const schedule = callback => {
	    if (transactions) {
	      queue.push(callback);
	    } else {
	      scheduleMicrotask(() => {
	        notifyFn(callback);
	      });
	    }
	  };
	  /**
	   * All calls to the wrapped function will be batched.
	   */


	  const batchCalls = callback => {
	    return (...args) => {
	      schedule(() => {
	        callback(...args);
	      });
	    };
	  };

	  const flush = () => {
	    const originalQueue = queue;
	    queue = [];

	    if (originalQueue.length) {
	      scheduleMicrotask(() => {
	        batchNotifyFn(() => {
	          originalQueue.forEach(callback => {
	            notifyFn(callback);
	          });
	        });
	      });
	    }
	  };
	  /**
	   * Use this method to set a custom notify function.
	   * This can be used to for example wrap notifications with `React.act` while running tests.
	   */


	  const setNotifyFunction = fn => {
	    notifyFn = fn;
	  };
	  /**
	   * Use this method to set a custom function to batch notifications together into a single tick.
	   * By default React Query will use the batch function provided by ReactDOM or React Native.
	   */


	  const setBatchNotifyFunction = fn => {
	    batchNotifyFn = fn;
	  };

	  return {
	    batch,
	    batchCalls,
	    schedule,
	    setNotifyFunction,
	    setBatchNotifyFunction
	  };
	} // SINGLETON

	const notifyManager = createNotifyManager();

	class OnlineManager extends Subscribable {
	  constructor() {
	    super();

	    this.setup = onOnline => {
	      // addEventListener does not exist in React Native, but window does
	      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
	      if (!isServer && window.addEventListener) {
	        const listener = () => onOnline(); // Listen to online


	        window.addEventListener('online', listener, false);
	        window.addEventListener('offline', listener, false);
	        return () => {
	          // Be sure to unsubscribe if a new handler is set
	          window.removeEventListener('online', listener);
	          window.removeEventListener('offline', listener);
	        };
	      }

	      return;
	    };
	  }

	  onSubscribe() {
	    if (!this.cleanup) {
	      this.setEventListener(this.setup);
	    }
	  }

	  onUnsubscribe() {
	    if (!this.hasListeners()) {
	      var _this$cleanup;

	      (_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);
	      this.cleanup = undefined;
	    }
	  }

	  setEventListener(setup) {
	    var _this$cleanup2;

	    this.setup = setup;
	    (_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);
	    this.cleanup = setup(online => {
	      if (typeof online === 'boolean') {
	        this.setOnline(online);
	      } else {
	        this.onOnline();
	      }
	    });
	  }

	  setOnline(online) {
	    this.online = online;

	    if (online) {
	      this.onOnline();
	    }
	  }

	  onOnline() {
	    this.listeners.forEach(listener => {
	      listener();
	    });
	  }

	  isOnline() {
	    if (typeof this.online === 'boolean') {
	      return this.online;
	    }

	    if (typeof navigator === 'undefined' || typeof navigator.onLine === 'undefined') {
	      return true;
	    }

	    return navigator.onLine;
	  }

	}
	const onlineManager = new OnlineManager();

	function defaultRetryDelay(failureCount) {
	  return Math.min(1000 * 2 ** failureCount, 30000);
	}

	function canFetch(networkMode) {
	  return (networkMode != null ? networkMode : 'online') === 'online' ? onlineManager.isOnline() : true;
	}
	class CancelledError {
	  constructor(options) {
	    this.revert = options == null ? void 0 : options.revert;
	    this.silent = options == null ? void 0 : options.silent;
	  }

	}
	function isCancelledError(value) {
	  return value instanceof CancelledError;
	}
	function createRetryer(config) {
	  let isRetryCancelled = false;
	  let failureCount = 0;
	  let isResolved = false;
	  let continueFn;
	  let promiseResolve;
	  let promiseReject;
	  const promise = new Promise((outerResolve, outerReject) => {
	    promiseResolve = outerResolve;
	    promiseReject = outerReject;
	  });

	  const cancel = cancelOptions => {
	    if (!isResolved) {
	      reject(new CancelledError(cancelOptions));
	      config.abort == null ? void 0 : config.abort();
	    }
	  };

	  const cancelRetry = () => {
	    isRetryCancelled = true;
	  };

	  const continueRetry = () => {
	    isRetryCancelled = false;
	  };

	  const shouldPause = () => !focusManager.isFocused() || config.networkMode !== 'always' && !onlineManager.isOnline();

	  const resolve = value => {
	    if (!isResolved) {
	      isResolved = true;
	      config.onSuccess == null ? void 0 : config.onSuccess(value);
	      continueFn == null ? void 0 : continueFn();
	      promiseResolve(value);
	    }
	  };

	  const reject = value => {
	    if (!isResolved) {
	      isResolved = true;
	      config.onError == null ? void 0 : config.onError(value);
	      continueFn == null ? void 0 : continueFn();
	      promiseReject(value);
	    }
	  };

	  const pause = () => {
	    return new Promise(continueResolve => {
	      continueFn = value => {
	        if (isResolved || !shouldPause()) {
	          return continueResolve(value);
	        }
	      };

	      config.onPause == null ? void 0 : config.onPause();
	    }).then(() => {
	      continueFn = undefined;

	      if (!isResolved) {
	        config.onContinue == null ? void 0 : config.onContinue();
	      }
	    });
	  }; // Create loop function


	  const run = () => {
	    // Do nothing if already resolved
	    if (isResolved) {
	      return;
	    }

	    let promiseOrValue; // Execute query

	    try {
	      promiseOrValue = config.fn();
	    } catch (error) {
	      promiseOrValue = Promise.reject(error);
	    }

	    Promise.resolve(promiseOrValue).then(resolve).catch(error => {
	      var _config$retry, _config$retryDelay;

	      // Stop if the fetch is already resolved
	      if (isResolved) {
	        return;
	      } // Do we need to retry the request?


	      const retry = (_config$retry = config.retry) != null ? _config$retry : 3;
	      const retryDelay = (_config$retryDelay = config.retryDelay) != null ? _config$retryDelay : defaultRetryDelay;
	      const delay = typeof retryDelay === 'function' ? retryDelay(failureCount, error) : retryDelay;
	      const shouldRetry = retry === true || typeof retry === 'number' && failureCount < retry || typeof retry === 'function' && retry(failureCount, error);

	      if (isRetryCancelled || !shouldRetry) {
	        // We are done if the query does not need to be retried
	        reject(error);
	        return;
	      }

	      failureCount++; // Notify on fail

	      config.onFail == null ? void 0 : config.onFail(failureCount, error); // Delay

	      sleep(delay) // Pause if the document is not visible or when the device is offline
	      .then(() => {
	        if (shouldPause()) {
	          return pause();
	        }

	        return;
	      }).then(() => {
	        if (isRetryCancelled) {
	          reject(error);
	        } else {
	          run();
	        }
	      });
	    });
	  }; // Start loop


	  if (canFetch(config.networkMode)) {
	    run();
	  } else {
	    pause().then(run);
	  }

	  return {
	    promise,
	    cancel,
	    continue: () => {
	      continueFn == null ? void 0 : continueFn();
	    },
	    cancelRetry,
	    continueRetry
	  };
	}

	class QueryObserver extends Subscribable {
	  constructor(client, options) {
	    super();
	    this.client = client;
	    this.options = options;
	    this.trackedProps = new Set();
	    this.selectError = null;
	    this.bindMethods();
	    this.setOptions(options);
	  }

	  bindMethods() {
	    this.remove = this.remove.bind(this);
	    this.refetch = this.refetch.bind(this);
	  }

	  onSubscribe() {
	    if (this.listeners.length === 1) {
	      this.currentQuery.addObserver(this);

	      if (shouldFetchOnMount(this.currentQuery, this.options)) {
	        this.executeFetch();
	      }

	      this.updateTimers();
	    }
	  }

	  onUnsubscribe() {
	    if (!this.listeners.length) {
	      this.destroy();
	    }
	  }

	  shouldFetchOnReconnect() {
	    return shouldFetchOn(this.currentQuery, this.options, this.options.refetchOnReconnect);
	  }

	  shouldFetchOnWindowFocus() {
	    return shouldFetchOn(this.currentQuery, this.options, this.options.refetchOnWindowFocus);
	  }

	  destroy() {
	    this.listeners = [];
	    this.clearStaleTimeout();
	    this.clearRefetchInterval();
	    this.currentQuery.removeObserver(this);
	  }

	  setOptions(options, notifyOptions) {
	    const prevOptions = this.options;
	    const prevQuery = this.currentQuery;
	    this.options = this.client.defaultQueryOptions(options);

	    if (!shallowEqualObjects(prevOptions, this.options)) {
	      this.client.getQueryCache().notify({
	        type: 'observerOptionsUpdated',
	        query: this.currentQuery,
	        observer: this
	      });
	    }

	    if (typeof this.options.enabled !== 'undefined' && typeof this.options.enabled !== 'boolean') {
	      throw new Error('Expected enabled to be a boolean');
	    } // Keep previous query key if the user does not supply one


	    if (!this.options.queryKey) {
	      this.options.queryKey = prevOptions.queryKey;
	    }

	    this.updateQuery();
	    const mounted = this.hasListeners(); // Fetch if there are subscribers

	    if (mounted && shouldFetchOptionally(this.currentQuery, prevQuery, this.options, prevOptions)) {
	      this.executeFetch();
	    } // Update result


	    this.updateResult(notifyOptions); // Update stale interval if needed

	    if (mounted && (this.currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || this.options.staleTime !== prevOptions.staleTime)) {
	      this.updateStaleTimeout();
	    }

	    const nextRefetchInterval = this.computeRefetchInterval(); // Update refetch interval if needed

	    if (mounted && (this.currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || nextRefetchInterval !== this.currentRefetchInterval)) {
	      this.updateRefetchInterval(nextRefetchInterval);
	    }
	  }

	  getOptimisticResult(options) {
	    const query = this.client.getQueryCache().build(this.client, options);
	    return this.createResult(query, options);
	  }

	  getCurrentResult() {
	    return this.currentResult;
	  }

	  trackResult(result) {
	    const trackedResult = {};
	    Object.keys(result).forEach(key => {
	      Object.defineProperty(trackedResult, key, {
	        configurable: false,
	        enumerable: true,
	        get: () => {
	          this.trackedProps.add(key);
	          return result[key];
	        }
	      });
	    });
	    return trackedResult;
	  }

	  getCurrentQuery() {
	    return this.currentQuery;
	  }

	  remove() {
	    this.client.getQueryCache().remove(this.currentQuery);
	  }

	  refetch({
	    refetchPage,
	    ...options
	  } = {}) {
	    return this.fetch({ ...options,
	      meta: {
	        refetchPage
	      }
	    });
	  }

	  fetchOptimistic(options) {
	    const defaultedOptions = this.client.defaultQueryOptions(options);
	    const query = this.client.getQueryCache().build(this.client, defaultedOptions);
	    query.isFetchingOptimistic = true;
	    return query.fetch().then(() => this.createResult(query, defaultedOptions));
	  }

	  fetch(fetchOptions) {
	    var _fetchOptions$cancelR;

	    return this.executeFetch({ ...fetchOptions,
	      cancelRefetch: (_fetchOptions$cancelR = fetchOptions.cancelRefetch) != null ? _fetchOptions$cancelR : true
	    }).then(() => {
	      this.updateResult();
	      return this.currentResult;
	    });
	  }

	  executeFetch(fetchOptions) {
	    // Make sure we reference the latest query as the current one might have been removed
	    this.updateQuery(); // Fetch

	    let promise = this.currentQuery.fetch(this.options, fetchOptions);

	    if (!(fetchOptions != null && fetchOptions.throwOnError)) {
	      promise = promise.catch(noop$5);
	    }

	    return promise;
	  }

	  updateStaleTimeout() {
	    this.clearStaleTimeout();

	    if (isServer || this.currentResult.isStale || !isValidTimeout(this.options.staleTime)) {
	      return;
	    }

	    const time = timeUntilStale(this.currentResult.dataUpdatedAt, this.options.staleTime); // The timeout is sometimes triggered 1 ms before the stale time expiration.
	    // To mitigate this issue we always add 1 ms to the timeout.

	    const timeout = time + 1;
	    this.staleTimeoutId = setTimeout(() => {
	      if (!this.currentResult.isStale) {
	        this.updateResult();
	      }
	    }, timeout);
	  }

	  computeRefetchInterval() {
	    var _this$options$refetch;

	    return typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(this.currentResult.data, this.currentQuery) : (_this$options$refetch = this.options.refetchInterval) != null ? _this$options$refetch : false;
	  }

	  updateRefetchInterval(nextInterval) {
	    this.clearRefetchInterval();
	    this.currentRefetchInterval = nextInterval;

	    if (isServer || this.options.enabled === false || !isValidTimeout(this.currentRefetchInterval) || this.currentRefetchInterval === 0) {
	      return;
	    }

	    this.refetchIntervalId = setInterval(() => {
	      if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
	        this.executeFetch();
	      }
	    }, this.currentRefetchInterval);
	  }

	  updateTimers() {
	    this.updateStaleTimeout();
	    this.updateRefetchInterval(this.computeRefetchInterval());
	  }

	  clearStaleTimeout() {
	    if (this.staleTimeoutId) {
	      clearTimeout(this.staleTimeoutId);
	      this.staleTimeoutId = undefined;
	    }
	  }

	  clearRefetchInterval() {
	    if (this.refetchIntervalId) {
	      clearInterval(this.refetchIntervalId);
	      this.refetchIntervalId = undefined;
	    }
	  }

	  createResult(query, options) {
	    const prevQuery = this.currentQuery;
	    const prevOptions = this.options;
	    const prevResult = this.currentResult;
	    const prevResultState = this.currentResultState;
	    const prevResultOptions = this.currentResultOptions;
	    const queryChange = query !== prevQuery;
	    const queryInitialState = queryChange ? query.state : this.currentQueryInitialState;
	    const prevQueryResult = queryChange ? this.currentResult : this.previousQueryResult;
	    const {
	      state
	    } = query;
	    let {
	      dataUpdatedAt,
	      error,
	      errorUpdatedAt,
	      fetchStatus,
	      status
	    } = state;
	    let isPreviousData = false;
	    let isPlaceholderData = false;
	    let data; // Optimistically set result in fetching state if needed

	    if (options._optimisticResults) {
	      const mounted = this.hasListeners();
	      const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
	      const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);

	      if (fetchOnMount || fetchOptionally) {
	        fetchStatus = canFetch(query.options.networkMode) ? 'fetching' : 'paused';

	        if (!dataUpdatedAt) {
	          status = 'loading';
	        }
	      }

	      if (options._optimisticResults === 'isRestoring') {
	        fetchStatus = 'idle';
	      }
	    } // Keep previous data if needed


	    if (options.keepPreviousData && !state.dataUpdatedAt && prevQueryResult != null && prevQueryResult.isSuccess && status !== 'error') {
	      data = prevQueryResult.data;
	      dataUpdatedAt = prevQueryResult.dataUpdatedAt;
	      status = prevQueryResult.status;
	      isPreviousData = true;
	    } // Select data if needed
	    else if (options.select && typeof state.data !== 'undefined') {
	      // Memoize select result
	      if (prevResult && state.data === (prevResultState == null ? void 0 : prevResultState.data) && options.select === this.selectFn) {
	        data = this.selectResult;
	      } else {
	        try {
	          this.selectFn = options.select;
	          data = options.select(state.data);
	          data = replaceData(prevResult == null ? void 0 : prevResult.data, data, options);
	          this.selectResult = data;
	          this.selectError = null;
	        } catch (selectError) {

	          this.selectError = selectError;
	        }
	      }
	    } // Use query data
	    else {
	      data = state.data;
	    } // Show placeholder data if needed


	    if (typeof options.placeholderData !== 'undefined' && typeof data === 'undefined' && status === 'loading') {
	      let placeholderData; // Memoize placeholder data

	      if (prevResult != null && prevResult.isPlaceholderData && options.placeholderData === (prevResultOptions == null ? void 0 : prevResultOptions.placeholderData)) {
	        placeholderData = prevResult.data;
	      } else {
	        placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData() : options.placeholderData;

	        if (options.select && typeof placeholderData !== 'undefined') {
	          try {
	            placeholderData = options.select(placeholderData);
	            this.selectError = null;
	          } catch (selectError) {

	            this.selectError = selectError;
	          }
	        }
	      }

	      if (typeof placeholderData !== 'undefined') {
	        status = 'success';
	        data = replaceData(prevResult == null ? void 0 : prevResult.data, placeholderData, options);
	        isPlaceholderData = true;
	      }
	    }

	    if (this.selectError) {
	      error = this.selectError;
	      data = this.selectResult;
	      errorUpdatedAt = Date.now();
	      status = 'error';
	    }

	    const isFetching = fetchStatus === 'fetching';
	    const isLoading = status === 'loading';
	    const isError = status === 'error';
	    const result = {
	      status,
	      fetchStatus,
	      isLoading,
	      isSuccess: status === 'success',
	      isError,
	      isInitialLoading: isLoading && isFetching,
	      data,
	      dataUpdatedAt,
	      error,
	      errorUpdatedAt,
	      failureCount: state.fetchFailureCount,
	      failureReason: state.fetchFailureReason,
	      errorUpdateCount: state.errorUpdateCount,
	      isFetched: state.dataUpdateCount > 0 || state.errorUpdateCount > 0,
	      isFetchedAfterMount: state.dataUpdateCount > queryInitialState.dataUpdateCount || state.errorUpdateCount > queryInitialState.errorUpdateCount,
	      isFetching,
	      isRefetching: isFetching && !isLoading,
	      isLoadingError: isError && state.dataUpdatedAt === 0,
	      isPaused: fetchStatus === 'paused',
	      isPlaceholderData,
	      isPreviousData,
	      isRefetchError: isError && state.dataUpdatedAt !== 0,
	      isStale: isStale(query, options),
	      refetch: this.refetch,
	      remove: this.remove
	    };
	    return result;
	  }

	  updateResult(notifyOptions) {
	    const prevResult = this.currentResult;
	    const nextResult = this.createResult(this.currentQuery, this.options);
	    this.currentResultState = this.currentQuery.state;
	    this.currentResultOptions = this.options; // Only notify and update result if something has changed

	    if (shallowEqualObjects(nextResult, prevResult)) {
	      return;
	    }

	    this.currentResult = nextResult; // Determine which callbacks to trigger

	    const defaultNotifyOptions = {
	      cache: true
	    };

	    const shouldNotifyListeners = () => {
	      if (!prevResult) {
	        return true;
	      }

	      const {
	        notifyOnChangeProps
	      } = this.options;

	      if (notifyOnChangeProps === 'all' || !notifyOnChangeProps && !this.trackedProps.size) {
	        return true;
	      }

	      const includedProps = new Set(notifyOnChangeProps != null ? notifyOnChangeProps : this.trackedProps);

	      if (this.options.useErrorBoundary) {
	        includedProps.add('error');
	      }

	      return Object.keys(this.currentResult).some(key => {
	        const typedKey = key;
	        const changed = this.currentResult[typedKey] !== prevResult[typedKey];
	        return changed && includedProps.has(typedKey);
	      });
	    };

	    if ((notifyOptions == null ? void 0 : notifyOptions.listeners) !== false && shouldNotifyListeners()) {
	      defaultNotifyOptions.listeners = true;
	    }

	    this.notify({ ...defaultNotifyOptions,
	      ...notifyOptions
	    });
	  }

	  updateQuery() {
	    const query = this.client.getQueryCache().build(this.client, this.options);

	    if (query === this.currentQuery) {
	      return;
	    }

	    const prevQuery = this.currentQuery;
	    this.currentQuery = query;
	    this.currentQueryInitialState = query.state;
	    this.previousQueryResult = this.currentResult;

	    if (this.hasListeners()) {
	      prevQuery == null ? void 0 : prevQuery.removeObserver(this);
	      query.addObserver(this);
	    }
	  }

	  onQueryUpdate(action) {
	    const notifyOptions = {};

	    if (action.type === 'success') {
	      notifyOptions.onSuccess = !action.manual;
	    } else if (action.type === 'error' && !isCancelledError(action.error)) {
	      notifyOptions.onError = true;
	    }

	    this.updateResult(notifyOptions);

	    if (this.hasListeners()) {
	      this.updateTimers();
	    }
	  }

	  notify(notifyOptions) {
	    notifyManager.batch(() => {
	      // First trigger the configuration callbacks
	      if (notifyOptions.onSuccess) {
	        var _this$options$onSucce, _this$options, _this$options$onSettl, _this$options2;

	        (_this$options$onSucce = (_this$options = this.options).onSuccess) == null ? void 0 : _this$options$onSucce.call(_this$options, this.currentResult.data);
	        (_this$options$onSettl = (_this$options2 = this.options).onSettled) == null ? void 0 : _this$options$onSettl.call(_this$options2, this.currentResult.data, null);
	      } else if (notifyOptions.onError) {
	        var _this$options$onError, _this$options3, _this$options$onSettl2, _this$options4;

	        (_this$options$onError = (_this$options3 = this.options).onError) == null ? void 0 : _this$options$onError.call(_this$options3, this.currentResult.error);
	        (_this$options$onSettl2 = (_this$options4 = this.options).onSettled) == null ? void 0 : _this$options$onSettl2.call(_this$options4, undefined, this.currentResult.error);
	      } // Then trigger the listeners


	      if (notifyOptions.listeners) {
	        this.listeners.forEach(listener => {
	          listener(this.currentResult);
	        });
	      } // Then the cache listeners


	      if (notifyOptions.cache) {
	        this.client.getQueryCache().notify({
	          query: this.currentQuery,
	          type: 'observerResultsUpdated'
	        });
	      }
	    });
	  }

	}

	function shouldLoadOnMount(query, options) {
	  return options.enabled !== false && !query.state.dataUpdatedAt && !(query.state.status === 'error' && options.retryOnMount === false);
	}

	function shouldFetchOnMount(query, options) {
	  return shouldLoadOnMount(query, options) || query.state.dataUpdatedAt > 0 && shouldFetchOn(query, options, options.refetchOnMount);
	}

	function shouldFetchOn(query, options, field) {
	  if (options.enabled !== false) {
	    const value = typeof field === 'function' ? field(query) : field;
	    return value === 'always' || value !== false && isStale(query, options);
	  }

	  return false;
	}

	function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
	  return options.enabled !== false && (query !== prevQuery || prevOptions.enabled === false) && (!options.suspense || query.state.status !== 'error') && isStale(query, options);
	}

	function isStale(query, options) {
	  return query.isStaleByTime(options.staleTime);
	}

	class InfiniteQueryObserver extends QueryObserver {
	  // Type override
	  // Type override
	  // Type override
	  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
	  constructor(client, options) {
	    super(client, options);
	  }

	  bindMethods() {
	    super.bindMethods();
	    this.fetchNextPage = this.fetchNextPage.bind(this);
	    this.fetchPreviousPage = this.fetchPreviousPage.bind(this);
	  }

	  setOptions(options, notifyOptions) {
	    super.setOptions({ ...options,
	      behavior: infiniteQueryBehavior()
	    }, notifyOptions);
	  }

	  getOptimisticResult(options) {
	    options.behavior = infiniteQueryBehavior();
	    return super.getOptimisticResult(options);
	  }

	  fetchNextPage({
	    pageParam,
	    ...options
	  } = {}) {
	    return this.fetch({ ...options,
	      meta: {
	        fetchMore: {
	          direction: 'forward',
	          pageParam
	        }
	      }
	    });
	  }

	  fetchPreviousPage({
	    pageParam,
	    ...options
	  } = {}) {
	    return this.fetch({ ...options,
	      meta: {
	        fetchMore: {
	          direction: 'backward',
	          pageParam
	        }
	      }
	    });
	  }

	  createResult(query, options) {
	    var _state$fetchMeta, _state$fetchMeta$fetc, _state$fetchMeta2, _state$fetchMeta2$fet, _state$data, _state$data2;

	    const {
	      state
	    } = query;
	    const result = super.createResult(query, options);
	    const {
	      isFetching,
	      isRefetching
	    } = result;
	    const isFetchingNextPage = isFetching && ((_state$fetchMeta = state.fetchMeta) == null ? void 0 : (_state$fetchMeta$fetc = _state$fetchMeta.fetchMore) == null ? void 0 : _state$fetchMeta$fetc.direction) === 'forward';
	    const isFetchingPreviousPage = isFetching && ((_state$fetchMeta2 = state.fetchMeta) == null ? void 0 : (_state$fetchMeta2$fet = _state$fetchMeta2.fetchMore) == null ? void 0 : _state$fetchMeta2$fet.direction) === 'backward';
	    return { ...result,
	      fetchNextPage: this.fetchNextPage,
	      fetchPreviousPage: this.fetchPreviousPage,
	      hasNextPage: hasNextPage(options, (_state$data = state.data) == null ? void 0 : _state$data.pages),
	      hasPreviousPage: hasPreviousPage(options, (_state$data2 = state.data) == null ? void 0 : _state$data2.pages),
	      isFetchingNextPage,
	      isFetchingPreviousPage,
	      isRefetching: isRefetching && !isFetchingNextPage && !isFetchingPreviousPage
	    };
	  }

	}

	const defaultLogger = console;

	class Removable {
	  destroy() {
	    this.clearGcTimeout();
	  }

	  scheduleGc() {
	    this.clearGcTimeout();

	    if (isValidTimeout(this.cacheTime)) {
	      this.gcTimeout = setTimeout(() => {
	        this.optionalRemove();
	      }, this.cacheTime);
	    }
	  }

	  updateCacheTime(newCacheTime) {
	    // Default to 5 minutes (Infinity for server-side) if no cache time is set
	    this.cacheTime = Math.max(this.cacheTime || 0, newCacheTime != null ? newCacheTime : isServer ? Infinity : 5 * 60 * 1000);
	  }

	  clearGcTimeout() {
	    if (this.gcTimeout) {
	      clearTimeout(this.gcTimeout);
	      this.gcTimeout = undefined;
	    }
	  }

	}

	// CLASS
	class Mutation extends Removable {
	  constructor(config) {
	    super();
	    this.options = { ...config.defaultOptions,
	      ...config.options
	    };
	    this.mutationId = config.mutationId;
	    this.mutationCache = config.mutationCache;
	    this.logger = config.logger || defaultLogger;
	    this.observers = [];
	    this.state = config.state || getDefaultState$1();
	    this.updateCacheTime(this.options.cacheTime);
	    this.scheduleGc();
	  }

	  get meta() {
	    return this.options.meta;
	  }

	  setState(state) {
	    this.dispatch({
	      type: 'setState',
	      state
	    });
	  }

	  addObserver(observer) {
	    if (this.observers.indexOf(observer) === -1) {
	      this.observers.push(observer); // Stop the mutation from being garbage collected

	      this.clearGcTimeout();
	      this.mutationCache.notify({
	        type: 'observerAdded',
	        mutation: this,
	        observer
	      });
	    }
	  }

	  removeObserver(observer) {
	    this.observers = this.observers.filter(x => x !== observer);
	    this.scheduleGc();
	    this.mutationCache.notify({
	      type: 'observerRemoved',
	      mutation: this,
	      observer
	    });
	  }

	  optionalRemove() {
	    if (!this.observers.length) {
	      if (this.state.status === 'loading') {
	        this.scheduleGc();
	      } else {
	        this.mutationCache.remove(this);
	      }
	    }
	  }

	  continue() {
	    if (this.retryer) {
	      this.retryer.continue();
	      return this.retryer.promise;
	    }

	    return this.execute();
	  }

	  async execute() {
	    const executeMutation = () => {
	      var _this$options$retry;

	      this.retryer = createRetryer({
	        fn: () => {
	          if (!this.options.mutationFn) {
	            return Promise.reject('No mutationFn found');
	          }

	          return this.options.mutationFn(this.state.variables);
	        },
	        onFail: (failureCount, error) => {
	          this.dispatch({
	            type: 'failed',
	            failureCount,
	            error
	          });
	        },
	        onPause: () => {
	          this.dispatch({
	            type: 'pause'
	          });
	        },
	        onContinue: () => {
	          this.dispatch({
	            type: 'continue'
	          });
	        },
	        retry: (_this$options$retry = this.options.retry) != null ? _this$options$retry : 0,
	        retryDelay: this.options.retryDelay,
	        networkMode: this.options.networkMode
	      });
	      return this.retryer.promise;
	    };

	    const restored = this.state.status === 'loading';

	    try {
	      var _this$mutationCache$c3, _this$mutationCache$c4, _this$options$onSucce, _this$options2, _this$options$onSettl, _this$options3;

	      if (!restored) {
	        var _this$mutationCache$c, _this$mutationCache$c2, _this$options$onMutat, _this$options;

	        this.dispatch({
	          type: 'loading',
	          variables: this.options.variables
	        }); // Notify cache callback

	        await ((_this$mutationCache$c = (_this$mutationCache$c2 = this.mutationCache.config).onMutate) == null ? void 0 : _this$mutationCache$c.call(_this$mutationCache$c2, this.state.variables, this));
	        const context = await ((_this$options$onMutat = (_this$options = this.options).onMutate) == null ? void 0 : _this$options$onMutat.call(_this$options, this.state.variables));

	        if (context !== this.state.context) {
	          this.dispatch({
	            type: 'loading',
	            context,
	            variables: this.state.variables
	          });
	        }
	      }

	      const data = await executeMutation(); // Notify cache callback

	      await ((_this$mutationCache$c3 = (_this$mutationCache$c4 = this.mutationCache.config).onSuccess) == null ? void 0 : _this$mutationCache$c3.call(_this$mutationCache$c4, data, this.state.variables, this.state.context, this));
	      await ((_this$options$onSucce = (_this$options2 = this.options).onSuccess) == null ? void 0 : _this$options$onSucce.call(_this$options2, data, this.state.variables, this.state.context));
	      await ((_this$options$onSettl = (_this$options3 = this.options).onSettled) == null ? void 0 : _this$options$onSettl.call(_this$options3, data, null, this.state.variables, this.state.context));
	      this.dispatch({
	        type: 'success',
	        data
	      });
	      return data;
	    } catch (error) {
	      try {
	        var _this$mutationCache$c5, _this$mutationCache$c6, _this$options$onError, _this$options4, _this$options$onSettl2, _this$options5;

	        // Notify cache callback
	        await ((_this$mutationCache$c5 = (_this$mutationCache$c6 = this.mutationCache.config).onError) == null ? void 0 : _this$mutationCache$c5.call(_this$mutationCache$c6, error, this.state.variables, this.state.context, this));

	        if ('production' !== 'production') ;

	        await ((_this$options$onError = (_this$options4 = this.options).onError) == null ? void 0 : _this$options$onError.call(_this$options4, error, this.state.variables, this.state.context));
	        await ((_this$options$onSettl2 = (_this$options5 = this.options).onSettled) == null ? void 0 : _this$options$onSettl2.call(_this$options5, undefined, error, this.state.variables, this.state.context));
	        throw error;
	      } finally {
	        this.dispatch({
	          type: 'error',
	          error: error
	        });
	      }
	    }
	  }

	  dispatch(action) {
	    const reducer = state => {
	      switch (action.type) {
	        case 'failed':
	          return { ...state,
	            failureCount: action.failureCount,
	            failureReason: action.error
	          };

	        case 'pause':
	          return { ...state,
	            isPaused: true
	          };

	        case 'continue':
	          return { ...state,
	            isPaused: false
	          };

	        case 'loading':
	          return { ...state,
	            context: action.context,
	            data: undefined,
	            failureCount: 0,
	            failureReason: null,
	            error: null,
	            isPaused: !canFetch(this.options.networkMode),
	            status: 'loading',
	            variables: action.variables
	          };

	        case 'success':
	          return { ...state,
	            data: action.data,
	            failureCount: 0,
	            failureReason: null,
	            error: null,
	            status: 'success',
	            isPaused: false
	          };

	        case 'error':
	          return { ...state,
	            data: undefined,
	            error: action.error,
	            failureCount: state.failureCount + 1,
	            failureReason: action.error,
	            isPaused: false,
	            status: 'error'
	          };

	        case 'setState':
	          return { ...state,
	            ...action.state
	          };
	      }
	    };

	    this.state = reducer(this.state);
	    notifyManager.batch(() => {
	      this.observers.forEach(observer => {
	        observer.onMutationUpdate(action);
	      });
	      this.mutationCache.notify({
	        mutation: this,
	        type: 'updated',
	        action
	      });
	    });
	  }

	}
	function getDefaultState$1() {
	  return {
	    context: undefined,
	    data: undefined,
	    error: null,
	    failureCount: 0,
	    failureReason: null,
	    isPaused: false,
	    status: 'idle',
	    variables: undefined
	  };
	}

	// CLASS
	class MutationCache extends Subscribable {
	  constructor(config) {
	    super();
	    this.config = config || {};
	    this.mutations = [];
	    this.mutationId = 0;
	  }

	  build(client, options, state) {
	    const mutation = new Mutation({
	      mutationCache: this,
	      logger: client.getLogger(),
	      mutationId: ++this.mutationId,
	      options: client.defaultMutationOptions(options),
	      state,
	      defaultOptions: options.mutationKey ? client.getMutationDefaults(options.mutationKey) : undefined
	    });
	    this.add(mutation);
	    return mutation;
	  }

	  add(mutation) {
	    this.mutations.push(mutation);
	    this.notify({
	      type: 'added',
	      mutation
	    });
	  }

	  remove(mutation) {
	    this.mutations = this.mutations.filter(x => x !== mutation);
	    this.notify({
	      type: 'removed',
	      mutation
	    });
	  }

	  clear() {
	    notifyManager.batch(() => {
	      this.mutations.forEach(mutation => {
	        this.remove(mutation);
	      });
	    });
	  }

	  getAll() {
	    return this.mutations;
	  }

	  find(filters) {
	    if (typeof filters.exact === 'undefined') {
	      filters.exact = true;
	    }

	    return this.mutations.find(mutation => matchMutation(filters, mutation));
	  }

	  findAll(filters) {
	    return this.mutations.filter(mutation => matchMutation(filters, mutation));
	  }

	  notify(event) {
	    notifyManager.batch(() => {
	      this.listeners.forEach(listener => {
	        listener(event);
	      });
	    });
	  }

	  resumePausedMutations() {
	    const pausedMutations = this.mutations.filter(x => x.state.isPaused);
	    return notifyManager.batch(() => pausedMutations.reduce((promise, mutation) => promise.then(() => mutation.continue().catch(noop$5)), Promise.resolve()));
	  }

	}

	// CLASS
	let MutationObserver$1 = class MutationObserver extends Subscribable {
	  constructor(client, options) {
	    super();
	    this.client = client;
	    this.setOptions(options);
	    this.bindMethods();
	    this.updateResult();
	  }

	  bindMethods() {
	    this.mutate = this.mutate.bind(this);
	    this.reset = this.reset.bind(this);
	  }

	  setOptions(options) {
	    const prevOptions = this.options;
	    this.options = this.client.defaultMutationOptions(options);

	    if (!shallowEqualObjects(prevOptions, this.options)) {
	      this.client.getMutationCache().notify({
	        type: 'observerOptionsUpdated',
	        mutation: this.currentMutation,
	        observer: this
	      });
	    }
	  }

	  onUnsubscribe() {
	    if (!this.listeners.length) {
	      var _this$currentMutation;

	      (_this$currentMutation = this.currentMutation) == null ? void 0 : _this$currentMutation.removeObserver(this);
	    }
	  }

	  onMutationUpdate(action) {
	    this.updateResult(); // Determine which callbacks to trigger

	    const notifyOptions = {
	      listeners: true
	    };

	    if (action.type === 'success') {
	      notifyOptions.onSuccess = true;
	    } else if (action.type === 'error') {
	      notifyOptions.onError = true;
	    }

	    this.notify(notifyOptions);
	  }

	  getCurrentResult() {
	    return this.currentResult;
	  }

	  reset() {
	    this.currentMutation = undefined;
	    this.updateResult();
	    this.notify({
	      listeners: true
	    });
	  }

	  mutate(variables, options) {
	    this.mutateOptions = options;

	    if (this.currentMutation) {
	      this.currentMutation.removeObserver(this);
	    }

	    this.currentMutation = this.client.getMutationCache().build(this.client, { ...this.options,
	      variables: typeof variables !== 'undefined' ? variables : this.options.variables
	    });
	    this.currentMutation.addObserver(this);
	    return this.currentMutation.execute();
	  }

	  updateResult() {
	    const state = this.currentMutation ? this.currentMutation.state : getDefaultState$1();
	    const result = { ...state,
	      isLoading: state.status === 'loading',
	      isSuccess: state.status === 'success',
	      isError: state.status === 'error',
	      isIdle: state.status === 'idle',
	      mutate: this.mutate,
	      reset: this.reset
	    };
	    this.currentResult = result;
	  }

	  notify(options) {
	    notifyManager.batch(() => {
	      // First trigger the mutate callbacks
	      if (this.mutateOptions) {
	        if (options.onSuccess) {
	          var _this$mutateOptions$o, _this$mutateOptions, _this$mutateOptions$o2, _this$mutateOptions2;

	          (_this$mutateOptions$o = (_this$mutateOptions = this.mutateOptions).onSuccess) == null ? void 0 : _this$mutateOptions$o.call(_this$mutateOptions, this.currentResult.data, this.currentResult.variables, this.currentResult.context);
	          (_this$mutateOptions$o2 = (_this$mutateOptions2 = this.mutateOptions).onSettled) == null ? void 0 : _this$mutateOptions$o2.call(_this$mutateOptions2, this.currentResult.data, null, this.currentResult.variables, this.currentResult.context);
	        } else if (options.onError) {
	          var _this$mutateOptions$o3, _this$mutateOptions3, _this$mutateOptions$o4, _this$mutateOptions4;

	          (_this$mutateOptions$o3 = (_this$mutateOptions3 = this.mutateOptions).onError) == null ? void 0 : _this$mutateOptions$o3.call(_this$mutateOptions3, this.currentResult.error, this.currentResult.variables, this.currentResult.context);
	          (_this$mutateOptions$o4 = (_this$mutateOptions4 = this.mutateOptions).onSettled) == null ? void 0 : _this$mutateOptions$o4.call(_this$mutateOptions4, undefined, this.currentResult.error, this.currentResult.variables, this.currentResult.context);
	        }
	      } // Then trigger the listeners


	      if (options.listeners) {
	        this.listeners.forEach(listener => {
	          listener(this.currentResult);
	        });
	      }
	    });
	  }

	};

	class QueriesObserver extends Subscribable {
	  constructor(client, queries) {
	    super();
	    this.client = client;
	    this.queries = [];
	    this.result = [];
	    this.observers = [];
	    this.observersMap = {};

	    if (queries) {
	      this.setQueries(queries);
	    }
	  }

	  onSubscribe() {
	    if (this.listeners.length === 1) {
	      this.observers.forEach(observer => {
	        observer.subscribe(result => {
	          this.onUpdate(observer, result);
	        });
	      });
	    }
	  }

	  onUnsubscribe() {
	    if (!this.listeners.length) {
	      this.destroy();
	    }
	  }

	  destroy() {
	    this.listeners = [];
	    this.observers.forEach(observer => {
	      observer.destroy();
	    });
	  }

	  setQueries(queries, notifyOptions) {
	    this.queries = queries;
	    notifyManager.batch(() => {
	      const prevObservers = this.observers;
	      const newObserverMatches = this.findMatchingObservers(this.queries); // set options for the new observers to notify of changes

	      newObserverMatches.forEach(match => match.observer.setOptions(match.defaultedQueryOptions, notifyOptions));
	      const newObservers = newObserverMatches.map(match => match.observer);
	      const newObserversMap = Object.fromEntries(newObservers.map(observer => [observer.options.queryHash, observer]));
	      const newResult = newObservers.map(observer => observer.getCurrentResult());
	      const hasIndexChange = newObservers.some((observer, index) => observer !== prevObservers[index]);

	      if (prevObservers.length === newObservers.length && !hasIndexChange) {
	        return;
	      }

	      this.observers = newObservers;
	      this.observersMap = newObserversMap;
	      this.result = newResult;

	      if (!this.hasListeners()) {
	        return;
	      }

	      difference(prevObservers, newObservers).forEach(observer => {
	        observer.destroy();
	      });
	      difference(newObservers, prevObservers).forEach(observer => {
	        observer.subscribe(result => {
	          this.onUpdate(observer, result);
	        });
	      });
	      this.notify();
	    });
	  }

	  getCurrentResult() {
	    return this.result;
	  }

	  getQueries() {
	    return this.observers.map(observer => observer.getCurrentQuery());
	  }

	  getObservers() {
	    return this.observers;
	  }

	  getOptimisticResult(queries) {
	    return this.findMatchingObservers(queries).map(match => match.observer.getOptimisticResult(match.defaultedQueryOptions));
	  }

	  findMatchingObservers(queries) {
	    const prevObservers = this.observers;
	    const defaultedQueryOptions = queries.map(options => this.client.defaultQueryOptions(options));
	    const matchingObservers = defaultedQueryOptions.flatMap(defaultedOptions => {
	      const match = prevObservers.find(observer => observer.options.queryHash === defaultedOptions.queryHash);

	      if (match != null) {
	        return [{
	          defaultedQueryOptions: defaultedOptions,
	          observer: match
	        }];
	      }

	      return [];
	    });
	    const matchedQueryHashes = matchingObservers.map(match => match.defaultedQueryOptions.queryHash);
	    const unmatchedQueries = defaultedQueryOptions.filter(defaultedOptions => !matchedQueryHashes.includes(defaultedOptions.queryHash));
	    const unmatchedObservers = prevObservers.filter(prevObserver => !matchingObservers.some(match => match.observer === prevObserver));

	    const getObserver = options => {
	      const defaultedOptions = this.client.defaultQueryOptions(options);
	      const currentObserver = this.observersMap[defaultedOptions.queryHash];
	      return currentObserver != null ? currentObserver : new QueryObserver(this.client, defaultedOptions);
	    };

	    const newOrReusedObservers = unmatchedQueries.map((options, index) => {
	      if (options.keepPreviousData) {
	        // return previous data from one of the observers that no longer match
	        const previouslyUsedObserver = unmatchedObservers[index];

	        if (previouslyUsedObserver !== undefined) {
	          return {
	            defaultedQueryOptions: options,
	            observer: previouslyUsedObserver
	          };
	        }
	      }

	      return {
	        defaultedQueryOptions: options,
	        observer: getObserver(options)
	      };
	    });

	    const sortMatchesByOrderOfQueries = (a, b) => defaultedQueryOptions.indexOf(a.defaultedQueryOptions) - defaultedQueryOptions.indexOf(b.defaultedQueryOptions);

	    return matchingObservers.concat(newOrReusedObservers).sort(sortMatchesByOrderOfQueries);
	  }

	  onUpdate(observer, result) {
	    const index = this.observers.indexOf(observer);

	    if (index !== -1) {
	      this.result = replaceAt(this.result, index, result);
	      this.notify();
	    }
	  }

	  notify() {
	    notifyManager.batch(() => {
	      this.listeners.forEach(listener => {
	        listener(this.result);
	      });
	    });
	  }

	}

	// CLASS
	class Query extends Removable {
	  constructor(config) {
	    super();
	    this.abortSignalConsumed = false;
	    this.defaultOptions = config.defaultOptions;
	    this.setOptions(config.options);
	    this.observers = [];
	    this.cache = config.cache;
	    this.logger = config.logger || defaultLogger;
	    this.queryKey = config.queryKey;
	    this.queryHash = config.queryHash;
	    this.initialState = config.state || getDefaultState(this.options);
	    this.state = this.initialState;
	  }

	  get meta() {
	    return this.options.meta;
	  }

	  setOptions(options) {
	    this.options = { ...this.defaultOptions,
	      ...options
	    };
	    this.updateCacheTime(this.options.cacheTime);
	  }

	  optionalRemove() {
	    if (!this.observers.length && this.state.fetchStatus === 'idle') {
	      this.cache.remove(this);
	    }
	  }

	  setData(newData, options) {
	    const data = replaceData(this.state.data, newData, this.options); // Set data and mark it as cached

	    this.dispatch({
	      data,
	      type: 'success',
	      dataUpdatedAt: options == null ? void 0 : options.updatedAt,
	      manual: options == null ? void 0 : options.manual
	    });
	    return data;
	  }

	  setState(state, setStateOptions) {
	    this.dispatch({
	      type: 'setState',
	      state,
	      setStateOptions
	    });
	  }

	  cancel(options) {
	    var _this$retryer;

	    const promise = this.promise;
	    (_this$retryer = this.retryer) == null ? void 0 : _this$retryer.cancel(options);
	    return promise ? promise.then(noop$5).catch(noop$5) : Promise.resolve();
	  }

	  destroy() {
	    super.destroy();
	    this.cancel({
	      silent: true
	    });
	  }

	  reset() {
	    this.destroy();
	    this.setState(this.initialState);
	  }

	  isActive() {
	    return this.observers.some(observer => observer.options.enabled !== false);
	  }

	  isDisabled() {
	    return this.getObserversCount() > 0 && !this.isActive();
	  }

	  isStale() {
	    return this.state.isInvalidated || !this.state.dataUpdatedAt || this.observers.some(observer => observer.getCurrentResult().isStale);
	  }

	  isStaleByTime(staleTime = 0) {
	    return this.state.isInvalidated || !this.state.dataUpdatedAt || !timeUntilStale(this.state.dataUpdatedAt, staleTime);
	  }

	  onFocus() {
	    var _this$retryer2;

	    const observer = this.observers.find(x => x.shouldFetchOnWindowFocus());

	    if (observer) {
	      observer.refetch({
	        cancelRefetch: false
	      });
	    } // Continue fetch if currently paused


	    (_this$retryer2 = this.retryer) == null ? void 0 : _this$retryer2.continue();
	  }

	  onOnline() {
	    var _this$retryer3;

	    const observer = this.observers.find(x => x.shouldFetchOnReconnect());

	    if (observer) {
	      observer.refetch({
	        cancelRefetch: false
	      });
	    } // Continue fetch if currently paused


	    (_this$retryer3 = this.retryer) == null ? void 0 : _this$retryer3.continue();
	  }

	  addObserver(observer) {
	    if (this.observers.indexOf(observer) === -1) {
	      this.observers.push(observer); // Stop the query from being garbage collected

	      this.clearGcTimeout();
	      this.cache.notify({
	        type: 'observerAdded',
	        query: this,
	        observer
	      });
	    }
	  }

	  removeObserver(observer) {
	    if (this.observers.indexOf(observer) !== -1) {
	      this.observers = this.observers.filter(x => x !== observer);

	      if (!this.observers.length) {
	        // If the transport layer does not support cancellation
	        // we'll let the query continue so the result can be cached
	        if (this.retryer) {
	          if (this.abortSignalConsumed) {
	            this.retryer.cancel({
	              revert: true
	            });
	          } else {
	            this.retryer.cancelRetry();
	          }
	        }

	        this.scheduleGc();
	      }

	      this.cache.notify({
	        type: 'observerRemoved',
	        query: this,
	        observer
	      });
	    }
	  }

	  getObserversCount() {
	    return this.observers.length;
	  }

	  invalidate() {
	    if (!this.state.isInvalidated) {
	      this.dispatch({
	        type: 'invalidate'
	      });
	    }
	  }

	  fetch(options, fetchOptions) {
	    var _this$options$behavio, _context$fetchOptions;

	    if (this.state.fetchStatus !== 'idle') {
	      if (this.state.dataUpdatedAt && fetchOptions != null && fetchOptions.cancelRefetch) {
	        // Silently cancel current fetch if the user wants to cancel refetches
	        this.cancel({
	          silent: true
	        });
	      } else if (this.promise) {
	        var _this$retryer4;

	        // make sure that retries that were potentially cancelled due to unmounts can continue
	        (_this$retryer4 = this.retryer) == null ? void 0 : _this$retryer4.continueRetry(); // Return current promise if we are already fetching

	        return this.promise;
	      }
	    } // Update config if passed, otherwise the config from the last execution is used


	    if (options) {
	      this.setOptions(options);
	    } // Use the options from the first observer with a query function if no function is found.
	    // This can happen when the query is hydrated or created with setQueryData.


	    if (!this.options.queryFn) {
	      const observer = this.observers.find(x => x.options.queryFn);

	      if (observer) {
	        this.setOptions(observer.options);
	      }
	    }

	    if (!Array.isArray(this.options.queryKey)) ;

	    const abortController = getAbortController$1(); // Create query function context

	    const queryFnContext = {
	      queryKey: this.queryKey,
	      pageParam: undefined,
	      meta: this.meta
	    }; // Adds an enumerable signal property to the object that
	    // which sets abortSignalConsumed to true when the signal
	    // is read.

	    const addSignalProperty = object => {
	      Object.defineProperty(object, 'signal', {
	        enumerable: true,
	        get: () => {
	          if (abortController) {
	            this.abortSignalConsumed = true;
	            return abortController.signal;
	          }

	          return undefined;
	        }
	      });
	    };

	    addSignalProperty(queryFnContext); // Create fetch function

	    const fetchFn = () => {
	      if (!this.options.queryFn) {
	        return Promise.reject('Missing queryFn');
	      }

	      this.abortSignalConsumed = false;
	      return this.options.queryFn(queryFnContext);
	    }; // Trigger behavior hook


	    const context = {
	      fetchOptions,
	      options: this.options,
	      queryKey: this.queryKey,
	      state: this.state,
	      fetchFn
	    };
	    addSignalProperty(context);
	    (_this$options$behavio = this.options.behavior) == null ? void 0 : _this$options$behavio.onFetch(context); // Store state in case the current fetch needs to be reverted

	    this.revertState = this.state; // Set to fetching state if not already in it

	    if (this.state.fetchStatus === 'idle' || this.state.fetchMeta !== ((_context$fetchOptions = context.fetchOptions) == null ? void 0 : _context$fetchOptions.meta)) {
	      var _context$fetchOptions2;

	      this.dispatch({
	        type: 'fetch',
	        meta: (_context$fetchOptions2 = context.fetchOptions) == null ? void 0 : _context$fetchOptions2.meta
	      });
	    }

	    const onError = error => {
	      // Optimistically update state if needed
	      if (!(isCancelledError(error) && error.silent)) {
	        this.dispatch({
	          type: 'error',
	          error: error
	        });
	      }

	      if (!isCancelledError(error)) {
	        var _this$cache$config$on, _this$cache$config;

	        // Notify cache callback
	        (_this$cache$config$on = (_this$cache$config = this.cache.config).onError) == null ? void 0 : _this$cache$config$on.call(_this$cache$config, error, this);
	      }

	      if (!this.isFetchingOptimistic) {
	        // Schedule query gc after fetching
	        this.scheduleGc();
	      }

	      this.isFetchingOptimistic = false;
	    }; // Try to fetch the data


	    this.retryer = createRetryer({
	      fn: context.fetchFn,
	      abort: abortController == null ? void 0 : abortController.abort.bind(abortController),
	      onSuccess: data => {
	        var _this$cache$config$on2, _this$cache$config2;

	        if (typeof data === 'undefined') {

	          onError(new Error('undefined'));
	          return;
	        }

	        this.setData(data); // Notify cache callback

	        (_this$cache$config$on2 = (_this$cache$config2 = this.cache.config).onSuccess) == null ? void 0 : _this$cache$config$on2.call(_this$cache$config2, data, this);

	        if (!this.isFetchingOptimistic) {
	          // Schedule query gc after fetching
	          this.scheduleGc();
	        }

	        this.isFetchingOptimistic = false;
	      },
	      onError,
	      onFail: (failureCount, error) => {
	        this.dispatch({
	          type: 'failed',
	          failureCount,
	          error
	        });
	      },
	      onPause: () => {
	        this.dispatch({
	          type: 'pause'
	        });
	      },
	      onContinue: () => {
	        this.dispatch({
	          type: 'continue'
	        });
	      },
	      retry: context.options.retry,
	      retryDelay: context.options.retryDelay,
	      networkMode: context.options.networkMode
	    });
	    this.promise = this.retryer.promise;
	    return this.promise;
	  }

	  dispatch(action) {
	    const reducer = state => {
	      var _action$meta, _action$dataUpdatedAt;

	      switch (action.type) {
	        case 'failed':
	          return { ...state,
	            fetchFailureCount: action.failureCount,
	            fetchFailureReason: action.error
	          };

	        case 'pause':
	          return { ...state,
	            fetchStatus: 'paused'
	          };

	        case 'continue':
	          return { ...state,
	            fetchStatus: 'fetching'
	          };

	        case 'fetch':
	          return { ...state,
	            fetchFailureCount: 0,
	            fetchFailureReason: null,
	            fetchMeta: (_action$meta = action.meta) != null ? _action$meta : null,
	            fetchStatus: canFetch(this.options.networkMode) ? 'fetching' : 'paused',
	            ...(!state.dataUpdatedAt && {
	              error: null,
	              status: 'loading'
	            })
	          };

	        case 'success':
	          return { ...state,
	            data: action.data,
	            dataUpdateCount: state.dataUpdateCount + 1,
	            dataUpdatedAt: (_action$dataUpdatedAt = action.dataUpdatedAt) != null ? _action$dataUpdatedAt : Date.now(),
	            error: null,
	            isInvalidated: false,
	            status: 'success',
	            ...(!action.manual && {
	              fetchStatus: 'idle',
	              fetchFailureCount: 0,
	              fetchFailureReason: null
	            })
	          };

	        case 'error':
	          const error = action.error;

	          if (isCancelledError(error) && error.revert && this.revertState) {
	            return { ...this.revertState
	            };
	          }

	          return { ...state,
	            error: error,
	            errorUpdateCount: state.errorUpdateCount + 1,
	            errorUpdatedAt: Date.now(),
	            fetchFailureCount: state.fetchFailureCount + 1,
	            fetchFailureReason: error,
	            fetchStatus: 'idle',
	            status: 'error'
	          };

	        case 'invalidate':
	          return { ...state,
	            isInvalidated: true
	          };

	        case 'setState':
	          return { ...state,
	            ...action.state
	          };
	      }
	    };

	    this.state = reducer(this.state);
	    notifyManager.batch(() => {
	      this.observers.forEach(observer => {
	        observer.onQueryUpdate(action);
	      });
	      this.cache.notify({
	        query: this,
	        type: 'updated',
	        action
	      });
	    });
	  }

	}

	function getDefaultState(options) {
	  const data = typeof options.initialData === 'function' ? options.initialData() : options.initialData;
	  const hasData = typeof data !== 'undefined';
	  const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === 'function' ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;
	  return {
	    data,
	    dataUpdateCount: 0,
	    dataUpdatedAt: hasData ? initialDataUpdatedAt != null ? initialDataUpdatedAt : Date.now() : 0,
	    error: null,
	    errorUpdateCount: 0,
	    errorUpdatedAt: 0,
	    fetchFailureCount: 0,
	    fetchFailureReason: null,
	    fetchMeta: null,
	    isInvalidated: false,
	    status: hasData ? 'success' : 'loading',
	    fetchStatus: 'idle'
	  };
	}

	// CLASS
	class QueryCache extends Subscribable {
	  constructor(config) {
	    super();
	    this.config = config || {};
	    this.queries = [];
	    this.queriesMap = {};
	  }

	  build(client, options, state) {
	    var _options$queryHash;

	    const queryKey = options.queryKey;
	    const queryHash = (_options$queryHash = options.queryHash) != null ? _options$queryHash : hashQueryKeyByOptions(queryKey, options);
	    let query = this.get(queryHash);

	    if (!query) {
	      query = new Query({
	        cache: this,
	        logger: client.getLogger(),
	        queryKey,
	        queryHash,
	        options: client.defaultQueryOptions(options),
	        state,
	        defaultOptions: client.getQueryDefaults(queryKey)
	      });
	      this.add(query);
	    }

	    return query;
	  }

	  add(query) {
	    if (!this.queriesMap[query.queryHash]) {
	      this.queriesMap[query.queryHash] = query;
	      this.queries.push(query);
	      this.notify({
	        type: 'added',
	        query
	      });
	    }
	  }

	  remove(query) {
	    const queryInMap = this.queriesMap[query.queryHash];

	    if (queryInMap) {
	      query.destroy();
	      this.queries = this.queries.filter(x => x !== query);

	      if (queryInMap === query) {
	        delete this.queriesMap[query.queryHash];
	      }

	      this.notify({
	        type: 'removed',
	        query
	      });
	    }
	  }

	  clear() {
	    notifyManager.batch(() => {
	      this.queries.forEach(query => {
	        this.remove(query);
	      });
	    });
	  }

	  get(queryHash) {
	    return this.queriesMap[queryHash];
	  }

	  getAll() {
	    return this.queries;
	  }

	  find(arg1, arg2) {
	    const [filters] = parseFilterArgs(arg1, arg2);

	    if (typeof filters.exact === 'undefined') {
	      filters.exact = true;
	    }

	    return this.queries.find(query => matchQuery(filters, query));
	  }

	  findAll(arg1, arg2) {
	    const [filters] = parseFilterArgs(arg1, arg2);
	    return Object.keys(filters).length > 0 ? this.queries.filter(query => matchQuery(filters, query)) : this.queries;
	  }

	  notify(event) {
	    notifyManager.batch(() => {
	      this.listeners.forEach(listener => {
	        listener(event);
	      });
	    });
	  }

	  onFocus() {
	    notifyManager.batch(() => {
	      this.queries.forEach(query => {
	        query.onFocus();
	      });
	    });
	  }

	  onOnline() {
	    notifyManager.batch(() => {
	      this.queries.forEach(query => {
	        query.onOnline();
	      });
	    });
	  }

	}

	// CLASS
	class QueryClient {
	  constructor(config = {}) {
	    this.queryCache = config.queryCache || new QueryCache();
	    this.mutationCache = config.mutationCache || new MutationCache();
	    this.logger = config.logger || defaultLogger;
	    this.defaultOptions = config.defaultOptions || {};
	    this.queryDefaults = [];
	    this.mutationDefaults = [];
	  }

	  mount() {
	    this.unsubscribeFocus = focusManager.subscribe(() => {
	      if (focusManager.isFocused()) {
	        this.resumePausedMutations();
	        this.queryCache.onFocus();
	      }
	    });
	    this.unsubscribeOnline = onlineManager.subscribe(() => {
	      if (onlineManager.isOnline()) {
	        this.resumePausedMutations();
	        this.queryCache.onOnline();
	      }
	    });
	  }

	  unmount() {
	    var _this$unsubscribeFocu, _this$unsubscribeOnli;

	    (_this$unsubscribeFocu = this.unsubscribeFocus) == null ? void 0 : _this$unsubscribeFocu.call(this);
	    (_this$unsubscribeOnli = this.unsubscribeOnline) == null ? void 0 : _this$unsubscribeOnli.call(this);
	  }

	  isFetching(arg1, arg2) {
	    const [filters] = parseFilterArgs(arg1, arg2);
	    filters.fetchStatus = 'fetching';
	    return this.queryCache.findAll(filters).length;
	  }

	  isMutating(filters) {
	    return this.mutationCache.findAll({ ...filters,
	      fetching: true
	    }).length;
	  }

	  getQueryData(queryKey, filters) {
	    var _this$queryCache$find;

	    return (_this$queryCache$find = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find.state.data;
	  }

	  ensureQueryData(arg1, arg2, arg3) {
	    const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
	    const cachedData = this.getQueryData(parsedOptions.queryKey);
	    return cachedData ? Promise.resolve(cachedData) : this.fetchQuery(parsedOptions);
	  }

	  getQueriesData(queryKeyOrFilters) {
	    return this.getQueryCache().findAll(queryKeyOrFilters).map(({
	      queryKey,
	      state
	    }) => {
	      const data = state.data;
	      return [queryKey, data];
	    });
	  }

	  setQueryData(queryKey, updater, options) {
	    const query = this.queryCache.find(queryKey);
	    const prevData = query == null ? void 0 : query.state.data;
	    const data = functionalUpdate(updater, prevData);

	    if (typeof data === 'undefined') {
	      return undefined;
	    }

	    const parsedOptions = parseQueryArgs(queryKey);
	    const defaultedOptions = this.defaultQueryOptions(parsedOptions);
	    return this.queryCache.build(this, defaultedOptions).setData(data, { ...options,
	      manual: true
	    });
	  }

	  setQueriesData(queryKeyOrFilters, updater, options) {
	    return notifyManager.batch(() => this.getQueryCache().findAll(queryKeyOrFilters).map(({
	      queryKey
	    }) => [queryKey, this.setQueryData(queryKey, updater, options)]));
	  }

	  getQueryState(queryKey, filters) {
	    var _this$queryCache$find2;

	    return (_this$queryCache$find2 = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find2.state;
	  }

	  removeQueries(arg1, arg2) {
	    const [filters] = parseFilterArgs(arg1, arg2);
	    const queryCache = this.queryCache;
	    notifyManager.batch(() => {
	      queryCache.findAll(filters).forEach(query => {
	        queryCache.remove(query);
	      });
	    });
	  }

	  resetQueries(arg1, arg2, arg3) {
	    const [filters, options] = parseFilterArgs(arg1, arg2, arg3);
	    const queryCache = this.queryCache;
	    const refetchFilters = {
	      type: 'active',
	      ...filters
	    };
	    return notifyManager.batch(() => {
	      queryCache.findAll(filters).forEach(query => {
	        query.reset();
	      });
	      return this.refetchQueries(refetchFilters, options);
	    });
	  }

	  cancelQueries(arg1, arg2, arg3) {
	    const [filters, cancelOptions = {}] = parseFilterArgs(arg1, arg2, arg3);

	    if (typeof cancelOptions.revert === 'undefined') {
	      cancelOptions.revert = true;
	    }

	    const promises = notifyManager.batch(() => this.queryCache.findAll(filters).map(query => query.cancel(cancelOptions)));
	    return Promise.all(promises).then(noop$5).catch(noop$5);
	  }

	  invalidateQueries(arg1, arg2, arg3) {
	    const [filters, options] = parseFilterArgs(arg1, arg2, arg3);
	    return notifyManager.batch(() => {
	      var _ref, _filters$refetchType;

	      this.queryCache.findAll(filters).forEach(query => {
	        query.invalidate();
	      });

	      if (filters.refetchType === 'none') {
	        return Promise.resolve();
	      }

	      const refetchFilters = { ...filters,
	        type: (_ref = (_filters$refetchType = filters.refetchType) != null ? _filters$refetchType : filters.type) != null ? _ref : 'active'
	      };
	      return this.refetchQueries(refetchFilters, options);
	    });
	  }

	  refetchQueries(arg1, arg2, arg3) {
	    const [filters, options] = parseFilterArgs(arg1, arg2, arg3);
	    const promises = notifyManager.batch(() => this.queryCache.findAll(filters).filter(query => !query.isDisabled()).map(query => {
	      var _options$cancelRefetc;

	      return query.fetch(undefined, { ...options,
	        cancelRefetch: (_options$cancelRefetc = options == null ? void 0 : options.cancelRefetch) != null ? _options$cancelRefetc : true,
	        meta: {
	          refetchPage: filters.refetchPage
	        }
	      });
	    }));
	    let promise = Promise.all(promises).then(noop$5);

	    if (!(options != null && options.throwOnError)) {
	      promise = promise.catch(noop$5);
	    }

	    return promise;
	  }

	  fetchQuery(arg1, arg2, arg3) {
	    const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
	    const defaultedOptions = this.defaultQueryOptions(parsedOptions); // https://github.com/tannerlinsley/react-query/issues/652

	    if (typeof defaultedOptions.retry === 'undefined') {
	      defaultedOptions.retry = false;
	    }

	    const query = this.queryCache.build(this, defaultedOptions);
	    return query.isStaleByTime(defaultedOptions.staleTime) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
	  }

	  prefetchQuery(arg1, arg2, arg3) {
	    return this.fetchQuery(arg1, arg2, arg3).then(noop$5).catch(noop$5);
	  }

	  fetchInfiniteQuery(arg1, arg2, arg3) {
	    const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
	    parsedOptions.behavior = infiniteQueryBehavior();
	    return this.fetchQuery(parsedOptions);
	  }

	  prefetchInfiniteQuery(arg1, arg2, arg3) {
	    return this.fetchInfiniteQuery(arg1, arg2, arg3).then(noop$5).catch(noop$5);
	  }

	  resumePausedMutations() {
	    return this.mutationCache.resumePausedMutations();
	  }

	  getQueryCache() {
	    return this.queryCache;
	  }

	  getMutationCache() {
	    return this.mutationCache;
	  }

	  getLogger() {
	    return this.logger;
	  }

	  getDefaultOptions() {
	    return this.defaultOptions;
	  }

	  setDefaultOptions(options) {
	    this.defaultOptions = options;
	  }

	  setQueryDefaults(queryKey, options) {
	    const result = this.queryDefaults.find(x => hashQueryKey$1(queryKey) === hashQueryKey$1(x.queryKey));

	    if (result) {
	      result.defaultOptions = options;
	    } else {
	      this.queryDefaults.push({
	        queryKey,
	        defaultOptions: options
	      });
	    }
	  }

	  getQueryDefaults(queryKey) {
	    if (!queryKey) {
	      return undefined;
	    } // Get the first matching defaults


	    const firstMatchingDefaults = this.queryDefaults.find(x => partialMatchKey(queryKey, x.queryKey)); // Additional checks and error in dev mode

	    return firstMatchingDefaults == null ? void 0 : firstMatchingDefaults.defaultOptions;
	  }

	  setMutationDefaults(mutationKey, options) {
	    const result = this.mutationDefaults.find(x => hashQueryKey$1(mutationKey) === hashQueryKey$1(x.mutationKey));

	    if (result) {
	      result.defaultOptions = options;
	    } else {
	      this.mutationDefaults.push({
	        mutationKey,
	        defaultOptions: options
	      });
	    }
	  }

	  getMutationDefaults(mutationKey) {
	    if (!mutationKey) {
	      return undefined;
	    } // Get the first matching defaults


	    const firstMatchingDefaults = this.mutationDefaults.find(x => partialMatchKey(mutationKey, x.mutationKey)); // Additional checks and error in dev mode

	    return firstMatchingDefaults == null ? void 0 : firstMatchingDefaults.defaultOptions;
	  }

	  defaultQueryOptions(options) {
	    if (options != null && options._defaulted) {
	      return options;
	    }

	    const defaultedOptions = { ...this.defaultOptions.queries,
	      ...this.getQueryDefaults(options == null ? void 0 : options.queryKey),
	      ...options,
	      _defaulted: true
	    };

	    if (!defaultedOptions.queryHash && defaultedOptions.queryKey) {
	      defaultedOptions.queryHash = hashQueryKeyByOptions(defaultedOptions.queryKey, defaultedOptions);
	    } // dependent default values


	    if (typeof defaultedOptions.refetchOnReconnect === 'undefined') {
	      defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== 'always';
	    }

	    if (typeof defaultedOptions.useErrorBoundary === 'undefined') {
	      defaultedOptions.useErrorBoundary = !!defaultedOptions.suspense;
	    }

	    return defaultedOptions;
	  }

	  defaultMutationOptions(options) {
	    if (options != null && options._defaulted) {
	      return options;
	    }

	    return { ...this.defaultOptions.mutations,
	      ...this.getMutationDefaults(options == null ? void 0 : options.mutationKey),
	      ...options,
	      _defaulted: true
	    };
	  }

	  clear() {
	    this.queryCache.clear();
	    this.mutationCache.clear();
	  }

	}

	function shouldThrowError(_useErrorBoundary, params) {
	  // Allow useErrorBoundary function to override throwing behavior on a per-error basis
	  if (typeof _useErrorBoundary === 'function') {
	    return _useErrorBoundary(...params);
	  }

	  return !!_useErrorBoundary;
	}

	const ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
	  if (options.suspense || options.useErrorBoundary) {
	    // Prevent retrying failed query if the error boundary has not been reset yet
	    if (!errorResetBoundary.isReset()) {
	      options.retryOnMount = false;
	    }
	  }
	};
	const useClearResetErrorBoundary = errorResetBoundary => {
	  reactExports.useEffect(() => {
	    errorResetBoundary.clearReset();
	  }, [errorResetBoundary]);
	};
	const getHasError = ({
	  result,
	  errorResetBoundary,
	  useErrorBoundary,
	  query
	}) => {
	  return result.isError && !errorResetBoundary.isReset() && !result.isFetching && shouldThrowError(useErrorBoundary, [result.error, query]);
	};

	const defaultContext = /*#__PURE__*/reactExports.createContext(undefined);
	const QueryClientSharingContext = /*#__PURE__*/reactExports.createContext(false); // If we are given a context, we will use it.
	// Otherwise, if contextSharing is on, we share the first and at least one
	// instance of the context across the window
	// to ensure that if React Query is used across
	// different bundles or microfrontends they will
	// all use the same **instance** of context, regardless
	// of module scoping.

	function getQueryClientContext(context, contextSharing) {
	  if (context) {
	    return context;
	  }

	  if (contextSharing && typeof window !== 'undefined') {
	    if (!window.ReactQueryClientContext) {
	      window.ReactQueryClientContext = defaultContext;
	    }

	    return window.ReactQueryClientContext;
	  }

	  return defaultContext;
	}

	const useQueryClient = ({
	  context
	} = {}) => {
	  const queryClient = reactExports.useContext(getQueryClientContext(context, reactExports.useContext(QueryClientSharingContext)));

	  if (!queryClient) {
	    throw new Error('No QueryClient set, use QueryClientProvider to set one');
	  }

	  return queryClient;
	};
	const QueryClientProvider = ({
	  client,
	  children,
	  context,
	  contextSharing = false
	}) => {
	  reactExports.useEffect(() => {
	    client.mount();
	    return () => {
	      client.unmount();
	    };
	  }, [client]);

	  const Context = getQueryClientContext(context, contextSharing);
	  return /*#__PURE__*/reactExports.createElement(QueryClientSharingContext.Provider, {
	    value: !context && contextSharing
	  }, /*#__PURE__*/reactExports.createElement(Context.Provider, {
	    value: client
	  }, children));
	};

	function useHydrate(state, options = {}) {
	  const queryClient = useQueryClient({
	    context: options.context
	  });
	  const optionsRef = reactExports.useRef(options);
	  optionsRef.current = options; // Running hydrate again with the same queries is safe,
	  // it wont overwrite or initialize existing queries,
	  // relying on useMemo here is only a performance optimization.
	  // hydrate can and should be run *during* render here for SSR to work properly

	  reactExports.useMemo(() => {
	    if (state) {
	      hydrate(queryClient, state, optionsRef.current);
	    }
	  }, [queryClient, state]);
	}
	const Hydrate = ({
	  children,
	  options,
	  state
	}) => {
	  useHydrate(state, options);
	  return children;
	};

	const IsRestoringContext = /*#__PURE__*/reactExports.createContext(false);
	const useIsRestoring = () => reactExports.useContext(IsRestoringContext);
	IsRestoringContext.Provider;

	function createValue() {
	  let isReset = false;
	  return {
	    clearReset: () => {
	      isReset = false;
	    },
	    reset: () => {
	      isReset = true;
	    },
	    isReset: () => {
	      return isReset;
	    }
	  };
	}

	const QueryErrorResetBoundaryContext = /*#__PURE__*/reactExports.createContext(createValue()); // HOOK

	const useQueryErrorResetBoundary = () => reactExports.useContext(QueryErrorResetBoundaryContext); // COMPONENT

	const ensureStaleTime = defaultedOptions => {
	  if (defaultedOptions.suspense) {
	    // Always set stale time when using suspense to prevent
	    // fetching again when directly mounting after suspending
	    if (typeof defaultedOptions.staleTime !== 'number') {
	      defaultedOptions.staleTime = 1000;
	    }
	  }
	};
	const willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
	const shouldSuspend = (defaultedOptions, result, isRestoring) => (defaultedOptions == null ? void 0 : defaultedOptions.suspense) && willFetch(result, isRestoring);
	const fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).then(({
	  data
	}) => {
	  defaultedOptions.onSuccess == null ? void 0 : defaultedOptions.onSuccess(data);
	  defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(data, null);
	}).catch(error => {
	  errorResetBoundary.clearReset();
	  defaultedOptions.onError == null ? void 0 : defaultedOptions.onError(error);
	  defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(undefined, error);
	});

	var shim = {exports: {}};

	var useSyncExternalStoreShim_production_min = {};

	var e$8=reactExports;function h$c(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var k$6="function"===typeof Object.is?Object.is:h$c,l$e=e$8.useState,m$7=e$8.useEffect,n$e=e$8.useLayoutEffect,p$e=e$8.useDebugValue;function q$7(a,b){var d=b(),f=l$e({inst:{value:d,getSnapshot:b}}),c=f[0].inst,g=f[1];n$e(function(){c.value=d;c.getSnapshot=b;r$a(c)&&g({inst:c});},[a,d,b]);m$7(function(){r$a(c)&&g({inst:c});return a(function(){r$a(c)&&g({inst:c});})},[a]);p$e(d);return d}
	function r$a(a){var b=a.getSnapshot;a=a.value;try{var d=b();return !k$6(a,d)}catch(f){return !0}}function t$e(a,b){return b()}var u$f="undefined"===typeof window||"undefined"===typeof window.document||"undefined"===typeof window.document.createElement?t$e:q$7;useSyncExternalStoreShim_production_min.useSyncExternalStore=void 0!==e$8.useSyncExternalStore?e$8.useSyncExternalStore:u$f;

	{
	  shim.exports = useSyncExternalStoreShim_production_min;
	}

	var shimExports = shim.exports;

	// Temporary workaround due to an issue with react-native uSES - https://github.com/TanStack/query/pull/3601
	const useSyncExternalStore$1 = shimExports.useSyncExternalStore;

	function useBaseQuery(options, Observer) {
	  const queryClient = useQueryClient({
	    context: options.context
	  });
	  const isRestoring = useIsRestoring();
	  const errorResetBoundary = useQueryErrorResetBoundary();
	  const defaultedOptions = queryClient.defaultQueryOptions(options); // Make sure results are optimistically set in fetching state before subscribing or updating options

	  defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic'; // Include callbacks in batch renders

	  if (defaultedOptions.onError) {
	    defaultedOptions.onError = notifyManager.batchCalls(defaultedOptions.onError);
	  }

	  if (defaultedOptions.onSuccess) {
	    defaultedOptions.onSuccess = notifyManager.batchCalls(defaultedOptions.onSuccess);
	  }

	  if (defaultedOptions.onSettled) {
	    defaultedOptions.onSettled = notifyManager.batchCalls(defaultedOptions.onSettled);
	  }

	  ensureStaleTime(defaultedOptions);
	  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
	  useClearResetErrorBoundary(errorResetBoundary);
	  const [observer] = reactExports.useState(() => new Observer(queryClient, defaultedOptions));
	  const result = observer.getOptimisticResult(defaultedOptions);
	  useSyncExternalStore$1(reactExports.useCallback(onStoreChange => isRestoring ? () => undefined : observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer, isRestoring]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
	  reactExports.useEffect(() => {
	    // Do not notify on updates because of changes in the options because
	    // these changes should already be reflected in the optimistic result.
	    observer.setOptions(defaultedOptions, {
	      listeners: false
	    });
	  }, [defaultedOptions, observer]); // Handle suspense

	  if (shouldSuspend(defaultedOptions, result, isRestoring)) {
	    throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
	  } // Handle error boundary


	  if (getHasError({
	    result,
	    errorResetBoundary,
	    useErrorBoundary: defaultedOptions.useErrorBoundary,
	    query: observer.getCurrentQuery()
	  })) {
	    throw result.error;
	  } // Handle result property usage tracking


	  return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
	}

	function useInfiniteQuery(arg1, arg2, arg3) {
	  const options = parseQueryArgs(arg1, arg2, arg3);
	  return useBaseQuery(options, InfiniteQueryObserver);
	}

	function useMutation(arg1, arg2, arg3) {
	  const options = parseMutationArgs(arg1, arg2);
	  const queryClient = useQueryClient({
	    context: options.context
	  });
	  const [observer] = reactExports.useState(() => new MutationObserver$1(queryClient, options));
	  reactExports.useEffect(() => {
	    observer.setOptions(options);
	  }, [observer, options]);
	  const result = useSyncExternalStore$1(reactExports.useCallback(onStoreChange => observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
	  const mutate = reactExports.useCallback((variables, mutateOptions) => {
	    observer.mutate(variables, mutateOptions).catch(noop$4);
	  }, [observer]);

	  if (result.error && shouldThrowError(observer.options.useErrorBoundary, [result.error])) {
	    throw result.error;
	  }

	  return { ...result,
	    mutate,
	    mutateAsync: result.mutate
	  };
	} // eslint-disable-next-line @typescript-eslint/no-empty-function

	function noop$4() {}

	// - `context` is omitted as it is passed as a root-level option to `useQueries` instead.

	function useQueries({
	  queries,
	  context
	}) {
	  const queryClient = useQueryClient({
	    context
	  });
	  const isRestoring = useIsRestoring();
	  const defaultedQueries = reactExports.useMemo(() => queries.map(options => {
	    const defaultedOptions = queryClient.defaultQueryOptions(options); // Make sure the results are already in fetching state before subscribing or updating options

	    defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic';
	    return defaultedOptions;
	  }), [queries, queryClient, isRestoring]);
	  const [observer] = reactExports.useState(() => new QueriesObserver(queryClient, defaultedQueries));
	  const optimisticResult = observer.getOptimisticResult(defaultedQueries);
	  useSyncExternalStore$1(reactExports.useCallback(onStoreChange => isRestoring ? () => undefined : observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer, isRestoring]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
	  reactExports.useEffect(() => {
	    // Do not notify on updates because of changes in the options because
	    // these changes should already be reflected in the optimistic result.
	    observer.setQueries(defaultedQueries, {
	      listeners: false
	    });
	  }, [defaultedQueries, observer]);
	  const errorResetBoundary = useQueryErrorResetBoundary();
	  defaultedQueries.forEach(query => {
	    ensurePreventErrorBoundaryRetry(query, errorResetBoundary);
	    ensureStaleTime(query);
	  });
	  useClearResetErrorBoundary(errorResetBoundary);
	  const shouldAtLeastOneSuspend = optimisticResult.some((result, index) => shouldSuspend(defaultedQueries[index], result, isRestoring));
	  const suspensePromises = shouldAtLeastOneSuspend ? optimisticResult.flatMap((result, index) => {
	    const options = defaultedQueries[index];
	    const queryObserver = observer.getObservers()[index];

	    if (options && queryObserver) {
	      if (shouldSuspend(options, result, isRestoring)) {
	        return fetchOptimistic(options, queryObserver, errorResetBoundary);
	      } else if (willFetch(result, isRestoring)) {
	        void fetchOptimistic(options, queryObserver, errorResetBoundary);
	      }
	    }

	    return [];
	  }) : [];

	  if (suspensePromises.length > 0) {
	    throw Promise.all(suspensePromises);
	  }

	  const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => {
	    var _defaultedQueries$ind, _defaultedQueries$ind2;

	    return getHasError({
	      result,
	      errorResetBoundary,
	      useErrorBoundary: (_defaultedQueries$ind = (_defaultedQueries$ind2 = defaultedQueries[index]) == null ? void 0 : _defaultedQueries$ind2.useErrorBoundary) != null ? _defaultedQueries$ind : false,
	      query: observer.getQueries()[index]
	    });
	  });

	  if (firstSingleResultWhichShouldThrow != null && firstSingleResultWhichShouldThrow.error) {
	    throw firstSingleResultWhichShouldThrow.error;
	  }

	  return optimisticResult;
	}

	function useQuery(arg1, arg2, arg3) {
	  const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
	  return useBaseQuery(parsedOptions, QueryObserver);
	}

	function hashQueryKey() { throw new Error('not implemented') }

	function identity$1(x) {
	    return x;
	}

	/** @internal */ function pipeFromArray(fns) {
	    if (fns.length === 0) {
	        return identity$1;
	    }
	    if (fns.length === 1) {
	        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
	        return fns[0];
	    }
	    return function piped(input) {
	        return fns.reduce((prev, fn)=>fn(prev), input);
	    };
	}
	function observable(subscribe) {
	    const self = {
	        subscribe (observer) {
	            let teardownRef = null;
	            let isDone = false;
	            let unsubscribed = false;
	            let teardownImmediately = false;
	            function unsubscribe() {
	                if (teardownRef === null) {
	                    teardownImmediately = true;
	                    return;
	                }
	                if (unsubscribed) {
	                    return;
	                }
	                unsubscribed = true;
	                if (typeof teardownRef === 'function') {
	                    teardownRef();
	                } else if (teardownRef) {
	                    teardownRef.unsubscribe();
	                }
	            }
	            teardownRef = subscribe({
	                next (value) {
	                    if (isDone) {
	                        return;
	                    }
	                    observer.next?.(value);
	                },
	                error (err) {
	                    if (isDone) {
	                        return;
	                    }
	                    isDone = true;
	                    observer.error?.(err);
	                    unsubscribe();
	                },
	                complete () {
	                    if (isDone) {
	                        return;
	                    }
	                    isDone = true;
	                    observer.complete?.();
	                    unsubscribe();
	                }
	            });
	            if (teardownImmediately) {
	                unsubscribe();
	            }
	            return {
	                unsubscribe
	            };
	        },
	        pipe (...operations) {
	            return pipeFromArray(operations)(self);
	        }
	    };
	    return self;
	}

	function share(_opts) {
	    return (originalObserver)=>{
	        let refCount = 0;
	        let subscription = null;
	        const observers = [];
	        function startIfNeeded() {
	            if (subscription) {
	                return;
	            }
	            subscription = originalObserver.subscribe({
	                next (value) {
	                    for (const observer of observers){
	                        observer.next?.(value);
	                    }
	                },
	                error (error) {
	                    for (const observer of observers){
	                        observer.error?.(error);
	                    }
	                },
	                complete () {
	                    for (const observer of observers){
	                        observer.complete?.();
	                    }
	                }
	            });
	        }
	        function resetIfNeeded() {
	            // "resetOnRefCountZero"
	            if (refCount === 0 && subscription) {
	                const _sub = subscription;
	                subscription = null;
	                _sub.unsubscribe();
	            }
	        }
	        return {
	            subscribe (observer) {
	                refCount++;
	                observers.push(observer);
	                startIfNeeded();
	                return {
	                    unsubscribe () {
	                        refCount--;
	                        resetIfNeeded();
	                        const index = observers.findIndex((v)=>v === observer);
	                        if (index > -1) {
	                            observers.splice(index, 1);
	                        }
	                    }
	                };
	            }
	        };
	    };
	}

	class ObservableAbortError extends Error {
	    constructor(message){
	        super(message);
	        this.name = 'ObservableAbortError';
	        Object.setPrototypeOf(this, ObservableAbortError.prototype);
	    }
	}
	/** @internal */ function observableToPromise(observable) {
	    let abort;
	    const promise = new Promise((resolve, reject)=>{
	        let isDone = false;
	        function onDone() {
	            if (isDone) {
	                return;
	            }
	            isDone = true;
	            reject(new ObservableAbortError('This operation was aborted.'));
	            obs$.unsubscribe();
	        }
	        const obs$ = observable.subscribe({
	            next (data) {
	                isDone = true;
	                resolve(data);
	                onDone();
	            },
	            error (data) {
	                isDone = true;
	                reject(data);
	                onDone();
	            },
	            complete () {
	                isDone = true;
	                onDone();
	            }
	        });
	        abort = onDone;
	    });
	    return {
	        promise,
	        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
	        abort: abort
	    };
	}

	function isObject$2(value) {
	    // check that value is object
	    return !!value && !Array.isArray(value) && typeof value === 'object';
	}

	// FIXME:
	// - the generics here are probably unnecessary
	// - the RPC-spec could probably be simplified to combine HTTP + WS
	/** @internal */ function transformResultInner(response, runtime) {
	    if ('error' in response) {
	        const error = runtime.transformer.deserialize(response.error);
	        return {
	            ok: false,
	            error: {
	                ...response,
	                error
	            }
	        };
	    }
	    const result = {
	        ...response.result,
	        ...(!response.result.type || response.result.type === 'data') && {
	            type: 'data',
	            data: runtime.transformer.deserialize(response.result.data)
	        }
	    };
	    return {
	        ok: true,
	        result
	    };
	}
	class TransformResultError extends Error {
	    constructor(){
	        super('Unable to transform response from server');
	    }
	}
	/**
	 * Transforms and validates that the result is a valid TRPCResponse
	 * @internal
	 */ function transformResult(response, runtime) {
	    let result;
	    try {
	        // Use the data transformers on the JSON-response
	        result = transformResultInner(response, runtime);
	    } catch (err) {
	        throw new TransformResultError();
	    }
	    // check that output of the transformers is a valid TRPCResponse
	    if (!result.ok && (!isObject$2(result.error.error) || typeof result.error.error.code !== 'number')) {
	        throw new TransformResultError();
	    }
	    if (result.ok && !isObject$2(result.result)) {
	        throw new TransformResultError();
	    }
	    return result;
	}

	function isTRPCClientError(cause) {
	    return cause instanceof TRPCClientError || /**
	     * @deprecated
	     * Delete in next major
	     */ cause instanceof Error && cause.name === 'TRPCClientError';
	}
	function isTRPCErrorResponse(obj) {
	    return isObject$2(obj) && isObject$2(obj.error) && typeof obj.error.code === 'number' && typeof obj.error.message === 'string';
	}
	class TRPCClientError extends Error {
	    static from(_cause, opts = {}) {
	        const cause = _cause;
	        if (isTRPCClientError(cause)) {
	            if (opts.meta) {
	                // Decorate with meta error data
	                cause.meta = {
	                    ...cause.meta,
	                    ...opts.meta
	                };
	            }
	            return cause;
	        }
	        if (isTRPCErrorResponse(cause)) {
	            return new TRPCClientError(cause.error.message, {
	                ...opts,
	                result: cause
	            });
	        }
	        if (!(cause instanceof Error)) {
	            return new TRPCClientError('Unknown error', {
	                ...opts,
	                cause: cause
	            });
	        }
	        return new TRPCClientError(cause.message, {
	            ...opts,
	            cause
	        });
	    }
	    constructor(message, opts){
	        const cause = opts?.cause;
	        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
	        // @ts-ignore https://github.com/tc39/proposal-error-cause
	        super(message, {
	            cause
	        });
	        this.meta = opts?.meta;
	        this.cause = cause;
	        this.shape = opts?.result?.error;
	        this.data = opts?.result?.error.data;
	        this.name = 'TRPCClientError';
	        Object.setPrototypeOf(this, TRPCClientError.prototype);
	    }
	}

	function getAbortController(customAbortControllerImpl) {
	    if (customAbortControllerImpl) {
	        return customAbortControllerImpl;
	    }
	    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
	    if (typeof window !== 'undefined' && window.AbortController) {
	        return window.AbortController;
	    }
	    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
	    if (typeof globalThis !== 'undefined' && globalThis.AbortController) {
	        return globalThis.AbortController;
	    }
	    return null;
	}

	function resolveHTTPLinkOptions(opts) {
	    return {
	        url: opts.url.toString().replace(/\/$/, ''),
	        fetch: opts.fetch,
	        AbortController: getAbortController(opts.AbortController)
	    };
	}
	// https://github.com/trpc/trpc/pull/669
	function arrayToDict(array) {
	    const dict = {};
	    for(let index = 0; index < array.length; index++){
	        const element = array[index];
	        dict[index] = element;
	    }
	    return dict;
	}
	function getInput$1(opts) {
	    return 'input' in opts ? opts.runtime.transformer.serialize(opts.input) : arrayToDict(opts.inputs.map((_input)=>opts.runtime.transformer.serialize(_input)));
	}
	const getUrl = (opts)=>{
	    let url = opts.url + '/' + opts.path;
	    const queryParts = [];
	    if ('inputs' in opts) {
	        queryParts.push('batch=1');
	    }
	    if (opts.type === 'query') {
	        const input = getInput$1(opts);
	        if (input !== undefined) {
	            queryParts.push(`input=${encodeURIComponent(JSON.stringify(input))}`);
	        }
	    }
	    if (queryParts.length) {
	        url += '?' + queryParts.join('&');
	    }
	    return url;
	};
	const getBody = (opts)=>{
	    if (opts.type === 'query') {
	        return undefined;
	    }
	    const input = getInput$1(opts);
	    return input !== undefined ? JSON.stringify(input) : undefined;
	};
	const jsonHttpRequester = (opts)=>{
	    return httpRequest({
	        ...opts,
	        contentTypeHeader: 'application/json',
	        getUrl,
	        getBody
	    });
	};
	async function fetchHTTPResponse(opts, ac) { return new Promise(() => {});
	}
	function httpRequest(opts) {
	    const ac = opts.AbortController ? new opts.AbortController() : null;
	    const meta = {};
	    let done = false;
	    const promise = new Promise((resolve, reject)=>{
	        fetchHTTPResponse().then((_res)=>{
	            meta.response = _res;
	            done = true;
	            return _res.json();
	        }).then((json)=>{
	            meta.responseJSON = json;
	            resolve({
	                json: json,
	                meta
	            });
	        }).catch((err)=>{
	            done = true;
	            reject(TRPCClientError.from(err, {
	                meta
	            }));
	        });
	    });
	    const cancel = ()=>{
	        if (!done) {
	            ac?.abort();
	        }
	    };
	    return {
	        promise,
	        cancel
	    };
	}

	/* eslint-disable @typescript-eslint/no-non-null-assertion */ /**
	 * A function that should never be called unless we messed something up.
	 */ const throwFatalError = ()=>{
	    throw new Error('Something went wrong. Please submit an issue at https://github.com/trpc/trpc/issues/new');
	};
	/**
	 * Dataloader that's very inspired by https://github.com/graphql/dataloader
	 * Less configuration, no caching, and allows you to cancel requests
	 * When cancelling a single fetch the whole batch will be cancelled only when _all_ items are cancelled
	 */ function dataLoader(batchLoader) {
	    let pendingItems = null;
	    let dispatchTimer = null;
	    const destroyTimerAndPendingItems = ()=>{
	        clearTimeout(dispatchTimer);
	        dispatchTimer = null;
	        pendingItems = null;
	    };
	    /**
	   * Iterate through the items and split them into groups based on the `batchLoader`'s validate function
	   */ function groupItems(items) {
	        const groupedItems = [
	            []
	        ];
	        let index = 0;
	        while(true){
	            const item = items[index];
	            if (!item) {
	                break;
	            }
	            const lastGroup = groupedItems[groupedItems.length - 1];
	            if (item.aborted) {
	                // Item was aborted before it was dispatched
	                item.reject?.(new Error('Aborted'));
	                index++;
	                continue;
	            }
	            const isValid = batchLoader.validate(lastGroup.concat(item).map((it)=>it.key));
	            if (isValid) {
	                lastGroup.push(item);
	                index++;
	                continue;
	            }
	            if (lastGroup.length === 0) {
	                item.reject?.(new Error('Input is too big for a single dispatch'));
	                index++;
	                continue;
	            }
	            // Create new group, next iteration will try to add the item to that
	            groupedItems.push([]);
	        }
	        return groupedItems;
	    }
	    function dispatch() {
	        const groupedItems = groupItems(pendingItems);
	        destroyTimerAndPendingItems();
	        // Create batches for each group of items
	        for (const items of groupedItems){
	            if (!items.length) {
	                continue;
	            }
	            const batch = {
	                items,
	                cancel: throwFatalError
	            };
	            for (const item of items){
	                item.batch = batch;
	            }
	            const unitResolver = (index, value)=>{
	                const item = batch.items[index];
	                item.resolve?.(value);
	                item.batch = null;
	                item.reject = null;
	                item.resolve = null;
	            };
	            const { promise , cancel  } = batchLoader.fetch(batch.items.map((_item)=>_item.key), unitResolver);
	            batch.cancel = cancel;
	            promise.then((result)=>{
	                for(let i = 0; i < result.length; i++){
	                    const value = result[i];
	                    unitResolver(i, value);
	                }
	                for (const item of batch.items){
	                    item.reject?.(new Error('Missing result'));
	                    item.batch = null;
	                }
	            }).catch((cause)=>{
	                for (const item of batch.items){
	                    item.reject?.(cause);
	                    item.batch = null;
	                }
	            });
	        }
	    }
	    function load(key) {
	        const item = {
	            aborted: false,
	            key,
	            batch: null,
	            resolve: throwFatalError,
	            reject: throwFatalError
	        };
	        const promise = new Promise((resolve, reject)=>{
	            item.reject = reject;
	            item.resolve = resolve;
	            if (!pendingItems) {
	                pendingItems = [];
	            }
	            pendingItems.push(item);
	        });
	        if (!dispatchTimer) {
	            dispatchTimer = setTimeout(dispatch);
	        }
	        const cancel = ()=>{
	            item.aborted = true;
	            if (item.batch?.items.every((item)=>item.aborted)) {
	                // All items in the batch have been cancelled
	                item.batch.cancel();
	                item.batch = null;
	            }
	        };
	        return {
	            promise,
	            cancel
	        };
	    }
	    return {
	        load
	    };
	}

	/**
	 * @internal
	 */ function createHTTPBatchLink(requester) {
	    return function httpBatchLink(opts) {
	        const resolvedOpts = resolveHTTPLinkOptions(opts);
	        const maxURLLength = opts.maxURLLength ?? Infinity;
	        // initialized config
	        return (runtime)=>{
	            const batchLoader = (type)=>{
	                const validate = (batchOps)=>{
	                    if (maxURLLength === Infinity) {
	                        // escape hatch for quick calcs
	                        return true;
	                    }
	                    const path = batchOps.map((op)=>op.path).join(',');
	                    const inputs = batchOps.map((op)=>op.input);
	                    const url = getUrl({
	                        ...resolvedOpts,
	                        runtime,
	                        type,
	                        path,
	                        inputs
	                    });
	                    return url.length <= maxURLLength;
	                };
	                const fetch = requester({
	                    ...resolvedOpts,
	                    runtime,
	                    type,
	                    opts
	                });
	                return {
	                    validate,
	                    fetch
	                };
	            };
	            const query = dataLoader(batchLoader('query'));
	            const mutation = dataLoader(batchLoader('mutation'));
	            const subscription = dataLoader(batchLoader('subscription'));
	            const loaders = {
	                query,
	                subscription,
	                mutation
	            };
	            return ({ op  })=>{
	                return observable((observer)=>{
	                    const loader = loaders[op.type];
	                    const { promise , cancel  } = loader.load(op);
	                    let _res = undefined;
	                    promise.then((res)=>{
	                        _res = res;
	                        const transformed = transformResult(res.json, runtime);
	                        if (!transformed.ok) {
	                            observer.error(TRPCClientError.from(transformed.error, {
	                                meta: res.meta
	                            }));
	                            return;
	                        }
	                        observer.next({
	                            context: res.meta,
	                            result: transformed.result
	                        });
	                        observer.complete();
	                    }).catch((err)=>{
	                        observer.error(TRPCClientError.from(err, {
	                            meta: _res?.meta
	                        }));
	                    });
	                    return ()=>{
	                        cancel();
	                    };
	                });
	            };
	        };
	    };
	}

	const batchRequester = (requesterOpts)=>{
	    return (batchOps)=>{
	        const path = batchOps.map((op)=>op.path).join(',');
	        const inputs = batchOps.map((op)=>op.input);
	        const { promise , cancel  } = jsonHttpRequester({
	            ...requesterOpts,
	            path,
	            inputs,
	            headers () {
	                if (!requesterOpts.opts.headers) {
	                    return {};
	                }
	                if (typeof requesterOpts.opts.headers === 'function') {
	                    return requesterOpts.opts.headers({
	                        opList: batchOps
	                    });
	                }
	                return requesterOpts.opts.headers;
	            }
	        });
	        return {
	            promise: promise.then((res)=>{
	                const resJSON = Array.isArray(res.json) ? res.json : batchOps.map(()=>res.json);
	                const result = resJSON.map((item)=>({
	                        meta: res.meta,
	                        json: item
	                    }));
	                return result;
	            }),
	            cancel
	        };
	    };
	};
	const httpBatchLink = createHTTPBatchLink(batchRequester);

	var index_browser = {exports: {}};

	var build = {};

	var tinyEmitter = {exports: {}};

	function E$4 () {
	  // Keep this empty so it's easier to inherit from
	  // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)
	}

	E$4.prototype = {
	  on: function (name, callback, ctx) {
	    var e = this.e || (this.e = {});

	    (e[name] || (e[name] = [])).push({
	      fn: callback,
	      ctx: ctx
	    });

	    return this;
	  },

	  once: function (name, callback, ctx) {
	    var self = this;
	    function listener () {
	      self.off(name, listener);
	      callback.apply(ctx, arguments);
	    }
	    listener._ = callback;
	    return this.on(name, listener, ctx);
	  },

	  emit: function (name) {
	    var data = [].slice.call(arguments, 1);
	    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
	    var i = 0;
	    var len = evtArr.length;

	    for (i; i < len; i++) {
	      evtArr[i].fn.apply(evtArr[i].ctx, data);
	    }

	    return this;
	  },

	  off: function (name, callback) {
	    var e = this.e || (this.e = {});
	    var evts = e[name];
	    var liveEvents = [];

	    if (evts && callback) {
	      for (var i = 0, len = evts.length; i < len; i++) {
	        if (evts[i].fn !== callback && evts[i].fn._ !== callback)
	          liveEvents.push(evts[i]);
	      }
	    }

	    // Remove event from queue to prevent memory leak
	    // Suggested by https://github.com/lazd
	    // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910

	    (liveEvents.length)
	      ? e[name] = liveEvents
	      : delete e[name];

	    return this;
	  }
	};

	tinyEmitter.exports = E$4;
	tinyEmitter.exports.TinyEmitter = E$4;

	var tinyEmitterExports = tinyEmitter.exports;

	var metrics = {};

	// Simplified version of: https://github.com/Unleash/unleash-client-node/blob/main/src/metrics.ts
	var __assign$7 = (commonjsGlobal && commonjsGlobal.__assign) || function () {
	    __assign$7 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$7.apply(this, arguments);
	};
	var __awaiter$2 = (commonjsGlobal && commonjsGlobal.__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());
	    });
	};
	var __generator$2 = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
	    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
	    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
	    function verb(n) { return function (v) { return step([n, v]); }; }
	    function step(op) {
	        if (f) throw new TypeError("Generator is already executing.");
	        while (_) try {
	            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
	            if (y = 0, t) op = [op[0] & 2, t.value];
	            switch (op[0]) {
	                case 0: case 1: t = op; break;
	                case 4: _.label++; return { value: op[1], done: false };
	                case 5: _.label++; y = op[1]; op = [0]; continue;
	                case 7: op = _.ops.pop(); _.trys.pop(); continue;
	                default:
	                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
	                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
	                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
	                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
	                    if (t[2]) _.ops.pop();
	                    _.trys.pop(); continue;
	            }
	            op = body.call(thisArg, _);
	        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
	        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
	    }
	};
	Object.defineProperty(metrics, "__esModule", { value: true });
	var Metrics = /** @class */ (function () {
	    function Metrics(_a) {
	        var onError = _a.onError, appName = _a.appName, metricsInterval = _a.metricsInterval, _b = _a.disableMetrics, disableMetrics = _b === void 0 ? false : _b, url = _a.url, clientKey = _a.clientKey, fetch = _a.fetch, headerName = _a.headerName;
	        this.onError = onError;
	        this.disabled = disableMetrics;
	        this.metricsInterval = metricsInterval * 1000;
	        this.appName = appName;
	        this.url = url instanceof URL ? url : new URL(url);
	        this.clientKey = clientKey;
	        this.bucket = this.createEmptyBucket();
	        this.fetch = fetch;
	        this.headerName = headerName;
	    }
	    Metrics.prototype.start = function () {
	        var _this = this;
	        if (this.disabled) {
	            return false;
	        }
	        if (typeof this.metricsInterval === 'number' &&
	            this.metricsInterval > 0) {
	            // send first metrics after two seconds.
	            setTimeout(function () {
	                _this.startTimer();
	                _this.sendMetrics();
	            }, 2000);
	        }
	    };
	    Metrics.prototype.stop = function () {
	        if (this.timer) {
	            clearTimeout(this.timer);
	            delete this.timer;
	        }
	    };
	    Metrics.prototype.createEmptyBucket = function () {
	        return {
	            start: new Date(),
	            stop: null,
	            toggles: {},
	        };
	    };
	    Metrics.prototype.sendMetrics = function () {
	        return __awaiter$2(this, void 0, void 0, function () {
	            var url, payload, e_1;
	            var _a;
	            return __generator$2(this, function (_b) {
	                switch (_b.label) {
	                    case 0:
	                        url = "".concat(this.url, "/client/metrics");
	                        payload = this.getPayload();
	                        if (this.bucketIsEmpty(payload)) {
	                            return [2 /*return*/];
	                        }
	                        _b.label = 1;
	                    case 1:
	                        _b.trys.push([1, 3, , 4]);
	                        return [4 /*yield*/, this.fetch(url, {
	                                cache: 'no-cache',
	                                method: 'POST',
	                                headers: (_a = {},
	                                    _a[this.headerName] = this.clientKey,
	                                    _a.Accept = 'application/json',
	                                    _a['Content-Type'] = 'application/json',
	                                    _a),
	                                body: JSON.stringify(payload),
	                            })];
	                    case 2:
	                        _b.sent();
	                        return [3 /*break*/, 4];
	                    case 3:
	                        e_1 = _b.sent();
	                        console.error('Unleash: unable to send feature metrics', e_1);
	                        this.onError(e_1);
	                        return [3 /*break*/, 4];
	                    case 4: return [2 /*return*/];
	                }
	            });
	        });
	    };
	    Metrics.prototype.count = function (name, enabled) {
	        if (this.disabled || !this.bucket) {
	            return false;
	        }
	        this.assertBucket(name);
	        this.bucket.toggles[name][enabled ? 'yes' : 'no']++;
	        return true;
	    };
	    Metrics.prototype.assertBucket = function (name) {
	        if (this.disabled || !this.bucket) {
	            return false;
	        }
	        if (!this.bucket.toggles[name]) {
	            this.bucket.toggles[name] = {
	                yes: 0,
	                no: 0,
	            };
	        }
	    };
	    Metrics.prototype.startTimer = function () {
	        var _this = this;
	        this.timer = setInterval(function () {
	            _this.sendMetrics();
	        }, this.metricsInterval);
	    };
	    Metrics.prototype.bucketIsEmpty = function (payload) {
	        return Object.keys(payload.bucket.toggles).length === 0;
	    };
	    Metrics.prototype.getPayload = function () {
	        var bucket = __assign$7(__assign$7({}, this.bucket), { stop: new Date() });
	        this.bucket = this.createEmptyBucket();
	        return {
	            bucket: bucket,
	            appName: this.appName,
	            instanceId: 'browser',
	        };
	    };
	    return Metrics;
	}());
	metrics.default = Metrics;

	var storageProviderInmemory = {};

	var __awaiter$1 = (commonjsGlobal && commonjsGlobal.__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());
	    });
	};
	var __generator$1 = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
	    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
	    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
	    function verb(n) { return function (v) { return step([n, v]); }; }
	    function step(op) {
	        if (f) throw new TypeError("Generator is already executing.");
	        while (_) try {
	            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
	            if (y = 0, t) op = [op[0] & 2, t.value];
	            switch (op[0]) {
	                case 0: case 1: t = op; break;
	                case 4: _.label++; return { value: op[1], done: false };
	                case 5: _.label++; y = op[1]; op = [0]; continue;
	                case 7: op = _.ops.pop(); _.trys.pop(); continue;
	                default:
	                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
	                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
	                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
	                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
	                    if (t[2]) _.ops.pop();
	                    _.trys.pop(); continue;
	            }
	            op = body.call(thisArg, _);
	        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
	        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
	    }
	};
	Object.defineProperty(storageProviderInmemory, "__esModule", { value: true });
	var ImMemoryStorageProvider = /** @class */ (function () {
	    function ImMemoryStorageProvider() {
	        this.store = new Map();
	    }
	    ImMemoryStorageProvider.prototype.save = function (name, data) {
	        return __awaiter$1(this, void 0, void 0, function () {
	            return __generator$1(this, function (_a) {
	                this.store.set(name, data);
	                return [2 /*return*/];
	            });
	        });
	    };
	    ImMemoryStorageProvider.prototype.get = function (name) {
	        return __awaiter$1(this, void 0, void 0, function () {
	            return __generator$1(this, function (_a) {
	                return [2 /*return*/, this.store.get(name)];
	            });
	        });
	    };
	    return ImMemoryStorageProvider;
	}());
	storageProviderInmemory.default = ImMemoryStorageProvider;

	var storageProviderLocal = {};

	var __awaiter = (commonjsGlobal && commonjsGlobal.__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());
	    });
	};
	var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
	    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
	    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
	    function verb(n) { return function (v) { return step([n, v]); }; }
	    function step(op) {
	        if (f) throw new TypeError("Generator is already executing.");
	        while (_) try {
	            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
	            if (y = 0, t) op = [op[0] & 2, t.value];
	            switch (op[0]) {
	                case 0: case 1: t = op; break;
	                case 4: _.label++; return { value: op[1], done: false };
	                case 5: _.label++; y = op[1]; op = [0]; continue;
	                case 7: op = _.ops.pop(); _.trys.pop(); continue;
	                default:
	                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
	                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
	                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
	                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
	                    if (t[2]) _.ops.pop();
	                    _.trys.pop(); continue;
	            }
	            op = body.call(thisArg, _);
	        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
	        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
	    }
	};
	Object.defineProperty(storageProviderLocal, "__esModule", { value: true });
	var LocalStorageProvider = /** @class */ (function () {
	    function LocalStorageProvider() {
	        this.prefix = 'unleash:repository';
	    }
	    LocalStorageProvider.prototype.save = function (name, data) {
	        return __awaiter(this, void 0, void 0, function () {
	            var repo, key;
	            return __generator(this, function (_a) {
	                repo = JSON.stringify(data);
	                key = "".concat(this.prefix, ":").concat(name);
	                try {
	                    window.localStorage.setItem(key, repo);
	                }
	                catch (ex) {
	                    console.error(ex);
	                }
	                return [2 /*return*/];
	            });
	        });
	    };
	    LocalStorageProvider.prototype.get = function (name) {
	        try {
	            var key = "".concat(this.prefix, ":").concat(name);
	            var data = window.localStorage.getItem(key);
	            return data ? JSON.parse(data) : undefined;
	        }
	        catch (e) {
	            console.error(e);
	        }
	    };
	    return LocalStorageProvider;
	}());
	storageProviderLocal.default = LocalStorageProvider;

	var eventsHandler = {};

	var nil = '00000000-0000-0000-0000-000000000000';

	// Unique ID creation requires a high quality random # generator. In the browser we therefore
	// require the crypto API and do not support built-in fallback to lower quality random number
	// generators (like Math.random()).
	var getRandomValues;
	var rnds8 = new Uint8Array(16);
	function rng() {
	  // lazy load so that environments that need to polyfill have a chance to do so
	  if (!getRandomValues) {
	    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
	    // find the complete implementation of crypto (msCrypto) on IE11.
	    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);

	    if (!getRandomValues) {
	      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
	    }
	  }

	  return getRandomValues(rnds8);
	}

	var REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;

	function validate(uuid) {
	  return typeof uuid === 'string' && REGEX.test(uuid);
	}

	/**
	 * Convert array of 16 byte values to UUID string format of the form:
	 * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
	 */

	var byteToHex = [];

	for (var i$a = 0; i$a < 256; ++i$a) {
	  byteToHex.push((i$a + 0x100).toString(16).substr(1));
	}

	function stringify$3(arr) {
	  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
	  // Note: Be careful editing this code!  It's been tuned for performance
	  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
	  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one
	  // of the following:
	  // - One or more input array values don't map to a hex octet (leading to
	  // "undefined" in the uuid)
	  // - Invalid input values for the RFC `version` or `variant` fields

	  if (!validate(uuid)) {
	    throw TypeError('Stringified UUID is invalid');
	  }

	  return uuid;
	}

	function v4(options, buf, offset) {
	  options = options || {};
	  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`

	  rnds[6] = rnds[6] & 0x0f | 0x40;
	  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided

	  if (buf) {
	    offset = offset || 0;

	    for (var i = 0; i < 16; ++i) {
	      buf[offset + i] = rnds[i];
	    }

	    return buf;
	  }

	  return stringify$3(rnds);
	}

	var special_uuid_ = /*#__PURE__*/Object.freeze({
		__proto__: null,
		NIL: nil,
		v4: v4
	});

	var require$$0$3 = /*@__PURE__*/getAugmentedNamespace(special_uuid_);

	var __assign$6 = (commonjsGlobal && commonjsGlobal.__assign) || function () {
	    __assign$6 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$6.apply(this, arguments);
	};
	Object.defineProperty(eventsHandler, "__esModule", { value: true });
	var uuid_1 = require$$0$3;
	var EventsHandler = /** @class */ (function () {
	    function EventsHandler() {
	    }
	    EventsHandler.prototype.generateEventId = function () {
	        return (0, uuid_1.v4)();
	    };
	    EventsHandler.prototype.createImpressionEvent = function (context, enabled, featureName, eventType, variant) {
	        var baseEvent = this.createBaseEvent(context, enabled, featureName, eventType);
	        if (variant) {
	            return __assign$6(__assign$6({}, baseEvent), { variant: variant });
	        }
	        return baseEvent;
	    };
	    EventsHandler.prototype.createBaseEvent = function (context, enabled, featureName, eventType) {
	        return {
	            eventType: eventType,
	            eventId: this.generateEventId(),
	            context: context,
	            enabled: enabled,
	            featureName: featureName,
	        };
	    };
	    return EventsHandler;
	}());
	eventsHandler.default = EventsHandler;

	var util$1 = {};

	Object.defineProperty(util$1, "__esModule", { value: true });
	util$1.notNullOrUndefined = void 0;
	var notNullOrUndefined = function (_a) {
	    var value = _a[1];
	    return value !== undefined && value !== null;
	};
	util$1.notNullOrUndefined = notNullOrUndefined;

	(function (exports) {
		var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
		    var extendStatics = function (d, b) {
		        extendStatics = Object.setPrototypeOf ||
		            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
		            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
		        return extendStatics(d, b);
		    };
		    return function (d, b) {
		        if (typeof b !== "function" && b !== null)
		            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
		        extendStatics(d, b);
		        function __() { this.constructor = d; }
		        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
		    };
		})();
		var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
		    __assign = Object.assign || function(t) {
		        for (var s, i = 1, n = arguments.length; i < n; i++) {
		            s = arguments[i];
		            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
		                t[p] = s[p];
		        }
		        return t;
		    };
		    return __assign.apply(this, arguments);
		};
		var __awaiter = (commonjsGlobal && commonjsGlobal.__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());
		    });
		};
		var __generator = (commonjsGlobal && commonjsGlobal.__generator) || function (thisArg, body) {
		    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
		    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
		    function verb(n) { return function (v) { return step([n, v]); }; }
		    function step(op) {
		        if (f) throw new TypeError("Generator is already executing.");
		        while (_) try {
		            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
		            if (y = 0, t) op = [op[0] & 2, t.value];
		            switch (op[0]) {
		                case 0: case 1: t = op; break;
		                case 4: _.label++; return { value: op[1], done: false };
		                case 5: _.label++; y = op[1]; op = [0]; continue;
		                case 7: op = _.ops.pop(); _.trys.pop(); continue;
		                default:
		                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
		                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
		                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
		                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
		                    if (t[2]) _.ops.pop();
		                    _.trys.pop(); continue;
		            }
		            op = body.call(thisArg, _);
		        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
		        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
		    }
		};
		var __spreadArray = (commonjsGlobal && commonjsGlobal.__spreadArray) || function (to, from, pack) {
		    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
		        if (ar || !(i in from)) {
		            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
		            ar[i] = from[i];
		        }
		    }
		    return to.concat(ar || Array.prototype.slice.call(from));
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.InMemoryStorageProvider = exports.LocalStorageProvider = exports.UnleashClient = exports.resolveFetch = exports.EVENTS = void 0;
		var tiny_emitter_1 = tinyEmitterExports;
		var metrics_1 = metrics;
		var storage_provider_inmemory_1 = storageProviderInmemory;
		exports.InMemoryStorageProvider = storage_provider_inmemory_1.default;
		var storage_provider_local_1 = storageProviderLocal;
		exports.LocalStorageProvider = storage_provider_local_1.default;
		var events_handler_1 = eventsHandler;
		var util_1 = util$1;
		var DEFINED_FIELDS = ['userId', 'sessionId', 'remoteAddress'];
		exports.EVENTS = {
		    INIT: 'initialized',
		    ERROR: 'error',
		    READY: 'ready',
		    UPDATE: 'update',
		    IMPRESSION: 'impression',
		};
		var IMPRESSION_EVENTS = {
		    IS_ENABLED: 'isEnabled',
		    GET_VARIANT: 'getVariant',
		};
		var defaultVariant = { name: 'disabled', enabled: false };
		var storeKey = 'repo';
		var resolveFetch = function () {
		    try {
		        if ('fetch' in window) {
		            return fetch.bind(window);
		        }
		        else if ('fetch' in globalThis) {
		            return fetch.bind(globalThis);
		        }
		    }
		    catch (e) {
		        console.error('Unleash failed to resolve "fetch"', e);
		    }
		    return undefined;
		};
		exports.resolveFetch = resolveFetch;
		var UnleashClient = /** @class */ (function (_super) {
		    __extends(UnleashClient, _super);
		    function UnleashClient(_a) {
		        var storageProvider = _a.storageProvider, url = _a.url, clientKey = _a.clientKey, _b = _a.disableRefresh, disableRefresh = _b === void 0 ? false : _b, _c = _a.refreshInterval, refreshInterval = _c === void 0 ? 30 : _c, _d = _a.metricsInterval, metricsInterval = _d === void 0 ? 30 : _d, _e = _a.disableMetrics, disableMetrics = _e === void 0 ? false : _e, appName = _a.appName, _f = _a.environment, environment = _f === void 0 ? 'default' : _f, context = _a.context, _g = _a.fetch, fetch = _g === void 0 ? (0, exports.resolveFetch)() : _g, bootstrap = _a.bootstrap, _h = _a.bootstrapOverride, bootstrapOverride = _h === void 0 ? true : _h, _j = _a.headerName, headerName = _j === void 0 ? 'Authorization' : _j, _k = _a.customHeaders, customHeaders = _k === void 0 ? {} : _k;
		        var _this = _super.call(this) || this;
		        _this.toggles = [];
		        _this.etag = '';
		        _this.readyEventEmitted = false;
		        // Validations
		        if (!url) {
		            throw new Error('url is required');
		        }
		        if (!clientKey) {
		            throw new Error('clientKey is required');
		        }
		        if (!appName) {
		            throw new Error('appName is required.');
		        }
		        _this.eventsHandler = new events_handler_1.default();
		        _this.toggles = bootstrap && bootstrap.length > 0 ? bootstrap : [];
		        _this.url = url instanceof URL ? url : new URL(url);
		        _this.clientKey = clientKey;
		        _this.headerName = headerName;
		        _this.customHeaders = customHeaders;
		        _this.storage = storageProvider || new storage_provider_local_1.default();
		        _this.refreshInterval = disableRefresh ? 0 : refreshInterval * 1000;
		        _this.context = __assign({ appName: appName, environment: environment }, context);
		        _this.ready = new Promise(function (resolve) {
		            _this.init()
		                .then(resolve)
		                .catch(function (error) {
		                console.error(error);
		                _this.emit(exports.EVENTS.ERROR, error);
		                resolve();
		            });
		        });
		        if (!fetch) {
		            console.error('Unleash: You must either provide your own "fetch" implementation or run in an environment where "fetch" is available.');
		        }
		        _this.fetch = fetch;
		        _this.bootstrap =
		            bootstrap && bootstrap.length > 0 ? bootstrap : undefined;
		        _this.bootstrapOverride = bootstrapOverride;
		        _this.metrics = new metrics_1.default({
		            onError: _this.emit.bind(_this, exports.EVENTS.ERROR),
		            appName: appName,
		            metricsInterval: metricsInterval,
		            disableMetrics: disableMetrics,
		            url: _this.url,
		            clientKey: clientKey,
		            fetch: fetch,
		            headerName: headerName,
		        });
		        return _this;
		    }
		    UnleashClient.prototype.getAllToggles = function () {
		        return __spreadArray([], this.toggles, true);
		    };
		    UnleashClient.prototype.isEnabled = function (toggleName) {
		        var toggle = this.toggles.find(function (t) { return t.name === toggleName; });
		        var enabled = toggle ? toggle.enabled : false;
		        this.metrics.count(toggleName, enabled);
		        if (toggle === null || toggle === void 0 ? void 0 : toggle.impressionData) {
		            var event_1 = this.eventsHandler.createImpressionEvent(this.context, enabled, toggleName, IMPRESSION_EVENTS.IS_ENABLED);
		            this.emit(exports.EVENTS.IMPRESSION, event_1);
		        }
		        return enabled;
		    };
		    UnleashClient.prototype.getVariant = function (toggleName) {
		        var toggle = this.toggles.find(function (t) { return t.name === toggleName; });
		        if (toggle) {
		            this.metrics.count(toggleName, true);
		            if (toggle.impressionData) {
		                var event_2 = this.eventsHandler.createImpressionEvent(this.context, toggle.enabled, toggleName, IMPRESSION_EVENTS.GET_VARIANT, toggle.variant.name);
		                this.emit(exports.EVENTS.IMPRESSION, event_2);
		            }
		            return toggle.variant;
		        }
		        else {
		            this.metrics.count(toggleName, false);
		            return defaultVariant;
		        }
		    };
		    UnleashClient.prototype.updateContext = function (context) {
		        return __awaiter(this, void 0, void 0, function () {
		            var staticContext;
		            return __generator(this, function (_a) {
		                switch (_a.label) {
		                    case 0:
		                        // @ts-expect-error Give the user a nicer error message when
		                        // including static fields in the mutable context object
		                        if (context.appName || context.environment) {
		                            console.warn("appName and environment are static. They can't be updated with updateContext.");
		                        }
		                        staticContext = {
		                            environment: this.context.environment,
		                            appName: this.context.appName,
		                        };
		                        this.context = __assign(__assign({}, staticContext), context);
		                        if (!this.timerRef) return [3 /*break*/, 2];
		                        return [4 /*yield*/, this.fetchToggles()];
		                    case 1:
		                        _a.sent();
		                        _a.label = 2;
		                    case 2: return [2 /*return*/];
		                }
		            });
		        });
		    };
		    UnleashClient.prototype.getContext = function () {
		        return __assign({}, this.context);
		    };
		    UnleashClient.prototype.setContextField = function (field, value) {
		        var _a, _b;
		        if (DEFINED_FIELDS.includes(field)) {
		            this.context = __assign(__assign({}, this.context), (_a = {}, _a[field] = value, _a));
		        }
		        else {
		            var properties = __assign(__assign({}, this.context.properties), (_b = {}, _b[field] = value, _b));
		            this.context = __assign(__assign({}, this.context), { properties: properties });
		        }
		        if (this.timerRef) {
		            this.fetchToggles();
		        }
		    };
		    UnleashClient.prototype.init = function () {
		        return __awaiter(this, void 0, void 0, function () {
		            var sessionId, _a;
		            return __generator(this, function (_b) {
		                switch (_b.label) {
		                    case 0: return [4 /*yield*/, this.resolveSessionId()];
		                    case 1:
		                        sessionId = _b.sent();
		                        this.context = __assign({ sessionId: sessionId }, this.context);
		                        _a = this;
		                        return [4 /*yield*/, this.storage.get(storeKey)];
		                    case 2:
		                        _a.toggles = (_b.sent()) || [];
		                        if (!(this.bootstrap &&
		                            (this.bootstrapOverride || this.toggles.length === 0))) return [3 /*break*/, 4];
		                        return [4 /*yield*/, this.storage.save(storeKey, this.bootstrap)];
		                    case 3:
		                        _b.sent();
		                        this.toggles = this.bootstrap;
		                        this.emit(exports.EVENTS.READY);
		                        _b.label = 4;
		                    case 4:
		                        this.emit(exports.EVENTS.INIT);
		                        return [2 /*return*/];
		                }
		            });
		        });
		    };
		    UnleashClient.prototype.start = function () {
		        return __awaiter(this, void 0, void 0, function () {
		            var interval;
		            var _this = this;
		            return __generator(this, function (_a) {
		                switch (_a.label) {
		                    case 0:
		                        if (this.timerRef) {
		                            console.error('Unleash SDK has already started, if you want to restart the SDK you should call client.stop() before starting again.');
		                            return [2 /*return*/];
		                        }
		                        return [4 /*yield*/, this.ready];
		                    case 1:
		                        _a.sent();
		                        this.metrics.start();
		                        interval = this.refreshInterval;
		                        return [4 /*yield*/, this.fetchToggles()];
		                    case 2:
		                        _a.sent();
		                        if (interval > 0) {
		                            this.timerRef = setInterval(function () { return _this.fetchToggles(); }, interval);
		                        }
		                        return [2 /*return*/];
		                }
		            });
		        });
		    };
		    UnleashClient.prototype.stop = function () {
		        if (this.timerRef) {
		            clearInterval(this.timerRef);
		            this.timerRef = undefined;
		        }
		        this.metrics.stop();
		    };
		    UnleashClient.prototype.resolveSessionId = function () {
		        return __awaiter(this, void 0, void 0, function () {
		            var sessionId;
		            return __generator(this, function (_a) {
		                switch (_a.label) {
		                    case 0:
		                        if (!this.context.sessionId) return [3 /*break*/, 1];
		                        return [2 /*return*/, this.context.sessionId];
		                    case 1: return [4 /*yield*/, this.storage.get('sessionId')];
		                    case 2:
		                        sessionId = _a.sent();
		                        if (!!sessionId) return [3 /*break*/, 4];
		                        sessionId = Math.floor(Math.random() * 1000000000);
		                        return [4 /*yield*/, this.storage.save('sessionId', sessionId)];
		                    case 3:
		                        _a.sent();
		                        _a.label = 4;
		                    case 4: return [2 /*return*/, sessionId];
		                }
		            });
		        });
		    };
		    UnleashClient.prototype.getHeaders = function () {
		        var _a;
		        var headers = (_a = {},
		            _a[this.headerName] = this.clientKey,
		            _a.Accept = 'application/json',
		            _a['Content-Type'] = 'application/json',
		            _a['If-None-Match'] = this.etag,
		            _a);
		        Object.entries(this.customHeaders)
		            .filter(util_1.notNullOrUndefined)
		            .forEach(function (_a) {
		            var name = _a[0], value = _a[1];
		            return (headers[name] = value);
		        });
		        return headers;
		    };
		    UnleashClient.prototype.storeToggles = function (toggles) {
		        return __awaiter(this, void 0, void 0, function () {
		            return __generator(this, function (_a) {
		                switch (_a.label) {
		                    case 0:
		                        this.toggles = toggles;
		                        this.emit(exports.EVENTS.UPDATE);
		                        return [4 /*yield*/, this.storage.save(storeKey, toggles)];
		                    case 1:
		                        _a.sent();
		                        return [2 /*return*/];
		                }
		            });
		        });
		    };
		    UnleashClient.prototype.fetchToggles = function () {
		        return __awaiter(this, void 0, void 0, function () {
		            var context, urlWithQuery_1, response, data, e_1;
		            return __generator(this, function (_a) {
		                switch (_a.label) {
		                    case 0:
		                        if (!this.fetch) return [3 /*break*/, 7];
		                        _a.label = 1;
		                    case 1:
		                        _a.trys.push([1, 6, , 7]);
		                        context = this.context;
		                        urlWithQuery_1 = new URL(this.url.toString());
		                        // Add context information to url search params. If the properties
		                        // object is included in the context, flatten it into the search params
		                        // e.g. /?...&property.param1=param1Value&property.param2=param2Value
		                        Object.entries(context)
		                            .filter(util_1.notNullOrUndefined)
		                            .forEach(function (_a) {
		                            var contextKey = _a[0], contextValue = _a[1];
		                            if (contextKey === 'properties' && contextValue) {
		                                Object.entries(contextValue)
		                                    .filter(util_1.notNullOrUndefined)
		                                    .forEach(function (_a) {
		                                    var propertyKey = _a[0], propertyValue = _a[1];
		                                    return urlWithQuery_1.searchParams.append("properties[".concat(propertyKey, "]"), propertyValue);
		                                });
		                            }
		                            else {
		                                urlWithQuery_1.searchParams.append(contextKey, contextValue);
		                            }
		                        });
		                        return [4 /*yield*/, this.fetch(urlWithQuery_1.toString(), {
		                                cache: 'no-cache',
		                                headers: this.getHeaders(),
		                            })];
		                    case 2:
		                        response = _a.sent();
		                        if (!(response.ok && response.status !== 304)) return [3 /*break*/, 5];
		                        this.etag = response.headers.get('ETag') || '';
		                        return [4 /*yield*/, response.json()];
		                    case 3:
		                        data = _a.sent();
		                        return [4 /*yield*/, this.storeToggles(data.toggles)];
		                    case 4:
		                        _a.sent();
		                        if (!this.bootstrap && !this.readyEventEmitted) {
		                            this.emit(exports.EVENTS.READY);
		                            this.readyEventEmitted = true;
		                        }
		                        _a.label = 5;
		                    case 5: return [3 /*break*/, 7];
		                    case 6:
		                        e_1 = _a.sent();
		                        console.error('Unleash: unable to fetch feature toggles', e_1);
		                        this.emit(exports.EVENTS.ERROR, e_1);
		                        return [3 /*break*/, 7];
		                    case 7: return [2 /*return*/];
		                }
		            });
		        });
		    };
		    return UnleashClient;
		}(tiny_emitter_1.TinyEmitter));
		exports.UnleashClient = UnleashClient;
		
	} (build));

	(()=>{var e={n:n=>{var t=n&&n.__esModule?()=>n.default:()=>n;return e.d(t,{a:t}),t},d:(n,t)=>{for(var r in t)e.o(t,r)&&!e.o(n,r)&&Object.defineProperty(n,r,{enumerable:!0,get:t[r]});},o:(e,n)=>Object.prototype.hasOwnProperty.call(e,n),r:e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0});}},n={};e.r(n),e.d(n,{FlagContext:()=>o,FlagProvider:()=>u,InMemoryStorageProvider:()=>t.InMemoryStorageProvider,LocalStorageProvider:()=>t.LocalStorageProvider,UnleashClient:()=>t.UnleashClient,default:()=>f,useFlag:()=>a,useFlagsStatus:()=>i,useUnleashClient:()=>s,useUnleashContext:()=>l,useVariant:()=>c});const t=build,r=reactExports,o=e.n(r)().createContext(null);const u=function(e){var n=e.config,u=e.children,a=e.unleashClient,i=e.startClient,c=void 0===i||i,l=r.useRef(a),s=r.useState(!1),f=s[0],d=s[1],v=r.useState(null),y=v[0],g=v[1];n||a||console.warn("You must provide either a config or an unleash client to the flag provider. If you are initializing the client in useEffect, you can avoid this warning by\n      checking if the client exists before rendering."),l.current||(l.current=new t.UnleashClient(n)),l.current.on("ready",(function(){d(!0);})),l.current.on("error",(function(e){g(e);})),r.useEffect((function(){(c||!a)&&l.current.start();}),[]);var h=function(e){return n=void 0,t=void 0,o=function(){return function(e,n){var t,r,o,u,a={label:0,sent:function(){if(1&o[0])throw o[1];return o[1]},trys:[],ops:[]};return u={next:i(0),throw:i(1),return:i(2)},"function"==typeof Symbol&&(u[Symbol.iterator]=function(){return this}),u;function i(u){return function(i){return function(u){if(t)throw new TypeError("Generator is already executing.");for(;a;)try{if(t=1,r&&(o=2&u[0]?r.return:u[0]?r.throw||((o=r.return)&&o.call(r),0):r.next)&&!(o=o.call(r,u[1])).done)return o;switch(r=0,o&&(u=[2&u[0],o.value]),u[0]){case 0:case 1:o=u;break;case 4:return a.label++,{value:u[1],done:!1};case 5:a.label++,r=u[1],u=[0];continue;case 7:u=a.ops.pop(),a.trys.pop();continue;default:if(!((o=(o=a.trys).length>0&&o[o.length-1])||6!==u[0]&&2!==u[0])){a=0;continue}if(3===u[0]&&(!o||u[1]>o[0]&&u[1]<o[3])){a.label=u[1];break}if(6===u[0]&&a.label<o[1]){a.label=o[1],o=u;break}if(o&&a.label<o[2]){a.label=o[2],a.ops.push(u);break}o[2]&&a.ops.pop(),a.trys.pop();continue}u=n.call(e,a);}catch(e){u=[6,e],r=0;}finally{t=o=0;}if(5&u[0])throw u[1];return {value:u[0]?u[1]:void 0,done:!0}}([u,i])}}}(this,(function(n){switch(n.label){case 0:return [4,l.current.updateContext(e)];case 1:return n.sent(),[2]}}))},new((r=void 0)||(r=Promise))((function(e,u){function a(e){try{c(o.next(e));}catch(e){u(e);}}function i(e){try{c(o.throw(e));}catch(e){u(e);}}function c(n){var t;n.done?e(n.value):(t=n.value,t instanceof r?t:new r((function(e){e(t);}))).then(a,i);}c((o=o.apply(n,t||[])).next());}));var n,t,r,o;},p=function(e){return l.current.isEnabled(e)},b=function(e){return l.current.getVariant(e)},x=function(e,n,t){return l.current.on(e,n,t)},C=r.useMemo((function(){return {on:x,updateContext:h,isEnabled:p,getVariant:b,client:l.current,flagsReady:f,flagsError:y,setFlagsReady:d,setFlagsError:g}}),[f,y]);return r.createElement(o.Provider,{value:C},u)},a=function(e){var n=(0, r.useContext)(o),t=n.isEnabled,u=n.client,a=(0, r.useState)(!!t(e)),i=a[0],c=a[1],l=(0, r.useRef)();return l.current=i,(0, r.useEffect)((function(){u&&(u.on("update",(function(){var n=t(e);n!==l.current&&(l.current=n,c(!!n));})),u.on("ready",(function(){var n=t(e);c(n);})));}),[u]),i},i=function(){var e=(0, r.useContext)(o);return {flagsReady:e.flagsReady,flagsError:e.flagsError}},c=function(e){var n=(0, r.useContext)(o),t=n.getVariant,u=n.client,a=(0, r.useState)(t(e)),i=a[0],c=a[1],l=(0, r.useRef)();return l.current=i,(0, r.useEffect)((function(){u&&(u.on("update",(function(){var n=t(e);l.current.name===n.name&&l.current.enabled===n.enabled||(c(n),l.current=n);})),u.on("ready",(function(){var n=t(e);c(n);})));}),[u]),i||{}},l=function(){return (0, r.useContext)(o).updateContext},s=function(){return (0, r.useContext)(o).client},f=u;index_browser.exports=n;})();

	var index_browserExports = index_browser.exports;
	var FlagsProvider = /*@__PURE__*/getDefaultExportFromCjs(index_browserExports);

	/* global Map:readonly, Set:readonly, ArrayBuffer:readonly */

	var hasElementType = typeof Element !== 'undefined';
	var hasMap = typeof Map === 'function';
	var hasSet = typeof Set === 'function';
	var hasArrayBuffer = typeof ArrayBuffer === 'function' && !!ArrayBuffer.isView;

	// Note: We **don't** need `envHasBigInt64Array` in fde es6/index.js

	function equal$1(a, b) {
	  // START: fast-deep-equal es6/index.js 3.1.3
	  if (a === b) return true;

	  if (a && b && typeof a == 'object' && typeof b == 'object') {
	    if (a.constructor !== b.constructor) return false;

	    var length, i, keys;
	    if (Array.isArray(a)) {
	      length = a.length;
	      if (length != b.length) return false;
	      for (i = length; i-- !== 0;)
	        if (!equal$1(a[i], b[i])) return false;
	      return true;
	    }

	    // START: Modifications:
	    // 1. Extra `has<Type> &&` helpers in initial condition allow es6 code
	    //    to co-exist with es5.
	    // 2. Replace `for of` with es5 compliant iteration using `for`.
	    //    Basically, take:
	    //
	    //    ```js
	    //    for (i of a.entries())
	    //      if (!b.has(i[0])) return false;
	    //    ```
	    //
	    //    ... and convert to:
	    //
	    //    ```js
	    //    it = a.entries();
	    //    while (!(i = it.next()).done)
	    //      if (!b.has(i.value[0])) return false;
	    //    ```
	    //
	    //    **Note**: `i` access switches to `i.value`.
	    var it;
	    if (hasMap && (a instanceof Map) && (b instanceof Map)) {
	      if (a.size !== b.size) return false;
	      it = a.entries();
	      while (!(i = it.next()).done)
	        if (!b.has(i.value[0])) return false;
	      it = a.entries();
	      while (!(i = it.next()).done)
	        if (!equal$1(i.value[1], b.get(i.value[0]))) return false;
	      return true;
	    }

	    if (hasSet && (a instanceof Set) && (b instanceof Set)) {
	      if (a.size !== b.size) return false;
	      it = a.entries();
	      while (!(i = it.next()).done)
	        if (!b.has(i.value[0])) return false;
	      return true;
	    }
	    // END: Modifications

	    if (hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
	      length = a.length;
	      if (length != b.length) return false;
	      for (i = length; i-- !== 0;)
	        if (a[i] !== b[i]) return false;
	      return true;
	    }

	    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
	    // START: Modifications:
	    // Apply guards for `Object.create(null)` handling. See:
	    // - https://github.com/FormidableLabs/react-fast-compare/issues/64
	    // - https://github.com/epoberezkin/fast-deep-equal/issues/49
	    if (a.valueOf !== Object.prototype.valueOf && typeof a.valueOf === 'function' && typeof b.valueOf === 'function') return a.valueOf() === b.valueOf();
	    if (a.toString !== Object.prototype.toString && typeof a.toString === 'function' && typeof b.toString === 'function') return a.toString() === b.toString();
	    // END: Modifications

	    keys = Object.keys(a);
	    length = keys.length;
	    if (length !== Object.keys(b).length) return false;

	    for (i = length; i-- !== 0;)
	      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
	    // END: fast-deep-equal

	    // START: react-fast-compare
	    // custom handling for DOM elements
	    if (hasElementType && a instanceof Element) return false;

	    // custom handling for React/Preact
	    for (i = length; i-- !== 0;) {
	      if ((keys[i] === '_owner' || keys[i] === '__v' || keys[i] === '__o') && a.$$typeof) {
	        // React-specific: avoid traversing React elements' _owner
	        // Preact-specific: avoid traversing Preact elements' __v and __o
	        //    __v = $_original / $_vnode
	        //    __o = $_owner
	        // These properties contain circular references and are not needed when
	        // comparing the actual elements (and not their owners)
	        // .$$typeof and ._store on just reasonable markers of elements

	        continue;
	      }

	      // all other properties should be traversed as usual
	      if (!equal$1(a[keys[i]], b[keys[i]])) return false;
	    }
	    // END: react-fast-compare

	    // START: fast-deep-equal
	    return true;
	  }

	  return a !== a && b !== b;
	}
	// end fast-deep-equal

	var reactFastCompare = function isEqual(a, b) {
	  try {
	    return equal$1(a, b);
	  } catch (error) {
	    if (((error.message || '').match(/stack|recursion/i))) {
	      // warn on circular references, don't crash
	      // browsers give this different errors name and messages:
	      // chrome/safari: "RangeError", "Maximum call stack size exceeded"
	      // firefox: "InternalError", too much recursion"
	      // edge: "Error", "Out of stack space"
	      console.warn('react-fast-compare cannot handle circular refs');
	      return false;
	    }
	    // some other error. we should definitely know about these
	    throw error;
	  }
	};

	var fastCompare = /*@__PURE__*/getDefaultExportFromCjs(reactFastCompare);

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */

	/**
	 * Use invariant() to assert state which your program assumes to be true.
	 *
	 * Provide sprintf-style format (only %s is supported) and arguments
	 * to provide information about what broke and what you were
	 * expecting.
	 *
	 * The invariant message will be stripped in production, but the invariant
	 * will remain to ensure logic does not differ in production.
	 */

	var invariant$2 = function(condition, format, a, b, c, d, e, f) {

	  if (!condition) {
	    var error;
	    if (format === undefined) {
	      error = new Error(
	        'Minified exception occurred; use the non-minified dev environment ' +
	        'for the full error message and additional helpful warnings.'
	      );
	    } else {
	      var args = [a, b, c, d, e, f];
	      var argIndex = 0;
	      error = new Error(
	        format.replace(/%s/g, function() { return args[argIndex++]; })
	      );
	      error.name = 'Invariant Violation';
	    }

	    error.framesToPop = 1; // we don't care about invariant's own frame
	    throw error;
	  }
	};

	var browser = invariant$2;

	var invariant$3 = /*@__PURE__*/getDefaultExportFromCjs(browser);

	//

	var shallowequal = function shallowEqual(objA, objB, compare, compareContext) {
	  var ret = compare ? compare.call(compareContext, objA, objB) : void 0;

	  if (ret !== void 0) {
	    return !!ret;
	  }

	  if (objA === objB) {
	    return true;
	  }

	  if (typeof objA !== "object" || !objA || typeof objB !== "object" || !objB) {
	    return false;
	  }

	  var keysA = Object.keys(objA);
	  var keysB = Object.keys(objB);

	  if (keysA.length !== keysB.length) {
	    return false;
	  }

	  var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);

	  // Test for A's keys different from B.
	  for (var idx = 0; idx < keysA.length; idx++) {
	    var key = keysA[idx];

	    if (!bHasOwnProperty(key)) {
	      return false;
	    }

	    var valueA = objA[key];
	    var valueB = objB[key];

	    ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;

	    if (ret === false || (ret === void 0 && valueA !== valueB)) {
	      return false;
	    }
	  }

	  return true;
	};

	var shallowEqual$1 = /*@__PURE__*/getDefaultExportFromCjs(shallowequal);

	// src/index.tsx

	// src/constants.ts
	var TAG_NAMES = /* @__PURE__ */ ((TAG_NAMES2) => {
	  TAG_NAMES2["BASE"] = "base";
	  TAG_NAMES2["BODY"] = "body";
	  TAG_NAMES2["HEAD"] = "head";
	  TAG_NAMES2["HTML"] = "html";
	  TAG_NAMES2["LINK"] = "link";
	  TAG_NAMES2["META"] = "meta";
	  TAG_NAMES2["NOSCRIPT"] = "noscript";
	  TAG_NAMES2["SCRIPT"] = "script";
	  TAG_NAMES2["STYLE"] = "style";
	  TAG_NAMES2["TITLE"] = "title";
	  TAG_NAMES2["FRAGMENT"] = "Symbol(react.fragment)";
	  return TAG_NAMES2;
	})(TAG_NAMES || {});
	var SEO_PRIORITY_TAGS = {
	  link: { rel: ["amphtml", "canonical", "alternate"] },
	  script: { type: ["application/ld+json"] },
	  meta: {
	    charset: "",
	    name: ["generator", "robots", "description"],
	    property: [
	      "og:type",
	      "og:title",
	      "og:url",
	      "og:image",
	      "og:image:alt",
	      "og:description",
	      "twitter:url",
	      "twitter:title",
	      "twitter:description",
	      "twitter:image",
	      "twitter:image:alt",
	      "twitter:card",
	      "twitter:site"
	    ]
	  }
	};
	var VALID_TAG_NAMES = Object.values(TAG_NAMES);
	var REACT_TAG_MAP = {
	  accesskey: "accessKey",
	  charset: "charSet",
	  class: "className",
	  contenteditable: "contentEditable",
	  contextmenu: "contextMenu",
	  "http-equiv": "httpEquiv",
	  itemprop: "itemProp",
	  tabindex: "tabIndex"
	};
	var HTML_TAG_MAP = Object.entries(REACT_TAG_MAP).reduce(
	  (carry, [key, value]) => {
	    carry[value] = key;
	    return carry;
	  },
	  {}
	);
	var HELMET_ATTRIBUTE = "data-rh";

	// src/utils.ts
	var HELMET_PROPS = {
	  DEFAULT_TITLE: "defaultTitle",
	  DEFER: "defer",
	  ENCODE_SPECIAL_CHARACTERS: "encodeSpecialCharacters",
	  ON_CHANGE_CLIENT_STATE: "onChangeClientState",
	  TITLE_TEMPLATE: "titleTemplate",
	  PRIORITIZE_SEO_TAGS: "prioritizeSeoTags"
	};
	var getInnermostProperty = (propsList, property) => {
	  for (let i = propsList.length - 1; i >= 0; i -= 1) {
	    const props = propsList[i];
	    if (Object.prototype.hasOwnProperty.call(props, property)) {
	      return props[property];
	    }
	  }
	  return null;
	};
	var getTitleFromPropsList = (propsList) => {
	  let innermostTitle = getInnermostProperty(propsList, "title" /* TITLE */);
	  const innermostTemplate = getInnermostProperty(propsList, HELMET_PROPS.TITLE_TEMPLATE);
	  if (Array.isArray(innermostTitle)) {
	    innermostTitle = innermostTitle.join("");
	  }
	  if (innermostTemplate && innermostTitle) {
	    return innermostTemplate.replace(/%s/g, () => innermostTitle);
	  }
	  const innermostDefaultTitle = getInnermostProperty(propsList, HELMET_PROPS.DEFAULT_TITLE);
	  return innermostTitle || innermostDefaultTitle || void 0;
	};
	var getOnChangeClientState = (propsList) => getInnermostProperty(propsList, HELMET_PROPS.ON_CHANGE_CLIENT_STATE) || (() => {
	});
	var getAttributesFromPropsList = (tagType, propsList) => propsList.filter((props) => typeof props[tagType] !== "undefined").map((props) => props[tagType]).reduce((tagAttrs, current) => ({ ...tagAttrs, ...current }), {});
	var getBaseTagFromPropsList = (primaryAttributes, propsList) => propsList.filter((props) => typeof props["base" /* BASE */] !== "undefined").map((props) => props["base" /* BASE */]).reverse().reduce((innermostBaseTag, tag) => {
	  if (!innermostBaseTag.length) {
	    const keys = Object.keys(tag);
	    for (let i = 0; i < keys.length; i += 1) {
	      const attributeKey = keys[i];
	      const lowerCaseAttributeKey = attributeKey.toLowerCase();
	      if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && tag[lowerCaseAttributeKey]) {
	        return innermostBaseTag.concat(tag);
	      }
	    }
	  }
	  return innermostBaseTag;
	}, []);
	var warn$2 = (msg) => console && typeof console.warn === "function" && console.warn(msg);
	var getTagsFromPropsList = (tagName, primaryAttributes, propsList) => {
	  const approvedSeenTags = {};
	  return propsList.filter((props) => {
	    if (Array.isArray(props[tagName])) {
	      return true;
	    }
	    if (typeof props[tagName] !== "undefined") {
	      warn$2(
	        `Helmet: ${tagName} should be of type "Array". Instead found type "${typeof props[tagName]}"`
	      );
	    }
	    return false;
	  }).map((props) => props[tagName]).reverse().reduce((approvedTags, instanceTags) => {
	    const instanceSeenTags = {};
	    instanceTags.filter((tag) => {
	      let primaryAttributeKey;
	      const keys2 = Object.keys(tag);
	      for (let i = 0; i < keys2.length; i += 1) {
	        const attributeKey = keys2[i];
	        const lowerCaseAttributeKey = attributeKey.toLowerCase();
	        if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && !(primaryAttributeKey === "rel" /* REL */ && tag[primaryAttributeKey].toLowerCase() === "canonical") && !(lowerCaseAttributeKey === "rel" /* REL */ && tag[lowerCaseAttributeKey].toLowerCase() === "stylesheet")) {
	          primaryAttributeKey = lowerCaseAttributeKey;
	        }
	        if (primaryAttributes.indexOf(attributeKey) !== -1 && (attributeKey === "innerHTML" /* INNER_HTML */ || attributeKey === "cssText" /* CSS_TEXT */ || attributeKey === "itemprop" /* ITEM_PROP */)) {
	          primaryAttributeKey = attributeKey;
	        }
	      }
	      if (!primaryAttributeKey || !tag[primaryAttributeKey]) {
	        return false;
	      }
	      const value = tag[primaryAttributeKey].toLowerCase();
	      if (!approvedSeenTags[primaryAttributeKey]) {
	        approvedSeenTags[primaryAttributeKey] = {};
	      }
	      if (!instanceSeenTags[primaryAttributeKey]) {
	        instanceSeenTags[primaryAttributeKey] = {};
	      }
	      if (!approvedSeenTags[primaryAttributeKey][value]) {
	        instanceSeenTags[primaryAttributeKey][value] = true;
	        return true;
	      }
	      return false;
	    }).reverse().forEach((tag) => approvedTags.push(tag));
	    const keys = Object.keys(instanceSeenTags);
	    for (let i = 0; i < keys.length; i += 1) {
	      const attributeKey = keys[i];
	      const tagUnion = {
	        ...approvedSeenTags[attributeKey],
	        ...instanceSeenTags[attributeKey]
	      };
	      approvedSeenTags[attributeKey] = tagUnion;
	    }
	    return approvedTags;
	  }, []).reverse();
	};
	var getAnyTrueFromPropsList = (propsList, checkedTag) => {
	  if (Array.isArray(propsList) && propsList.length) {
	    for (let index = 0; index < propsList.length; index += 1) {
	      const prop = propsList[index];
	      if (prop[checkedTag]) {
	        return true;
	      }
	    }
	  }
	  return false;
	};
	var reducePropsToState = (propsList) => ({
	  baseTag: getBaseTagFromPropsList(["href" /* HREF */], propsList),
	  bodyAttributes: getAttributesFromPropsList("bodyAttributes" /* BODY */, propsList),
	  defer: getInnermostProperty(propsList, HELMET_PROPS.DEFER),
	  encode: getInnermostProperty(propsList, HELMET_PROPS.ENCODE_SPECIAL_CHARACTERS),
	  htmlAttributes: getAttributesFromPropsList("htmlAttributes" /* HTML */, propsList),
	  linkTags: getTagsFromPropsList(
	    "link" /* LINK */,
	    ["rel" /* REL */, "href" /* HREF */],
	    propsList
	  ),
	  metaTags: getTagsFromPropsList(
	    "meta" /* META */,
	    [
	      "name" /* NAME */,
	      "charset" /* CHARSET */,
	      "http-equiv" /* HTTPEQUIV */,
	      "property" /* PROPERTY */,
	      "itemprop" /* ITEM_PROP */
	    ],
	    propsList
	  ),
	  noscriptTags: getTagsFromPropsList("noscript" /* NOSCRIPT */, ["innerHTML" /* INNER_HTML */], propsList),
	  onChangeClientState: getOnChangeClientState(propsList),
	  scriptTags: getTagsFromPropsList(
	    "script" /* SCRIPT */,
	    ["src" /* SRC */, "innerHTML" /* INNER_HTML */],
	    propsList
	  ),
	  styleTags: getTagsFromPropsList("style" /* STYLE */, ["cssText" /* CSS_TEXT */], propsList),
	  title: getTitleFromPropsList(propsList),
	  titleAttributes: getAttributesFromPropsList("titleAttributes" /* TITLE */, propsList),
	  prioritizeSeoTags: getAnyTrueFromPropsList(propsList, HELMET_PROPS.PRIORITIZE_SEO_TAGS)
	});
	var flattenArray = (possibleArray) => Array.isArray(possibleArray) ? possibleArray.join("") : possibleArray;
	var checkIfPropsMatch = (props, toMatch) => {
	  const keys = Object.keys(props);
	  for (let i = 0; i < keys.length; i += 1) {
	    if (toMatch[keys[i]] && toMatch[keys[i]].includes(props[keys[i]])) {
	      return true;
	    }
	  }
	  return false;
	};
	var prioritizer = (elementsList, propsToMatch) => {
	  if (Array.isArray(elementsList)) {
	    return elementsList.reduce(
	      (acc, elementAttrs) => {
	        if (checkIfPropsMatch(elementAttrs, propsToMatch)) {
	          acc.priority.push(elementAttrs);
	        } else {
	          acc.default.push(elementAttrs);
	        }
	        return acc;
	      },
	      { priority: [], default: [] }
	    );
	  }
	  return { default: elementsList, priority: [] };
	};
	var without$2 = (obj, key) => {
	  return {
	    ...obj,
	    [key]: void 0
	  };
	};

	// src/server.ts
	var SELF_CLOSING_TAGS = ["noscript" /* NOSCRIPT */, "script" /* SCRIPT */, "style" /* STYLE */];
	var encodeSpecialCharacters = (str, encode = true) => {
	  if (encode === false) {
	    return String(str);
	  }
	  return String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
	};
	var generateElementAttributesAsString = (attributes) => Object.keys(attributes).reduce((str, key) => {
	  const attr = typeof attributes[key] !== "undefined" ? `${key}="${attributes[key]}"` : `${key}`;
	  return str ? `${str} ${attr}` : attr;
	}, "");
	var generateTitleAsString = (type, title, attributes, encode) => {
	  const attributeString = generateElementAttributesAsString(attributes);
	  const flattenedTitle = flattenArray(title);
	  return attributeString ? `<${type} ${HELMET_ATTRIBUTE}="true" ${attributeString}>${encodeSpecialCharacters(
    flattenedTitle,
    encode
  )}</${type}>` : `<${type} ${HELMET_ATTRIBUTE}="true">${encodeSpecialCharacters(
    flattenedTitle,
    encode
  )}</${type}>`;
	};
	var generateTagsAsString = (type, tags, encode = true) => tags.reduce((str, t) => {
	  const tag = t;
	  const attributeHtml = Object.keys(tag).filter(
	    (attribute) => !(attribute === "innerHTML" /* INNER_HTML */ || attribute === "cssText" /* CSS_TEXT */)
	  ).reduce((string, attribute) => {
	    const attr = typeof tag[attribute] === "undefined" ? attribute : `${attribute}="${encodeSpecialCharacters(tag[attribute], encode)}"`;
	    return string ? `${string} ${attr}` : attr;
	  }, "");
	  const tagContent = tag.innerHTML || tag.cssText || "";
	  const isSelfClosing = SELF_CLOSING_TAGS.indexOf(type) === -1;
	  return `${str}<${type} ${HELMET_ATTRIBUTE}="true" ${attributeHtml}${isSelfClosing ? `/>` : `>${tagContent}</${type}>`}`;
	}, "");
	var convertElementAttributesToReactProps = (attributes, initProps = {}) => Object.keys(attributes).reduce((obj, key) => {
	  const mapped = REACT_TAG_MAP[key];
	  obj[mapped || key] = attributes[key];
	  return obj;
	}, initProps);
	var generateTitleAsReactComponent = (_type, title, attributes) => {
	  const initProps = {
	    key: title,
	    [HELMET_ATTRIBUTE]: true
	  };
	  const props = convertElementAttributesToReactProps(attributes, initProps);
	  return [React$2.createElement("title" /* TITLE */, props, title)];
	};
	var generateTagsAsReactComponent = (type, tags) => tags.map((tag, i) => {
	  const mappedTag = {
	    key: i,
	    [HELMET_ATTRIBUTE]: true
	  };
	  Object.keys(tag).forEach((attribute) => {
	    const mapped = REACT_TAG_MAP[attribute];
	    const mappedAttribute = mapped || attribute;
	    if (mappedAttribute === "innerHTML" /* INNER_HTML */ || mappedAttribute === "cssText" /* CSS_TEXT */) {
	      const content = tag.innerHTML || tag.cssText;
	      mappedTag.dangerouslySetInnerHTML = { __html: content };
	    } else {
	      mappedTag[mappedAttribute] = tag[attribute];
	    }
	  });
	  return React$2.createElement(type, mappedTag);
	});
	var getMethodsForTag = (type, tags, encode = true) => {
	  switch (type) {
	    case "title" /* TITLE */:
	      return {
	        toComponent: () => generateTitleAsReactComponent(type, tags.title, tags.titleAttributes),
	        toString: () => generateTitleAsString(type, tags.title, tags.titleAttributes, encode)
	      };
	    case "bodyAttributes" /* BODY */:
	    case "htmlAttributes" /* HTML */:
	      return {
	        toComponent: () => convertElementAttributesToReactProps(tags),
	        toString: () => generateElementAttributesAsString(tags)
	      };
	    default:
	      return {
	        toComponent: () => generateTagsAsReactComponent(type, tags),
	        toString: () => generateTagsAsString(type, tags, encode)
	      };
	  }
	};
	var getPriorityMethods = ({ metaTags, linkTags, scriptTags, encode }) => {
	  const meta = prioritizer(metaTags, SEO_PRIORITY_TAGS.meta);
	  const link = prioritizer(linkTags, SEO_PRIORITY_TAGS.link);
	  const script = prioritizer(scriptTags, SEO_PRIORITY_TAGS.script);
	  const priorityMethods = {
	    toComponent: () => [
	      ...generateTagsAsReactComponent("meta" /* META */, meta.priority),
	      ...generateTagsAsReactComponent("link" /* LINK */, link.priority),
	      ...generateTagsAsReactComponent("script" /* SCRIPT */, script.priority)
	    ],
	    toString: () => (
	      // generate all the tags as strings and concatenate them
	      `${getMethodsForTag("meta" /* META */, meta.priority, encode)} ${getMethodsForTag(
        "link" /* LINK */,
        link.priority,
        encode
      )} ${getMethodsForTag("script" /* SCRIPT */, script.priority, encode)}`
	    )
	  };
	  return {
	    priorityMethods,
	    metaTags: meta.default,
	    linkTags: link.default,
	    scriptTags: script.default
	  };
	};
	var mapStateOnServer = (props) => {
	  const {
	    baseTag,
	    bodyAttributes,
	    encode = true,
	    htmlAttributes,
	    noscriptTags,
	    styleTags,
	    title = "",
	    titleAttributes,
	    prioritizeSeoTags
	  } = props;
	  let { linkTags, metaTags, scriptTags } = props;
	  let priorityMethods = {
	    toComponent: () => {
	    },
	    toString: () => ""
	  };
	  if (prioritizeSeoTags) {
	    ({ priorityMethods, linkTags, metaTags, scriptTags } = getPriorityMethods(props));
	  }
	  return {
	    priority: priorityMethods,
	    base: getMethodsForTag("base" /* BASE */, baseTag, encode),
	    bodyAttributes: getMethodsForTag("bodyAttributes" /* BODY */, bodyAttributes, encode),
	    htmlAttributes: getMethodsForTag("htmlAttributes" /* HTML */, htmlAttributes, encode),
	    link: getMethodsForTag("link" /* LINK */, linkTags, encode),
	    meta: getMethodsForTag("meta" /* META */, metaTags, encode),
	    noscript: getMethodsForTag("noscript" /* NOSCRIPT */, noscriptTags, encode),
	    script: getMethodsForTag("script" /* SCRIPT */, scriptTags, encode),
	    style: getMethodsForTag("style" /* STYLE */, styleTags, encode),
	    title: getMethodsForTag("title" /* TITLE */, { title, titleAttributes }, encode)
	  };
	};
	var server_default = mapStateOnServer;

	// src/HelmetData.ts
	var instances = [];
	var isDocument$1 = !!(typeof window !== "undefined" && window.document && window.document.createElement);
	var HelmetData = class {
	  instances = [];
	  canUseDOM = isDocument$1;
	  context;
	  value = {
	    setHelmet: (serverState) => {
	      this.context.helmet = serverState;
	    },
	    helmetInstances: {
	      get: () => this.canUseDOM ? instances : this.instances,
	      add: (instance) => {
	        (this.canUseDOM ? instances : this.instances).push(instance);
	      },
	      remove: (instance) => {
	        const index = (this.canUseDOM ? instances : this.instances).indexOf(instance);
	        (this.canUseDOM ? instances : this.instances).splice(index, 1);
	      }
	    }
	  };
	  constructor(context, canUseDOM) {
	    this.context = context;
	    this.canUseDOM = canUseDOM || false;
	    if (!canUseDOM) {
	      context.helmet = server_default({
	        baseTag: [],
	        bodyAttributes: {},
	        encodeSpecialCharacters: true,
	        htmlAttributes: {},
	        linkTags: [],
	        metaTags: [],
	        noscriptTags: [],
	        scriptTags: [],
	        styleTags: [],
	        title: "",
	        titleAttributes: {}
	      });
	    }
	  }
	};

	// src/Provider.tsx
	var defaultValue = {};
	var Context = React$2.createContext(defaultValue);
	var HelmetProvider = class _HelmetProvider extends reactExports.Component {
	  static canUseDOM = isDocument$1;
	  helmetData;
	  constructor(props) {
	    super(props);
	    this.helmetData = new HelmetData(this.props.context || {}, _HelmetProvider.canUseDOM);
	  }
	  render() {
	    return /* @__PURE__ */ React$2.createElement(Context.Provider, { value: this.helmetData.value }, this.props.children);
	  }
	};

	// src/client.ts
	var updateTags = (type, tags) => {
	  const headElement = document.head || document.querySelector("head" /* HEAD */);
	  const tagNodes = headElement.querySelectorAll(`${type}[${HELMET_ATTRIBUTE}]`);
	  const oldTags = [].slice.call(tagNodes);
	  const newTags = [];
	  let indexToDelete;
	  if (tags && tags.length) {
	    tags.forEach((tag) => {
	      const newElement = document.createElement(type);
	      for (const attribute in tag) {
	        if (Object.prototype.hasOwnProperty.call(tag, attribute)) {
	          if (attribute === "innerHTML" /* INNER_HTML */) {
	            newElement.innerHTML = tag.innerHTML;
	          } else if (attribute === "cssText" /* CSS_TEXT */) {
	            if (newElement.styleSheet) {
	              newElement.styleSheet.cssText = tag.cssText;
	            } else {
	              newElement.appendChild(document.createTextNode(tag.cssText));
	            }
	          } else {
	            const attr = attribute;
	            const value = typeof tag[attr] === "undefined" ? "" : tag[attr];
	            newElement.setAttribute(attribute, value);
	          }
	        }
	      }
	      newElement.setAttribute(HELMET_ATTRIBUTE, "true");
	      if (oldTags.some((existingTag, index) => {
	        indexToDelete = index;
	        return newElement.isEqualNode(existingTag);
	      })) {
	        oldTags.splice(indexToDelete, 1);
	      } else {
	        newTags.push(newElement);
	      }
	    });
	  }
	  oldTags.forEach((tag) => tag.parentNode?.removeChild(tag));
	  newTags.forEach((tag) => headElement.appendChild(tag));
	  return {
	    oldTags,
	    newTags
	  };
	};
	var updateAttributes = (tagName, attributes) => {
	  const elementTag = document.getElementsByTagName(tagName)[0];
	  if (!elementTag) {
	    return;
	  }
	  const helmetAttributeString = elementTag.getAttribute(HELMET_ATTRIBUTE);
	  const helmetAttributes = helmetAttributeString ? helmetAttributeString.split(",") : [];
	  const attributesToRemove = [...helmetAttributes];
	  const attributeKeys = Object.keys(attributes);
	  for (const attribute of attributeKeys) {
	    const value = attributes[attribute] || "";
	    if (elementTag.getAttribute(attribute) !== value) {
	      elementTag.setAttribute(attribute, value);
	    }
	    if (helmetAttributes.indexOf(attribute) === -1) {
	      helmetAttributes.push(attribute);
	    }
	    const indexToSave = attributesToRemove.indexOf(attribute);
	    if (indexToSave !== -1) {
	      attributesToRemove.splice(indexToSave, 1);
	    }
	  }
	  for (let i = attributesToRemove.length - 1; i >= 0; i -= 1) {
	    elementTag.removeAttribute(attributesToRemove[i]);
	  }
	  if (helmetAttributes.length === attributesToRemove.length) {
	    elementTag.removeAttribute(HELMET_ATTRIBUTE);
	  } else if (elementTag.getAttribute(HELMET_ATTRIBUTE) !== attributeKeys.join(",")) {
	    elementTag.setAttribute(HELMET_ATTRIBUTE, attributeKeys.join(","));
	  }
	};
	var updateTitle = (title, attributes) => {
	  if (typeof title !== "undefined" && document.title !== title) {
	    document.title = flattenArray(title);
	  }
	  updateAttributes("title" /* TITLE */, attributes);
	};
	var commitTagChanges = (newState, cb) => {
	  const {
	    baseTag,
	    bodyAttributes,
	    htmlAttributes,
	    linkTags,
	    metaTags,
	    noscriptTags,
	    onChangeClientState,
	    scriptTags,
	    styleTags,
	    title,
	    titleAttributes
	  } = newState;
	  updateAttributes("body" /* BODY */, bodyAttributes);
	  updateAttributes("html" /* HTML */, htmlAttributes);
	  updateTitle(title, titleAttributes);
	  const tagUpdates = {
	    baseTag: updateTags("base" /* BASE */, baseTag),
	    linkTags: updateTags("link" /* LINK */, linkTags),
	    metaTags: updateTags("meta" /* META */, metaTags),
	    noscriptTags: updateTags("noscript" /* NOSCRIPT */, noscriptTags),
	    scriptTags: updateTags("script" /* SCRIPT */, scriptTags),
	    styleTags: updateTags("style" /* STYLE */, styleTags)
	  };
	  const addedTags = {};
	  const removedTags = {};
	  Object.keys(tagUpdates).forEach((tagType) => {
	    const { newTags, oldTags } = tagUpdates[tagType];
	    if (newTags.length) {
	      addedTags[tagType] = newTags;
	    }
	    if (oldTags.length) {
	      removedTags[tagType] = tagUpdates[tagType].oldTags;
	    }
	  });
	  if (cb) {
	    cb();
	  }
	  onChangeClientState(newState, addedTags, removedTags);
	};
	var _helmetCallback = null;
	var handleStateChangeOnClient = (newState) => {
	  if (_helmetCallback) {
	    cancelAnimationFrame(_helmetCallback);
	  }
	  if (newState.defer) {
	    _helmetCallback = requestAnimationFrame(() => {
	      commitTagChanges(newState, () => {
	        _helmetCallback = null;
	      });
	    });
	  } else {
	    commitTagChanges(newState);
	    _helmetCallback = null;
	  }
	};
	var client_default = handleStateChangeOnClient;

	// src/Dispatcher.tsx
	var HelmetDispatcher = class extends reactExports.Component {
	  rendered = false;
	  shouldComponentUpdate(nextProps) {
	    return !shallowEqual$1(nextProps, this.props);
	  }
	  componentDidUpdate() {
	    this.emitChange();
	  }
	  componentWillUnmount() {
	    const { helmetInstances } = this.props.context;
	    helmetInstances.remove(this);
	    this.emitChange();
	  }
	  emitChange() {
	    const { helmetInstances, setHelmet } = this.props.context;
	    let serverState = null;
	    const state = reducePropsToState(
	      helmetInstances.get().map((instance) => {
	        const props = { ...instance.props };
	        delete props.context;
	        return props;
	      })
	    );
	    if (HelmetProvider.canUseDOM) {
	      client_default(state);
	    } else if (server_default) {
	      serverState = server_default(state);
	    }
	    setHelmet(serverState);
	  }
	  // componentWillMount will be deprecated
	  // for SSR, initialize on first render
	  // constructor is also unsafe in StrictMode
	  init() {
	    if (this.rendered) {
	      return;
	    }
	    this.rendered = true;
	    const { helmetInstances } = this.props.context;
	    helmetInstances.add(this);
	    this.emitChange();
	  }
	  render() {
	    this.init();
	    return null;
	  }
	};

	// src/index.tsx
	var Helmet = class extends reactExports.Component {
	  static defaultProps = {
	    defer: true,
	    encodeSpecialCharacters: true,
	    prioritizeSeoTags: false
	  };
	  shouldComponentUpdate(nextProps) {
	    return !fastCompare(without$2(this.props, "helmetData"), without$2(nextProps, "helmetData"));
	  }
	  mapNestedChildrenToProps(child, nestedChildren) {
	    if (!nestedChildren) {
	      return null;
	    }
	    switch (child.type) {
	      case "script" /* SCRIPT */:
	      case "noscript" /* NOSCRIPT */:
	        return {
	          innerHTML: nestedChildren
	        };
	      case "style" /* STYLE */:
	        return {
	          cssText: nestedChildren
	        };
	      default:
	        throw new Error(
	          `<${child.type} /> elements are self-closing and can not contain children. Refer to our API for more information.`
	        );
	    }
	  }
	  flattenArrayTypeChildren(child, arrayTypeChildren, newChildProps, nestedChildren) {
	    return {
	      ...arrayTypeChildren,
	      [child.type]: [
	        ...arrayTypeChildren[child.type] || [],
	        {
	          ...newChildProps,
	          ...this.mapNestedChildrenToProps(child, nestedChildren)
	        }
	      ]
	    };
	  }
	  mapObjectTypeChildren(child, newProps, newChildProps, nestedChildren) {
	    switch (child.type) {
	      case "title" /* TITLE */:
	        return {
	          ...newProps,
	          [child.type]: nestedChildren,
	          titleAttributes: { ...newChildProps }
	        };
	      case "body" /* BODY */:
	        return {
	          ...newProps,
	          bodyAttributes: { ...newChildProps }
	        };
	      case "html" /* HTML */:
	        return {
	          ...newProps,
	          htmlAttributes: { ...newChildProps }
	        };
	      default:
	        return {
	          ...newProps,
	          [child.type]: { ...newChildProps }
	        };
	    }
	  }
	  mapArrayTypeChildrenToProps(arrayTypeChildren, newProps) {
	    let newFlattenedProps = { ...newProps };
	    Object.keys(arrayTypeChildren).forEach((arrayChildName) => {
	      newFlattenedProps = {
	        ...newFlattenedProps,
	        [arrayChildName]: arrayTypeChildren[arrayChildName]
	      };
	    });
	    return newFlattenedProps;
	  }
	  warnOnInvalidChildren(child, nestedChildren) {
	    invariant$3(
	      VALID_TAG_NAMES.some((name) => child.type === name),
	      typeof child.type === "function" ? `You may be attempting to nest <Helmet> components within each other, which is not allowed. Refer to our API for more information.` : `Only elements types ${VALID_TAG_NAMES.join(
        ", "
      )} are allowed. Helmet does not support rendering <${child.type}> elements. Refer to our API for more information.`
	    );
	    invariant$3(
	      !nestedChildren || typeof nestedChildren === "string" || Array.isArray(nestedChildren) && !nestedChildren.some((nestedChild) => typeof nestedChild !== "string"),
	      `Helmet expects a string as a child of <${child.type}>. Did you forget to wrap your children in braces? ( <${child.type}>{\`\`}</${child.type}> ) Refer to our API for more information.`
	    );
	    return true;
	  }
	  mapChildrenToProps(children, newProps) {
	    let arrayTypeChildren = {};
	    React$2.Children.forEach(children, (child) => {
	      if (!child || !child.props) {
	        return;
	      }
	      const { children: nestedChildren, ...childProps } = child.props;
	      const newChildProps = Object.keys(childProps).reduce((obj, key) => {
	        obj[HTML_TAG_MAP[key] || key] = childProps[key];
	        return obj;
	      }, {});
	      let { type } = child;
	      if (typeof type === "symbol") {
	        type = type.toString();
	      } else {
	        this.warnOnInvalidChildren(child, nestedChildren);
	      }
	      switch (type) {
	        case "Symbol(react.fragment)" /* FRAGMENT */:
	          newProps = this.mapChildrenToProps(nestedChildren, newProps);
	          break;
	        case "link" /* LINK */:
	        case "meta" /* META */:
	        case "noscript" /* NOSCRIPT */:
	        case "script" /* SCRIPT */:
	        case "style" /* STYLE */:
	          arrayTypeChildren = this.flattenArrayTypeChildren(
	            child,
	            arrayTypeChildren,
	            newChildProps,
	            nestedChildren
	          );
	          break;
	        default:
	          newProps = this.mapObjectTypeChildren(child, newProps, newChildProps, nestedChildren);
	          break;
	      }
	    });
	    return this.mapArrayTypeChildrenToProps(arrayTypeChildren, newProps);
	  }
	  render() {
	    const { children, ...props } = this.props;
	    let newProps = { ...props };
	    let { helmetData } = props;
	    if (children) {
	      newProps = this.mapChildrenToProps(children, newProps);
	    }
	    if (helmetData && !(helmetData instanceof HelmetData)) {
	      const data = helmetData;
	      helmetData = new HelmetData(data.context, true);
	      delete newProps.helmetData;
	    }
	    return helmetData ? /* @__PURE__ */ React$2.createElement(HelmetDispatcher, { ...newProps, context: helmetData.value }) : /* @__PURE__ */ React$2.createElement(Context.Consumer, null, (context) => /* @__PURE__ */ React$2.createElement(HelmetDispatcher, { ...newProps, context }));
	  }
	};

	const matchHtmlEntity = /&(?:amp|#38|lt|#60|gt|#62|apos|#39|quot|#34|nbsp|#160|copy|#169|reg|#174|hellip|#8230|#x2F|#47);/g;
	const htmlEntities = {
	  '&amp;': '&',
	  '&#38;': '&',
	  '&lt;': '<',
	  '&#60;': '<',
	  '&gt;': '>',
	  '&#62;': '>',
	  '&apos;': "'",
	  '&#39;': "'",
	  '&quot;': '"',
	  '&#34;': '"',
	  '&nbsp;': ' ',
	  '&#160;': ' ',
	  '&copy;': '©',
	  '&#169;': '©',
	  '&reg;': '®',
	  '&#174;': '®',
	  '&hellip;': '…',
	  '&#8230;': '…',
	  '&#x2F;': '/',
	  '&#47;': '/'
	};
	const unescapeHtmlEntity = m => htmlEntities[m];
	const unescape$1 = text => text.replace(matchHtmlEntity, unescapeHtmlEntity);

	let defaultOptions$2 = {
	  bindI18n: 'languageChanged',
	  bindI18nStore: '',
	  transEmptyNodeValue: '',
	  transSupportBasicHtmlNodes: true,
	  transWrapTextNodes: '',
	  transKeepBasicHtmlNodesFor: ['br', 'strong', 'i', 'p'],
	  useSuspense: true,
	  unescape: unescape$1
	};
	function setDefaults() {
	  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	  defaultOptions$2 = {
	    ...defaultOptions$2,
	    ...options
	  };
	}
	function getDefaults() {
	  return defaultOptions$2;
	}

	let i18nInstance;
	function setI18n(instance) {
	  i18nInstance = instance;
	}
	function getI18n() {
	  return i18nInstance;
	}

	const I18nContext = reactExports.createContext();
	class ReportNamespaces {
	  constructor() {
	    this.usedNamespaces = {};
	  }
	  addUsedNamespaces(namespaces) {
	    namespaces.forEach(ns => {
	      if (!this.usedNamespaces[ns]) this.usedNamespaces[ns] = true;
	    });
	  }
	  getUsedNamespaces() {
	    return Object.keys(this.usedNamespaces);
	  }
	}

	function _extends$1() {
	  _extends$1 = Object.assign ? Object.assign.bind() : function (target) {
	    for (var i = 1; i < arguments.length; i++) {
	      var source = arguments[i];
	      for (var key in source) {
	        if (Object.prototype.hasOwnProperty.call(source, key)) {
	          target[key] = source[key];
	        }
	      }
	    }
	    return target;
	  };
	  return _extends$1.apply(this, arguments);
	}

	/**
	 * This file automatically generated from `pre-publish.js`.
	 * Do not manually edit.
	 */

	var voidElements$1 = {
	  "area": true,
	  "base": true,
	  "br": true,
	  "col": true,
	  "embed": true,
	  "hr": true,
	  "img": true,
	  "input": true,
	  "link": true,
	  "meta": true,
	  "param": true,
	  "source": true,
	  "track": true,
	  "wbr": true
	};

	var e$7 = /*@__PURE__*/getDefaultExportFromCjs(voidElements$1);

	var t$d=/\s([^'"/\s><]+?)[\s/>]|([^\s=]+)=\s?(".*?"|'.*?')/g;function n$d(n){var r={type:"tag",name:"",voidElement:!1,attrs:{},children:[]},i=n.match(/<\/?([^\s]+?)[/\s>]/);if(i&&(r.name=i[1],(e$7[i[1]]||"/"===n.charAt(n.length-2))&&(r.voidElement=!0),r.name.startsWith("!--"))){var s=n.indexOf("--\x3e");return {type:"comment",comment:-1!==s?n.slice(4,s):""}}for(var a=new RegExp(t$d),c=null;null!==(c=a.exec(n));)if(c[0].trim())if(c[1]){var o=c[1].trim(),l=[o,""];o.indexOf("=")>-1&&(l=o.split("=")),r.attrs[l[0]]=l[1],a.lastIndex--;}else c[2]&&(r.attrs[c[2]]=c[3].trim().substring(1,c[3].length-1));return r}var r$9=/<[a-zA-Z0-9\-\!\/](?:"[^"]*"|'[^']*'|[^'">])*>/g,i$9=/^\s*$/,s$g=Object.create(null);function a$c(e,t){switch(t.type){case"text":return e+t.content;case"tag":return e+="<"+t.name+(t.attrs?function(e){var t=[];for(var n in e)t.push(n+'="'+e[n]+'"');return t.length?" "+t.join(" "):""}(t.attrs):"")+(t.voidElement?"/>":">"),t.voidElement?e:e+t.children.reduce(a$c,"")+"</"+t.name+">";case"comment":return e+"\x3c!--"+t.comment+"--\x3e"}}var c$c={parse:function(e,t){t||(t={}),t.components||(t.components=s$g);var a,c=[],o=[],l=-1,m=!1;if(0!==e.indexOf("<")){var u=e.indexOf("<");c.push({type:"text",content:-1===u?e:e.substring(0,u)});}return e.replace(r$9,function(r,s){if(m){if(r!=="</"+a.name+">")return;m=!1;}var u,f="/"!==r.charAt(1),h=r.startsWith("\x3c!--"),p=s+r.length,d=e.charAt(p);if(h){var v=n$d(r);return l<0?(c.push(v),c):((u=o[l]).children.push(v),c)}if(f&&(l++,"tag"===(a=n$d(r)).type&&t.components[a.name]&&(a.type="component",m=!0),a.voidElement||m||!d||"<"===d||a.children.push({type:"text",content:e.slice(p,e.indexOf("<",p))}),0===l&&c.push(a),(u=o[l-1])&&u.children.push(a),o[l]=a),(!f||a.voidElement)&&(l>-1&&(a.voidElement||a.name===r.slice(2,-1))&&(l--,a=-1===l?c:o[l]),!m&&"<"!==d&&d)){u=-1===l?c:o[l].children;var x=e.indexOf("<",p),g=e.slice(p,-1===x?void 0:x);i$9.test(g)&&(g=" "),(x>-1&&l+u.length>=0||" "!==g)&&u.push({type:"text",content:g});}}),c},stringify:function(e){return e.reduce(function(e,t){return e+a$c("",t)},"")}};

	function warn$1() {
	  if (console && console.warn) {
	    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	    if (typeof args[0] === 'string') args[0] = `react-i18next:: ${args[0]}`;
	    console.warn(...args);
	  }
	}
	const alreadyWarned = {};
	function warnOnce() {
	  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
	    args[_key2] = arguments[_key2];
	  }
	  if (typeof args[0] === 'string' && alreadyWarned[args[0]]) return;
	  if (typeof args[0] === 'string') alreadyWarned[args[0]] = new Date();
	  warn$1(...args);
	}
	const loadedClb = (i18n, cb) => () => {
	  if (i18n.isInitialized) {
	    cb();
	  } else {
	    const initialized = () => {
	      setTimeout(() => {
	        i18n.off('initialized', initialized);
	      }, 0);
	      cb();
	    };
	    i18n.on('initialized', initialized);
	  }
	};
	function loadNamespaces(i18n, ns, cb) {
	  i18n.loadNamespaces(ns, loadedClb(i18n, cb));
	}
	function loadLanguages(i18n, lng, ns, cb) {
	  if (typeof ns === 'string') ns = [ns];
	  ns.forEach(n => {
	    if (i18n.options.ns.indexOf(n) < 0) i18n.options.ns.push(n);
	  });
	  i18n.loadLanguages(lng, loadedClb(i18n, cb));
	}
	function oldI18nextHasLoadedNamespace(ns, i18n) {
	  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
	  const lng = i18n.languages[0];
	  const fallbackLng = i18n.options ? i18n.options.fallbackLng : false;
	  const lastLng = i18n.languages[i18n.languages.length - 1];
	  if (lng.toLowerCase() === 'cimode') return true;
	  const loadNotPending = (l, n) => {
	    const loadState = i18n.services.backendConnector.state[`${l}|${n}`];
	    return loadState === -1 || loadState === 2;
	  };
	  if (options.bindI18n && options.bindI18n.indexOf('languageChanging') > -1 && i18n.services.backendConnector.backend && i18n.isLanguageChangingTo && !loadNotPending(i18n.isLanguageChangingTo, ns)) return false;
	  if (i18n.hasResourceBundle(lng, ns)) return true;
	  if (!i18n.services.backendConnector.backend || i18n.options.resources && !i18n.options.partialBundledLanguages) return true;
	  if (loadNotPending(lng, ns) && (!fallbackLng || loadNotPending(lastLng, ns))) return true;
	  return false;
	}
	function hasLoadedNamespace(ns, i18n) {
	  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
	  if (!i18n.languages || !i18n.languages.length) {
	    warnOnce('i18n.languages were undefined or empty', i18n.languages);
	    return true;
	  }
	  const isNewerI18next = i18n.options.ignoreJSONStructure !== undefined;
	  if (!isNewerI18next) {
	    return oldI18nextHasLoadedNamespace(ns, i18n, options);
	  }
	  return i18n.hasLoadedNamespace(ns, {
	    lng: options.lng,
	    precheck: (i18nInstance, loadNotPending) => {
	      if (options.bindI18n && options.bindI18n.indexOf('languageChanging') > -1 && i18nInstance.services.backendConnector.backend && i18nInstance.isLanguageChangingTo && !loadNotPending(i18nInstance.isLanguageChangingTo, ns)) return false;
	    }
	  });
	}

	function hasChildren$1(node, checkLength) {
	  if (!node) return false;
	  const base = node.props ? node.props.children : node.children;
	  if (checkLength) return base.length > 0;
	  return !!base;
	}
	function getChildren$2(node) {
	  if (!node) return [];
	  const children = node.props ? node.props.children : node.children;
	  return node.props && node.props.i18nIsDynamicList ? getAsArray(children) : children;
	}
	function hasValidReactChildren(children) {
	  if (Object.prototype.toString.call(children) !== '[object Array]') return false;
	  return children.every(child => reactExports.isValidElement(child));
	}
	function getAsArray(data) {
	  return Array.isArray(data) ? data : [data];
	}
	function mergeProps(source, target) {
	  const newTarget = {
	    ...target
	  };
	  newTarget.props = Object.assign(source.props, target.props);
	  return newTarget;
	}
	function nodesToString(children, i18nOptions) {
	  if (!children) return '';
	  let stringNode = '';
	  const childrenArray = getAsArray(children);
	  const keepArray = i18nOptions.transSupportBasicHtmlNodes && i18nOptions.transKeepBasicHtmlNodesFor ? i18nOptions.transKeepBasicHtmlNodesFor : [];
	  childrenArray.forEach((child, childIndex) => {
	    if (typeof child === 'string') {
	      stringNode += `${child}`;
	    } else if (reactExports.isValidElement(child)) {
	      const childPropsCount = Object.keys(child.props).length;
	      const shouldKeepChild = keepArray.indexOf(child.type) > -1;
	      const childChildren = child.props.children;
	      if (!childChildren && shouldKeepChild && childPropsCount === 0) {
	        stringNode += `<${child.type}/>`;
	      } else if (!childChildren && (!shouldKeepChild || childPropsCount !== 0)) {
	        stringNode += `<${childIndex}></${childIndex}>`;
	      } else if (child.props.i18nIsDynamicList) {
	        stringNode += `<${childIndex}></${childIndex}>`;
	      } else if (shouldKeepChild && childPropsCount === 1 && typeof childChildren === 'string') {
	        stringNode += `<${child.type}>${childChildren}</${child.type}>`;
	      } else {
	        const content = nodesToString(childChildren, i18nOptions);
	        stringNode += `<${childIndex}>${content}</${childIndex}>`;
	      }
	    } else if (child === null) {
	      warn$1(`Trans: the passed in value is invalid - seems you passed in a null child.`);
	    } else if (typeof child === 'object') {
	      const {
	        format,
	        ...clone
	      } = child;
	      const keys = Object.keys(clone);
	      if (keys.length === 1) {
	        const value = format ? `${keys[0]}, ${format}` : keys[0];
	        stringNode += `{{${value}}}`;
	      } else {
	        warn$1(`react-i18next: the passed in object contained more than one variable - the object should look like {{ value, format }} where format is optional.`, child);
	      }
	    } else {
	      warn$1(`Trans: the passed in value is invalid - seems you passed in a variable like {number} - please pass in variables for interpolation as full objects like {{number}}.`, child);
	    }
	  });
	  return stringNode;
	}
	function renderNodes(children, targetString, i18n, i18nOptions, combinedTOpts, shouldUnescape) {
	  if (targetString === '') return [];
	  const keepArray = i18nOptions.transKeepBasicHtmlNodesFor || [];
	  const emptyChildrenButNeedsHandling = targetString && new RegExp(keepArray.map(keep => `<${keep}`).join('|')).test(targetString);
	  if (!children && !emptyChildrenButNeedsHandling && !shouldUnescape) return [targetString];
	  const data = {};
	  function getData(childs) {
	    const childrenArray = getAsArray(childs);
	    childrenArray.forEach(child => {
	      if (typeof child === 'string') return;
	      if (hasChildren$1(child)) getData(getChildren$2(child));else if (typeof child === 'object' && !reactExports.isValidElement(child)) Object.assign(data, child);
	    });
	  }
	  getData(children);
	  const ast = c$c.parse(`<0>${targetString}</0>`);
	  const opts = {
	    ...data,
	    ...combinedTOpts
	  };
	  function renderInner(child, node, rootReactNode) {
	    const childs = getChildren$2(child);
	    const mappedChildren = mapAST(childs, node.children, rootReactNode);
	    return hasValidReactChildren(childs) && mappedChildren.length === 0 || child.props && child.props.i18nIsDynamicList ? childs : mappedChildren;
	  }
	  function pushTranslatedJSX(child, inner, mem, i, isVoid) {
	    if (child.dummy) {
	      child.children = inner;
	      mem.push(reactExports.cloneElement(child, {
	        key: i
	      }, isVoid ? undefined : inner));
	    } else {
	      mem.push(...reactExports.Children.map([child], c => {
	        const props = {
	          ...c.props
	        };
	        delete props.i18nIsDynamicList;
	        return React$2.createElement(c.type, _extends$1({}, props, {
	          key: i,
	          ref: c.ref
	        }, isVoid ? {} : {
	          children: inner
	        }));
	      }));
	    }
	  }
	  function mapAST(reactNode, astNode, rootReactNode) {
	    const reactNodes = getAsArray(reactNode);
	    const astNodes = getAsArray(astNode);
	    return astNodes.reduce((mem, node, i) => {
	      const translationContent = node.children && node.children[0] && node.children[0].content && i18n.services.interpolator.interpolate(node.children[0].content, opts, i18n.language);
	      if (node.type === 'tag') {
	        let tmp = reactNodes[parseInt(node.name, 10)];
	        if (rootReactNode.length === 1 && !tmp) tmp = rootReactNode[0][node.name];
	        if (!tmp) tmp = {};
	        const child = Object.keys(node.attrs).length !== 0 ? mergeProps({
	          props: node.attrs
	        }, tmp) : tmp;
	        const isElement = reactExports.isValidElement(child);
	        const isValidTranslationWithChildren = isElement && hasChildren$1(node, true) && !node.voidElement;
	        const isEmptyTransWithHTML = emptyChildrenButNeedsHandling && typeof child === 'object' && child.dummy && !isElement;
	        const isKnownComponent = typeof children === 'object' && children !== null && Object.hasOwnProperty.call(children, node.name);
	        if (typeof child === 'string') {
	          const value = i18n.services.interpolator.interpolate(child, opts, i18n.language);
	          mem.push(value);
	        } else if (hasChildren$1(child) || isValidTranslationWithChildren) {
	          const inner = renderInner(child, node, rootReactNode);
	          pushTranslatedJSX(child, inner, mem, i);
	        } else if (isEmptyTransWithHTML) {
	          const inner = mapAST(reactNodes, node.children, rootReactNode);
	          pushTranslatedJSX(child, inner, mem, i);
	        } else if (Number.isNaN(parseFloat(node.name))) {
	          if (isKnownComponent) {
	            const inner = renderInner(child, node, rootReactNode);
	            pushTranslatedJSX(child, inner, mem, i, node.voidElement);
	          } else if (i18nOptions.transSupportBasicHtmlNodes && keepArray.indexOf(node.name) > -1) {
	            if (node.voidElement) {
	              mem.push(reactExports.createElement(node.name, {
	                key: `${node.name}-${i}`
	              }));
	            } else {
	              const inner = mapAST(reactNodes, node.children, rootReactNode);
	              mem.push(reactExports.createElement(node.name, {
	                key: `${node.name}-${i}`
	              }, inner));
	            }
	          } else if (node.voidElement) {
	            mem.push(`<${node.name} />`);
	          } else {
	            const inner = mapAST(reactNodes, node.children, rootReactNode);
	            mem.push(`<${node.name}>${inner}</${node.name}>`);
	          }
	        } else if (typeof child === 'object' && !isElement) {
	          const content = node.children[0] ? translationContent : null;
	          if (content) mem.push(content);
	        } else {
	          pushTranslatedJSX(child, translationContent, mem, i, node.children.length !== 1 || !translationContent);
	        }
	      } else if (node.type === 'text') {
	        const wrapTextNodes = i18nOptions.transWrapTextNodes;
	        const content = shouldUnescape ? i18nOptions.unescape(i18n.services.interpolator.interpolate(node.content, opts, i18n.language)) : i18n.services.interpolator.interpolate(node.content, opts, i18n.language);
	        if (wrapTextNodes) {
	          mem.push(reactExports.createElement(wrapTextNodes, {
	            key: `${node.name}-${i}`
	          }, content));
	        } else {
	          mem.push(content);
	        }
	      }
	      return mem;
	    }, []);
	  }
	  const result = mapAST([{
	    dummy: true,
	    children: children || []
	  }], ast, getAsArray(children || []));
	  return getChildren$2(result[0]);
	}
	function Trans$1(_ref) {
	  let {
	    children,
	    count,
	    parent,
	    i18nKey,
	    context,
	    tOptions = {},
	    values,
	    defaults,
	    components,
	    ns,
	    i18n: i18nFromProps,
	    t: tFromProps,
	    shouldUnescape,
	    ...additionalProps
	  } = _ref;
	  const i18n = i18nFromProps || getI18n();
	  if (!i18n) {
	    warnOnce('You will need to pass in an i18next instance by using i18nextReactModule');
	    return children;
	  }
	  const t = tFromProps || i18n.t.bind(i18n) || (k => k);
	  if (context) tOptions.context = context;
	  const reactI18nextOptions = {
	    ...getDefaults(),
	    ...(i18n.options && i18n.options.react)
	  };
	  let namespaces = ns || t.ns || i18n.options && i18n.options.defaultNS;
	  namespaces = typeof namespaces === 'string' ? [namespaces] : namespaces || ['translation'];
	  const nodeAsString = nodesToString(children, reactI18nextOptions);
	  const defaultValue = defaults || nodeAsString || reactI18nextOptions.transEmptyNodeValue || i18nKey;
	  const {
	    hashTransKey
	  } = reactI18nextOptions;
	  const key = i18nKey || (hashTransKey ? hashTransKey(nodeAsString || defaultValue) : nodeAsString || defaultValue);
	  let interpolationOverride = values ? tOptions.interpolation : {
	    interpolation: {
	      ...tOptions.interpolation,
	      prefix: '#$?',
	      suffix: '?$#'
	    }
	  };
	  if (i18n.options && i18n.options.interpolation && i18n.options.interpolation.defaultVariables) {
	    if (!interpolationOverride) interpolationOverride = {};
	    interpolationOverride.interpolation = {
	      defaultVariables: {
	        ...i18n.options.interpolation.defaultVariables,
	        ...(interpolationOverride.interpolation && interpolationOverride.interpolation.defaultVariables || {})
	      }
	    };
	  }
	  const combinedTOpts = {
	    ...tOptions,
	    count,
	    ...values,
	    ...interpolationOverride,
	    defaultValue,
	    ns: namespaces
	  };
	  const translation = key ? t(key, combinedTOpts) : defaultValue;
	  const content = renderNodes(components || children, translation, i18n, reactI18nextOptions, combinedTOpts, shouldUnescape);
	  const useAsParent = parent !== undefined ? parent : reactI18nextOptions.defaultTransParent;
	  return useAsParent ? reactExports.createElement(useAsParent, additionalProps, content) : content;
	}

	function Trans(_ref) {
	  let {
	    children,
	    count,
	    parent,
	    i18nKey,
	    context,
	    tOptions = {},
	    values,
	    defaults,
	    components,
	    ns,
	    i18n: i18nFromProps,
	    t: tFromProps,
	    shouldUnescape,
	    ...additionalProps
	  } = _ref;
	  const {
	    i18n: i18nFromContext,
	    defaultNS: defaultNSFromContext
	  } = reactExports.useContext(I18nContext) || {};
	  const i18n = i18nFromProps || i18nFromContext || getI18n();
	  const t = tFromProps || i18n && i18n.t.bind(i18n);
	  return Trans$1({
	    children,
	    count,
	    parent,
	    i18nKey,
	    context,
	    tOptions,
	    values,
	    defaults,
	    components,
	    ns: ns || t && t.ns || defaultNSFromContext || i18n && i18n.options && i18n.options.defaultNS,
	    i18n,
	    t: tFromProps,
	    shouldUnescape,
	    ...additionalProps
	  });
	}

	function useSSR$1(initialI18nStore, initialLanguage) {
	  let props = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
	  const {
	    i18n: i18nFromProps
	  } = props;
	  const {
	    i18n: i18nFromContext
	  } = reactExports.useContext(I18nContext) || {};
	  const i18n = i18nFromProps || i18nFromContext || getI18n();
	  if (i18n.options && i18n.options.isClone) return;
	  if (initialI18nStore && !i18n.initializedStoreOnce) {
	    i18n.services.resourceStore.data = initialI18nStore;
	    i18n.options.ns = Object.values(initialI18nStore).reduce((mem, lngResources) => {
	      Object.keys(lngResources).forEach(ns => {
	        if (mem.indexOf(ns) < 0) mem.push(ns);
	      });
	      return mem;
	    }, i18n.options.ns);
	    i18n.initializedStoreOnce = true;
	    i18n.isInitialized = true;
	  }
	  if (initialLanguage && !i18n.initializedLanguageOnce) {
	    i18n.changeLanguage(initialLanguage);
	    i18n.initializedLanguageOnce = true;
	  }
	}

	const usePrevious$1 = (value, ignore) => {
	  const ref = reactExports.useRef();
	  reactExports.useEffect(() => {
	    ref.current = value;
	  }, [value, ignore]);
	  return ref.current;
	};
	function useTranslation(ns) {
	  let props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	  const {
	    i18n: i18nFromProps
	  } = props;
	  const {
	    i18n: i18nFromContext,
	    defaultNS: defaultNSFromContext
	  } = reactExports.useContext(I18nContext) || {};
	  const i18n = i18nFromProps || i18nFromContext || getI18n();
	  if (i18n && !i18n.reportNamespaces) i18n.reportNamespaces = new ReportNamespaces();
	  if (!i18n) {
	    warnOnce('You will need to pass in an i18next instance by using initReactI18next');
	    const notReadyT = (k, optsOrDefaultValue) => {
	      if (typeof optsOrDefaultValue === 'string') return optsOrDefaultValue;
	      if (optsOrDefaultValue && typeof optsOrDefaultValue === 'object' && typeof optsOrDefaultValue.defaultValue === 'string') return optsOrDefaultValue.defaultValue;
	      return Array.isArray(k) ? k[k.length - 1] : k;
	    };
	    const retNotReady = [notReadyT, {}, false];
	    retNotReady.t = notReadyT;
	    retNotReady.i18n = {};
	    retNotReady.ready = false;
	    return retNotReady;
	  }
	  if (i18n.options.react && i18n.options.react.wait !== undefined) warnOnce('It seems you are still using the old wait option, you may migrate to the new useSuspense behaviour.');
	  const i18nOptions = {
	    ...getDefaults(),
	    ...i18n.options.react,
	    ...props
	  };
	  const {
	    useSuspense,
	    keyPrefix
	  } = i18nOptions;
	  let namespaces = defaultNSFromContext || i18n.options && i18n.options.defaultNS;
	  namespaces = typeof namespaces === 'string' ? [namespaces] : namespaces || ['translation'];
	  if (i18n.reportNamespaces.addUsedNamespaces) i18n.reportNamespaces.addUsedNamespaces(namespaces);
	  const ready = (i18n.isInitialized || i18n.initializedStoreOnce) && namespaces.every(n => hasLoadedNamespace(n, i18n, i18nOptions));
	  function getT() {
	    return i18n.getFixedT(props.lng || null, i18nOptions.nsMode === 'fallback' ? namespaces : namespaces[0], keyPrefix);
	  }
	  const [t, setT] = reactExports.useState(getT);
	  let joinedNS = namespaces.join();
	  if (props.lng) joinedNS = `${props.lng}${joinedNS}`;
	  const previousJoinedNS = usePrevious$1(joinedNS);
	  const isMounted = reactExports.useRef(true);
	  reactExports.useEffect(() => {
	    const {
	      bindI18n,
	      bindI18nStore
	    } = i18nOptions;
	    isMounted.current = true;
	    if (!ready && !useSuspense) {
	      if (props.lng) {
	        loadLanguages(i18n, props.lng, namespaces, () => {
	          if (isMounted.current) setT(getT);
	        });
	      } else {
	        loadNamespaces(i18n, namespaces, () => {
	          if (isMounted.current) setT(getT);
	        });
	      }
	    }
	    if (ready && previousJoinedNS && previousJoinedNS !== joinedNS && isMounted.current) {
	      setT(getT);
	    }
	    function boundReset() {
	      if (isMounted.current) setT(getT);
	    }
	    if (bindI18n && i18n) i18n.on(bindI18n, boundReset);
	    if (bindI18nStore && i18n) i18n.store.on(bindI18nStore, boundReset);
	    return () => {
	      isMounted.current = false;
	      if (bindI18n && i18n) bindI18n.split(' ').forEach(e => i18n.off(e, boundReset));
	      if (bindI18nStore && i18n) bindI18nStore.split(' ').forEach(e => i18n.store.off(e, boundReset));
	    };
	  }, [i18n, joinedNS]);
	  const isInitial = reactExports.useRef(true);
	  reactExports.useEffect(() => {
	    if (isMounted.current && !isInitial.current) {
	      setT(getT);
	    }
	    isInitial.current = false;
	  }, [i18n, keyPrefix]);
	  const ret = [t, i18n, ready];
	  ret.t = t;
	  ret.i18n = i18n;
	  ret.ready = ready;
	  if (ready) return ret;
	  if (!ready && !useSuspense) return ret;
	  throw new Promise(resolve => {
	    if (props.lng) {
	      loadLanguages(i18n, props.lng, namespaces, () => resolve());
	    } else {
	      loadNamespaces(i18n, namespaces, () => resolve());
	    }
	  });
	}

	const loadJSONFromID = (id) => {
	    const unparsed = document.getElementById(id)?.innerHTML;
	    if (!unparsed) throw new Error(`Couldn't load config from ID: ${id}`);
	    return JSON.parse(unparsed) ;
	};

	/** @internal */ function createChain(opts) {
	    return observable((observer)=>{
	        function execute(index = 0, op = opts.op) {
	            const next = opts.links[index];
	            if (!next) {
	                throw new Error('No more links to execute - did you forget to add an ending link?');
	            }
	            const subscription = next({
	                op,
	                next (nextOp) {
	                    const nextObserver = execute(index + 1, nextOp);
	                    return nextObserver;
	                }
	            });
	            return subscription;
	        }
	        const obs$ = execute();
	        return obs$.subscribe(observer);
	    });
	}

	/**
	 * @internal
	 */ function invert(obj) {
	    const newObj = Object.create(null);
	    for(const key in obj){
	        const v = obj[key];
	        newObj[v] = key;
	    }
	    return newObj;
	}

	// reference: https://www.jsonrpc.org/specification
	/**
	 * JSON-RPC 2.0 Error codes
	 *
	 * `-32000` to `-32099` are reserved for implementation-defined server-errors.
	 * For tRPC we're copying the last digits of HTTP 4XX errors.
	 */ const TRPC_ERROR_CODES_BY_KEY = {
	    /**
	   * Invalid JSON was received by the server.
	   * An error occurred on the server while parsing the JSON text.
	   */ PARSE_ERROR: -32700,
	    /**
	   * The JSON sent is not a valid Request object.
	   */ BAD_REQUEST: -32600,
	    // Internal JSON-RPC error
	    INTERNAL_SERVER_ERROR: -32603,
	    NOT_IMPLEMENTED: -32603,
	    // Implementation specific errors
	    UNAUTHORIZED: -32001,
	    FORBIDDEN: -32003,
	    NOT_FOUND: -32004,
	    METHOD_NOT_SUPPORTED: -32005,
	    TIMEOUT: -32008,
	    CONFLICT: -32009,
	    PRECONDITION_FAILED: -32012,
	    PAYLOAD_TOO_LARGE: -32013,
	    UNPROCESSABLE_CONTENT: -32022,
	    TOO_MANY_REQUESTS: -32029,
	    CLIENT_CLOSED_REQUEST: -32099
	};
	invert(TRPC_ERROR_CODES_BY_KEY);

	invert(TRPC_ERROR_CODES_BY_KEY);

	const noop$3 = ()=>{
	// noop
	};
	function createInnerProxy(callback, path) {
	    const proxy = new Proxy(noop$3, {
	        get (_obj, key) {
	            if (typeof key !== 'string' || key === 'then') {
	                // special case for if the proxy is accidentally treated
	                // like a PromiseLike (like in `Promise.resolve(proxy)`)
	                return undefined;
	            }
	            return createInnerProxy(callback, [
	                ...path,
	                key
	            ]);
	        },
	        apply (_1, _2, args) {
	            const isApply = path[path.length - 1] === 'apply';
	            return callback({
	                args: isApply ? args.length >= 2 ? args[1] : [] : args,
	                path: isApply ? path.slice(0, -1) : path
	            });
	        }
	    });
	    return proxy;
	}
	/**
	 * Creates a proxy that calls the callback with the path and arguments
	 *
	 * @internal
	 */ const createRecursiveProxy = (callback)=>createInnerProxy(callback, []);
	/**
	 * Used in place of `new Proxy` where each handler will map 1 level deep to another value.
	 *
	 * @internal
	 */ const createFlatProxy = (callback)=>{
	    return new Proxy(noop$3, {
	        get (_obj, name) {
	            if (typeof name !== 'string' || name === 'then') {
	                // special case for if the proxy is accidentally treated
	                // like a PromiseLike (like in `Promise.resolve(proxy)`)
	                return undefined;
	            }
	            return callback(name);
	        }
	    });
	};

	class TRPCUntypedClient {
	    $request({ type , input , path , context ={}  }) {
	        const chain$ = createChain({
	            links: this.links,
	            op: {
	                id: ++this.requestId,
	                type,
	                path,
	                input,
	                context
	            }
	        });
	        return chain$.pipe(share());
	    }
	    requestAsPromise(opts) {
	        const req$ = this.$request(opts);
	        const { promise , abort  } = observableToPromise(req$);
	        const abortablePromise = new Promise((resolve, reject)=>{
	            opts.signal?.addEventListener('abort', abort);
	            promise.then((envelope)=>{
	                resolve(envelope.result.data);
	            }).catch((err)=>{
	                reject(TRPCClientError.from(err));
	            });
	        });
	        return abortablePromise;
	    }
	    query(path, input, opts) {
	        return this.requestAsPromise({
	            type: 'query',
	            path,
	            input,
	            context: opts?.context,
	            signal: opts?.signal
	        });
	    }
	    mutation(path, input, opts) {
	        return this.requestAsPromise({
	            type: 'mutation',
	            path,
	            input,
	            context: opts?.context,
	            signal: opts?.signal
	        });
	    }
	    subscription(path, input, opts) {
	        const observable$ = this.$request({
	            type: 'subscription',
	            path,
	            input,
	            context: opts?.context
	        });
	        return observable$.subscribe({
	            next (envelope) {
	                if (envelope.result.type === 'started') {
	                    opts.onStarted?.();
	                } else if (envelope.result.type === 'stopped') {
	                    opts.onStopped?.();
	                } else {
	                    opts.onData?.(envelope.result.data);
	                }
	            },
	            error (err) {
	                opts.onError?.(err);
	            },
	            complete () {
	                opts.onComplete?.();
	            }
	        });
	    }
	    constructor(opts){
	        this.requestId = 0;
	        const combinedTransformer = (()=>{
	            const transformer = opts.transformer;
	            if (!transformer) {
	                return {
	                    input: {
	                        serialize: (data)=>data,
	                        deserialize: (data)=>data
	                    },
	                    output: {
	                        serialize: (data)=>data,
	                        deserialize: (data)=>data
	                    }
	                };
	            }
	            if ('input' in transformer) {
	                return opts.transformer;
	            }
	            return {
	                input: transformer,
	                output: transformer
	            };
	        })();
	        this.runtime = {
	            transformer: {
	                serialize: (data)=>combinedTransformer.input.serialize(data),
	                deserialize: (data)=>combinedTransformer.output.deserialize(data)
	            },
	            combinedTransformer
	        };
	        // Initialize the links
	        this.links = opts.links.map((link)=>link(this.runtime));
	    }
	}

	/**
	 * @deprecated use `createTRPCProxyClient` instead
	 */ function createTRPCClient(opts) {
	    const client = new TRPCUntypedClient(opts);
	    return client;
	}

	const clientCallTypeMap = {
	    query: 'query',
	    mutate: 'mutation',
	    subscribe: 'subscription'
	};
	/** @internal */ const clientCallTypeToProcedureType = (clientCallType)=>{
	    return clientCallTypeMap[clientCallType];
	};
	/**
	 * @deprecated use `createTRPCProxyClient` instead
	 * @internal
	 */ function createTRPCClientProxy(client) {
	    return createFlatProxy((key)=>{
	        if (client.hasOwnProperty(key)) {
	            return client[key];
	        }
	        if (key === '__untypedClient') {
	            return client;
	        }
	        return createRecursiveProxy(({ path , args  })=>{
	            const pathCopy = [
	                key,
	                ...path
	            ];
	            const procedureType = clientCallTypeToProcedureType(pathCopy.pop());
	            const fullPath = pathCopy.join('.');
	            return client[procedureType](fullPath, ...args);
	        });
	    });
	}
	function createTRPCProxyClient(opts) {
	    const client = new TRPCUntypedClient(opts);
	    const proxy = createTRPCClientProxy(client);
	    return proxy;
	}

	/**
	 * To allow easy interactions with groups of related queries, such as
	 * invalidating all queries of a router, we use an array as the path when
	 * storing in tanstack query. This function converts from the `.` separated
	 * path passed around internally by both the legacy and proxy implementation.
	 * https://github.com/trpc/trpc/issues/2611
	 **/ function getArrayQueryKey(queryKey, type) {
	    const queryKeyArrayed = Array.isArray(queryKey) ? queryKey : [
	        queryKey
	    ];
	    const [path, input] = queryKeyArrayed;
	    const arrayPath = typeof path !== 'string' || path === '' ? [] : path.split('.');
	    // Construct a query key that is easy to destructure and flexible for
	    // partial selecting etc.
	    // https://github.com/trpc/trpc/issues/3128
	    if (!input && (!type || type === 'any')) // for `utils.invalidate()` to match all queries (including vanilla react-query)
	    // we don't want nested array if path is empty, i.e. `[]` instead of `[[]]`
	    return arrayPath.length ? [
	        arrayPath
	    ] : [];
	    return [
	        arrayPath,
	        {
	            ...typeof input !== 'undefined' && {
	                input: input
	            },
	            ...type && type !== 'any' && {
	                type: type
	            }
	        }
	    ];
	}

	/**
	 * We treat `undefined` as an input the same as omitting an `input`
	 * https://github.com/trpc/trpc/issues/2290
	 */ function getQueryKeyInternal(path, input) {
	    if (path.length) return input === undefined ? [
	        path
	    ] : [
	        path,
	        input
	    ];
	    return [];
	}

	/**
	 * Create proxy for decorating procedures
	 * @internal
	 */ function createReactProxyDecoration(name, hooks) {
	    return createRecursiveProxy((opts)=>{
	        const args = opts.args;
	        const pathCopy = [
	            name,
	            ...opts.path
	        ];
	        // The last arg is for instance `.useMutation` or `.useQuery()`
	        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
	        const lastArg = pathCopy.pop();
	        // The `path` ends up being something like `post.byId`
	        const path = pathCopy.join('.');
	        if (lastArg === 'useMutation') {
	            return hooks[lastArg](path, ...args);
	        }
	        const [input, ...rest] = args;
	        const queryKey = getQueryKeyInternal(path, input);
	        // Expose queryKey helper
	        if (lastArg === 'getQueryKey') {
	            return getArrayQueryKey(queryKey, rest[0] ?? 'any');
	        }
	        if (lastArg === '_def') {
	            return {
	                path: pathCopy
	            };
	        }
	        if (lastArg.startsWith('useSuspense')) {
	            const opts1 = rest[0] || {};
	            const fn = lastArg === 'useSuspenseQuery' ? 'useQuery' : 'useInfiniteQuery';
	            const result = hooks[fn](queryKey, {
	                ...opts1,
	                suspense: true,
	                enabled: true
	            });
	            return [
	                result.data,
	                result
	            ];
	        }
	        return hooks[lastArg](queryKey, ...rest);
	    });
	}

	const contextProps = [
	    'client',
	    'ssrContext',
	    'ssrState',
	    'abortOnUnmount'
	];
	const TRPCContext = /*#__PURE__*/ reactExports.createContext(null);

	/**
	 * @internal
	 */ function createReactQueryUtilsProxy(context) {
	    return createFlatProxy((key)=>{
	        const contextName = key;
	        if (contextName === 'client') {
	            return createTRPCClientProxy(context.client);
	        }
	        if (contextProps.includes(contextName)) {
	            return context[contextName];
	        }
	        return createRecursiveProxy(({ path , args  })=>{
	            const pathCopy = [
	                key,
	                ...path
	            ];
	            const utilName = pathCopy.pop();
	            const fullPath = pathCopy.join('.');
	            const getOpts = (name)=>{
	                if ([
	                    'setData',
	                    'setInfiniteData'
	                ].includes(name)) {
	                    const [input, updater, ...rest] = args;
	                    const queryKey = getQueryKeyInternal(fullPath, input);
	                    return {
	                        queryKey,
	                        updater,
	                        rest
	                    };
	                }
	                const [input1, ...rest1] = args;
	                const queryKey1 = getQueryKeyInternal(fullPath, input1);
	                return {
	                    queryKey: queryKey1,
	                    rest: rest1
	                };
	            };
	            const { queryKey , rest , updater  } = getOpts(utilName);
	            const contextMap = {
	                fetch: ()=>context.fetchQuery(queryKey, ...rest),
	                fetchInfinite: ()=>context.fetchInfiniteQuery(queryKey, ...rest),
	                prefetch: ()=>context.prefetchQuery(queryKey, ...rest),
	                prefetchInfinite: ()=>context.prefetchInfiniteQuery(queryKey, ...rest),
	                ensureData: ()=>context.ensureQueryData(queryKey, ...rest),
	                invalidate: ()=>context.invalidateQueries(queryKey, ...rest),
	                reset: ()=>context.resetQueries(queryKey, ...rest),
	                refetch: ()=>context.refetchQueries(queryKey, ...rest),
	                cancel: ()=>context.cancelQuery(queryKey, ...rest),
	                setData: ()=>{
	                    context.setQueryData(queryKey, updater, ...rest);
	                },
	                setInfiniteData: ()=>{
	                    context.setInfiniteQueryData(queryKey, updater, ...rest);
	                },
	                getData: ()=>context.getQueryData(queryKey),
	                getInfiniteData: ()=>context.getInfiniteQueryData(queryKey)
	            };
	            return contextMap[utilName]();
	        });
	    });
	}

	/**
	 * Create proxy for `useQueries` options
	 * @internal
	 */ function createUseQueriesProxy(client) {
	    return createRecursiveProxy((opts)=>{
	        const path = opts.path.join('.');
	        const [input, _opts] = opts.args;
	        const queryKey = getQueryKeyInternal(path, input);
	        const options = {
	            queryKey,
	            queryFn: ()=>{
	                return client.query(path, input, _opts?.trpc);
	            },
	            ..._opts
	        };
	        return options;
	    });
	}

	function getClientArgs(pathAndInput, opts) {
	    const [path, input] = pathAndInput;
	    return [
	        path,
	        input,
	        opts?.trpc
	    ];
	}

	/**
	 * Makes a stable reference of the `trpc` prop
	 */ function useHookResult(value) {
	    const ref = reactExports.useRef(value);
	    ref.current.path = value.path;
	    return ref.current;
	}

	/**
	 * @internal
	 */ function createRootHooks(config) {
	    const mutationSuccessOverride = ((options)=>options.originalFn());
	    const Context = TRPCContext;
	    const ReactQueryContext = config?.reactQueryContext;
	    const createClient = (opts)=>{
	        return createTRPCClient(opts);
	    };
	    const TRPCProvider = (props)=>{
	        const { abortOnUnmount =false , client , queryClient , ssrContext  } = props;
	        const [ssrState, setSSRState] = reactExports.useState(props.ssrState ?? false);
	        reactExports.useEffect(()=>{
	            // Only updating state to `mounted` if we are using SSR.
	            // This makes it so we don't have an unnecessary re-render when opting out of SSR.
	            setSSRState((state)=>state ? 'mounted' : false);
	        }, []);
	        return /*#__PURE__*/ React$2.createElement(Context.Provider, {
	            value: {
	                abortOnUnmount,
	                queryClient,
	                client,
	                ssrContext: ssrContext ?? null,
	                ssrState,
	                fetchQuery: reactExports.useCallback((pathAndInput, opts)=>{
	                    return queryClient.fetchQuery({
	                        ...opts,
	                        queryKey: getArrayQueryKey(pathAndInput, 'query'),
	                        queryFn: ()=>client.query(...getClientArgs(pathAndInput, opts))
	                    });
	                }, [
	                    client,
	                    queryClient
	                ]),
	                fetchInfiniteQuery: reactExports.useCallback((pathAndInput, opts)=>{
	                    return queryClient.fetchInfiniteQuery({
	                        ...opts,
	                        queryKey: getArrayQueryKey(pathAndInput, 'infinite'),
	                        queryFn: ({ pageParam  })=>{
	                            const [path, input] = pathAndInput;
	                            const actualInput = {
	                                ...input,
	                                cursor: pageParam
	                            };
	                            return client.query(...getClientArgs([
	                                path,
	                                actualInput
	                            ], opts));
	                        }
	                    });
	                }, [
	                    client,
	                    queryClient
	                ]),
	                prefetchQuery: reactExports.useCallback((pathAndInput, opts)=>{
	                    return queryClient.prefetchQuery({
	                        ...opts,
	                        queryKey: getArrayQueryKey(pathAndInput, 'query'),
	                        queryFn: ()=>client.query(...getClientArgs(pathAndInput, opts))
	                    });
	                }, [
	                    client,
	                    queryClient
	                ]),
	                prefetchInfiniteQuery: reactExports.useCallback((pathAndInput, opts)=>{
	                    return queryClient.prefetchInfiniteQuery({
	                        ...opts,
	                        queryKey: getArrayQueryKey(pathAndInput, 'infinite'),
	                        queryFn: ({ pageParam  })=>{
	                            const [path, input] = pathAndInput;
	                            const actualInput = {
	                                ...input,
	                                cursor: pageParam
	                            };
	                            return client.query(...getClientArgs([
	                                path,
	                                actualInput
	                            ], opts));
	                        }
	                    });
	                }, [
	                    client,
	                    queryClient
	                ]),
	                ensureQueryData: reactExports.useCallback((pathAndInput, opts)=>{
	                    return queryClient.ensureQueryData({
	                        ...opts,
	                        queryKey: getArrayQueryKey(pathAndInput, 'query'),
	                        queryFn: ()=>client.query(...getClientArgs(pathAndInput, opts))
	                    });
	                }, [
	                    client,
	                    queryClient
	                ]),
	                invalidateQueries: reactExports.useCallback((queryKey, filters, options)=>{
	                    return queryClient.invalidateQueries({
	                        ...filters,
	                        queryKey: getArrayQueryKey(queryKey, 'any')
	                    }, options);
	                }, [
	                    queryClient
	                ]),
	                resetQueries: reactExports.useCallback((...args)=>{
	                    const [queryKey, filters, options] = args;
	                    return queryClient.resetQueries({
	                        ...filters,
	                        queryKey: getArrayQueryKey(queryKey, 'any')
	                    }, options);
	                }, [
	                    queryClient
	                ]),
	                refetchQueries: reactExports.useCallback((...args)=>{
	                    const [queryKey, filters, options] = args;
	                    return queryClient.refetchQueries({
	                        ...filters,
	                        queryKey: getArrayQueryKey(queryKey, 'any')
	                    }, options);
	                }, [
	                    queryClient
	                ]),
	                cancelQuery: reactExports.useCallback((pathAndInput)=>{
	                    return queryClient.cancelQueries({
	                        queryKey: getArrayQueryKey(pathAndInput, 'any')
	                    });
	                }, [
	                    queryClient
	                ]),
	                setQueryData: reactExports.useCallback((...args)=>{
	                    const [queryKey, ...rest] = args;
	                    return queryClient.setQueryData(getArrayQueryKey(queryKey, 'query'), ...rest);
	                }, [
	                    queryClient
	                ]),
	                getQueryData: reactExports.useCallback((...args)=>{
	                    const [queryKey, ...rest] = args;
	                    return queryClient.getQueryData(getArrayQueryKey(queryKey, 'query'), ...rest);
	                }, [
	                    queryClient
	                ]),
	                setInfiniteQueryData: reactExports.useCallback((...args)=>{
	                    const [queryKey, ...rest] = args;
	                    return queryClient.setQueryData(getArrayQueryKey(queryKey, 'infinite'), ...rest);
	                }, [
	                    queryClient
	                ]),
	                getInfiniteQueryData: reactExports.useCallback((...args)=>{
	                    const [queryKey, ...rest] = args;
	                    return queryClient.getQueryData(getArrayQueryKey(queryKey, 'infinite'), ...rest);
	                }, [
	                    queryClient
	                ])
	            }
	        }, props.children);
	    };
	    function useContext() {
	        return React$2.useContext(Context);
	    }
	    /**
	   * Hack to make sure errors return `status`='error` when doing SSR
	   * @link https://github.com/trpc/trpc/pull/1645
	   */ function useSSRQueryOptionsIfNeeded(pathAndInput, type, opts) {
	        const { queryClient , ssrState  } = useContext();
	        return ssrState && ssrState !== 'mounted' && queryClient.getQueryCache().find(getArrayQueryKey(pathAndInput, type))?.state.status === 'error' ? {
	            retryOnMount: false,
	            ...opts
	        } : opts;
	    }
	    function useQuery$1(// FIXME path should be a tuple in next major
	    pathAndInput, opts) {
	        const context = useContext();
	        if (!context) {
	            throw new Error('Unable to retrieve application context. Did you forget to wrap your App inside `withTRPC` HoC?');
	        }
	        const { abortOnUnmount , client , ssrState , queryClient , prefetchQuery  } = context;
	        const defaultOpts = queryClient.getQueryDefaults(getArrayQueryKey(pathAndInput, 'query'));
	        if (typeof window === 'undefined' && ssrState === 'prepass' && opts?.trpc?.ssr !== false && (opts?.enabled ?? defaultOpts?.enabled) !== false && !queryClient.getQueryCache().find(getArrayQueryKey(pathAndInput, 'query'))) {
	            void prefetchQuery(pathAndInput, opts);
	        }
	        const ssrOpts = useSSRQueryOptionsIfNeeded(pathAndInput, 'query', {
	            ...defaultOpts,
	            ...opts
	        });
	        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? config?.abortOnUnmount ?? abortOnUnmount;
	        const hook = useQuery({
	            ...ssrOpts,
	            queryKey: getArrayQueryKey(pathAndInput, 'query'),
	            queryFn: (queryFunctionContext)=>{
	                const actualOpts = {
	                    ...ssrOpts,
	                    trpc: {
	                        ...ssrOpts?.trpc,
	                        ...shouldAbortOnUnmount ? {
	                            signal: queryFunctionContext.signal
	                        } : {}
	                    }
	                };
	                return client.query(...getClientArgs(pathAndInput, actualOpts));
	            },
	            context: ReactQueryContext
	        });
	        hook.trpc = useHookResult({
	            path: pathAndInput[0]
	        });
	        return hook;
	    }
	    function useMutation$1(// FIXME: this should only be a tuple path in next major
	    path, opts) {
	        const { client  } = useContext();
	        const queryClient = useQueryClient({
	            context: ReactQueryContext
	        });
	        const actualPath = Array.isArray(path) ? path[0] : path;
	        const defaultOpts = queryClient.getMutationDefaults([
	            actualPath.split('.')
	        ]);
	        const hook = useMutation({
	            ...opts,
	            mutationKey: [
	                actualPath.split('.')
	            ],
	            mutationFn: (input)=>{
	                return client.mutation(...getClientArgs([
	                    actualPath,
	                    input
	                ], opts));
	            },
	            context: ReactQueryContext,
	            onSuccess (...args) {
	                const originalFn = ()=>opts?.onSuccess?.(...args) ?? defaultOpts?.onSuccess?.(...args);
	                return mutationSuccessOverride({
	                    originalFn,
	                    queryClient,
	                    meta: opts?.meta ?? defaultOpts?.meta ?? {}
	                });
	            }
	        });
	        hook.trpc = useHookResult({
	            path: actualPath
	        });
	        return hook;
	    }
	    /* istanbul ignore next -- @preserve */ function useSubscription(pathAndInput, opts) {
	        const enabled = opts?.enabled ?? true;
	        const queryKey = hashQueryKey();
	        const { client  } = useContext();
	        const optsRef = reactExports.useRef(opts);
	        optsRef.current = opts;
	        reactExports.useEffect(()=>{
	            if (!enabled) {
	                return;
	            }
	            const [path, input] = pathAndInput;
	            let isStopped = false;
	            const subscription = client.subscription(path, input ?? undefined, {
	                onStarted: ()=>{
	                    if (!isStopped) {
	                        optsRef.current.onStarted?.();
	                    }
	                },
	                onData: (data)=>{
	                    if (!isStopped) {
	                        // FIXME this shouldn't be needed as both should be `unknown` in next major
	                        optsRef.current.onData(data);
	                    }
	                },
	                onError: (err)=>{
	                    if (!isStopped) {
	                        optsRef.current.onError?.(err);
	                    }
	                }
	            });
	            return ()=>{
	                isStopped = true;
	                subscription.unsubscribe();
	            };
	        // eslint-disable-next-line react-hooks/exhaustive-deps
	        }, [
	            queryKey,
	            enabled
	        ]);
	    }
	    function useInfiniteQuery$1(pathAndInput, opts) {
	        const [path, input] = pathAndInput;
	        const { client , ssrState , prefetchInfiniteQuery , queryClient , abortOnUnmount ,  } = useContext();
	        const defaultOpts = queryClient.getQueryDefaults(getArrayQueryKey(pathAndInput, 'infinite'));
	        if (typeof window === 'undefined' && ssrState === 'prepass' && opts?.trpc?.ssr !== false && (opts?.enabled ?? defaultOpts?.enabled) !== false && !queryClient.getQueryCache().find(getArrayQueryKey(pathAndInput, 'infinite'))) {
	            void prefetchInfiniteQuery(pathAndInput, {
	                ...defaultOpts,
	                ...opts
	            });
	        }
	        const ssrOpts = useSSRQueryOptionsIfNeeded(pathAndInput, 'infinite', {
	            ...defaultOpts,
	            ...opts
	        });
	        // request option should take priority over global
	        const shouldAbortOnUnmount = opts?.trpc?.abortOnUnmount ?? abortOnUnmount;
	        const hook = useInfiniteQuery({
	            ...ssrOpts,
	            queryKey: getArrayQueryKey(pathAndInput, 'infinite'),
	            queryFn: (queryFunctionContext)=>{
	                const actualOpts = {
	                    ...ssrOpts,
	                    trpc: {
	                        ...ssrOpts?.trpc,
	                        ...shouldAbortOnUnmount ? {
	                            signal: queryFunctionContext.signal
	                        } : {}
	                    }
	                };
	                const actualInput = {
	                    ...input ?? {},
	                    cursor: queryFunctionContext.pageParam ?? opts?.initialCursor
	                };
	                // FIXME as any shouldn't be needed as client should be untyped too
	                return client.query(...getClientArgs([
	                    path,
	                    actualInput
	                ], actualOpts));
	            },
	            context: ReactQueryContext
	        });
	        hook.trpc = useHookResult({
	            path
	        });
	        return hook;
	    }
	    const useQueries$1 = (queriesCallback, context)=>{
	        const { ssrState , queryClient , prefetchQuery , client  } = useContext();
	        const proxy = createUseQueriesProxy(client);
	        const queries = queriesCallback(proxy);
	        if (typeof window === 'undefined' && ssrState === 'prepass') {
	            for (const query of queries){
	                const queryOption = query;
	                if (queryOption.trpc?.ssr !== false && !queryClient.getQueryCache().find(getArrayQueryKey(queryOption.queryKey, 'query'))) {
	                    void prefetchQuery(queryOption.queryKey, queryOption);
	                }
	            }
	        }
	        return useQueries({
	            queries: queries.map((query)=>({
	                    ...query,
	                    queryKey: getArrayQueryKey(query.queryKey, 'query')
	                })),
	            context
	        });
	    };
	    const useDehydratedState = (client, trpcState)=>{
	        const transformed = reactExports.useMemo(()=>{
	            if (!trpcState) {
	                return trpcState;
	            }
	            return client.runtime.transformer.deserialize(trpcState);
	        }, [
	            trpcState,
	            client
	        ]);
	        return transformed;
	    };
	    return {
	        Provider: TRPCProvider,
	        createClient,
	        useContext,
	        useQuery: useQuery$1,
	        useQueries: useQueries$1,
	        useMutation: useMutation$1,
	        useSubscription,
	        useDehydratedState,
	        useInfiniteQuery: useInfiniteQuery$1
	    };
	}

	/**
	 * Create strongly typed react hooks
	 * @internal
	 * @deprecated
	 */ function createHooksInternal(config) {
	    return createRootHooks(config);
	}

	/**
	 * @internal
	 */ function createHooksInternalProxy(trpc) {
	    return createFlatProxy((key)=>{
	        if (key === 'useContext') {
	            return ()=>{
	                const context = trpc.useContext();
	                // create a stable reference of the utils context
	                return reactExports.useMemo(()=>{
	                    return createReactQueryUtilsProxy(context);
	                }, [
	                    context
	                ]);
	            };
	        }
	        if (trpc.hasOwnProperty(key)) {
	            return trpc[key];
	        }
	        return createReactProxyDecoration(key, trpc);
	    });
	}
	function createTRPCReact(opts) {
	    const hooks = createHooksInternal(opts);
	    const proxy = createHooksInternalProxy(hooks);
	    return proxy;
	}

	const trpc = createTRPCReact();

	const FlashesProvider = reactExports.createContext


	({
	    info: [],
	    error: [],
	});

	const defaultMutableStore = {
	    ssrUrl: "",
	    lightThemeOnly: false,
	};

	class ReqMutableStore {
	    constructor( _store) {this._store = _store;
	        this._store = Object.assign({}, _store);
	    }

	    get(key) {
	        return this._store[key];
	    }

	    assign(newConfig) {
	        Object.assign(this._store, newConfig);
	    }
	}

	const ReqMutableStoreContext = reactExports.createContext(
	    new ReqMutableStore({ ...defaultMutableStore })
	);

	const ReqMutableStoreProvider


	 = React$2.memo(({ children, store }) => {
	    const mutableStore = new ReqMutableStore(store);
	    return (
	        React$2.createElement(ReqMutableStoreContext.Provider, { value: mutableStore,}
	            , children
	        )
	    );
	});
	ReqMutableStoreProvider.displayName = "ReqMutableStoreProvider";

	const useReqMutableStore = () => reactExports.useContext(ReqMutableStoreContext);

	var rollbar_umd_min = {exports: {}};

	(function (module, exports) {
		!function(t,e){module.exports=e();}(commonjsGlobal,(function(){return function(t){var e={};function r(n){if(e[n])return e[n].exports;var o=e[n]={i:n,l:!1,exports:{}};return t[n].call(o.exports,o,o.exports,r),o.l=!0,o.exports}return r.m=t,r.c=e,r.d=function(t,e,n){r.o(t,e)||Object.defineProperty(t,e,{enumerable:!0,get:n});},r.r=function(t){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0});},r.t=function(t,e){if(1&e&&(t=r(t)),8&e)return t;if(4&e&&"object"==typeof t&&t&&t.__esModule)return t;var n=Object.create(null);if(r.r(n),Object.defineProperty(n,"default",{enumerable:!0,value:t}),2&e&&"string"!=typeof t)for(var o in t)r.d(n,o,function(e){return t[e]}.bind(null,o));return n},r.n=function(t){var e=t&&t.__esModule?function(){return t.default}:function(){return t};return r.d(e,"a",e),e},r.o=function(t,e){return Object.prototype.hasOwnProperty.call(t,e)},r.p="",r(r.s=6)}([function(t,e,r){var n=r(12),o={},i=!1;function a(t,e){return e===s(t)}function s(t){var e=typeof t;return "object"!==e?e:t?t instanceof Error?"error":{}.toString.call(t).match(/\s([a-zA-Z]+)/)[1].toLowerCase():"null"}function u(t){return a(t,"function")}function c(t){var e=Function.prototype.toString.call(Object.prototype.hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?"),r=RegExp("^"+e+"$");return l(t)&&r.test(t)}function l(t){var e=typeof t;return null!=t&&("object"==e||"function"==e)}function p(){var t=y();return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,(function(e){var r=(t+16*Math.random())%16|0;return t=Math.floor(t/16),("x"===e?r:7&r|8).toString(16)}))}var f={strictMode:!1,key:["source","protocol","authority","userInfo","user","password","host","port","relative","path","directory","file","query","anchor"],q:{name:"queryKey",parser:/(?:^|&)([^&=]*)=?([^&]*)/g},parser:{strict:/^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,loose:/^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/}};function h(t,e){var r,n;try{r=o.stringify(t);}catch(o){if(e&&u(e))try{r=e(t);}catch(t){n=t;}else n=o;}return {error:n,value:r}}function d(t,e){return function(r,n){try{e(r,n);}catch(e){t.error(e);}}}var m=["log","network","dom","navigation","error","manual"],g=["critical","error","warning","info","debug"];function v(t,e){for(var r=0;r<t.length;++r)if(t[r]===e)return !0;return !1}function y(){return Date.now?+Date.now():+new Date}t.exports={addParamsAndAccessTokenToPath:function(t,e,r){(r=r||{}).access_token=t;var n,o=[];for(n in r)Object.prototype.hasOwnProperty.call(r,n)&&o.push([n,r[n]].join("="));var i="?"+o.sort().join("&");(e=e||{}).path=e.path||"";var a,s=e.path.indexOf("?"),u=e.path.indexOf("#");-1!==s&&(-1===u||u>s)?(a=e.path,e.path=a.substring(0,s)+i+"&"+a.substring(s+1)):-1!==u?(a=e.path,e.path=a.substring(0,u)+i+a.substring(u)):e.path=e.path+i;},createItem:function(t,e,r,o,i){for(var a,u,c,l,f,h,m=[],g=[],v=0,b=t.length;v<b;++v){var w=s(h=t[v]);switch(g.push(w),w){case"undefined":break;case"string":a?m.push(h):a=h;break;case"function":l=d(e,h);break;case"date":m.push(h);break;case"error":case"domexception":case"exception":u?m.push(h):u=h;break;case"object":case"array":if(h instanceof Error||"undefined"!=typeof DOMException&&h instanceof DOMException){u?m.push(h):u=h;break}if(o&&"object"===w&&!f){for(var _=0,x=o.length;_<x;++_)if(void 0!==h[o[_]]){f=h;break}if(f)break}c?m.push(h):c=h;break;default:if(h instanceof Error||"undefined"!=typeof DOMException&&h instanceof DOMException){u?m.push(h):u=h;break}m.push(h);}}m.length>0&&((c=n(c)).extraArgs=m);var k={message:a,err:u,custom:c,timestamp:y(),callback:l,notifier:r,diagnostic:{},uuid:p()};return function(t,e){e&&void 0!==e.level&&(t.level=e.level,delete e.level);e&&void 0!==e.skipFrames&&(t.skipFrames=e.skipFrames,delete e.skipFrames);}(k,c),o&&f&&(k.request=f),i&&(k.lambdaContext=i),k._originalArgs=t,k.diagnostic.original_arg_types=g,k},addErrorContext:function(t,e){var r=t.data.custom||{},o=!1;try{for(var i=0;i<e.length;++i)e[i].hasOwnProperty("rollbarContext")&&(r=n(r,e[i].rollbarContext),o=!0);o&&(t.data.custom=r);}catch(e){t.diagnostic.error_context="Failed: "+e.message;}},createTelemetryEvent:function(t){for(var e,r,n,o,i=0,a=t.length;i<a;++i){switch(s(o=t[i])){case"string":!e&&v(m,o)?e=o:!n&&v(g,o)&&(n=o);break;case"object":r=o;}}return {type:e||"manual",metadata:r||{},level:n}},filterIp:function(t,e){if(t&&t.user_ip&&!0!==e){var r=t.user_ip;if(e)try{var n;if(-1!==r.indexOf("."))(n=r.split(".")).pop(),n.push("0"),r=n.join(".");else if(-1!==r.indexOf(":")){if((n=r.split(":")).length>2){var o=n.slice(0,3),i=o[2].indexOf("/");-1!==i&&(o[2]=o[2].substring(0,i));r=o.concat("0000:0000:0000:0000:0000").join(":");}}else r=null;}catch(t){r=null;}else r=null;t.user_ip=r;}},formatArgsAsString:function(t){var e,r,n,o=[];for(e=0,r=t.length;e<r;++e){switch(s(n=t[e])){case"object":(n=(n=h(n)).error||n.value).length>500&&(n=n.substr(0,497)+"...");break;case"null":n="null";break;case"undefined":n="undefined";break;case"symbol":n=n.toString();}o.push(n);}return o.join(" ")},formatUrl:function(t,e){if(!(e=e||t.protocol)&&t.port&&(80===t.port?e="http:":443===t.port&&(e="https:")),e=e||"https:",!t.hostname)return null;var r=e+"//"+t.hostname;return t.port&&(r=r+":"+t.port),t.path&&(r+=t.path),r},get:function(t,e){if(t){var r=e.split("."),n=t;try{for(var o=0,i=r.length;o<i;++o)n=n[r[o]];}catch(t){n=void 0;}return n}},handleOptions:function(t,e,r){var o=n(t,e,r);return !e||e.overwriteScrubFields||e.scrubFields&&(o.scrubFields=(t.scrubFields||[]).concat(e.scrubFields)),o},isError:function(t){return a(t,"error")||a(t,"exception")},isFunction:u,isIterable:function(t){var e=s(t);return "object"===e||"array"===e},isNativeFunction:c,isType:a,isObject:l,isString:function(t){return "string"==typeof t||t instanceof String},jsonParse:function(t){var e,r;try{e=o.parse(t);}catch(t){r=t;}return {error:r,value:e}},LEVELS:{debug:0,info:1,warning:2,error:3,critical:4},makeUnhandledStackInfo:function(t,e,r,n,o,i,a,s){var u={url:e||"",line:r,column:n};u.func=s.guessFunctionName(u.url,u.line),u.context=s.gatherContext(u.url,u.line);var c=document&&document.location&&document.location.href,l=window&&window.navigator&&window.navigator.userAgent;return {mode:i,message:o?String(o):t||a,url:c,stack:[u],useragent:l}},merge:n,now:y,redact:function(){return "********"},sanitizeUrl:function(t){var e=function(t){if(!a(t,"string"))return;for(var e=f,r=e.parser[e.strictMode?"strict":"loose"].exec(t),n={},o=0,i=e.key.length;o<i;++o)n[e.key[o]]=r[o]||"";return n[e.q.name]={},n[e.key[12]].replace(e.q.parser,(function(t,r,o){r&&(n[e.q.name][r]=o);})),n}(t);return e?(""===e.anchor&&(e.source=e.source.replace("#","")),t=e.source.replace("?"+e.query,"")):"(unknown)"},set:function(t,e,r){if(t){var n=e.split("."),o=n.length;if(!(o<1))if(1!==o)try{for(var i=t[n[0]]||{},a=i,s=1;s<o-1;++s)i[n[s]]=i[n[s]]||{},i=i[n[s]];i[n[o-1]]=r,t[n[0]]=a;}catch(t){return}else t[n[0]]=r;}},setupJSON:function(t){i||(i=!0,a(JSON,"undefined")||(c(JSON.stringify)&&(o.stringify=JSON.stringify),c(JSON.parse)&&(o.parse=JSON.parse)),u(o.stringify)&&u(o.parse)||t(o));},stringify:h,maxByteSize:function(t){for(var e=0,r=t.length,n=0;n<r;n++){var o=t.charCodeAt(n);o<128?e+=1:o<2048?e+=2:o<65536&&(e+=3);}return e},typeName:s,uuid4:p};},function(t,e,r){r(17);var n=r(18),o=r(0);t.exports={error:function(){var t=Array.prototype.slice.call(arguments,0);t.unshift("Rollbar:"),n.ieVersion()<=8?console.error(o.formatArgsAsString(t)):console.error.apply(console,t);},info:function(){var t=Array.prototype.slice.call(arguments,0);t.unshift("Rollbar:"),n.ieVersion()<=8?console.info(o.formatArgsAsString(t)):console.info.apply(console,t);},log:function(){var t=Array.prototype.slice.call(arguments,0);t.unshift("Rollbar:"),n.ieVersion()<=8?console.log(o.formatArgsAsString(t)):console.log.apply(console,t);}};},function(t,e,r){t.exports={parse:function(t){var e,r,n={protocol:null,auth:null,host:null,path:null,hash:null,href:t,hostname:null,port:null,pathname:null,search:null,query:null};if(-1!==(e=t.indexOf("//"))?(n.protocol=t.substring(0,e),r=e+2):r=0,-1!==(e=t.indexOf("@",r))&&(n.auth=t.substring(r,e),r=e+1),-1===(e=t.indexOf("/",r))){if(-1===(e=t.indexOf("?",r)))return -1===(e=t.indexOf("#",r))?n.host=t.substring(r):(n.host=t.substring(r,e),n.hash=t.substring(e)),n.hostname=n.host.split(":")[0],n.port=n.host.split(":")[1],n.port&&(n.port=parseInt(n.port,10)),n;n.host=t.substring(r,e),n.hostname=n.host.split(":")[0],n.port=n.host.split(":")[1],n.port&&(n.port=parseInt(n.port,10)),r=e;}else n.host=t.substring(r,e),n.hostname=n.host.split(":")[0],n.port=n.host.split(":")[1],n.port&&(n.port=parseInt(n.port,10)),r=e;if(-1===(e=t.indexOf("#",r))?n.path=t.substring(r):(n.path=t.substring(r,e),n.hash=t.substring(e)),n.path){var o=n.path.split("?");n.pathname=o[0],n.query=o[1],n.search=n.query?"?"+n.query:null;}return n}};},function(t,e,r){var n=r(22),o=new RegExp("^(([a-zA-Z0-9-_$ ]*): *)?(Uncaught )?([a-zA-Z0-9-_$ ]*): ");function i(){return null}function a(t){var e={};return e._stackFrame=t,e.url=t.fileName,e.line=t.lineNumber,e.func=t.functionName,e.column=t.columnNumber,e.args=t.args,e.context=null,e}function s(t,e){return {stack:function(){var r=[];e=e||0;try{r=n.parse(t);}catch(t){r=[];}for(var o=[],i=e;i<r.length;i++)o.push(new a(r[i]));return o}(),message:t.message,name:u(t),rawStack:t.stack,rawException:t}}function u(t){var e=t.name&&t.name.length&&t.name,r=t.constructor.name&&t.constructor.name.length&&t.constructor.name;return e&&r?"Error"===e?r:e:e||r}t.exports={guessFunctionName:function(){return "?"},guessErrorClass:function(t){if(!t||!t.match)return ["Unknown error. There was no error message to display.",""];var e=t.match(o),r="(unknown)";return e&&(r=e[e.length-1],t=(t=t.replace((e[e.length-2]||"")+r+":","")).replace(/(^[\s]+|[\s]+$)/g,"")),[r,t]},gatherContext:i,parse:function(t,e){var r=t;if(r.nested){for(var n=[];r;)n.push(new s(r,e)),r=r.nested,e=0;return n[0].traceChain=n,n[0]}return new s(r,e)},Stack:s,Frame:a};},function(t,e,r){var n=r(0),o=r(5);function i(t,e){var r=e.split("."),o=r.length-1;try{for(var i=0;i<=o;++i)i<o?t=t[r[i]]:t[r[i]]=n.redact();}catch(t){}}t.exports=function(t,e,r){if(e=e||[],r)for(var a=0;a<r.length;++a)i(t,r[a]);var s=function(t){for(var e,r=[],n=0;n<t.length;++n)e="^\\[?(%5[bB])?"+t[n]+"\\[?(%5[bB])?\\]?(%5[dD])?$",r.push(new RegExp(e,"i"));return r}(e),u=function(t){for(var e,r=[],n=0;n<t.length;++n)e="\\[?(%5[bB])?"+t[n]+"\\[?(%5[bB])?\\]?(%5[dD])?",r.push(new RegExp("("+e+"=)([^&\\n]+)","igm"));return r}(e);function c(t,e){return e+n.redact()}return o(t,(function t(e,r,i){var a=function(t,e){var r;for(r=0;r<s.length;++r)if(s[r].test(t)){e=n.redact();break}return e}(e,r);return a===r?n.isType(r,"object")||n.isType(r,"array")?o(r,t,i):function(t){var e;if(n.isType(t,"string"))for(e=0;e<u.length;++e)t=t.replace(u[e],c);return t}(a):a}),[])};},function(t,e,r){var n=r(0);t.exports=function(t,e,r){var o,i,a,s=n.isType(t,"object"),u=n.isType(t,"array"),c=[];if(s&&-1!==r.indexOf(t))return t;if(r.push(t),s)for(o in t)Object.prototype.hasOwnProperty.call(t,o)&&c.push(o);else if(u)for(a=0;a<t.length;++a)c.push(a);var l=s?{}:[],p=!0;for(a=0;a<c.length;++a)i=t[o=c[a]],l[o]=e(o,i,r),p=p&&l[o]===t[o];return 0==c.length||p?t:l};},function(t,e,r){t.exports=r(7);},function(t,e,r){var n=r(8),o="undefined"!=typeof window&&window._rollbarConfig,i=o&&o.globalAlias||"Rollbar",a="undefined"!=typeof window&&window[i]&&"function"==typeof window[i].shimId&&void 0!==window[i].shimId();if("undefined"==typeof window||window._rollbarStartTime||(window._rollbarStartTime=(new Date).getTime()),!a&&o){var s=new n(o);window[i]=s;}else "undefined"!=typeof window?(window.rollbar=n,window._rollbarDidLoad=!0):"undefined"!=typeof self&&(self.rollbar=n,self._rollbarDidLoad=!0);t.exports=n;},function(t,e,r){var n=r(9),o=r(29),i=r(30),a=r(32),s=r(33),u=r(4),c=r(34);n.setComponents({telemeter:o,instrumenter:i,polyfillJSON:a,wrapGlobals:s,scrub:u,truncation:c}),t.exports=n;},function(t,e,r){var n=r(10),o=r(0),i=r(15),a=r(1),s=r(19),u=r(20),c=r(2),l=r(21),p=r(24),f=r(25),h=r(26),d=r(3);function m(t,e){this.options=o.handleOptions(x,t),this.options._configuredOptions=t;var r=this.components.telemeter,s=this.components.instrumenter,d=this.components.polyfillJSON;this.wrapGlobals=this.components.wrapGlobals,this.scrub=this.components.scrub;var m=this.components.truncation,g=new u(m),v=new i(this.options,g,c,m);r&&(this.telemeter=new r(this.options)),this.client=e||new n(this.options,v,a,this.telemeter,"browser");var y=b(),w="undefined"!=typeof document&&document;this.isChrome=y.chrome&&y.chrome.runtime,this.anonymousErrorsPending=0,function(t,e,r){t.addTransform(l.handleDomException).addTransform(l.handleItemWithError).addTransform(l.ensureItemHasSomethingToSay).addTransform(l.addBaseInfo).addTransform(l.addRequestInfo(r)).addTransform(l.addClientInfo(r)).addTransform(l.addPluginInfo(r)).addTransform(l.addBody).addTransform(p.addMessageWithError).addTransform(p.addTelemetryData).addTransform(p.addConfigToPayload).addTransform(l.addScrubber(e.scrub)).addTransform(p.userTransform(a)).addTransform(p.addConfiguredOptions).addTransform(p.addDiagnosticKeys).addTransform(p.itemToPayload);}(this.client.notifier,this,y),this.client.queue.addPredicate(h.checkLevel).addPredicate(f.checkIgnore).addPredicate(h.userCheckIgnore(a)).addPredicate(h.urlIsNotBlacklisted(a)).addPredicate(h.urlIsWhitelisted(a)).addPredicate(h.messageIsIgnored(a)),this.setupUnhandledCapture(),s&&(this.instrumenter=new s(this.options,this.client.telemeter,this,y,w),this.instrumenter.instrument()),o.setupJSON(d);}var g=null;function v(t){var e="Rollbar is not initialized";a.error(e),t&&t(new Error(e));}function y(t){for(var e=0,r=t.length;e<r;++e)if(o.isFunction(t[e]))return t[e]}function b(){return "undefined"!=typeof window&&window||"undefined"!=typeof self&&self}m.init=function(t,e){return g?g.global(t).configure(t):g=new m(t,e)},m.prototype.components={},m.setComponents=function(t){m.prototype.components=t;},m.prototype.global=function(t){return this.client.global(t),this},m.global=function(t){if(g)return g.global(t);v();},m.prototype.configure=function(t,e){var r=this.options,n={};return e&&(n={payload:e}),this.options=o.handleOptions(r,t,n),this.options._configuredOptions=o.handleOptions(r._configuredOptions,t,n),this.client.configure(this.options,e),this.instrumenter&&this.instrumenter.configure(this.options),this.setupUnhandledCapture(),this},m.configure=function(t,e){if(g)return g.configure(t,e);v();},m.prototype.lastError=function(){return this.client.lastError},m.lastError=function(){if(g)return g.lastError();v();},m.prototype.log=function(){var t=this._createItem(arguments),e=t.uuid;return this.client.log(t),{uuid:e}},m.log=function(){if(g)return g.log.apply(g,arguments);var t=y(arguments);v(t);},m.prototype.debug=function(){var t=this._createItem(arguments),e=t.uuid;return this.client.debug(t),{uuid:e}},m.debug=function(){if(g)return g.debug.apply(g,arguments);var t=y(arguments);v(t);},m.prototype.info=function(){var t=this._createItem(arguments),e=t.uuid;return this.client.info(t),{uuid:e}},m.info=function(){if(g)return g.info.apply(g,arguments);var t=y(arguments);v(t);},m.prototype.warn=function(){var t=this._createItem(arguments),e=t.uuid;return this.client.warn(t),{uuid:e}},m.warn=function(){if(g)return g.warn.apply(g,arguments);var t=y(arguments);v(t);},m.prototype.warning=function(){var t=this._createItem(arguments),e=t.uuid;return this.client.warning(t),{uuid:e}},m.warning=function(){if(g)return g.warning.apply(g,arguments);var t=y(arguments);v(t);},m.prototype.error=function(){var t=this._createItem(arguments),e=t.uuid;return this.client.error(t),{uuid:e}},m.error=function(){if(g)return g.error.apply(g,arguments);var t=y(arguments);v(t);},m.prototype.critical=function(){var t=this._createItem(arguments),e=t.uuid;return this.client.critical(t),{uuid:e}},m.critical=function(){if(g)return g.critical.apply(g,arguments);var t=y(arguments);v(t);},m.prototype.buildJsonPayload=function(t){return this.client.buildJsonPayload(t)},m.buildJsonPayload=function(){if(g)return g.buildJsonPayload.apply(g,arguments);v();},m.prototype.sendJsonPayload=function(t){return this.client.sendJsonPayload(t)},m.sendJsonPayload=function(){if(g)return g.sendJsonPayload.apply(g,arguments);v();},m.prototype.setupUnhandledCapture=function(){var t=b();this.unhandledExceptionsInitialized||(this.options.captureUncaught||this.options.handleUncaughtExceptions)&&(s.captureUncaughtExceptions(t,this),this.wrapGlobals&&this.options.wrapGlobalEventHandlers&&this.wrapGlobals(t,this),this.unhandledExceptionsInitialized=!0),this.unhandledRejectionsInitialized||(this.options.captureUnhandledRejections||this.options.handleUnhandledRejections)&&(s.captureUnhandledRejections(t,this),this.unhandledRejectionsInitialized=!0);},m.prototype.handleUncaughtException=function(t,e,r,n,i,a){if(this.options.captureUncaught||this.options.handleUncaughtExceptions){if(this.options.inspectAnonymousErrors&&this.isChrome&&null===i)return "anonymous";var s,u=o.makeUnhandledStackInfo(t,e,r,n,i,"onerror","uncaught exception",d);o.isError(i)?(s=this._createItem([t,i,a]))._unhandledStackInfo=u:o.isError(e)?(s=this._createItem([t,e,a]))._unhandledStackInfo=u:(s=this._createItem([t,a])).stackInfo=u,s.level=this.options.uncaughtErrorLevel,s._isUncaught=!0,this.client.log(s);}},m.prototype.handleAnonymousErrors=function(){if(this.options.inspectAnonymousErrors&&this.isChrome){var t=this;try{Error.prepareStackTrace=function(e,r){if(t.options.inspectAnonymousErrors&&t.anonymousErrorsPending){if(t.anonymousErrorsPending-=1,!e)return;e._isAnonymous=!0,t.handleUncaughtException(e.message,null,null,null,e);}return e.stack};}catch(t){this.options.inspectAnonymousErrors=!1,this.error("anonymous error handler failed",t);}}},m.prototype.handleUnhandledRejection=function(t,e){if(this.options.captureUnhandledRejections||this.options.handleUnhandledRejections){var r="unhandled rejection was null or undefined!";if(t)if(t.message)r=t.message;else {var n=o.stringify(t);n.value&&(r=n.value);}var i,a=t&&t._rollbarContext||e&&e._rollbarContext;o.isError(t)?i=this._createItem([r,t,a]):(i=this._createItem([r,t,a])).stackInfo=o.makeUnhandledStackInfo(r,"",0,0,null,"unhandledrejection","",d),i.level=this.options.uncaughtErrorLevel,i._isUncaught=!0,i._originalArgs=i._originalArgs||[],i._originalArgs.push(e),this.client.log(i);}},m.prototype.wrap=function(t,e,r){try{var n;if(n=o.isFunction(e)?e:function(){return e||{}},!o.isFunction(t))return t;if(t._isWrap)return t;if(!t._rollbar_wrapped&&(t._rollbar_wrapped=function(){r&&o.isFunction(r)&&r.apply(this,arguments);try{return t.apply(this,arguments)}catch(r){var e=r;throw e&&window._rollbarWrappedError!==e&&(o.isType(e,"string")&&(e=new String(e)),e._rollbarContext=n()||{},e._rollbarContext._wrappedSource=t.toString(),window._rollbarWrappedError=e),e}},t._rollbar_wrapped._isWrap=!0,t.hasOwnProperty))for(var i in t)t.hasOwnProperty(i)&&"_rollbar_wrapped"!==i&&(t._rollbar_wrapped[i]=t[i]);return t._rollbar_wrapped}catch(e){return t}},m.wrap=function(t,e){if(g)return g.wrap(t,e);v();},m.prototype.captureEvent=function(){var t=o.createTelemetryEvent(arguments);return this.client.captureEvent(t.type,t.metadata,t.level)},m.captureEvent=function(){if(g)return g.captureEvent.apply(g,arguments);v();},m.prototype.captureDomContentLoaded=function(t,e){return e||(e=new Date),this.client.captureDomContentLoaded(e)},m.prototype.captureLoad=function(t,e){return e||(e=new Date),this.client.captureLoad(e)},m.prototype.loadFull=function(){a.info("Unexpected Rollbar.loadFull() called on a Notifier instance. This can happen when Rollbar is loaded multiple times.");},m.prototype._createItem=function(t){return o.createItem(t,a,this)};var w=r(27),_=r(28),x={version:w.version,scrubFields:_.scrubFields,logLevel:w.logLevel,reportLevel:w.reportLevel,uncaughtErrorLevel:w.uncaughtErrorLevel,endpoint:w.endpoint,verbose:!1,enabled:!0,transmit:!0,sendConfig:!1,includeItemsInTelemetry:!0,captureIp:!0,inspectAnonymousErrors:!0,ignoreDuplicateErrors:!0,wrapGlobalEventHandlers:!1};t.exports=m;},function(t,e,r){var n=r(11),o=r(13),i=r(14),a=r(0);function s(t,e,r,n,l){this.options=a.merge(t),this.logger=r,s.rateLimiter.configureGlobal(this.options),s.rateLimiter.setPlatformOptions(l,this.options),this.api=e,this.queue=new o(s.rateLimiter,e,r,this.options);var p=this.options.tracer||null;c(p)?(this.tracer=p,this.options.tracer="opentracing-tracer-enabled",this.options._configuredOptions.tracer="opentracing-tracer-enabled"):this.tracer=null,this.notifier=new i(this.queue,this.options),this.telemeter=n,u(t),this.lastError=null,this.lastErrorHash="none";}function u(t){t.stackTraceLimit&&(Error.stackTraceLimit=t.stackTraceLimit);}function c(t){if(!t)return !1;if(!t.scope||"function"!=typeof t.scope)return !1;var e=t.scope();return !(!e||!e.active||"function"!=typeof e.active)}s.rateLimiter=new n({maxItems:0,itemsPerMinute:60}),s.prototype.global=function(t){return s.rateLimiter.configureGlobal(t),this},s.prototype.configure=function(t,e){var r=this.options,n={};e&&(n={payload:e}),this.options=a.merge(r,t,n);var o=this.options.tracer||null;return c(o)?(this.tracer=o,this.options.tracer="opentracing-tracer-enabled",this.options._configuredOptions.tracer="opentracing-tracer-enabled"):this.tracer=null,this.notifier&&this.notifier.configure(this.options),this.telemeter&&this.telemeter.configure(this.options),u(t),this.global(this.options),c(t.tracer)&&(this.tracer=t.tracer),this},s.prototype.log=function(t){var e=this._defaultLogLevel();return this._log(e,t)},s.prototype.debug=function(t){this._log("debug",t);},s.prototype.info=function(t){this._log("info",t);},s.prototype.warn=function(t){this._log("warning",t);},s.prototype.warning=function(t){this._log("warning",t);},s.prototype.error=function(t){this._log("error",t);},s.prototype.critical=function(t){this._log("critical",t);},s.prototype.wait=function(t){this.queue.wait(t);},s.prototype.captureEvent=function(t,e,r){return this.telemeter&&this.telemeter.captureEvent(t,e,r)},s.prototype.captureDomContentLoaded=function(t){return this.telemeter&&this.telemeter.captureDomContentLoaded(t)},s.prototype.captureLoad=function(t){return this.telemeter&&this.telemeter.captureLoad(t)},s.prototype.buildJsonPayload=function(t){return this.api.buildJsonPayload(t)},s.prototype.sendJsonPayload=function(t){this.api.postJsonPayload(t);},s.prototype._log=function(t,e){var r;if(e.callback&&(r=e.callback,delete e.callback),this.options.ignoreDuplicateErrors&&this._sameAsLastError(e)){if(r){var n=new Error("ignored identical item");n.item=e,r(n);}}else try{this._addTracingInfo(e),e.level=e.level||t,this.telemeter&&this.telemeter._captureRollbarItem(e),e.telemetryEvents=this.telemeter&&this.telemeter.copyEvents()||[],this.notifier.log(e,r);}catch(t){this.logger.error(t);}},s.prototype._defaultLogLevel=function(){return this.options.logLevel||"debug"},s.prototype._sameAsLastError=function(t){if(!t._isUncaught)return !1;var e=function(t){var e=t.message||"",r=(t.err||{}).stack||String(t.err);return e+"::"+r}(t);return this.lastErrorHash===e||(this.lastError=t.err,this.lastErrorHash=e,!1)},s.prototype._addTracingInfo=function(t){if(this.tracer){var e=this.tracer.scope().active();if(function(t){if(!t||!t.context||"function"!=typeof t.context)return !1;var e=t.context();if(!e||!e.toSpanId||!e.toTraceId||"function"!=typeof e.toSpanId||"function"!=typeof e.toTraceId)return !1;return !0}(e)){e.setTag("rollbar.error_uuid",t.uuid),e.setTag("rollbar.has_error",!0);var r=e.context().toSpanId(),n=e.context().toTraceId();t.custom?(t.custom.opentracing_span_id=r,t.custom.opentracing_trace_id=n):t.custom={opentracing_span_id:r,opentracing_trace_id:n};}}},t.exports=s;},function(t,e,r){var n=r(0);function o(t){this.startTime=n.now(),this.counter=0,this.perMinCounter=0,this.platform=null,this.platformOptions={},this.configureGlobal(t);}function i(t,e,r){return !t.ignoreRateLimit&&e>=1&&r>e}function a(t,e,r,n,o,i,a){var s=null;return r&&(r=new Error(r)),r||n||(s=function(t,e,r,n,o){var i,a=e.environment||e.payload&&e.payload.environment;i=o?"item per minute limit reached, ignoring errors until timeout":"maxItems has been hit, ignoring errors until reset.";var s={body:{message:{body:i,extra:{maxItems:r,itemsPerMinute:n}}},language:"javascript",environment:a,notifier:{version:e.notifier&&e.notifier.version||e.version}};"browser"===t?(s.platform="browser",s.framework="browser-js",s.notifier.name="rollbar-browser-js"):"server"===t?(s.framework=e.framework||"node-js",s.notifier.name=e.notifier.name):"react-native"===t&&(s.framework=e.framework||"react-native",s.notifier.name=e.notifier.name);return s}(t,e,o,i,a)),{error:r,shouldSend:n,payload:s}}o.globalSettings={startTime:n.now(),maxItems:void 0,itemsPerMinute:void 0},o.prototype.configureGlobal=function(t){void 0!==t.startTime&&(o.globalSettings.startTime=t.startTime),void 0!==t.maxItems&&(o.globalSettings.maxItems=t.maxItems),void 0!==t.itemsPerMinute&&(o.globalSettings.itemsPerMinute=t.itemsPerMinute);},o.prototype.shouldSend=function(t,e){var r=(e=e||n.now())-this.startTime;(r<0||r>=6e4)&&(this.startTime=e,this.perMinCounter=0);var s=o.globalSettings.maxItems,u=o.globalSettings.itemsPerMinute;if(i(t,s,this.counter))return a(this.platform,this.platformOptions,s+" max items reached",!1);if(i(t,u,this.perMinCounter))return a(this.platform,this.platformOptions,u+" items per minute reached",!1);this.counter++,this.perMinCounter++;var c=!i(t,s,this.counter),l=c;return c=c&&!i(t,u,this.perMinCounter),a(this.platform,this.platformOptions,null,c,s,u,l)},o.prototype.setPlatformOptions=function(t,e){this.platform=t,this.platformOptions=e;},t.exports=o;},function(t,e,r){var n=Object.prototype.hasOwnProperty,o=Object.prototype.toString,i=function(t){if(!t||"[object Object]"!==o.call(t))return !1;var e,r=n.call(t,"constructor"),i=t.constructor&&t.constructor.prototype&&n.call(t.constructor.prototype,"isPrototypeOf");if(t.constructor&&!r&&!i)return !1;for(e in t);return void 0===e||n.call(t,e)};t.exports=function t(){var e,r,n,o,a,s={},u=null,c=arguments.length;for(e=0;e<c;e++)if(null!=(u=arguments[e]))for(a in u)r=s[a],s!==(n=u[a])&&(n&&i(n)?(o=r&&i(r)?r:{},s[a]=t(o,n)):void 0!==n&&(s[a]=n));return s};},function(t,e,r){var n=r(0);function o(t,e,r,n){this.rateLimiter=t,this.api=e,this.logger=r,this.options=n,this.predicates=[],this.pendingItems=[],this.pendingRequests=[],this.retryQueue=[],this.retryHandle=null,this.waitCallback=null,this.waitIntervalID=null;}o.prototype.configure=function(t){this.api&&this.api.configure(t);var e=this.options;return this.options=n.merge(e,t),this},o.prototype.addPredicate=function(t){return n.isFunction(t)&&this.predicates.push(t),this},o.prototype.addPendingItem=function(t){this.pendingItems.push(t);},o.prototype.removePendingItem=function(t){var e=this.pendingItems.indexOf(t);-1!==e&&this.pendingItems.splice(e,1);},o.prototype.addItem=function(t,e,r,o){e&&n.isFunction(e)||(e=function(){});var i=this._applyPredicates(t);if(i.stop)return this.removePendingItem(o),void e(i.err);if(this._maybeLog(t,r),this.removePendingItem(o),this.options.transmit){this.pendingRequests.push(t);try{this._makeApiRequest(t,function(r,n){this._dequeuePendingRequest(t),e(r,n);}.bind(this));}catch(r){this._dequeuePendingRequest(t),e(r);}}else e(new Error("Transmit disabled"));},o.prototype.wait=function(t){n.isFunction(t)&&(this.waitCallback=t,this._maybeCallWait()||(this.waitIntervalID&&(this.waitIntervalID=clearInterval(this.waitIntervalID)),this.waitIntervalID=setInterval(function(){this._maybeCallWait();}.bind(this),500)));},o.prototype._applyPredicates=function(t){for(var e=null,r=0,n=this.predicates.length;r<n;r++)if(!(e=this.predicates[r](t,this.options))||void 0!==e.err)return {stop:!0,err:e.err};return {stop:!1,err:null}},o.prototype._makeApiRequest=function(t,e){var r=this.rateLimiter.shouldSend(t);r.shouldSend?this.api.postItem(t,function(r,n){r?this._maybeRetry(r,t,e):e(r,n);}.bind(this)):r.error?e(r.error):this.api.postItem(r.payload,e);};var i=["ECONNRESET","ENOTFOUND","ESOCKETTIMEDOUT","ETIMEDOUT","ECONNREFUSED","EHOSTUNREACH","EPIPE","EAI_AGAIN"];o.prototype._maybeRetry=function(t,e,r){var n=!1;if(this.options.retryInterval)for(var o=0,a=i.length;o<a;o++)if(t.code===i[o]){n=!0;break}n?this._retryApiRequest(e,r):r(t);},o.prototype._retryApiRequest=function(t,e){this.retryQueue.push({item:t,callback:e}),this.retryHandle||(this.retryHandle=setInterval(function(){for(;this.retryQueue.length;){var t=this.retryQueue.shift();this._makeApiRequest(t.item,t.callback);}}.bind(this),this.options.retryInterval));},o.prototype._dequeuePendingRequest=function(t){var e=this.pendingRequests.indexOf(t);-1!==e&&(this.pendingRequests.splice(e,1),this._maybeCallWait());},o.prototype._maybeLog=function(t,e){if(this.logger&&this.options.verbose){var r=e;if(r=(r=r||n.get(t,"body.trace.exception.message"))||n.get(t,"body.trace_chain.0.exception.message"))return void this.logger.error(r);(r=n.get(t,"body.message.body"))&&this.logger.log(r);}},o.prototype._maybeCallWait=function(){return !(!n.isFunction(this.waitCallback)||0!==this.pendingItems.length||0!==this.pendingRequests.length)&&(this.waitIntervalID&&(this.waitIntervalID=clearInterval(this.waitIntervalID)),this.waitCallback(),!0)},t.exports=o;},function(t,e,r){var n=r(0);function o(t,e){this.queue=t,this.options=e,this.transforms=[],this.diagnostic={};}o.prototype.configure=function(t){this.queue&&this.queue.configure(t);var e=this.options;return this.options=n.merge(e,t),this},o.prototype.addTransform=function(t){return n.isFunction(t)&&this.transforms.push(t),this},o.prototype.log=function(t,e){if(e&&n.isFunction(e)||(e=function(){}),!this.options.enabled)return e(new Error("Rollbar is not enabled"));this.queue.addPendingItem(t);var r=t.err;this._applyTransforms(t,function(n,o){if(n)return this.queue.removePendingItem(t),e(n,null);this.queue.addItem(o,e,r,t);}.bind(this));},o.prototype._applyTransforms=function(t,e){var r=-1,n=this.transforms.length,o=this.transforms,i=this.options,a=function(t,s){t?e(t,null):++r!==n?o[r](s,i,a):e(null,s);};a(null,t);},t.exports=o;},function(t,e,r){var n=r(0),o=r(16),i={hostname:"api.rollbar.com",path:"/api/1/item/",search:null,version:"1",protocol:"https:",port:443};function a(t,e,r,n,o){this.options=t,this.transport=e,this.url=r,this.truncation=n,this.jsonBackup=o,this.accessToken=t.accessToken,this.transportOptions=s(t,r);}function s(t,e){return o.getTransportFromOptions(t,i,e)}a.prototype.postItem=function(t,e){var r=o.transportOptions(this.transportOptions,"POST"),n=o.buildPayload(this.accessToken,t,this.jsonBackup);this.transport.post(this.accessToken,r,n,e);},a.prototype.buildJsonPayload=function(t,e){var r,i=o.buildPayload(this.accessToken,t,this.jsonBackup);return (r=this.truncation?this.truncation.truncate(i):n.stringify(i)).error?(e&&e(r.error),null):r.value},a.prototype.postJsonPayload=function(t,e){var r=o.transportOptions(this.transportOptions,"POST");this.transport.postJsonPayload(this.accessToken,r,t,e);},a.prototype.configure=function(t){var e=this.oldOptions;return this.options=n.merge(e,t),this.transportOptions=s(this.options,this.url),void 0!==this.options.accessToken&&(this.accessToken=this.options.accessToken),this},t.exports=a;},function(t,e,r){var n=r(0);t.exports={buildPayload:function(t,e,r){if(!n.isType(e.context,"string")){var o=n.stringify(e.context,r);o.error?e.context="Error: could not serialize 'context'":e.context=o.value||"",e.context.length>255&&(e.context=e.context.substr(0,255));}return {access_token:t,data:e}},getTransportFromOptions:function(t,e,r){var n=e.hostname,o=e.protocol,i=e.port,a=e.path,s=e.search,u=t.proxy;if(t.endpoint){var c=r.parse(t.endpoint);n=c.hostname,o=c.protocol,i=c.port,a=c.pathname,s=c.search;}return {hostname:n,protocol:o,port:i,path:a,search:s,proxy:u}},transportOptions:function(t,e){var r=t.protocol||"https:",n=t.port||("http:"===r?80:"https:"===r?443:void 0),o=t.hostname,i=t.path;return t.search&&(i+=t.search),t.proxy&&(i=r+"//"+o+i,o=t.proxy.host||t.proxy.hostname,n=t.proxy.port,r=t.proxy.protocol||r),{protocol:r,hostname:o,path:i,port:n,method:e}},appendPathToPath:function(t,e){var r=/\/$/.test(t),n=/^\//.test(e);return r&&n?e=e.substring(1):r||n||(e="/"+e),t+e}};},function(t,e){!function(t){t.console||(t.console={});for(var e,r,n=t.console,o=function(){},i=["memory"],a="assert,clear,count,debug,dir,dirxml,error,exception,group,groupCollapsed,groupEnd,info,log,markTimeline,profile,profiles,profileEnd,show,table,time,timeEnd,timeline,timelineEnd,timeStamp,trace,warn".split(",");e=i.pop();)n[e]||(n[e]={});for(;r=a.pop();)n[r]||(n[r]=o);}("undefined"==typeof window?this:window);},function(t,e,r){var n={ieVersion:function(){if("undefined"!=typeof document){for(var t=3,e=document.createElement("div"),r=e.getElementsByTagName("i");e.innerHTML="\x3c!--[if gt IE "+ ++t+"]><i></i><![endif]--\x3e",r[0];);return t>4?t:void 0}}};t.exports=n;},function(t,e,r){function n(t,e,r,n){t._rollbarWrappedError&&(n[4]||(n[4]=t._rollbarWrappedError),n[5]||(n[5]=t._rollbarWrappedError._rollbarContext),t._rollbarWrappedError=null);var o=e.handleUncaughtException.apply(e,n);r&&r.apply(t,n),"anonymous"===o&&(e.anonymousErrorsPending+=1);}t.exports={captureUncaughtExceptions:function(t,e,r){if(t){var o;if("function"==typeof e._rollbarOldOnError)o=e._rollbarOldOnError;else if(t.onerror){for(o=t.onerror;o._rollbarOldOnError;)o=o._rollbarOldOnError;e._rollbarOldOnError=o;}e.handleAnonymousErrors();var i=function(){var r=Array.prototype.slice.call(arguments,0);n(t,e,o,r);};r&&(i._rollbarOldOnError=o),t.onerror=i;}},captureUnhandledRejections:function(t,e,r){if(t){"function"==typeof t._rollbarURH&&t._rollbarURH.belongsToShim&&t.removeEventListener("unhandledrejection",t._rollbarURH);var n=function(t){var r,n,o;try{r=t.reason;}catch(t){r=void 0;}try{n=t.promise;}catch(t){n="[unhandledrejection] error getting `promise` from event";}try{o=t.detail,!r&&o&&(r=o.reason,n=o.promise);}catch(t){}r||(r="[unhandledrejection] error getting `reason` from event"),e&&e.handleUnhandledRejection&&e.handleUnhandledRejection(r,n);};n.belongsToShim=r,t._rollbarURH=n,t.addEventListener("unhandledrejection",n);}}};},function(t,e,r){var n=r(0),o=r(1);function i(t){this.truncation=t;}function a(t,e,r,n,o,i){var a="undefined"!=typeof window&&window||"undefined"!=typeof self&&self,u=a&&a.Zone&&a.Zone.current;u&&"angular"===u._name?u._parent.run((function(){s(t,e,r,n,o,i);})):s(t,e,r,n,o,i);}function s(t,e,r,i,a,s){if("undefined"!=typeof RollbarProxy)return function(t,e){(new RollbarProxy).sendJsonPayload(t,(function(t){}),(function(t){e(new Error(t));}));}(i,a);var c;if(!(c=s?s():function(){var t,e,r=[function(){return new XMLHttpRequest},function(){return new ActiveXObject("Msxml2.XMLHTTP")},function(){return new ActiveXObject("Msxml3.XMLHTTP")},function(){return new ActiveXObject("Microsoft.XMLHTTP")}],n=r.length;for(e=0;e<n;e++)try{t=r[e]();break}catch(t){}return t}()))return a(new Error("No way to send a request"));try{try{var l=function(){try{if(l&&4===c.readyState){l=void 0;var t=n.jsonParse(c.responseText);if((i=c)&&i.status&&200===i.status)return void a(t.error,t.value);if(function(t){return t&&n.isType(t.status,"number")&&t.status>=400&&t.status<600}(c)){if(403===c.status){var e=t.value&&t.value.message;o.error(e);}a(new Error(String(c.status)));}else {a(u("XHR response had no status code (likely connection failure)"));}}}catch(t){var r;r=t&&t.stack?t:new Error(t),a(r);}var i;};c.open(r,e,!0),c.setRequestHeader&&(c.setRequestHeader("Content-Type","application/json"),c.setRequestHeader("X-Rollbar-Access-Token",t)),c.onreadystatechange=l,c.send(i);}catch(t){if("undefined"!=typeof XDomainRequest){if(!window||!window.location)return a(new Error("No window available during request, unknown environment"));"http:"===window.location.href.substring(0,5)&&"https"===e.substring(0,5)&&(e="http"+e.substring(5));var p=new XDomainRequest;p.onprogress=function(){},p.ontimeout=function(){a(u("Request timed out","ETIMEDOUT"));},p.onerror=function(){a(new Error("Error during request"));},p.onload=function(){var t=n.jsonParse(p.responseText);a(t.error,t.value);},p.open(r,e,!0),p.send(i);}else a(new Error("Cannot find a method to transport a request"));}}catch(t){a(t);}}function u(t,e){var r=new Error(t);return r.code=e||"ENOTFOUND",r}i.prototype.get=function(t,e,r,o,i){o&&n.isFunction(o)||(o=function(){}),n.addParamsAndAccessTokenToPath(t,e,r);a(t,n.formatUrl(e),"GET",null,o,i);},i.prototype.post=function(t,e,r,o,i){if(o&&n.isFunction(o)||(o=function(){}),!r)return o(new Error("Cannot send empty request"));var s;if((s=this.truncation?this.truncation.truncate(r):n.stringify(r)).error)return o(s.error);var u=s.value;a(t,n.formatUrl(e),"POST",u,o,i);},i.prototype.postJsonPayload=function(t,e,r,o,i){o&&n.isFunction(o)||(o=function(){});a(t,n.formatUrl(e),"POST",r,o,i);},t.exports=i;},function(t,e,r){var n=r(0),o=r(3),i=r(1);function a(t,e,r){var o=t.message,i=t.custom;o||(o="Item sent with null or missing arguments.");var a={body:o};i&&(a.extra=n.merge(i)),n.set(t,"data.body",{message:a}),r(null,t);}function s(t){var e=t.stackInfo.stack;return e&&0===e.length&&t._unhandledStackInfo&&t._unhandledStackInfo.stack&&(e=t._unhandledStackInfo.stack),e}function u(t,e,r){var i=t&&t.data.description,a=t&&t.custom,u=s(t),l=o.guessErrorClass(e.message),p={exception:{class:c(e,l[0],r),message:l[1]}};if(i&&(p.exception.description=i),u){var f,h,d,m,g,v,y,b;for(0===u.length&&(p.exception.stack=e.rawStack,p.exception.raw=String(e.rawException)),p.frames=[],y=0;y<u.length;++y)h={filename:(f=u[y]).url?n.sanitizeUrl(f.url):"(unknown)",lineno:f.line||null,method:f.func&&"?"!==f.func?f.func:"[anonymous]",colno:f.column},r.sendFrameUrl&&(h.url=f.url),h.method&&h.method.endsWith&&h.method.endsWith("_rollbar_wrapped")||(d=m=g=null,(v=f.context?f.context.length:0)&&(b=Math.floor(v/2),m=f.context.slice(0,b),d=f.context[b],g=f.context.slice(b)),d&&(h.code=d),(m||g)&&(h.context={},m&&m.length&&(h.context.pre=m),g&&g.length&&(h.context.post=g)),f.args&&(h.args=f.args),p.frames.push(h));p.frames.reverse(),a&&(p.extra=n.merge(a));}return p}function c(t,e,r){return t.name?t.name:r.guessErrorClass?e:"(unknown)"}t.exports={handleDomException:function(t,e,r){if(t.err&&"DOMException"===o.Stack(t.err).name){var n=new Error;n.name=t.err.name,n.message=t.err.message,n.stack=t.err.stack,n.nested=t.err,t.err=n;}r(null,t);},handleItemWithError:function(t,e,r){if(t.data=t.data||{},t.err)try{t.stackInfo=t.err._savedStackTrace||o.parse(t.err,t.skipFrames),e.addErrorContext&&function(t){var e=[],r=t.err;e.push(r);for(;r.nested;)r=r.nested,e.push(r);n.addErrorContext(t,e);}(t);}catch(e){i.error("Error while parsing the error object.",e);try{t.message=t.err.message||t.err.description||t.message||String(t.err);}catch(e){t.message=String(t.err)||String(e);}delete t.err;}r(null,t);},ensureItemHasSomethingToSay:function(t,e,r){t.message||t.stackInfo||t.custom||r(new Error("No message, stack info, or custom data"),null),r(null,t);},addBaseInfo:function(t,e,r){var o=e.payload&&e.payload.environment||e.environment;t.data=n.merge(t.data,{environment:o,level:t.level,endpoint:e.endpoint,platform:"browser",framework:"browser-js",language:"javascript",server:{},uuid:t.uuid,notifier:{name:"rollbar-browser-js",version:e.version},custom:t.custom}),r(null,t);},addRequestInfo:function(t){return function(e,r,o){if(!t||!t.location)return o(null,e);var i="$remote_ip";r.captureIp?!0!==r.captureIp&&(i+="_anonymize"):i=null,n.set(e,"data.request",{url:t.location.href,query_string:t.location.search,user_ip:i}),o(null,e);}},addClientInfo:function(t){return function(e,r,o){if(!t)return o(null,e);var i=t.navigator||{},a=t.screen||{};n.set(e,"data.client",{runtime_ms:e.timestamp-t._rollbarStartTime,timestamp:Math.round(e.timestamp/1e3),javascript:{browser:i.userAgent,language:i.language,cookie_enabled:i.cookieEnabled,screen:{width:a.width,height:a.height}}}),o(null,e);}},addPluginInfo:function(t){return function(e,r,o){if(!t||!t.navigator)return o(null,e);for(var i,a=[],s=t.navigator.plugins||[],u=0,c=s.length;u<c;++u)i=s[u],a.push({name:i.name,description:i.description});n.set(e,"data.client.javascript.plugins",a),o(null,e);}},addBody:function(t,e,r){t.stackInfo?t.stackInfo.traceChain?function(t,e,r){for(var o=t.stackInfo.traceChain,i=[],a=o.length,s=0;s<a;s++){var c=u(t,o[s],e);i.push(c);}n.set(t,"data.body",{trace_chain:i}),r(null,t);}(t,e,r):function(t,e,r){if(s(t)){var i=u(t,t.stackInfo,e);n.set(t,"data.body",{trace:i}),r(null,t);}else {var l=t.stackInfo,p=o.guessErrorClass(l.message),f=c(l,p[0],e),h=p[1];t.message=f+": "+h,a(t,e,r);}}(t,e,r):a(t,e,r);},addScrubber:function(t){return function(e,r,n){if(t){var o=r.scrubFields||[],i=r.scrubPaths||[];e.data=t(e.data,o,i);}n(null,e);}}};},function(t,e,r){var n,o,i;!function(a,s){o=[r(23)],void 0===(i="function"==typeof(n=function(t){var e=/(^|@)\S+:\d+/,r=/^\s*at .*(\S+:\d+|\(native\))/m,n=/^(eval@)?(\[native code])?$/;return {parse:function(t){if(void 0!==t.stacktrace||void 0!==t["opera#sourceloc"])return this.parseOpera(t);if(t.stack&&t.stack.match(r))return this.parseV8OrIE(t);if(t.stack)return this.parseFFOrSafari(t);throw new Error("Cannot parse given Error object")},extractLocation:function(t){if(-1===t.indexOf(":"))return [t];var e=/(.+?)(?::(\d+))?(?::(\d+))?$/.exec(t.replace(/[()]/g,""));return [e[1],e[2]||void 0,e[3]||void 0]},parseV8OrIE:function(e){return e.stack.split("\n").filter((function(t){return !!t.match(r)}),this).map((function(e){e.indexOf("(eval ")>-1&&(e=e.replace(/eval code/g,"eval").replace(/(\(eval at [^()]*)|(\),.*$)/g,""));var r=e.replace(/^\s+/,"").replace(/\(eval code/g,"("),n=r.match(/ (\((.+):(\d+):(\d+)\)$)/),o=(r=n?r.replace(n[0],""):r).split(/\s+/).slice(1),i=this.extractLocation(n?n[1]:o.pop()),a=o.join(" ")||void 0,s=["eval","<anonymous>"].indexOf(i[0])>-1?void 0:i[0];return new t({functionName:a,fileName:s,lineNumber:i[1],columnNumber:i[2],source:e})}),this)},parseFFOrSafari:function(e){return e.stack.split("\n").filter((function(t){return !t.match(n)}),this).map((function(e){if(e.indexOf(" > eval")>-1&&(e=e.replace(/ line (\d+)(?: > eval line \d+)* > eval:\d+:\d+/g,":$1")),-1===e.indexOf("@")&&-1===e.indexOf(":"))return new t({functionName:e});var r=/((.*".+"[^@]*)?[^@]*)(?:@)/,n=e.match(r),o=n&&n[1]?n[1]:void 0,i=this.extractLocation(e.replace(r,""));return new t({functionName:o,fileName:i[0],lineNumber:i[1],columnNumber:i[2],source:e})}),this)},parseOpera:function(t){return !t.stacktrace||t.message.indexOf("\n")>-1&&t.message.split("\n").length>t.stacktrace.split("\n").length?this.parseOpera9(t):t.stack?this.parseOpera11(t):this.parseOpera10(t)},parseOpera9:function(e){for(var r=/Line (\d+).*script (?:in )?(\S+)/i,n=e.message.split("\n"),o=[],i=2,a=n.length;i<a;i+=2){var s=r.exec(n[i]);s&&o.push(new t({fileName:s[2],lineNumber:s[1],source:n[i]}));}return o},parseOpera10:function(e){for(var r=/Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i,n=e.stacktrace.split("\n"),o=[],i=0,a=n.length;i<a;i+=2){var s=r.exec(n[i]);s&&o.push(new t({functionName:s[3]||void 0,fileName:s[2],lineNumber:s[1],source:n[i]}));}return o},parseOpera11:function(r){return r.stack.split("\n").filter((function(t){return !!t.match(e)&&!t.match(/^Error created at/)}),this).map((function(e){var r,n=e.split("@"),o=this.extractLocation(n.pop()),i=n.shift()||"",a=i.replace(/<anonymous function(: (\w+))?>/,"$2").replace(/\([^)]*\)/g,"")||void 0;i.match(/\(([^)]*)\)/)&&(r=i.replace(/^[^(]+\(([^)]*)\)$/,"$1"));var s=void 0===r||"[arguments not available]"===r?void 0:r.split(",");return new t({functionName:a,args:s,fileName:o[0],lineNumber:o[1],columnNumber:o[2],source:e})}),this)}}})?n.apply(e,o):n)||(t.exports=i);}();},function(t,e,r){var n,o,i;!function(r,a){o=[],void 0===(i="function"==typeof(n=function(){function t(t){return t.charAt(0).toUpperCase()+t.substring(1)}function e(t){return function(){return this[t]}}var r=["isConstructor","isEval","isNative","isToplevel"],n=["columnNumber","lineNumber"],o=["fileName","functionName","source"],i=r.concat(n,o,["args"],["evalOrigin"]);function a(e){if(e)for(var r=0;r<i.length;r++)void 0!==e[i[r]]&&this["set"+t(i[r])](e[i[r]]);}a.prototype={getArgs:function(){return this.args},setArgs:function(t){if("[object Array]"!==Object.prototype.toString.call(t))throw new TypeError("Args must be an Array");this.args=t;},getEvalOrigin:function(){return this.evalOrigin},setEvalOrigin:function(t){if(t instanceof a)this.evalOrigin=t;else {if(!(t instanceof Object))throw new TypeError("Eval Origin must be an Object or StackFrame");this.evalOrigin=new a(t);}},toString:function(){var t=this.getFileName()||"",e=this.getLineNumber()||"",r=this.getColumnNumber()||"",n=this.getFunctionName()||"";return this.getIsEval()?t?"[eval] ("+t+":"+e+":"+r+")":"[eval]:"+e+":"+r:n?n+" ("+t+":"+e+":"+r+")":t+":"+e+":"+r}},a.fromString=function(t){var e=t.indexOf("("),r=t.lastIndexOf(")"),n=t.substring(0,e),o=t.substring(e+1,r).split(","),i=t.substring(r+1);if(0===i.indexOf("@"))var s=/@(.+?)(?::(\d+))?(?::(\d+))?$/.exec(i,""),u=s[1],c=s[2],l=s[3];return new a({functionName:n,args:o||void 0,fileName:u,lineNumber:c||void 0,columnNumber:l||void 0})};for(var s=0;s<r.length;s++)a.prototype["get"+t(r[s])]=e(r[s]),a.prototype["set"+t(r[s])]=function(t){return function(e){this[t]=Boolean(e);}}(r[s]);for(var u=0;u<n.length;u++)a.prototype["get"+t(n[u])]=e(n[u]),a.prototype["set"+t(n[u])]=function(t){return function(e){if(r=e,isNaN(parseFloat(r))||!isFinite(r))throw new TypeError(t+" must be a Number");var r;this[t]=Number(e);}}(n[u]);for(var c=0;c<o.length;c++)a.prototype["get"+t(o[c])]=e(o[c]),a.prototype["set"+t(o[c])]=function(t){return function(e){this[t]=String(e);}}(o[c]);return a})?n.apply(e,o):n)||(t.exports=i);}();},function(t,e,r){var n=r(0);function o(t,e){n.isFunction(t[e])&&(t[e]=t[e].toString());}t.exports={itemToPayload:function(t,e,r){var o=e.payload||{};o.body&&delete o.body;var i=n.merge(t.data,o);t._isUncaught&&(i._isUncaught=!0),t._originalArgs&&(i._originalArgs=t._originalArgs),r(null,i);},addTelemetryData:function(t,e,r){t.telemetryEvents&&n.set(t,"data.body.telemetry",t.telemetryEvents),r(null,t);},addMessageWithError:function(t,e,r){if(t.message){var o="data.body.trace_chain.0",i=n.get(t,o);if(i||(o="data.body.trace",i=n.get(t,o)),i){if(!i.exception||!i.exception.description)return n.set(t,o+".exception.description",t.message),void r(null,t);var a=n.get(t,o+".extra")||{},s=n.merge(a,{message:t.message});n.set(t,o+".extra",s);}r(null,t);}else r(null,t);},userTransform:function(t){return function(e,r,o){var i=n.merge(e);try{n.isFunction(r.transform)&&r.transform(i.data,e);}catch(n){return r.transform=null,t.error("Error while calling custom transform() function. Removing custom transform().",n),void o(null,e)}o(null,i);}},addConfigToPayload:function(t,e,r){if(!e.sendConfig)return r(null,t);var o=n.get(t,"data.custom")||{};o._rollbarConfig=e,t.data.custom=o,r(null,t);},addConfiguredOptions:function(t,e,r){var n=e._configuredOptions;o(n,"transform"),o(n,"checkIgnore"),o(n,"onSendCallback"),delete n.accessToken,t.data.notifier.configured_options=n,r(null,t);},addDiagnosticKeys:function(t,e,r){var o=n.merge(t.notifier.client.notifier.diagnostic,t.diagnostic);if(n.get(t,"err._isAnonymous")&&(o.is_anonymous=!0),t._isUncaught&&(o.is_uncaught=t._isUncaught),t.err)try{o.raw_error={message:t.err.message,name:t.err.name,constructor_name:t.err.constructor&&t.err.constructor.name,filename:t.err.fileName,line:t.err.lineNumber,column:t.err.columnNumber,stack:t.err.stack};}catch(t){o.raw_error={failed:String(t)};}t.data.notifier.diagnostic=n.merge(t.data.notifier.diagnostic,o),r(null,t);}};},function(t,e,r){var n=r(0);t.exports={checkIgnore:function(t,e){return !n.get(e,"plugins.jquery.ignoreAjaxErrors")||!n.get(t,"body.message.extra.isAjax")}};},function(t,e,r){var n=r(0);function o(t,e,r){if(!t)return !r;var o,i,a=t.frames;if(!a||0===a.length)return !r;for(var s=e.length,u=a.length,c=0;c<u;c++){if(o=a[c].filename,!n.isType(o,"string"))return !r;for(var l=0;l<s;l++)if(i=e[l],new RegExp(i).test(o))return !0}return !1}function i(t,e,r,i){var a,s,u=!1;"blacklist"===r&&(u=!0);try{if(a=u?e.hostBlackList:e.hostWhiteList,s=n.get(t,"body.trace_chain")||[n.get(t,"body.trace")],!a||0===a.length)return !u;if(0===s.length||!s[0])return !u;for(var c=s.length,l=0;l<c;l++)if(o(s[l],a,u))return !0}catch(t){u?e.hostBlackList=null:e.hostWhiteList=null;var p=u?"hostBlackList":"hostWhiteList";return i.error("Error while reading your configuration's "+p+" option. Removing custom "+p+".",t),!u}return !1}t.exports={checkLevel:function(t,e){var r=t.level,o=n.LEVELS[r]||0,i=e.reportLevel;return !(o<(n.LEVELS[i]||0))},userCheckIgnore:function(t){return function(e,r){var o=!!e._isUncaught;delete e._isUncaught;var i=e._originalArgs;delete e._originalArgs;try{n.isFunction(r.onSendCallback)&&r.onSendCallback(o,i,e);}catch(e){r.onSendCallback=null,t.error("Error while calling onSendCallback, removing",e);}try{if(n.isFunction(r.checkIgnore)&&r.checkIgnore(o,i,e))return !1}catch(e){r.checkIgnore=null,t.error("Error while calling custom checkIgnore(), removing",e);}return !0}},urlIsNotBlacklisted:function(t){return function(e,r){return !i(e,r,"blacklist",t)}},urlIsWhitelisted:function(t){return function(e,r){return i(e,r,"whitelist",t)}},messageIsIgnored:function(t){return function(e,r){var o,i,a,s,u,c,l,p;try{if(u=!1,!(a=r.ignoredMessages)||0===a.length)return !0;if(c=e.body,l=n.get(c,"trace.exception.message"),p=n.get(c,"message.body"),!(o=l||p))return !0;for(s=a.length,i=0;i<s&&!(u=new RegExp(a[i],"gi").test(o));i++);}catch(e){r.ignoredMessages=null,t.error("Error while reading your configuration's ignoredMessages option. Removing custom ignoredMessages.");}return !u}}};},function(t,e,r){t.exports={version:"2.19.2",endpoint:"api.rollbar.com/api/1/item/",logLevel:"debug",reportLevel:"debug",uncaughtErrorLevel:"error",maxItems:0,itemsPerMin:60};},function(t,e,r){t.exports={scrubFields:["pw","pass","passwd","password","secret","confirm_password","confirmPassword","password_confirmation","passwordConfirmation","access_token","accessToken","X-Rollbar-Access-Token","secret_key","secretKey","secretToken","cc-number","card number","cardnumber","cardnum","ccnum","ccnumber","cc num","creditcardnumber","credit card number","newcreditcardnumber","new credit card","creditcardno","credit card no","card#","card #","cc-csc","cvc","cvc2","cvv2","ccv2","security code","card verification","name on credit card","name on card","nameoncard","cardholder","card holder","name des karteninhabers","ccname","card type","cardtype","cc type","cctype","payment type","expiration date","expirationdate","expdate","cc-exp","ccmonth","ccyear"]};},function(t,e,r){var n=r(0);function o(t){this.queue=[],this.options=n.merge(t);var e=this.options.maxTelemetryEvents||100;this.maxQueueSize=Math.max(0,Math.min(e,100));}function i(t,e){if(e)return e;return {error:"error",manual:"info"}[t]||"info"}o.prototype.configure=function(t){var e=this.options;this.options=n.merge(e,t);var r=this.options.maxTelemetryEvents||100,o=Math.max(0,Math.min(r,100)),i=0;this.maxQueueSize>o&&(i=this.maxQueueSize-o),this.maxQueueSize=o,this.queue.splice(0,i);},o.prototype.copyEvents=function(){var t=Array.prototype.slice.call(this.queue,0);if(n.isFunction(this.options.filterTelemetry))try{for(var e=t.length;e--;)this.options.filterTelemetry(t[e])&&t.splice(e,1);}catch(t){this.options.filterTelemetry=null;}return t},o.prototype.capture=function(t,e,r,o,a){var s={level:i(t,r),type:t,timestamp_ms:a||n.now(),body:e,source:"client"};o&&(s.uuid=o);try{if(n.isFunction(this.options.filterTelemetry)&&this.options.filterTelemetry(s))return !1}catch(t){this.options.filterTelemetry=null;}return this.push(s),s},o.prototype.captureEvent=function(t,e,r,n){return this.capture(t,e,r,n)},o.prototype.captureError=function(t,e,r,n){var o={message:t.message||String(t)};return t.stack&&(o.stack=t.stack),this.capture("error",o,e,r,n)},o.prototype.captureLog=function(t,e,r,n){return this.capture("log",{message:t},e,r,n)},o.prototype.captureNetwork=function(t,e,r,n){e=e||"xhr",t.subtype=t.subtype||e,n&&(t.request=n);var o=this.levelFromStatus(t.status_code);return this.capture("network",t,o,r)},o.prototype.levelFromStatus=function(t){return t>=200&&t<400?"info":0===t||t>=400?"error":"info"},o.prototype.captureDom=function(t,e,r,n,o){var i={subtype:t,element:e};return void 0!==r&&(i.value=r),void 0!==n&&(i.checked=n),this.capture("dom",i,"info",o)},o.prototype.captureNavigation=function(t,e,r){return this.capture("navigation",{from:t,to:e},"info",r)},o.prototype.captureDomContentLoaded=function(t){return this.capture("navigation",{subtype:"DOMContentLoaded"},"info",void 0,t&&t.getTime())},o.prototype.captureLoad=function(t){return this.capture("navigation",{subtype:"load"},"info",void 0,t&&t.getTime())},o.prototype.captureConnectivityChange=function(t,e){return this.captureNetwork({change:t},"connectivity",e)},o.prototype._captureRollbarItem=function(t){if(this.options.includeItemsInTelemetry)return t.err?this.captureError(t.err,t.level,t.uuid,t.timestamp):t.message?this.captureLog(t.message,t.level,t.uuid,t.timestamp):t.custom?this.capture("log",t.custom,t.level,t.uuid,t.timestamp):void 0},o.prototype.push=function(t){this.queue.push(t),this.queue.length>this.maxQueueSize&&this.queue.shift();},t.exports=o;},function(t,e,r){var n=r(0),o=r(4),i=r(2),a=r(31),s={network:!0,networkResponseHeaders:!1,networkResponseBody:!1,networkRequestHeaders:!1,networkRequestBody:!1,networkErrorOnHttp5xx:!1,networkErrorOnHttp4xx:!1,networkErrorOnHttp0:!1,log:!0,dom:!0,navigation:!0,connectivity:!0};function u(t,e,r,n,o){var i=t[e];t[e]=r(i),n&&n[o].push([t,e,i]);}function c(t,e){for(var r;t[e].length;)(r=t[e].shift())[0][r[1]]=r[2];}function l(t,e,r,o,i){this.options=t;var a=t.autoInstrument;!1===t.enabled||!1===a?this.autoInstrument={}:(n.isType(a,"object")||(a=s),this.autoInstrument=n.merge(s,a)),this.scrubTelemetryInputs=!!t.scrubTelemetryInputs,this.telemetryScrubber=t.telemetryScrubber,this.defaultValueScrubber=function(t){for(var e=[],r=0;r<t.length;++r)e.push(new RegExp(t[r],"i"));return function(t){var r=function(t){if(!t||!t.attributes)return null;for(var e=t.attributes,r=0;r<e.length;++r)if("name"===e[r].key)return e[r].value;return null}(t);if(!r)return !1;for(var n=0;n<e.length;++n)if(e[n].test(r))return !0;return !1}}(t.scrubFields),this.telemeter=e,this.rollbar=r,this.diagnostic=r.client.notifier.diagnostic,this._window=o||{},this._document=i||{},this.replacements={network:[],log:[],navigation:[],connectivity:[]},this.eventRemovers={dom:[],connectivity:[]},this._location=this._window.location,this._lastHref=this._location&&this._location.href;}l.prototype.configure=function(t){this.options=n.merge(this.options,t);var e=t.autoInstrument,r=n.merge(this.autoInstrument);!1===t.enabled||!1===e?this.autoInstrument={}:(n.isType(e,"object")||(e=s),this.autoInstrument=n.merge(s,e)),this.instrument(r),void 0!==t.scrubTelemetryInputs&&(this.scrubTelemetryInputs=!!t.scrubTelemetryInputs),void 0!==t.telemetryScrubber&&(this.telemetryScrubber=t.telemetryScrubber);},l.prototype.instrument=function(t){!this.autoInstrument.network||t&&t.network?!this.autoInstrument.network&&t&&t.network&&this.deinstrumentNetwork():this.instrumentNetwork(),!this.autoInstrument.log||t&&t.log?!this.autoInstrument.log&&t&&t.log&&this.deinstrumentConsole():this.instrumentConsole(),!this.autoInstrument.dom||t&&t.dom?!this.autoInstrument.dom&&t&&t.dom&&this.deinstrumentDom():this.instrumentDom(),!this.autoInstrument.navigation||t&&t.navigation?!this.autoInstrument.navigation&&t&&t.navigation&&this.deinstrumentNavigation():this.instrumentNavigation(),!this.autoInstrument.connectivity||t&&t.connectivity?!this.autoInstrument.connectivity&&t&&t.connectivity&&this.deinstrumentConnectivity():this.instrumentConnectivity();},l.prototype.deinstrumentNetwork=function(){c(this.replacements,"network");},l.prototype.instrumentNetwork=function(){var t=this;function e(e,r){e in r&&n.isFunction(r[e])&&u(r,e,(function(e){return t.rollbar.wrap(e)}));}if("XMLHttpRequest"in this._window){var r=this._window.XMLHttpRequest.prototype;u(r,"open",(function(t){return function(e,r){return n.isType(r,"string")&&(this.__rollbar_xhr?(this.__rollbar_xhr.method=e,this.__rollbar_xhr.url=r,this.__rollbar_xhr.status_code=null,this.__rollbar_xhr.start_time_ms=n.now(),this.__rollbar_xhr.end_time_ms=null):this.__rollbar_xhr={method:e,url:r,status_code:null,start_time_ms:n.now(),end_time_ms:null}),t.apply(this,arguments)}}),this.replacements,"network"),u(r,"setRequestHeader",(function(e){return function(r,o){return this.__rollbar_xhr||(this.__rollbar_xhr={}),n.isType(r,"string")&&n.isType(o,"string")&&(t.autoInstrument.networkRequestHeaders&&(this.__rollbar_xhr.request_headers||(this.__rollbar_xhr.request_headers={}),this.__rollbar_xhr.request_headers[r]=o),"content-type"===r.toLowerCase()&&(this.__rollbar_xhr.request_content_type=o)),e.apply(this,arguments)}}),this.replacements,"network"),u(r,"send",(function(r){return function(o){var i=this;function a(){if(i.__rollbar_xhr&&(null===i.__rollbar_xhr.status_code&&(i.__rollbar_xhr.status_code=0,t.autoInstrument.networkRequestBody&&(i.__rollbar_xhr.request=o),i.__rollbar_event=t.captureNetwork(i.__rollbar_xhr,"xhr",void 0)),i.readyState<2&&(i.__rollbar_xhr.start_time_ms=n.now()),i.readyState>3)){i.__rollbar_xhr.end_time_ms=n.now();var e=null;if(i.__rollbar_xhr.response_content_type=i.getResponseHeader("Content-Type"),t.autoInstrument.networkResponseHeaders){var r=t.autoInstrument.networkResponseHeaders;e={};try{var a,s;if(!0===r){var u=i.getAllResponseHeaders();if(u){var c,l,p=u.trim().split(/[\r\n]+/);for(s=0;s<p.length;s++)a=(c=p[s].split(": ")).shift(),l=c.join(": "),e[a]=l;}}else for(s=0;s<r.length;s++)e[a=r[s]]=i.getResponseHeader(a);}catch(t){}}var f=null;if(t.autoInstrument.networkResponseBody)try{f=i.responseText;}catch(t){}var h=null;(f||e)&&(h={},f&&(t.isJsonContentType(i.__rollbar_xhr.request_content_type)?h.body=t.scrubJson(f):h.body=f),e&&(h.headers=e)),h&&(i.__rollbar_xhr.response=h);try{var d=i.status;d=1223===d?204:d,i.__rollbar_xhr.status_code=d,i.__rollbar_event.level=t.telemeter.levelFromStatus(d),t.errorOnHttpStatus(i.__rollbar_xhr);}catch(t){}}}return e("onload",i),e("onerror",i),e("onprogress",i),"onreadystatechange"in i&&n.isFunction(i.onreadystatechange)?u(i,"onreadystatechange",(function(e){return t.rollbar.wrap(e,void 0,a)})):i.onreadystatechange=a,i.__rollbar_xhr&&t.trackHttpErrors()&&(i.__rollbar_xhr.stack=(new Error).stack),r.apply(this,arguments)}}),this.replacements,"network");}"fetch"in this._window&&u(this._window,"fetch",(function(e){return function(r,o){for(var i=new Array(arguments.length),a=0,s=i.length;a<s;a++)i[a]=arguments[a];var u,c=i[0],l="GET";n.isType(c,"string")?u=c:c&&(u=c.url,c.method&&(l=c.method)),i[1]&&i[1].method&&(l=i[1].method);var p={method:l,url:u,status_code:null,start_time_ms:n.now(),end_time_ms:null};if(i[1]&&i[1].headers){var f=new Headers(i[1].headers);p.request_content_type=f.get("Content-Type"),t.autoInstrument.networkRequestHeaders&&(p.request_headers=t.fetchHeaders(f,t.autoInstrument.networkRequestHeaders));}return t.autoInstrument.networkRequestBody&&(i[1]&&i[1].body?p.request=i[1].body:i[0]&&!n.isType(i[0],"string")&&i[0].body&&(p.request=i[0].body)),t.captureNetwork(p,"fetch",void 0),t.trackHttpErrors()&&(p.stack=(new Error).stack),e.apply(this,i).then((function(e){p.end_time_ms=n.now(),p.status_code=e.status,p.response_content_type=e.headers.get("Content-Type");var r=null;t.autoInstrument.networkResponseHeaders&&(r=t.fetchHeaders(e.headers,t.autoInstrument.networkResponseHeaders));var o=null;return t.autoInstrument.networkResponseBody&&"function"==typeof e.text&&(o=e.clone().text()),(r||o)&&(p.response={},o&&("function"==typeof o.then?o.then((function(e){t.isJsonContentType(p.response_content_type)&&(p.response.body=t.scrubJson(e));})):p.response.body=o),r&&(p.response.headers=r)),t.errorOnHttpStatus(p),e}))}}),this.replacements,"network");},l.prototype.captureNetwork=function(t,e,r){return t.request&&this.isJsonContentType(t.request_content_type)&&(t.request=this.scrubJson(t.request)),this.telemeter.captureNetwork(t,e,r)},l.prototype.isJsonContentType=function(t){return !(!t||!t.toLowerCase().includes("json"))},l.prototype.scrubJson=function(t){return JSON.stringify(o(JSON.parse(t),this.options.scrubFields))},l.prototype.fetchHeaders=function(t,e){var r={};try{var n;if(!0===e){if("function"==typeof t.entries)for(var o=t.entries(),i=o.next();!i.done;)r[i.value[0]]=i.value[1],i=o.next();}else for(n=0;n<e.length;n++){var a=e[n];r[a]=t.get(a);}}catch(t){}return r},l.prototype.trackHttpErrors=function(){return this.autoInstrument.networkErrorOnHttp5xx||this.autoInstrument.networkErrorOnHttp4xx||this.autoInstrument.networkErrorOnHttp0},l.prototype.errorOnHttpStatus=function(t){var e=t.status_code;if(e>=500&&this.autoInstrument.networkErrorOnHttp5xx||e>=400&&this.autoInstrument.networkErrorOnHttp4xx||0===e&&this.autoInstrument.networkErrorOnHttp0){var r=new Error("HTTP request failed with Status "+e);r.stack=t.stack,this.rollbar.error(r,{skipFrames:1});}},l.prototype.deinstrumentConsole=function(){if("console"in this._window&&this._window.console.log)for(var t;this.replacements.log.length;)t=this.replacements.log.shift(),this._window.console[t[0]]=t[1];},l.prototype.instrumentConsole=function(){if("console"in this._window&&this._window.console.log){var t=this,e=this._window.console,r=["debug","info","warn","error","log"];try{for(var o=0,i=r.length;o<i;o++)a(r[o]);}catch(t){this.diagnostic.instrumentConsole={error:t.message};}}function a(r){var o=e[r],i=e,a="warn"===r?"warning":r;e[r]=function(){var e=Array.prototype.slice.call(arguments),r=n.formatArgsAsString(e);t.telemeter.captureLog(r,a),o&&Function.prototype.apply.call(o,i,e);},t.replacements.log.push([r,o]);}},l.prototype.deinstrumentDom=function(){("addEventListener"in this._window||"attachEvent"in this._window)&&this.removeListeners("dom");},l.prototype.instrumentDom=function(){if("addEventListener"in this._window||"attachEvent"in this._window){var t=this.handleClick.bind(this),e=this.handleBlur.bind(this);this.addListener("dom",this._window,"click","onclick",t,!0),this.addListener("dom",this._window,"blur","onfocusout",e,!0);}},l.prototype.handleClick=function(t){try{var e=a.getElementFromEvent(t,this._document),r=e&&e.tagName,n=a.isDescribedElement(e,"a")||a.isDescribedElement(e,"button");r&&(n||a.isDescribedElement(e,"input",["button","submit"]))?this.captureDomEvent("click",e):a.isDescribedElement(e,"input",["checkbox","radio"])&&this.captureDomEvent("input",e,e.value,e.checked);}catch(t){}},l.prototype.handleBlur=function(t){try{var e=a.getElementFromEvent(t,this._document);e&&e.tagName&&(a.isDescribedElement(e,"textarea")?this.captureDomEvent("input",e,e.value):a.isDescribedElement(e,"select")&&e.options&&e.options.length?this.handleSelectInputChanged(e):a.isDescribedElement(e,"input")&&!a.isDescribedElement(e,"input",["button","submit","hidden","checkbox","radio"])&&this.captureDomEvent("input",e,e.value));}catch(t){}},l.prototype.handleSelectInputChanged=function(t){if(t.multiple)for(var e=0;e<t.options.length;e++)t.options[e].selected&&this.captureDomEvent("input",t,t.options[e].value);else t.selectedIndex>=0&&t.options[t.selectedIndex]&&this.captureDomEvent("input",t,t.options[t.selectedIndex].value);},l.prototype.captureDomEvent=function(t,e,r,n){if(void 0!==r)if(this.scrubTelemetryInputs||"password"===a.getElementType(e))r="[scrubbed]";else {var o=a.describeElement(e);this.telemetryScrubber?this.telemetryScrubber(o)&&(r="[scrubbed]"):this.defaultValueScrubber(o)&&(r="[scrubbed]");}var i=a.elementArrayToString(a.treeToArray(e));this.telemeter.captureDom(t,i,r,n);},l.prototype.deinstrumentNavigation=function(){var t=this._window.chrome;!(t&&t.app&&t.app.runtime)&&this._window.history&&this._window.history.pushState&&c(this.replacements,"navigation");},l.prototype.instrumentNavigation=function(){var t=this._window.chrome;if(!(t&&t.app&&t.app.runtime)&&this._window.history&&this._window.history.pushState){var e=this;u(this._window,"onpopstate",(function(t){return function(){var r=e._location.href;e.handleUrlChange(e._lastHref,r),t&&t.apply(this,arguments);}}),this.replacements,"navigation"),u(this._window.history,"pushState",(function(t){return function(){var r=arguments.length>2?arguments[2]:void 0;return r&&e.handleUrlChange(e._lastHref,r+""),t.apply(this,arguments)}}),this.replacements,"navigation");}},l.prototype.handleUrlChange=function(t,e){var r=i.parse(this._location.href),n=i.parse(e),o=i.parse(t);this._lastHref=e,r.protocol===n.protocol&&r.host===n.host&&(e=n.path+(n.hash||"")),r.protocol===o.protocol&&r.host===o.host&&(t=o.path+(o.hash||"")),this.telemeter.captureNavigation(t,e);},l.prototype.deinstrumentConnectivity=function(){("addEventListener"in this._window||"body"in this._document)&&(this._window.addEventListener?this.removeListeners("connectivity"):c(this.replacements,"connectivity"));},l.prototype.instrumentConnectivity=function(){if("addEventListener"in this._window||"body"in this._document)if(this._window.addEventListener)this.addListener("connectivity",this._window,"online",void 0,function(){this.telemeter.captureConnectivityChange("online");}.bind(this),!0),this.addListener("connectivity",this._window,"offline",void 0,function(){this.telemeter.captureConnectivityChange("offline");}.bind(this),!0);else {var t=this;u(this._document.body,"ononline",(function(e){return function(){t.telemeter.captureConnectivityChange("online"),e&&e.apply(this,arguments);}}),this.replacements,"connectivity"),u(this._document.body,"onoffline",(function(e){return function(){t.telemeter.captureConnectivityChange("offline"),e&&e.apply(this,arguments);}}),this.replacements,"connectivity");}},l.prototype.addListener=function(t,e,r,n,o,i){e.addEventListener?(e.addEventListener(r,o,i),this.eventRemovers[t].push((function(){e.removeEventListener(r,o,i);}))):n&&(e.attachEvent(n,o),this.eventRemovers[t].push((function(){e.detachEvent(n,o);})));},l.prototype.removeListeners=function(t){for(;this.eventRemovers[t].length;)this.eventRemovers[t].shift()();},t.exports=l;},function(t,e,r){function n(t){return (t.getAttribute("type")||"").toLowerCase()}function o(t){if(!t||!t.tagName)return "";var e=[t.tagName];t.id&&e.push("#"+t.id),t.classes&&e.push("."+t.classes.join("."));for(var r=0;r<t.attributes.length;r++)e.push("["+t.attributes[r].key+'="'+t.attributes[r].value+'"]');return e.join("")}function i(t){if(!t||!t.tagName)return null;var e,r,n,o,i={};i.tagName=t.tagName.toLowerCase(),t.id&&(i.id=t.id),(e=t.className)&&"string"==typeof e&&(i.classes=e.split(/\s+/));var a=["type","name","title","alt"];for(i.attributes=[],o=0;o<a.length;o++)r=a[o],(n=t.getAttribute(r))&&i.attributes.push({key:r,value:n});return i}t.exports={describeElement:i,descriptionToString:o,elementArrayToString:function(t){for(var e,r,n=" > ".length,i=[],a=0,s=t.length-1;s>=0;s--){if(e=o(t[s]),r=a+i.length*n+e.length,s<t.length-1&&r>=83){i.unshift("...");break}i.unshift(e),a+=e.length;}return i.join(" > ")},treeToArray:function(t){for(var e,r=[],n=0;t&&n<5&&"html"!==(e=i(t)).tagName;n++)r.unshift(e),t=t.parentNode;return r},getElementFromEvent:function(t,e){return t.target?t.target:e&&e.elementFromPoint?e.elementFromPoint(t.clientX,t.clientY):void 0},isDescribedElement:function(t,e,r){if(t.tagName.toLowerCase()!==e.toLowerCase())return !1;if(!r)return !0;t=n(t);for(var o=0;o<r.length;o++)if(r[o]===t)return !0;return !1},getElementType:n};},function(t,e){t.exports=function(t){var e,r,n,o,i,a,s,u,c,l,p,f,h,d=/[\\"\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;function m(t){return t<10?"0"+t:t}function g(){return this.valueOf()}function v(t){return d.lastIndex=0,d.test(t)?'"'+t.replace(d,(function(t){var e=n[t];return "string"==typeof e?e:"\\u"+("0000"+t.charCodeAt(0).toString(16)).slice(-4)}))+'"':'"'+t+'"'}"function"!=typeof Date.prototype.toJSON&&(Date.prototype.toJSON=function(){return isFinite(this.valueOf())?this.getUTCFullYear()+"-"+m(this.getUTCMonth()+1)+"-"+m(this.getUTCDate())+"T"+m(this.getUTCHours())+":"+m(this.getUTCMinutes())+":"+m(this.getUTCSeconds())+"Z":null},Boolean.prototype.toJSON=g,Number.prototype.toJSON=g,String.prototype.toJSON=g),"function"!=typeof t.stringify&&(n={"\b":"\\b","\t":"\\t","\n":"\\n","\f":"\\f","\r":"\\r",'"':'\\"',"\\":"\\\\"},t.stringify=function(t,n,i){var a;if(e="",r="","number"==typeof i)for(a=0;a<i;a+=1)r+=" ";else "string"==typeof i&&(r=i);if(o=n,n&&"function"!=typeof n&&("object"!=typeof n||"number"!=typeof n.length))throw new Error("JSON.stringify");return function t(n,i){var a,s,u,c,l,p=e,f=i[n];switch(f&&"object"==typeof f&&"function"==typeof f.toJSON&&(f=f.toJSON(n)),"function"==typeof o&&(f=o.call(i,n,f)),typeof f){case"string":return v(f);case"number":return isFinite(f)?String(f):"null";case"boolean":case"null":return String(f);case"object":if(!f)return "null";if(e+=r,l=[],"[object Array]"===Object.prototype.toString.apply(f)){for(c=f.length,a=0;a<c;a+=1)l[a]=t(a,f)||"null";return u=0===l.length?"[]":e?"[\n"+e+l.join(",\n"+e)+"\n"+p+"]":"["+l.join(",")+"]",e=p,u}if(o&&"object"==typeof o)for(c=o.length,a=0;a<c;a+=1)"string"==typeof o[a]&&(u=t(s=o[a],f))&&l.push(v(s)+(e?": ":":")+u);else for(s in f)Object.prototype.hasOwnProperty.call(f,s)&&(u=t(s,f))&&l.push(v(s)+(e?": ":":")+u);return u=0===l.length?"{}":e?"{\n"+e+l.join(",\n"+e)+"\n"+p+"}":"{"+l.join(",")+"}",e=p,u}}("",{"":t})}),"function"!=typeof t.parse&&(t.parse=(l={"\\":"\\",'"':'"',"/":"/",t:"\t",n:"\n",r:"\r",f:"\f",b:"\b"},p={go:function(){i="ok";},firstokey:function(){u=c,i="colon";},okey:function(){u=c,i="colon";},ovalue:function(){i="ocomma";},firstavalue:function(){i="acomma";},avalue:function(){i="acomma";}},f={go:function(){i="ok";},ovalue:function(){i="ocomma";},firstavalue:function(){i="acomma";},avalue:function(){i="acomma";}},h={"{":{go:function(){a.push({state:"ok"}),s={},i="firstokey";},ovalue:function(){a.push({container:s,state:"ocomma",key:u}),s={},i="firstokey";},firstavalue:function(){a.push({container:s,state:"acomma"}),s={},i="firstokey";},avalue:function(){a.push({container:s,state:"acomma"}),s={},i="firstokey";}},"}":{firstokey:function(){var t=a.pop();c=s,s=t.container,u=t.key,i=t.state;},ocomma:function(){var t=a.pop();s[u]=c,c=s,s=t.container,u=t.key,i=t.state;}},"[":{go:function(){a.push({state:"ok"}),s=[],i="firstavalue";},ovalue:function(){a.push({container:s,state:"ocomma",key:u}),s=[],i="firstavalue";},firstavalue:function(){a.push({container:s,state:"acomma"}),s=[],i="firstavalue";},avalue:function(){a.push({container:s,state:"acomma"}),s=[],i="firstavalue";}},"]":{firstavalue:function(){var t=a.pop();c=s,s=t.container,u=t.key,i=t.state;},acomma:function(){var t=a.pop();s.push(c),c=s,s=t.container,u=t.key,i=t.state;}},":":{colon:function(){if(Object.hasOwnProperty.call(s,u))throw new SyntaxError("Duplicate key '"+u+'"');i="ovalue";}},",":{ocomma:function(){s[u]=c,i="okey";},acomma:function(){s.push(c),i="avalue";}},true:{go:function(){c=!0,i="ok";},ovalue:function(){c=!0,i="ocomma";},firstavalue:function(){c=!0,i="acomma";},avalue:function(){c=!0,i="acomma";}},false:{go:function(){c=!1,i="ok";},ovalue:function(){c=!1,i="ocomma";},firstavalue:function(){c=!1,i="acomma";},avalue:function(){c=!1,i="acomma";}},null:{go:function(){c=null,i="ok";},ovalue:function(){c=null,i="ocomma";},firstavalue:function(){c=null,i="acomma";},avalue:function(){c=null,i="acomma";}}},function(t,e){var r,n,o=/^[\u0020\t\n\r]*(?:([,:\[\]{}]|true|false|null)|(-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)|"((?:[^\r\n\t\\\"]|\\(?:["\\\/trnfb]|u[0-9a-fA-F]{4}))*)")/;i="go",a=[];try{for(;r=o.exec(t);)r[1]?h[r[1]][i]():r[2]?(c=+r[2],f[i]()):(n=r[3],c=n.replace(/\\(?:u(.{4})|([^u]))/g,(function(t,e,r){return e?String.fromCharCode(parseInt(e,16)):l[r]})),p[i]()),t=t.slice(r[0].length);}catch(t){i=t;}if("ok"!==i||/[^\u0020\t\n\r]/.test(t))throw i instanceof SyntaxError?i:new SyntaxError("JSON");return "function"==typeof e?function t(r,n){var o,i,a=r[n];if(a&&"object"==typeof a)for(o in c)Object.prototype.hasOwnProperty.call(a,o)&&(void 0!==(i=t(a,o))?a[o]=i:delete a[o]);return e.call(r,n,a)}({"":c},""):c}));};},function(t,e,r){function n(t,e,r){if(e.hasOwnProperty&&e.hasOwnProperty("addEventListener")){for(var n=e.addEventListener;n._rollbarOldAdd&&n.belongsToShim;)n=n._rollbarOldAdd;var o=function(e,r,o){n.call(this,e,t.wrap(r),o);};o._rollbarOldAdd=n,o.belongsToShim=r,e.addEventListener=o;for(var i=e.removeEventListener;i._rollbarOldRemove&&i.belongsToShim;)i=i._rollbarOldRemove;var a=function(t,e,r){i.call(this,t,e&&e._rollbar_wrapped||e,r);};a._rollbarOldRemove=i,a.belongsToShim=r,e.removeEventListener=a;}}t.exports=function(t,e,r){if(t){var o,i,a="EventTarget,Window,Node,ApplicationCache,AudioTrackList,ChannelMergerNode,CryptoOperation,EventSource,FileReader,HTMLUnknownElement,IDBDatabase,IDBRequest,IDBTransaction,KeyOperation,MediaController,MessagePort,ModalWindow,Notification,SVGElementInstance,Screen,TextTrack,TextTrackCue,TextTrackList,WebSocket,WebSocketWorker,Worker,XMLHttpRequest,XMLHttpRequestEventTarget,XMLHttpRequestUpload".split(",");for(o=0;o<a.length;++o)t[i=a[o]]&&t[i].prototype&&n(e,t[i].prototype,r);}};},function(t,e,r){var n=r(0),o=r(5);function i(t,e){return [t,n.stringify(t,e)]}function a(t,e){var r=t.length;return r>2*e?t.slice(0,e).concat(t.slice(r-e)):t}function s(t,e,r){r=void 0===r?30:r;var o,i=t.data.body;if(i.trace_chain)for(var s=i.trace_chain,u=0;u<s.length;u++)o=a(o=s[u].frames,r),s[u].frames=o;else i.trace&&(o=a(o=i.trace.frames,r),i.trace.frames=o);return [t,n.stringify(t,e)]}function u(t,e){return e&&e.length>t?e.slice(0,t-3).concat("..."):e}function c(t,e,r){return [e=o(e,(function e(r,i,a){switch(n.typeName(i)){case"string":return u(t,i);case"object":case"array":return o(i,e,a);default:return i}}),[]),n.stringify(e,r)]}function l(t){return t.exception&&(delete t.exception.description,t.exception.message=u(255,t.exception.message)),t.frames=a(t.frames,1),t}function p(t,e){var r=t.data.body;if(r.trace_chain)for(var o=r.trace_chain,i=0;i<o.length;i++)o[i]=l(o[i]);else r.trace&&(r.trace=l(r.trace));return [t,n.stringify(t,e)]}function f(t,e){return n.maxByteSize(t)>e}t.exports={truncate:function(t,e,r){r=void 0===r?524288:r;for(var n,o,a,u=[i,s,c.bind(null,1024),c.bind(null,512),c.bind(null,256),p];n=u.shift();)if(t=(o=n(t,e))[0],(a=o[1]).error||!f(a.value,r))return a;return a},raw:i,truncateFrames:s,truncateStrings:c,maybeTruncateValue:u};}])}));
		
	} (rollbar_umd_min));

	var rollbar_umd_minExports = rollbar_umd_min.exports;
	var Rollbar = /*@__PURE__*/getDefaultExportFromCjs(rollbar_umd_minExports);

	const RollbarContext = reactExports.createContext(null);

	const RollbarProvider


	 = ({ config, children }) => {
	    const rollbar = new Rollbar({
	        ...config,
	        // substring match, per https://docs.rollbar.com/docs/javascript/#section-ignoring-specific-exception-messages
	        ignoredMessages: ["Minified React error"],
	    });
	    return reactExports.createElement(
	        RollbarContext.Provider,
	        {
	            value: rollbar,
	        },
	        children
	    );
	};

	const defaultConfig = {
	    HCAPTCHA_SITE_KEY: "",
	    IFRAMELY_KEY: "",
	    UNLEASH_APP_NAME: "",
	    UNLEASH_CLIENT_KEY: "",
	    limits: {
	        attachmentSize: {
	            normal: 5 * 1024 * 1024,
	            cohostPlus: 10 * 1024 * 1024,
	        },
	        attachmentCount: 10,
	        attachmentContentTypes: {
	            // fastly supports gif, jpeg, png, and webp. we also support svg. see:
	            // https://developer.fastly.com/reference/io/#limitations-and-constraints
	            "image/png": "image",
	            "image/jpeg": "image",
	            "image/gif": "image",
	            "image/webp": "image",
	            "image/svg+xml": "image",
	            // list of audio formats taken from https://caniuse.com/?search=audio%20format,
	            // >= 95% as of 7/10/2023
	            "audio/aac": "audio",
	            "audio/mp4": "audio",
	            "audio/x-m4a": "audio",
	            "audio/flac": "audio",
	            "audio/x-flac": "audio",
	            "audio/mpeg": "audio",
	            "audio/wav": "audio",
	        },
	    },
	    operatingPrime: 1,
	} ;

	function isValidAttachmentContentType(
	    siteConfig,
	    contentType
	) {
	    for (const supportedContentType in siteConfig.limits
	        .attachmentContentTypes) {
	        const kind =
	            siteConfig.limits.attachmentContentTypes[supportedContentType];

	        if (supportedContentType.endsWith("/*")) {
	            // wildcard; truncate it off and check the start of the content
	            // type
	            if (
	                contentType.startsWith(
	                    supportedContentType.substring(
	                        0,
	                        supportedContentType.length - 1
	                    )
	                )
	            )
	                return { valid: true, kind };
	        } else {
	            // otherwise check identity
	            if (contentType === supportedContentType)
	                return { valid: true, kind };
	        }
	    }

	    console.warn(`rejected mime type: ${contentType}`);
	    return { valid: false };
	}

	function listValidAttachmentContentTypes(
	    siteConfig
	) {
	    return Object.getOwnPropertyNames(siteConfig.limits.attachmentContentTypes);
	}

	class SiteConfig {
	     _currentConfig;

	     constructor(config) {
	        this._currentConfig = config;
	    }

	    get currentConfig() {
	        return this._currentConfig;
	    }

	    assign(changes) {
	        this._currentConfig = {
	            ...this._currentConfig,
	            ...changes,
	        };
	    }

	     static shared = new SiteConfig({ ...defaultConfig });
	}

	const SiteConfigProvider = reactExports.createContext(defaultConfig);

	const useSiteConfig = () => {
	    const ctx = reactExports.useContext(SiteConfigProvider);
	    return ctx;
	};

	const usePrevious = (value) => {
	    const ref = reactExports.useRef();
	    reactExports.useEffect(() => {
	        ref.current = value;
	    });
	    return ref.current;
	};

	var util;
	(function (util) {
	    function assertNever(_x) {
	        throw new Error();
	    }
	    util.assertNever = assertNever;
	    util.arrayToEnum = (items) => {
	        const obj = {};
	        for (const item of items) {
	            obj[item] = item;
	        }
	        return obj;
	    };
	    util.getValidEnumValues = (obj) => {
	        const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
	        const filtered = {};
	        for (const k of validKeys) {
	            filtered[k] = obj[k];
	        }
	        return util.objectValues(filtered);
	    };
	    util.objectValues = (obj) => {
	        return util.objectKeys(obj).map(function (e) {
	            return obj[e];
	        });
	    };
	    util.objectKeys = typeof Object.keys === "function" // eslint-disable-line ban/ban
	        ? (obj) => Object.keys(obj) // eslint-disable-line ban/ban
	        : (object) => {
	            const keys = [];
	            for (const key in object) {
	                if (Object.prototype.hasOwnProperty.call(object, key)) {
	                    keys.push(key);
	                }
	            }
	            return keys;
	        };
	    util.find = (arr, checker) => {
	        for (const item of arr) {
	            if (checker(item))
	                return item;
	        }
	        return undefined;
	    };
	    util.isInteger = typeof Number.isInteger === "function"
	        ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
	        : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
	})(util || (util = {}));

	const ZodIssueCode = util.arrayToEnum([
	    "invalid_type",
	    "invalid_literal",
	    "custom",
	    "invalid_union",
	    "invalid_union_discriminator",
	    "invalid_enum_value",
	    "unrecognized_keys",
	    "invalid_arguments",
	    "invalid_return_type",
	    "invalid_date",
	    "invalid_string",
	    "too_small",
	    "too_big",
	    "invalid_intersection_types",
	    "not_multiple_of",
	]);
	const quotelessJson = (obj) => {
	    const json = JSON.stringify(obj, null, 2);
	    return json.replace(/"([^"]+)":/g, "$1:");
	};
	class ZodError extends Error {
	    constructor(issues) {
	        super();
	        this.issues = [];
	        this.format = () => {
	            const fieldErrors = { _errors: [] };
	            const processError = (error) => {
	                for (const issue of error.issues) {
	                    if (issue.code === "invalid_union") {
	                        issue.unionErrors.map(processError);
	                    }
	                    else if (issue.code === "invalid_return_type") {
	                        processError(issue.returnTypeError);
	                    }
	                    else if (issue.code === "invalid_arguments") {
	                        processError(issue.argumentsError);
	                    }
	                    else if (issue.path.length === 0) {
	                        fieldErrors._errors.push(issue.message);
	                    }
	                    else {
	                        let curr = fieldErrors;
	                        let i = 0;
	                        while (i < issue.path.length) {
	                            const el = issue.path[i];
	                            const terminal = i === issue.path.length - 1;
	                            if (!terminal) {
	                                if (typeof el === "string") {
	                                    curr[el] = curr[el] || { _errors: [] };
	                                }
	                                else if (typeof el === "number") {
	                                    const errorArray = [];
	                                    errorArray._errors = [];
	                                    curr[el] = curr[el] || errorArray;
	                                }
	                            }
	                            else {
	                                curr[el] = curr[el] || { _errors: [] };
	                                curr[el]._errors.push(issue.message);
	                            }
	                            curr = curr[el];
	                            i++;
	                        }
	                    }
	                }
	            };
	            processError(this);
	            return fieldErrors;
	        };
	        this.addIssue = (sub) => {
	            this.issues = [...this.issues, sub];
	        };
	        this.addIssues = (subs = []) => {
	            this.issues = [...this.issues, ...subs];
	        };
	        const actualProto = new.target.prototype;
	        if (Object.setPrototypeOf) {
	            // eslint-disable-next-line ban/ban
	            Object.setPrototypeOf(this, actualProto);
	        }
	        else {
	            this.__proto__ = actualProto;
	        }
	        this.name = "ZodError";
	        this.issues = issues;
	    }
	    get errors() {
	        return this.issues;
	    }
	    toString() {
	        return this.message;
	    }
	    get message() {
	        return JSON.stringify(this.issues, null, 2);
	    }
	    get isEmpty() {
	        return this.issues.length === 0;
	    }
	    flatten(mapper = (issue) => issue.message) {
	        const fieldErrors = {};
	        const formErrors = [];
	        for (const sub of this.issues) {
	            if (sub.path.length > 0) {
	                fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
	                fieldErrors[sub.path[0]].push(mapper(sub));
	            }
	            else {
	                formErrors.push(mapper(sub));
	            }
	        }
	        return { formErrors, fieldErrors };
	    }
	    get formErrors() {
	        return this.flatten();
	    }
	}
	ZodError.create = (issues) => {
	    const error = new ZodError(issues);
	    return error;
	};
	const defaultErrorMap = (issue, _ctx) => {
	    let message;
	    switch (issue.code) {
	        case ZodIssueCode.invalid_type:
	            if (issue.received === "undefined") {
	                message = "Required";
	            }
	            else {
	                message = `Expected ${issue.expected}, received ${issue.received}`;
	            }
	            break;
	        case ZodIssueCode.invalid_literal:
	            message = `Invalid literal value, expected ${JSON.stringify(issue.expected)}`;
	            break;
	        case ZodIssueCode.unrecognized_keys:
	            message = `Unrecognized key(s) in object: ${issue.keys
                .map((k) => `'${k}'`)
                .join(", ")}`;
	            break;
	        case ZodIssueCode.invalid_union:
	            message = `Invalid input`;
	            break;
	        case ZodIssueCode.invalid_union_discriminator:
	            message = `Invalid discriminator value. Expected ${issue.options
                .map((val) => (typeof val === "string" ? `'${val}'` : val))
                .join(" | ")}`;
	            break;
	        case ZodIssueCode.invalid_enum_value:
	            message = `Invalid enum value. Expected ${issue.options
                .map((val) => (typeof val === "string" ? `'${val}'` : val))
                .join(" | ")}`;
	            break;
	        case ZodIssueCode.invalid_arguments:
	            message = `Invalid function arguments`;
	            break;
	        case ZodIssueCode.invalid_return_type:
	            message = `Invalid function return type`;
	            break;
	        case ZodIssueCode.invalid_date:
	            message = `Invalid date`;
	            break;
	        case ZodIssueCode.invalid_string:
	            if (issue.validation !== "regex")
	                message = `Invalid ${issue.validation}`;
	            else
	                message = "Invalid";
	            break;
	        case ZodIssueCode.too_small:
	            if (issue.type === "array")
	                message = `Array must contain ${issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
	            else if (issue.type === "string")
	                message = `String must contain ${issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
	            else if (issue.type === "number")
	                message = `Number must be greater than ${issue.inclusive ? `or equal to ` : ``}${issue.minimum}`;
	            else
	                message = "Invalid input";
	            break;
	        case ZodIssueCode.too_big:
	            if (issue.type === "array")
	                message = `Array must contain ${issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
	            else if (issue.type === "string")
	                message = `String must contain ${issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
	            else if (issue.type === "number")
	                message = `Number must be less than ${issue.inclusive ? `or equal to ` : ``}${issue.maximum}`;
	            else
	                message = "Invalid input";
	            break;
	        case ZodIssueCode.custom:
	            message = `Invalid input`;
	            break;
	        case ZodIssueCode.invalid_intersection_types:
	            message = `Intersection results could not be merged`;
	            break;
	        case ZodIssueCode.not_multiple_of:
	            message = `Number must be a multiple of ${issue.multipleOf}`;
	            break;
	        default:
	            message = _ctx.defaultError;
	            util.assertNever(issue);
	    }
	    return { message };
	};
	let overrideErrorMap = defaultErrorMap;
	const setErrorMap = (map) => {
	    overrideErrorMap = map;
	};

	const ZodParsedType = util.arrayToEnum([
	    "string",
	    "nan",
	    "number",
	    "integer",
	    "float",
	    "boolean",
	    "date",
	    "bigint",
	    "symbol",
	    "function",
	    "undefined",
	    "null",
	    "array",
	    "object",
	    "unknown",
	    "promise",
	    "void",
	    "never",
	    "map",
	    "set",
	]);
	const getParsedType = (data) => {
	    const t = typeof data;
	    switch (t) {
	        case "undefined":
	            return ZodParsedType.undefined;
	        case "string":
	            return ZodParsedType.string;
	        case "number":
	            return isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
	        case "boolean":
	            return ZodParsedType.boolean;
	        case "function":
	            return ZodParsedType.function;
	        case "bigint":
	            return ZodParsedType.bigint;
	        case "object":
	            if (Array.isArray(data)) {
	                return ZodParsedType.array;
	            }
	            if (data === null) {
	                return ZodParsedType.null;
	            }
	            if (data.then &&
	                typeof data.then === "function" &&
	                data.catch &&
	                typeof data.catch === "function") {
	                return ZodParsedType.promise;
	            }
	            if (typeof Map !== "undefined" && data instanceof Map) {
	                return ZodParsedType.map;
	            }
	            if (typeof Set !== "undefined" && data instanceof Set) {
	                return ZodParsedType.set;
	            }
	            if (typeof Date !== "undefined" && data instanceof Date) {
	                return ZodParsedType.date;
	            }
	            return ZodParsedType.object;
	        default:
	            return ZodParsedType.unknown;
	    }
	};
	const makeIssue = (params) => {
	    const { data, path, errorMaps, issueData } = params;
	    const fullPath = [...path, ...(issueData.path || [])];
	    const fullIssue = {
	        ...issueData,
	        path: fullPath,
	    };
	    let errorMessage = "";
	    const maps = errorMaps
	        .filter((m) => !!m)
	        .slice()
	        .reverse();
	    for (const map of maps) {
	        errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
	    }
	    return {
	        ...issueData,
	        path: fullPath,
	        message: issueData.message || errorMessage,
	    };
	};
	const EMPTY_PATH = [];
	function addIssueToContext(ctx, issueData) {
	    const issue = makeIssue({
	        issueData: issueData,
	        data: ctx.data,
	        path: ctx.path,
	        errorMaps: [
	            ctx.common.contextualErrorMap,
	            ctx.schemaErrorMap,
	            overrideErrorMap,
	            defaultErrorMap, // then global default map
	        ].filter((x) => !!x),
	    });
	    ctx.common.issues.push(issue);
	}
	class ParseStatus {
	    constructor() {
	        this.value = "valid";
	    }
	    dirty() {
	        if (this.value === "valid")
	            this.value = "dirty";
	    }
	    abort() {
	        if (this.value !== "aborted")
	            this.value = "aborted";
	    }
	    static mergeArray(status, results) {
	        const arrayValue = [];
	        for (const s of results) {
	            if (s.status === "aborted")
	                return INVALID$3;
	            if (s.status === "dirty")
	                status.dirty();
	            arrayValue.push(s.value);
	        }
	        return { status: status.value, value: arrayValue };
	    }
	    static async mergeObjectAsync(status, pairs) {
	        const syncPairs = [];
	        for (const pair of pairs) {
	            syncPairs.push({
	                key: await pair.key,
	                value: await pair.value,
	            });
	        }
	        return ParseStatus.mergeObjectSync(status, syncPairs);
	    }
	    static mergeObjectSync(status, pairs) {
	        const finalObject = {};
	        for (const pair of pairs) {
	            const { key, value } = pair;
	            if (key.status === "aborted")
	                return INVALID$3;
	            if (value.status === "aborted")
	                return INVALID$3;
	            if (key.status === "dirty")
	                status.dirty();
	            if (value.status === "dirty")
	                status.dirty();
	            if (typeof value.value !== "undefined" || pair.alwaysSet) {
	                finalObject[key.value] = value.value;
	            }
	        }
	        return { status: status.value, value: finalObject };
	    }
	}
	const INVALID$3 = Object.freeze({
	    status: "aborted",
	});
	const DIRTY = (value) => ({ status: "dirty", value });
	const OK = (value) => ({ status: "valid", value });
	const isAborted = (x) => x.status === "aborted";
	const isDirty = (x) => x.status === "dirty";
	const isValid = (x) => x.status === "valid";
	const isAsync = (x) => typeof Promise !== undefined && x instanceof Promise;

	var errorUtil;
	(function (errorUtil) {
	    errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
	    errorUtil.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
	})(errorUtil || (errorUtil = {}));

	class ParseInputLazyPath {
	    constructor(parent, value, path, key) {
	        this.parent = parent;
	        this.data = value;
	        this._path = path;
	        this._key = key;
	    }
	    get path() {
	        return this._path.concat(this._key);
	    }
	}
	const handleResult = (ctx, result) => {
	    if (isValid(result)) {
	        return { success: true, data: result.value };
	    }
	    else {
	        if (!ctx.common.issues.length) {
	            throw new Error("Validation failed but no issues detected.");
	        }
	        const error = new ZodError(ctx.common.issues);
	        return { success: false, error };
	    }
	};
	function processCreateParams(params) {
	    if (!params)
	        return {};
	    const { errorMap, invalid_type_error, required_error, description } = params;
	    if (errorMap && (invalid_type_error || required_error)) {
	        throw new Error(`Can't use "invalid" or "required" in conjunction with custom error map.`);
	    }
	    if (errorMap)
	        return { errorMap: errorMap, description };
	    const customMap = (iss, ctx) => {
	        if (iss.code !== "invalid_type")
	            return { message: ctx.defaultError };
	        if (typeof ctx.data === "undefined" && required_error)
	            return { message: required_error };
	        if (params.invalid_type_error)
	            return { message: params.invalid_type_error };
	        return { message: ctx.defaultError };
	    };
	    return { errorMap: customMap, description };
	}
	class ZodType {
	    constructor(def) {
	        /** Alias of safeParseAsync */
	        this.spa = this.safeParseAsync;
	        this.superRefine = this._refinement;
	        this._def = def;
	        this.parse = this.parse.bind(this);
	        this.safeParse = this.safeParse.bind(this);
	        this.parseAsync = this.parseAsync.bind(this);
	        this.safeParseAsync = this.safeParseAsync.bind(this);
	        this.spa = this.spa.bind(this);
	        this.refine = this.refine.bind(this);
	        this.refinement = this.refinement.bind(this);
	        this.superRefine = this.superRefine.bind(this);
	        this.optional = this.optional.bind(this);
	        this.nullable = this.nullable.bind(this);
	        this.nullish = this.nullish.bind(this);
	        this.array = this.array.bind(this);
	        this.promise = this.promise.bind(this);
	        this.or = this.or.bind(this);
	        this.and = this.and.bind(this);
	        this.transform = this.transform.bind(this);
	        this.default = this.default.bind(this);
	        this.describe = this.describe.bind(this);
	        this.isNullable = this.isNullable.bind(this);
	        this.isOptional = this.isOptional.bind(this);
	    }
	    get description() {
	        return this._def.description;
	    }
	    _getType(input) {
	        return getParsedType(input.data);
	    }
	    _getOrReturnCtx(input, ctx) {
	        return (ctx || {
	            common: input.parent.common,
	            data: input.data,
	            parsedType: getParsedType(input.data),
	            schemaErrorMap: this._def.errorMap,
	            path: input.path,
	            parent: input.parent,
	        });
	    }
	    _processInputParams(input) {
	        return {
	            status: new ParseStatus(),
	            ctx: {
	                common: input.parent.common,
	                data: input.data,
	                parsedType: getParsedType(input.data),
	                schemaErrorMap: this._def.errorMap,
	                path: input.path,
	                parent: input.parent,
	            },
	        };
	    }
	    _parseSync(input) {
	        const result = this._parse(input);
	        if (isAsync(result)) {
	            throw new Error("Synchronous parse encountered promise.");
	        }
	        return result;
	    }
	    _parseAsync(input) {
	        const result = this._parse(input);
	        return Promise.resolve(result);
	    }
	    parse(data, params) {
	        const result = this.safeParse(data, params);
	        if (result.success)
	            return result.data;
	        throw result.error;
	    }
	    safeParse(data, params) {
	        var _a;
	        const ctx = {
	            common: {
	                issues: [],
	                async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
	                contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
	            },
	            path: (params === null || params === void 0 ? void 0 : params.path) || [],
	            schemaErrorMap: this._def.errorMap,
	            parent: null,
	            data,
	            parsedType: getParsedType(data),
	        };
	        const result = this._parseSync({ data, path: ctx.path, parent: ctx });
	        return handleResult(ctx, result);
	    }
	    async parseAsync(data, params) {
	        const result = await this.safeParseAsync(data, params);
	        if (result.success)
	            return result.data;
	        throw result.error;
	    }
	    async safeParseAsync(data, params) {
	        const ctx = {
	            common: {
	                issues: [],
	                contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
	                async: true,
	            },
	            path: (params === null || params === void 0 ? void 0 : params.path) || [],
	            schemaErrorMap: this._def.errorMap,
	            parent: null,
	            data,
	            parsedType: getParsedType(data),
	        };
	        const maybeAsyncResult = this._parse({ data, path: [], parent: ctx });
	        const result = await (isAsync(maybeAsyncResult)
	            ? maybeAsyncResult
	            : Promise.resolve(maybeAsyncResult));
	        return handleResult(ctx, result);
	    }
	    refine(check, message) {
	        const getIssueProperties = (val) => {
	            if (typeof message === "string" || typeof message === "undefined") {
	                return { message };
	            }
	            else if (typeof message === "function") {
	                return message(val);
	            }
	            else {
	                return message;
	            }
	        };
	        return this._refinement((val, ctx) => {
	            const result = check(val);
	            const setError = () => ctx.addIssue({
	                code: ZodIssueCode.custom,
	                ...getIssueProperties(val),
	            });
	            if (typeof Promise !== "undefined" && result instanceof Promise) {
	                return result.then((data) => {
	                    if (!data) {
	                        setError();
	                        return false;
	                    }
	                    else {
	                        return true;
	                    }
	                });
	            }
	            if (!result) {
	                setError();
	                return false;
	            }
	            else {
	                return true;
	            }
	        });
	    }
	    refinement(check, refinementData) {
	        return this._refinement((val, ctx) => {
	            if (!check(val)) {
	                ctx.addIssue(typeof refinementData === "function"
	                    ? refinementData(val, ctx)
	                    : refinementData);
	                return false;
	            }
	            else {
	                return true;
	            }
	        });
	    }
	    _refinement(refinement) {
	        return new ZodEffects({
	            schema: this,
	            typeName: ZodFirstPartyTypeKind.ZodEffects,
	            effect: { type: "refinement", refinement },
	        });
	    }
	    optional() {
	        return ZodOptional.create(this);
	    }
	    nullable() {
	        return ZodNullable.create(this);
	    }
	    nullish() {
	        return this.optional().nullable();
	    }
	    array() {
	        return ZodArray.create(this);
	    }
	    promise() {
	        return ZodPromise.create(this);
	    }
	    or(option) {
	        return ZodUnion.create([this, option]);
	    }
	    and(incoming) {
	        return ZodIntersection.create(this, incoming);
	    }
	    transform(transform) {
	        return new ZodEffects({
	            schema: this,
	            typeName: ZodFirstPartyTypeKind.ZodEffects,
	            effect: { type: "transform", transform },
	        });
	    }
	    default(def) {
	        const defaultValueFunc = typeof def === "function" ? def : () => def;
	        return new ZodDefault({
	            innerType: this,
	            defaultValue: defaultValueFunc,
	            typeName: ZodFirstPartyTypeKind.ZodDefault,
	        });
	    }
	    describe(description) {
	        const This = this.constructor;
	        return new This({
	            ...this._def,
	            description,
	        });
	    }
	    isOptional() {
	        return this.safeParse(undefined).success;
	    }
	    isNullable() {
	        return this.safeParse(null).success;
	    }
	}
	const cuidRegex = /^c[^\s-]{8,}$/i;
	const uuidRegex = /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i;
	// from https://stackoverflow.com/a/46181/1550155
	// old version: too slow, didn't support unicode
	// const emailRegex = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i;
	// eslint-disable-next-line
	const emailRegex = /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
	class ZodString extends ZodType {
	    constructor() {
	        super(...arguments);
	        this._regex = (regex, validation, message) => this.refinement((data) => regex.test(data), {
	            validation,
	            code: ZodIssueCode.invalid_string,
	            ...errorUtil.errToObj(message),
	        });
	        /**
	         * Deprecated.
	         * Use z.string().min(1) instead.
	         */
	        this.nonempty = (message) => this.min(1, errorUtil.errToObj(message));
	    }
	    _parse(input) {
	        const parsedType = this._getType(input);
	        if (parsedType !== ZodParsedType.string) {
	            const ctx = this._getOrReturnCtx(input);
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.string,
	                received: ctx.parsedType,
	            }
	            //
	            );
	            return INVALID$3;
	        }
	        const status = new ParseStatus();
	        let ctx = undefined;
	        for (const check of this._def.checks) {
	            if (check.kind === "min") {
	                if (input.data.length < check.value) {
	                    ctx = this._getOrReturnCtx(input, ctx);
	                    addIssueToContext(ctx, {
	                        code: ZodIssueCode.too_small,
	                        minimum: check.value,
	                        type: "string",
	                        inclusive: true,
	                        message: check.message,
	                    });
	                    status.dirty();
	                }
	            }
	            else if (check.kind === "max") {
	                if (input.data.length > check.value) {
	                    ctx = this._getOrReturnCtx(input, ctx);
	                    addIssueToContext(ctx, {
	                        code: ZodIssueCode.too_big,
	                        maximum: check.value,
	                        type: "string",
	                        inclusive: true,
	                        message: check.message,
	                    });
	                    status.dirty();
	                }
	            }
	            else if (check.kind === "email") {
	                if (!emailRegex.test(input.data)) {
	                    ctx = this._getOrReturnCtx(input, ctx);
	                    addIssueToContext(ctx, {
	                        validation: "email",
	                        code: ZodIssueCode.invalid_string,
	                        message: check.message,
	                    });
	                    status.dirty();
	                }
	            }
	            else if (check.kind === "uuid") {
	                if (!uuidRegex.test(input.data)) {
	                    ctx = this._getOrReturnCtx(input, ctx);
	                    addIssueToContext(ctx, {
	                        validation: "uuid",
	                        code: ZodIssueCode.invalid_string,
	                        message: check.message,
	                    });
	                    status.dirty();
	                }
	            }
	            else if (check.kind === "cuid") {
	                if (!cuidRegex.test(input.data)) {
	                    ctx = this._getOrReturnCtx(input, ctx);
	                    addIssueToContext(ctx, {
	                        validation: "cuid",
	                        code: ZodIssueCode.invalid_string,
	                        message: check.message,
	                    });
	                    status.dirty();
	                }
	            }
	            else if (check.kind === "url") {
	                try {
	                    new URL(input.data);
	                }
	                catch (_a) {
	                    ctx = this._getOrReturnCtx(input, ctx);
	                    addIssueToContext(ctx, {
	                        validation: "url",
	                        code: ZodIssueCode.invalid_string,
	                        message: check.message,
	                    });
	                    status.dirty();
	                }
	            }
	            else if (check.kind === "regex") {
	                check.regex.lastIndex = 0;
	                const testResult = check.regex.test(input.data);
	                if (!testResult) {
	                    ctx = this._getOrReturnCtx(input, ctx);
	                    addIssueToContext(ctx, {
	                        validation: "regex",
	                        code: ZodIssueCode.invalid_string,
	                        message: check.message,
	                    });
	                    status.dirty();
	                }
	            }
	        }
	        return { status: status.value, value: input.data };
	    }
	    _addCheck(check) {
	        return new ZodString({
	            ...this._def,
	            checks: [...this._def.checks, check],
	        });
	    }
	    email(message) {
	        return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) });
	    }
	    url(message) {
	        return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) });
	    }
	    uuid(message) {
	        return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
	    }
	    cuid(message) {
	        return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
	    }
	    regex(regex, message) {
	        return this._addCheck({
	            kind: "regex",
	            regex: regex,
	            ...errorUtil.errToObj(message),
	        });
	    }
	    min(minLength, message) {
	        return this._addCheck({
	            kind: "min",
	            value: minLength,
	            ...errorUtil.errToObj(message),
	        });
	    }
	    max(maxLength, message) {
	        return this._addCheck({
	            kind: "max",
	            value: maxLength,
	            ...errorUtil.errToObj(message),
	        });
	    }
	    length(len, message) {
	        return this.min(len, message).max(len, message);
	    }
	    get isEmail() {
	        return !!this._def.checks.find((ch) => ch.kind === "email");
	    }
	    get isURL() {
	        return !!this._def.checks.find((ch) => ch.kind === "url");
	    }
	    get isUUID() {
	        return !!this._def.checks.find((ch) => ch.kind === "uuid");
	    }
	    get isCUID() {
	        return !!this._def.checks.find((ch) => ch.kind === "cuid");
	    }
	    get minLength() {
	        let min = -Infinity;
	        this._def.checks.map((ch) => {
	            if (ch.kind === "min") {
	                if (min === null || ch.value > min) {
	                    min = ch.value;
	                }
	            }
	        });
	        return min;
	    }
	    get maxLength() {
	        let max = null;
	        this._def.checks.map((ch) => {
	            if (ch.kind === "max") {
	                if (max === null || ch.value < max) {
	                    max = ch.value;
	                }
	            }
	        });
	        return max;
	    }
	}
	ZodString.create = (params) => {
	    return new ZodString({
	        checks: [],
	        typeName: ZodFirstPartyTypeKind.ZodString,
	        ...processCreateParams(params),
	    });
	};
	// https://stackoverflow.com/questions/3966484/why-does-modulus-operator-return-fractional-number-in-javascript/31711034#31711034
	function floatSafeRemainder(val, step) {
	    const valDecCount = (val.toString().split(".")[1] || "").length;
	    const stepDecCount = (step.toString().split(".")[1] || "").length;
	    const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
	    const valInt = parseInt(val.toFixed(decCount).replace(".", ""));
	    const stepInt = parseInt(step.toFixed(decCount).replace(".", ""));
	    return (valInt % stepInt) / Math.pow(10, decCount);
	}
	class ZodNumber extends ZodType {
	    constructor() {
	        super(...arguments);
	        this.min = this.gte;
	        this.max = this.lte;
	        this.step = this.multipleOf;
	    }
	    _parse(input) {
	        const parsedType = this._getType(input);
	        if (parsedType !== ZodParsedType.number) {
	            const ctx = this._getOrReturnCtx(input);
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.number,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        let ctx = undefined;
	        const status = new ParseStatus();
	        for (const check of this._def.checks) {
	            if (check.kind === "int") {
	                if (!util.isInteger(input.data)) {
	                    ctx = this._getOrReturnCtx(input, ctx);
	                    addIssueToContext(ctx, {
	                        code: ZodIssueCode.invalid_type,
	                        expected: "integer",
	                        received: "float",
	                        message: check.message,
	                    });
	                    status.dirty();
	                }
	            }
	            else if (check.kind === "min") {
	                const tooSmall = check.inclusive
	                    ? input.data < check.value
	                    : input.data <= check.value;
	                if (tooSmall) {
	                    ctx = this._getOrReturnCtx(input, ctx);
	                    addIssueToContext(ctx, {
	                        code: ZodIssueCode.too_small,
	                        minimum: check.value,
	                        type: "number",
	                        inclusive: check.inclusive,
	                        message: check.message,
	                    });
	                    status.dirty();
	                }
	            }
	            else if (check.kind === "max") {
	                const tooBig = check.inclusive
	                    ? input.data > check.value
	                    : input.data >= check.value;
	                if (tooBig) {
	                    ctx = this._getOrReturnCtx(input, ctx);
	                    addIssueToContext(ctx, {
	                        code: ZodIssueCode.too_big,
	                        maximum: check.value,
	                        type: "number",
	                        inclusive: check.inclusive,
	                        message: check.message,
	                    });
	                    status.dirty();
	                }
	            }
	            else if (check.kind === "multipleOf") {
	                if (floatSafeRemainder(input.data, check.value) !== 0) {
	                    ctx = this._getOrReturnCtx(input, ctx);
	                    addIssueToContext(ctx, {
	                        code: ZodIssueCode.not_multiple_of,
	                        multipleOf: check.value,
	                        message: check.message,
	                    });
	                    status.dirty();
	                }
	            }
	            else {
	                util.assertNever(check);
	            }
	        }
	        return { status: status.value, value: input.data };
	    }
	    gte(value, message) {
	        return this.setLimit("min", value, true, errorUtil.toString(message));
	    }
	    gt(value, message) {
	        return this.setLimit("min", value, false, errorUtil.toString(message));
	    }
	    lte(value, message) {
	        return this.setLimit("max", value, true, errorUtil.toString(message));
	    }
	    lt(value, message) {
	        return this.setLimit("max", value, false, errorUtil.toString(message));
	    }
	    setLimit(kind, value, inclusive, message) {
	        return new ZodNumber({
	            ...this._def,
	            checks: [
	                ...this._def.checks,
	                {
	                    kind,
	                    value,
	                    inclusive,
	                    message: errorUtil.toString(message),
	                },
	            ],
	        });
	    }
	    _addCheck(check) {
	        return new ZodNumber({
	            ...this._def,
	            checks: [...this._def.checks, check],
	        });
	    }
	    int(message) {
	        return this._addCheck({
	            kind: "int",
	            message: errorUtil.toString(message),
	        });
	    }
	    positive(message) {
	        return this._addCheck({
	            kind: "min",
	            value: 0,
	            inclusive: false,
	            message: errorUtil.toString(message),
	        });
	    }
	    negative(message) {
	        return this._addCheck({
	            kind: "max",
	            value: 0,
	            inclusive: false,
	            message: errorUtil.toString(message),
	        });
	    }
	    nonpositive(message) {
	        return this._addCheck({
	            kind: "max",
	            value: 0,
	            inclusive: true,
	            message: errorUtil.toString(message),
	        });
	    }
	    nonnegative(message) {
	        return this._addCheck({
	            kind: "min",
	            value: 0,
	            inclusive: true,
	            message: errorUtil.toString(message),
	        });
	    }
	    multipleOf(value, message) {
	        return this._addCheck({
	            kind: "multipleOf",
	            value: value,
	            message: errorUtil.toString(message),
	        });
	    }
	    get minValue() {
	        let min = null;
	        for (const ch of this._def.checks) {
	            if (ch.kind === "min") {
	                if (min === null || ch.value > min)
	                    min = ch.value;
	            }
	        }
	        return min;
	    }
	    get maxValue() {
	        let max = null;
	        for (const ch of this._def.checks) {
	            if (ch.kind === "max") {
	                if (max === null || ch.value < max)
	                    max = ch.value;
	            }
	        }
	        return max;
	    }
	    get isInt() {
	        return !!this._def.checks.find((ch) => ch.kind === "int");
	    }
	}
	ZodNumber.create = (params) => {
	    return new ZodNumber({
	        checks: [],
	        typeName: ZodFirstPartyTypeKind.ZodNumber,
	        ...processCreateParams(params),
	    });
	};
	class ZodBigInt extends ZodType {
	    _parse(input) {
	        const parsedType = this._getType(input);
	        if (parsedType !== ZodParsedType.bigint) {
	            const ctx = this._getOrReturnCtx(input);
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.bigint,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        return OK(input.data);
	    }
	}
	ZodBigInt.create = (params) => {
	    return new ZodBigInt({
	        typeName: ZodFirstPartyTypeKind.ZodBigInt,
	        ...processCreateParams(params),
	    });
	};
	class ZodBoolean extends ZodType {
	    _parse(input) {
	        const parsedType = this._getType(input);
	        if (parsedType !== ZodParsedType.boolean) {
	            const ctx = this._getOrReturnCtx(input);
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.boolean,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        return OK(input.data);
	    }
	}
	ZodBoolean.create = (params) => {
	    return new ZodBoolean({
	        typeName: ZodFirstPartyTypeKind.ZodBoolean,
	        ...processCreateParams(params),
	    });
	};
	class ZodDate extends ZodType {
	    _parse(input) {
	        const parsedType = this._getType(input);
	        if (parsedType !== ZodParsedType.date) {
	            const ctx = this._getOrReturnCtx(input);
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.date,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        if (isNaN(input.data.getTime())) {
	            const ctx = this._getOrReturnCtx(input);
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_date,
	            });
	            return INVALID$3;
	        }
	        return {
	            status: "valid",
	            value: new Date(input.data.getTime()),
	        };
	    }
	}
	ZodDate.create = (params) => {
	    return new ZodDate({
	        typeName: ZodFirstPartyTypeKind.ZodDate,
	        ...processCreateParams(params),
	    });
	};
	class ZodUndefined extends ZodType {
	    _parse(input) {
	        const parsedType = this._getType(input);
	        if (parsedType !== ZodParsedType.undefined) {
	            const ctx = this._getOrReturnCtx(input);
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.undefined,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        return OK(input.data);
	    }
	}
	ZodUndefined.create = (params) => {
	    return new ZodUndefined({
	        typeName: ZodFirstPartyTypeKind.ZodUndefined,
	        ...processCreateParams(params),
	    });
	};
	class ZodNull extends ZodType {
	    _parse(input) {
	        const parsedType = this._getType(input);
	        if (parsedType !== ZodParsedType.null) {
	            const ctx = this._getOrReturnCtx(input);
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.null,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        return OK(input.data);
	    }
	}
	ZodNull.create = (params) => {
	    return new ZodNull({
	        typeName: ZodFirstPartyTypeKind.ZodNull,
	        ...processCreateParams(params),
	    });
	};
	class ZodAny extends ZodType {
	    constructor() {
	        super(...arguments);
	        // to prevent instances of other classes from extending ZodAny. this causes issues with catchall in ZodObject.
	        this._any = true;
	    }
	    _parse(input) {
	        return OK(input.data);
	    }
	}
	ZodAny.create = (params) => {
	    return new ZodAny({
	        typeName: ZodFirstPartyTypeKind.ZodAny,
	        ...processCreateParams(params),
	    });
	};
	class ZodUnknown extends ZodType {
	    constructor() {
	        super(...arguments);
	        // required
	        this._unknown = true;
	    }
	    _parse(input) {
	        return OK(input.data);
	    }
	}
	ZodUnknown.create = (params) => {
	    return new ZodUnknown({
	        typeName: ZodFirstPartyTypeKind.ZodUnknown,
	        ...processCreateParams(params),
	    });
	};
	class ZodNever extends ZodType {
	    _parse(input) {
	        const ctx = this._getOrReturnCtx(input);
	        addIssueToContext(ctx, {
	            code: ZodIssueCode.invalid_type,
	            expected: ZodParsedType.never,
	            received: ctx.parsedType,
	        });
	        return INVALID$3;
	    }
	}
	ZodNever.create = (params) => {
	    return new ZodNever({
	        typeName: ZodFirstPartyTypeKind.ZodNever,
	        ...processCreateParams(params),
	    });
	};
	class ZodVoid extends ZodType {
	    _parse(input) {
	        const parsedType = this._getType(input);
	        if (parsedType !== ZodParsedType.undefined) {
	            const ctx = this._getOrReturnCtx(input);
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.void,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        return OK(input.data);
	    }
	}
	ZodVoid.create = (params) => {
	    return new ZodVoid({
	        typeName: ZodFirstPartyTypeKind.ZodVoid,
	        ...processCreateParams(params),
	    });
	};
	class ZodArray extends ZodType {
	    _parse(input) {
	        const { ctx, status } = this._processInputParams(input);
	        const def = this._def;
	        if (ctx.parsedType !== ZodParsedType.array) {
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.array,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        if (def.minLength !== null) {
	            if (ctx.data.length < def.minLength.value) {
	                addIssueToContext(ctx, {
	                    code: ZodIssueCode.too_small,
	                    minimum: def.minLength.value,
	                    type: "array",
	                    inclusive: true,
	                    message: def.minLength.message,
	                });
	                status.dirty();
	            }
	        }
	        if (def.maxLength !== null) {
	            if (ctx.data.length > def.maxLength.value) {
	                addIssueToContext(ctx, {
	                    code: ZodIssueCode.too_big,
	                    maximum: def.maxLength.value,
	                    type: "array",
	                    inclusive: true,
	                    message: def.maxLength.message,
	                });
	                status.dirty();
	            }
	        }
	        if (ctx.common.async) {
	            return Promise.all(ctx.data.map((item, i) => {
	                return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
	            })).then((result) => {
	                return ParseStatus.mergeArray(status, result);
	            });
	        }
	        const result = ctx.data.map((item, i) => {
	            return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
	        });
	        return ParseStatus.mergeArray(status, result);
	    }
	    get element() {
	        return this._def.type;
	    }
	    min(minLength, message) {
	        return new ZodArray({
	            ...this._def,
	            minLength: { value: minLength, message: errorUtil.toString(message) },
	        });
	    }
	    max(maxLength, message) {
	        return new ZodArray({
	            ...this._def,
	            maxLength: { value: maxLength, message: errorUtil.toString(message) },
	        });
	    }
	    length(len, message) {
	        return this.min(len, message).max(len, message);
	    }
	    nonempty(message) {
	        return this.min(1, message);
	    }
	}
	ZodArray.create = (schema, params) => {
	    return new ZodArray({
	        type: schema,
	        minLength: null,
	        maxLength: null,
	        typeName: ZodFirstPartyTypeKind.ZodArray,
	        ...processCreateParams(params),
	    });
	};
	/////////////////////////////////////////
	/////////////////////////////////////////
	//////////                     //////////
	//////////      ZodObject      //////////
	//////////                     //////////
	/////////////////////////////////////////
	/////////////////////////////////////////
	var objectUtil;
	(function (objectUtil) {
	    objectUtil.mergeShapes = (first, second) => {
	        return {
	            ...first,
	            ...second, // second overwrites first
	        };
	    };
	})(objectUtil || (objectUtil = {}));
	const AugmentFactory = (def) => (augmentation) => {
	    return new ZodObject({
	        ...def,
	        shape: () => ({
	            ...def.shape(),
	            ...augmentation,
	        }),
	    });
	};
	function deepPartialify(schema) {
	    if (schema instanceof ZodObject) {
	        const newShape = {};
	        for (const key in schema.shape) {
	            const fieldSchema = schema.shape[key];
	            newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
	        }
	        return new ZodObject({
	            ...schema._def,
	            shape: () => newShape,
	        });
	    }
	    else if (schema instanceof ZodArray) {
	        return ZodArray.create(deepPartialify(schema.element));
	    }
	    else if (schema instanceof ZodOptional) {
	        return ZodOptional.create(deepPartialify(schema.unwrap()));
	    }
	    else if (schema instanceof ZodNullable) {
	        return ZodNullable.create(deepPartialify(schema.unwrap()));
	    }
	    else if (schema instanceof ZodTuple) {
	        return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
	    }
	    else {
	        return schema;
	    }
	}
	class ZodObject extends ZodType {
	    constructor() {
	        super(...arguments);
	        this._cached = null;
	        /**
	         * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
	         * If you want to pass through unknown properties, use `.passthrough()` instead.
	         */
	        this.nonstrict = this.passthrough;
	        this.augment = AugmentFactory(this._def);
	        this.extend = AugmentFactory(this._def);
	    }
	    _getCached() {
	        if (this._cached !== null)
	            return this._cached;
	        const shape = this._def.shape();
	        const keys = util.objectKeys(shape);
	        return (this._cached = { shape, keys });
	    }
	    _parse(input) {
	        const parsedType = this._getType(input);
	        if (parsedType !== ZodParsedType.object) {
	            const ctx = this._getOrReturnCtx(input);
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.object,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        const { status, ctx } = this._processInputParams(input);
	        const { shape, keys: shapeKeys } = this._getCached();
	        const extraKeys = [];
	        for (const key in ctx.data) {
	            if (!shapeKeys.includes(key)) {
	                extraKeys.push(key);
	            }
	        }
	        const pairs = [];
	        for (const key of shapeKeys) {
	            const keyValidator = shape[key];
	            const value = ctx.data[key];
	            pairs.push({
	                key: { status: "valid", value: key },
	                value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
	                alwaysSet: key in ctx.data,
	            });
	        }
	        if (this._def.catchall instanceof ZodNever) {
	            const unknownKeys = this._def.unknownKeys;
	            if (unknownKeys === "passthrough") {
	                for (const key of extraKeys) {
	                    pairs.push({
	                        key: { status: "valid", value: key },
	                        value: { status: "valid", value: ctx.data[key] },
	                    });
	                }
	            }
	            else if (unknownKeys === "strict") {
	                if (extraKeys.length > 0) {
	                    addIssueToContext(ctx, {
	                        code: ZodIssueCode.unrecognized_keys,
	                        keys: extraKeys,
	                    });
	                    status.dirty();
	                }
	            }
	            else if (unknownKeys === "strip") ;
	            else {
	                throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
	            }
	        }
	        else {
	            // run catchall validation
	            const catchall = this._def.catchall;
	            for (const key of extraKeys) {
	                const value = ctx.data[key];
	                pairs.push({
	                    key: { status: "valid", value: key },
	                    value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key) //, ctx.child(key), value, getParsedType(value)
	                    ),
	                    alwaysSet: key in ctx.data,
	                });
	            }
	        }
	        if (ctx.common.async) {
	            return Promise.resolve()
	                .then(async () => {
	                const syncPairs = [];
	                for (const pair of pairs) {
	                    const key = await pair.key;
	                    syncPairs.push({
	                        key,
	                        value: await pair.value,
	                        alwaysSet: pair.alwaysSet,
	                    });
	                }
	                return syncPairs;
	            })
	                .then((syncPairs) => {
	                return ParseStatus.mergeObjectSync(status, syncPairs);
	            });
	        }
	        else {
	            return ParseStatus.mergeObjectSync(status, pairs);
	        }
	    }
	    get shape() {
	        return this._def.shape();
	    }
	    strict(message) {
	        errorUtil.errToObj;
	        return new ZodObject({
	            ...this._def,
	            unknownKeys: "strict",
	            ...(message !== undefined
	                ? {
	                    errorMap: (issue, ctx) => {
	                        var _a, _b, _c, _d;
	                        const defaultError = (_c = (_b = (_a = this._def).errorMap) === null || _b === void 0 ? void 0 : _b.call(_a, issue, ctx).message) !== null && _c !== void 0 ? _c : ctx.defaultError;
	                        if (issue.code === "unrecognized_keys")
	                            return {
	                                message: (_d = errorUtil.errToObj(message).message) !== null && _d !== void 0 ? _d : defaultError,
	                            };
	                        return {
	                            message: defaultError,
	                        };
	                    },
	                }
	                : {}),
	        });
	    }
	    strip() {
	        return new ZodObject({
	            ...this._def,
	            unknownKeys: "strip",
	        });
	    }
	    passthrough() {
	        return new ZodObject({
	            ...this._def,
	            unknownKeys: "passthrough",
	        });
	    }
	    setKey(key, schema) {
	        return this.augment({ [key]: schema });
	    }
	    /**
	     * Prior to zod@1.0.12 there was a bug in the
	     * inferred type of merged objects. Please
	     * upgrade if you are experiencing issues.
	     */
	    merge(merging) {
	        // const mergedShape = objectUtil.mergeShapes(
	        //   this._def.shape(),
	        //   merging._def.shape()
	        // );
	        const merged = new ZodObject({
	            unknownKeys: merging._def.unknownKeys,
	            catchall: merging._def.catchall,
	            shape: () => objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
	            typeName: ZodFirstPartyTypeKind.ZodObject,
	        });
	        return merged;
	    }
	    catchall(index) {
	        return new ZodObject({
	            ...this._def,
	            catchall: index,
	        });
	    }
	    pick(mask) {
	        const shape = {};
	        util.objectKeys(mask).map((key) => {
	            shape[key] = this.shape[key];
	        });
	        return new ZodObject({
	            ...this._def,
	            shape: () => shape,
	        });
	    }
	    omit(mask) {
	        const shape = {};
	        util.objectKeys(this.shape).map((key) => {
	            if (util.objectKeys(mask).indexOf(key) === -1) {
	                shape[key] = this.shape[key];
	            }
	        });
	        return new ZodObject({
	            ...this._def,
	            shape: () => shape,
	        });
	    }
	    deepPartial() {
	        return deepPartialify(this);
	    }
	    partial(mask) {
	        const newShape = {};
	        if (mask) {
	            util.objectKeys(this.shape).map((key) => {
	                if (util.objectKeys(mask).indexOf(key) === -1) {
	                    newShape[key] = this.shape[key];
	                }
	                else {
	                    newShape[key] = this.shape[key].optional();
	                }
	            });
	            return new ZodObject({
	                ...this._def,
	                shape: () => newShape,
	            });
	        }
	        else {
	            for (const key in this.shape) {
	                const fieldSchema = this.shape[key];
	                newShape[key] = fieldSchema.optional();
	            }
	        }
	        return new ZodObject({
	            ...this._def,
	            shape: () => newShape,
	        });
	    }
	    required() {
	        const newShape = {};
	        for (const key in this.shape) {
	            const fieldSchema = this.shape[key];
	            let newField = fieldSchema;
	            while (newField instanceof ZodOptional) {
	                newField = newField._def.innerType;
	            }
	            newShape[key] = newField;
	        }
	        return new ZodObject({
	            ...this._def,
	            shape: () => newShape,
	        });
	    }
	}
	ZodObject.create = (shape, params) => {
	    return new ZodObject({
	        shape: () => shape,
	        unknownKeys: "strip",
	        catchall: ZodNever.create(),
	        typeName: ZodFirstPartyTypeKind.ZodObject,
	        ...processCreateParams(params),
	    });
	};
	ZodObject.strictCreate = (shape, params) => {
	    return new ZodObject({
	        shape: () => shape,
	        unknownKeys: "strict",
	        catchall: ZodNever.create(),
	        typeName: ZodFirstPartyTypeKind.ZodObject,
	        ...processCreateParams(params),
	    });
	};
	ZodObject.lazycreate = (shape, params) => {
	    return new ZodObject({
	        shape,
	        unknownKeys: "strip",
	        catchall: ZodNever.create(),
	        typeName: ZodFirstPartyTypeKind.ZodObject,
	        ...processCreateParams(params),
	    });
	};
	class ZodUnion extends ZodType {
	    _parse(input) {
	        const { ctx } = this._processInputParams(input);
	        const options = this._def.options;
	        function handleResults(results) {
	            // return first issue-free validation if it exists
	            for (const result of results) {
	                if (result.result.status === "valid") {
	                    return result.result;
	                }
	            }
	            for (const result of results) {
	                if (result.result.status === "dirty") {
	                    // add issues from dirty option
	                    ctx.common.issues.push(...result.ctx.common.issues);
	                    return result.result;
	                }
	            }
	            // return invalid
	            const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_union,
	                unionErrors,
	            });
	            return INVALID$3;
	        }
	        if (ctx.common.async) {
	            return Promise.all(options.map(async (option) => {
	                const childCtx = {
	                    ...ctx,
	                    common: {
	                        ...ctx.common,
	                        issues: [],
	                    },
	                    parent: null,
	                };
	                return {
	                    result: await option._parseAsync({
	                        data: ctx.data,
	                        path: ctx.path,
	                        parent: childCtx,
	                    }),
	                    ctx: childCtx,
	                };
	            })).then(handleResults);
	        }
	        else {
	            let dirty = undefined;
	            const issues = [];
	            for (const option of options) {
	                const childCtx = {
	                    ...ctx,
	                    common: {
	                        ...ctx.common,
	                        issues: [],
	                    },
	                    parent: null,
	                };
	                const result = option._parseSync({
	                    data: ctx.data,
	                    path: ctx.path,
	                    parent: childCtx,
	                });
	                if (result.status === "valid") {
	                    return result;
	                }
	                else if (result.status === "dirty" && !dirty) {
	                    dirty = { result, ctx: childCtx };
	                }
	                if (childCtx.common.issues.length) {
	                    issues.push(childCtx.common.issues);
	                }
	            }
	            if (dirty) {
	                ctx.common.issues.push(...dirty.ctx.common.issues);
	                return dirty.result;
	            }
	            const unionErrors = issues.map((issues) => new ZodError(issues));
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_union,
	                unionErrors,
	            });
	            return INVALID$3;
	        }
	    }
	    get options() {
	        return this._def.options;
	    }
	}
	ZodUnion.create = (types, params) => {
	    return new ZodUnion({
	        options: types,
	        typeName: ZodFirstPartyTypeKind.ZodUnion,
	        ...processCreateParams(params),
	    });
	};
	class ZodDiscriminatedUnion extends ZodType {
	    _parse(input) {
	        const { ctx } = this._processInputParams(input);
	        if (ctx.parsedType !== ZodParsedType.object) {
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.object,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        const discriminator = this.discriminator;
	        const discriminatorValue = ctx.data[discriminator];
	        const option = this.options.get(discriminatorValue);
	        if (!option) {
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_union_discriminator,
	                options: this.validDiscriminatorValues,
	                path: [discriminator],
	            });
	            return INVALID$3;
	        }
	        if (ctx.common.async) {
	            return option._parseAsync({
	                data: ctx.data,
	                path: ctx.path,
	                parent: ctx,
	            });
	        }
	        else {
	            return option._parseSync({
	                data: ctx.data,
	                path: ctx.path,
	                parent: ctx,
	            });
	        }
	    }
	    get discriminator() {
	        return this._def.discriminator;
	    }
	    get validDiscriminatorValues() {
	        return Array.from(this.options.keys());
	    }
	    get options() {
	        return this._def.options;
	    }
	    /**
	     * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
	     * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
	     * have a different value for each object in the union.
	     * @param discriminator the name of the discriminator property
	     * @param types an array of object schemas
	     * @param params
	     */
	    static create(discriminator, types, params) {
	        // Get all the valid discriminator values
	        const options = new Map();
	        try {
	            types.forEach((type) => {
	                const discriminatorValue = type.shape[discriminator].value;
	                options.set(discriminatorValue, type);
	            });
	        }
	        catch (e) {
	            throw new Error("The discriminator value could not be extracted from all the provided schemas");
	        }
	        // Assert that all the discriminator values are unique
	        if (options.size !== types.length) {
	            throw new Error("Some of the discriminator values are not unique");
	        }
	        return new ZodDiscriminatedUnion({
	            typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
	            discriminator,
	            options,
	            ...processCreateParams(params),
	        });
	    }
	}
	function mergeValues(a, b) {
	    const aType = getParsedType(a);
	    const bType = getParsedType(b);
	    if (a === b) {
	        return { valid: true, data: a };
	    }
	    else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
	        const bKeys = util.objectKeys(b);
	        const sharedKeys = util
	            .objectKeys(a)
	            .filter((key) => bKeys.indexOf(key) !== -1);
	        const newObj = { ...a, ...b };
	        for (const key of sharedKeys) {
	            const sharedValue = mergeValues(a[key], b[key]);
	            if (!sharedValue.valid) {
	                return { valid: false };
	            }
	            newObj[key] = sharedValue.data;
	        }
	        return { valid: true, data: newObj };
	    }
	    else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
	        if (a.length !== b.length) {
	            return { valid: false };
	        }
	        const newArray = [];
	        for (let index = 0; index < a.length; index++) {
	            const itemA = a[index];
	            const itemB = b[index];
	            const sharedValue = mergeValues(itemA, itemB);
	            if (!sharedValue.valid) {
	                return { valid: false };
	            }
	            newArray.push(sharedValue.data);
	        }
	        return { valid: true, data: newArray };
	    }
	    else if (aType === ZodParsedType.date &&
	        bType === ZodParsedType.date &&
	        +a === +b) {
	        return { valid: true, data: a };
	    }
	    else {
	        return { valid: false };
	    }
	}
	class ZodIntersection extends ZodType {
	    _parse(input) {
	        const { status, ctx } = this._processInputParams(input);
	        const handleParsed = (parsedLeft, parsedRight) => {
	            if (isAborted(parsedLeft) || isAborted(parsedRight)) {
	                return INVALID$3;
	            }
	            const merged = mergeValues(parsedLeft.value, parsedRight.value);
	            if (!merged.valid) {
	                addIssueToContext(ctx, {
	                    code: ZodIssueCode.invalid_intersection_types,
	                });
	                return INVALID$3;
	            }
	            if (isDirty(parsedLeft) || isDirty(parsedRight)) {
	                status.dirty();
	            }
	            return { status: status.value, value: merged.data };
	        };
	        if (ctx.common.async) {
	            return Promise.all([
	                this._def.left._parseAsync({
	                    data: ctx.data,
	                    path: ctx.path,
	                    parent: ctx,
	                }),
	                this._def.right._parseAsync({
	                    data: ctx.data,
	                    path: ctx.path,
	                    parent: ctx,
	                }),
	            ]).then(([left, right]) => handleParsed(left, right));
	        }
	        else {
	            return handleParsed(this._def.left._parseSync({
	                data: ctx.data,
	                path: ctx.path,
	                parent: ctx,
	            }), this._def.right._parseSync({
	                data: ctx.data,
	                path: ctx.path,
	                parent: ctx,
	            }));
	        }
	    }
	}
	ZodIntersection.create = (left, right, params) => {
	    return new ZodIntersection({
	        left: left,
	        right: right,
	        typeName: ZodFirstPartyTypeKind.ZodIntersection,
	        ...processCreateParams(params),
	    });
	};
	class ZodTuple extends ZodType {
	    _parse(input) {
	        const { status, ctx } = this._processInputParams(input);
	        if (ctx.parsedType !== ZodParsedType.array) {
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.array,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        if (ctx.data.length < this._def.items.length) {
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.too_small,
	                minimum: this._def.items.length,
	                inclusive: true,
	                type: "array",
	            });
	            return INVALID$3;
	        }
	        const rest = this._def.rest;
	        if (!rest && ctx.data.length > this._def.items.length) {
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.too_big,
	                maximum: this._def.items.length,
	                inclusive: true,
	                type: "array",
	            });
	            status.dirty();
	        }
	        const items = ctx.data
	            .map((item, itemIndex) => {
	            const schema = this._def.items[itemIndex] || this._def.rest;
	            if (!schema)
	                return null;
	            return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
	        })
	            .filter((x) => !!x); // filter nulls
	        if (ctx.common.async) {
	            return Promise.all(items).then((results) => {
	                return ParseStatus.mergeArray(status, results);
	            });
	        }
	        else {
	            return ParseStatus.mergeArray(status, items);
	        }
	    }
	    get items() {
	        return this._def.items;
	    }
	    rest(rest) {
	        return new ZodTuple({
	            ...this._def,
	            rest,
	        });
	    }
	}
	ZodTuple.create = (schemas, params) => {
	    return new ZodTuple({
	        items: schemas,
	        typeName: ZodFirstPartyTypeKind.ZodTuple,
	        rest: null,
	        ...processCreateParams(params),
	    });
	};
	class ZodRecord extends ZodType {
	    get keySchema() {
	        return this._def.keyType;
	    }
	    get valueSchema() {
	        return this._def.valueType;
	    }
	    _parse(input) {
	        const { status, ctx } = this._processInputParams(input);
	        if (ctx.parsedType !== ZodParsedType.object) {
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.object,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        const pairs = [];
	        const keyType = this._def.keyType;
	        const valueType = this._def.valueType;
	        for (const key in ctx.data) {
	            pairs.push({
	                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
	                value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
	            });
	        }
	        if (ctx.common.async) {
	            return ParseStatus.mergeObjectAsync(status, pairs);
	        }
	        else {
	            return ParseStatus.mergeObjectSync(status, pairs);
	        }
	    }
	    get element() {
	        return this._def.valueType;
	    }
	    static create(first, second, third) {
	        if (second instanceof ZodType) {
	            return new ZodRecord({
	                keyType: first,
	                valueType: second,
	                typeName: ZodFirstPartyTypeKind.ZodRecord,
	                ...processCreateParams(third),
	            });
	        }
	        return new ZodRecord({
	            keyType: ZodString.create(),
	            valueType: first,
	            typeName: ZodFirstPartyTypeKind.ZodRecord,
	            ...processCreateParams(second),
	        });
	    }
	}
	class ZodMap extends ZodType {
	    _parse(input) {
	        const { status, ctx } = this._processInputParams(input);
	        if (ctx.parsedType !== ZodParsedType.map) {
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.map,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        const keyType = this._def.keyType;
	        const valueType = this._def.valueType;
	        const pairs = [...ctx.data.entries()].map(([key, value], index) => {
	            return {
	                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
	                value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"])),
	            };
	        });
	        if (ctx.common.async) {
	            const finalMap = new Map();
	            return Promise.resolve().then(async () => {
	                for (const pair of pairs) {
	                    const key = await pair.key;
	                    const value = await pair.value;
	                    if (key.status === "aborted" || value.status === "aborted") {
	                        return INVALID$3;
	                    }
	                    if (key.status === "dirty" || value.status === "dirty") {
	                        status.dirty();
	                    }
	                    finalMap.set(key.value, value.value);
	                }
	                return { status: status.value, value: finalMap };
	            });
	        }
	        else {
	            const finalMap = new Map();
	            for (const pair of pairs) {
	                const key = pair.key;
	                const value = pair.value;
	                if (key.status === "aborted" || value.status === "aborted") {
	                    return INVALID$3;
	                }
	                if (key.status === "dirty" || value.status === "dirty") {
	                    status.dirty();
	                }
	                finalMap.set(key.value, value.value);
	            }
	            return { status: status.value, value: finalMap };
	        }
	    }
	}
	ZodMap.create = (keyType, valueType, params) => {
	    return new ZodMap({
	        valueType,
	        keyType,
	        typeName: ZodFirstPartyTypeKind.ZodMap,
	        ...processCreateParams(params),
	    });
	};
	class ZodSet extends ZodType {
	    _parse(input) {
	        const { status, ctx } = this._processInputParams(input);
	        if (ctx.parsedType !== ZodParsedType.set) {
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.set,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        const def = this._def;
	        if (def.minSize !== null) {
	            if (ctx.data.size < def.minSize.value) {
	                addIssueToContext(ctx, {
	                    code: ZodIssueCode.too_small,
	                    minimum: def.minSize.value,
	                    type: "set",
	                    inclusive: true,
	                    message: def.minSize.message,
	                });
	                status.dirty();
	            }
	        }
	        if (def.maxSize !== null) {
	            if (ctx.data.size > def.maxSize.value) {
	                addIssueToContext(ctx, {
	                    code: ZodIssueCode.too_big,
	                    maximum: def.maxSize.value,
	                    type: "set",
	                    inclusive: true,
	                    message: def.maxSize.message,
	                });
	                status.dirty();
	            }
	        }
	        const valueType = this._def.valueType;
	        function finalizeSet(elements) {
	            const parsedSet = new Set();
	            for (const element of elements) {
	                if (element.status === "aborted")
	                    return INVALID$3;
	                if (element.status === "dirty")
	                    status.dirty();
	                parsedSet.add(element.value);
	            }
	            return { status: status.value, value: parsedSet };
	        }
	        const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
	        if (ctx.common.async) {
	            return Promise.all(elements).then((elements) => finalizeSet(elements));
	        }
	        else {
	            return finalizeSet(elements);
	        }
	    }
	    min(minSize, message) {
	        return new ZodSet({
	            ...this._def,
	            minSize: { value: minSize, message: errorUtil.toString(message) },
	        });
	    }
	    max(maxSize, message) {
	        return new ZodSet({
	            ...this._def,
	            maxSize: { value: maxSize, message: errorUtil.toString(message) },
	        });
	    }
	    size(size, message) {
	        return this.min(size, message).max(size, message);
	    }
	    nonempty(message) {
	        return this.min(1, message);
	    }
	}
	ZodSet.create = (valueType, params) => {
	    return new ZodSet({
	        valueType,
	        minSize: null,
	        maxSize: null,
	        typeName: ZodFirstPartyTypeKind.ZodSet,
	        ...processCreateParams(params),
	    });
	};
	class ZodFunction extends ZodType {
	    constructor() {
	        super(...arguments);
	        this.validate = this.implement;
	    }
	    _parse(input) {
	        const { ctx } = this._processInputParams(input);
	        if (ctx.parsedType !== ZodParsedType.function) {
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.function,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        function makeArgsIssue(args, error) {
	            return makeIssue({
	                data: args,
	                path: ctx.path,
	                errorMaps: [
	                    ctx.common.contextualErrorMap,
	                    ctx.schemaErrorMap,
	                    overrideErrorMap,
	                    defaultErrorMap,
	                ].filter((x) => !!x),
	                issueData: {
	                    code: ZodIssueCode.invalid_arguments,
	                    argumentsError: error,
	                },
	            });
	        }
	        function makeReturnsIssue(returns, error) {
	            return makeIssue({
	                data: returns,
	                path: ctx.path,
	                errorMaps: [
	                    ctx.common.contextualErrorMap,
	                    ctx.schemaErrorMap,
	                    overrideErrorMap,
	                    defaultErrorMap,
	                ].filter((x) => !!x),
	                issueData: {
	                    code: ZodIssueCode.invalid_return_type,
	                    returnTypeError: error,
	                },
	            });
	        }
	        const params = { errorMap: ctx.common.contextualErrorMap };
	        const fn = ctx.data;
	        if (this._def.returns instanceof ZodPromise) {
	            return OK(async (...args) => {
	                const error = new ZodError([]);
	                const parsedArgs = await this._def.args
	                    .parseAsync(args, params)
	                    .catch((e) => {
	                    error.addIssue(makeArgsIssue(args, e));
	                    throw error;
	                });
	                const result = await fn(...parsedArgs);
	                const parsedReturns = await this._def.returns._def.type
	                    .parseAsync(result, params)
	                    .catch((e) => {
	                    error.addIssue(makeReturnsIssue(result, e));
	                    throw error;
	                });
	                return parsedReturns;
	            });
	        }
	        else {
	            return OK((...args) => {
	                const parsedArgs = this._def.args.safeParse(args, params);
	                if (!parsedArgs.success) {
	                    throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
	                }
	                const result = fn(...parsedArgs.data);
	                const parsedReturns = this._def.returns.safeParse(result, params);
	                if (!parsedReturns.success) {
	                    throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
	                }
	                return parsedReturns.data;
	            });
	        }
	    }
	    parameters() {
	        return this._def.args;
	    }
	    returnType() {
	        return this._def.returns;
	    }
	    args(...items) {
	        return new ZodFunction({
	            ...this._def,
	            args: ZodTuple.create(items).rest(ZodUnknown.create()),
	        });
	    }
	    returns(returnType) {
	        return new ZodFunction({
	            ...this._def,
	            returns: returnType,
	        });
	    }
	    implement(func) {
	        const validatedFunc = this.parse(func);
	        return validatedFunc;
	    }
	    strictImplement(func) {
	        const validatedFunc = this.parse(func);
	        return validatedFunc;
	    }
	}
	ZodFunction.create = (args, returns, params) => {
	    return new ZodFunction({
	        args: (args
	            ? args.rest(ZodUnknown.create())
	            : ZodTuple.create([]).rest(ZodUnknown.create())),
	        returns: returns || ZodUnknown.create(),
	        typeName: ZodFirstPartyTypeKind.ZodFunction,
	        ...processCreateParams(params),
	    });
	};
	class ZodLazy extends ZodType {
	    get schema() {
	        return this._def.getter();
	    }
	    _parse(input) {
	        const { ctx } = this._processInputParams(input);
	        const lazySchema = this._def.getter();
	        return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
	    }
	}
	ZodLazy.create = (getter, params) => {
	    return new ZodLazy({
	        getter: getter,
	        typeName: ZodFirstPartyTypeKind.ZodLazy,
	        ...processCreateParams(params),
	    });
	};
	class ZodLiteral extends ZodType {
	    _parse(input) {
	        if (input.data !== this._def.value) {
	            const ctx = this._getOrReturnCtx(input);
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_literal,
	                expected: this._def.value,
	            });
	            return INVALID$3;
	        }
	        return { status: "valid", value: input.data };
	    }
	    get value() {
	        return this._def.value;
	    }
	}
	ZodLiteral.create = (value, params) => {
	    return new ZodLiteral({
	        value: value,
	        typeName: ZodFirstPartyTypeKind.ZodLiteral,
	        ...processCreateParams(params),
	    });
	};
	function createZodEnum(values) {
	    return new ZodEnum({
	        values: values,
	        typeName: ZodFirstPartyTypeKind.ZodEnum,
	    });
	}
	class ZodEnum extends ZodType {
	    _parse(input) {
	        if (this._def.values.indexOf(input.data) === -1) {
	            const ctx = this._getOrReturnCtx(input);
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_enum_value,
	                options: this._def.values,
	            });
	            return INVALID$3;
	        }
	        return OK(input.data);
	    }
	    get options() {
	        return this._def.values;
	    }
	    get enum() {
	        const enumValues = {};
	        for (const val of this._def.values) {
	            enumValues[val] = val;
	        }
	        return enumValues;
	    }
	    get Values() {
	        const enumValues = {};
	        for (const val of this._def.values) {
	            enumValues[val] = val;
	        }
	        return enumValues;
	    }
	    get Enum() {
	        const enumValues = {};
	        for (const val of this._def.values) {
	            enumValues[val] = val;
	        }
	        return enumValues;
	    }
	}
	ZodEnum.create = createZodEnum;
	class ZodNativeEnum extends ZodType {
	    _parse(input) {
	        const nativeEnumValues = util.getValidEnumValues(this._def.values);
	        if (nativeEnumValues.indexOf(input.data) === -1) {
	            const ctx = this._getOrReturnCtx(input);
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_enum_value,
	                options: util.objectValues(nativeEnumValues),
	            });
	            return INVALID$3;
	        }
	        return OK(input.data);
	    }
	    get enum() {
	        return this._def.values;
	    }
	}
	ZodNativeEnum.create = (values, params) => {
	    return new ZodNativeEnum({
	        values: values,
	        typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
	        ...processCreateParams(params),
	    });
	};
	class ZodPromise extends ZodType {
	    _parse(input) {
	        const { ctx } = this._processInputParams(input);
	        if (ctx.parsedType !== ZodParsedType.promise &&
	            ctx.common.async === false) {
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.promise,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        const promisified = ctx.parsedType === ZodParsedType.promise
	            ? ctx.data
	            : Promise.resolve(ctx.data);
	        return OK(promisified.then((data) => {
	            return this._def.type.parseAsync(data, {
	                path: ctx.path,
	                errorMap: ctx.common.contextualErrorMap,
	            });
	        }));
	    }
	}
	ZodPromise.create = (schema, params) => {
	    return new ZodPromise({
	        type: schema,
	        typeName: ZodFirstPartyTypeKind.ZodPromise,
	        ...processCreateParams(params),
	    });
	};
	class ZodEffects extends ZodType {
	    innerType() {
	        return this._def.schema;
	    }
	    _parse(input) {
	        const { status, ctx } = this._processInputParams(input);
	        const effect = this._def.effect || null;
	        if (effect.type === "preprocess") {
	            const processed = effect.transform(ctx.data);
	            if (ctx.common.async) {
	                return Promise.resolve(processed).then((processed) => {
	                    return this._def.schema._parseAsync({
	                        data: processed,
	                        path: ctx.path,
	                        parent: ctx,
	                    });
	                });
	            }
	            else {
	                return this._def.schema._parseSync({
	                    data: processed,
	                    path: ctx.path,
	                    parent: ctx,
	                });
	            }
	        }
	        if (effect.type === "refinement") {
	            const checkCtx = {
	                addIssue: (arg) => {
	                    addIssueToContext(ctx, arg);
	                    if (arg.fatal) {
	                        status.abort();
	                    }
	                    else {
	                        status.dirty();
	                    }
	                },
	                get path() {
	                    return ctx.path;
	                },
	            };
	            checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
	            const executeRefinement = (acc
	            // effect: RefinementEffect<any>
	            ) => {
	                const result = effect.refinement(acc, checkCtx);
	                if (ctx.common.async) {
	                    return Promise.resolve(result);
	                }
	                if (result instanceof Promise) {
	                    throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
	                }
	                return acc;
	            };
	            if (ctx.common.async === false) {
	                const inner = this._def.schema._parseSync({
	                    data: ctx.data,
	                    path: ctx.path,
	                    parent: ctx,
	                });
	                if (inner.status === "aborted")
	                    return INVALID$3;
	                if (inner.status === "dirty")
	                    status.dirty();
	                // return value is ignored
	                executeRefinement(inner.value);
	                return { status: status.value, value: inner.value };
	            }
	            else {
	                return this._def.schema
	                    ._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx })
	                    .then((inner) => {
	                    if (inner.status === "aborted")
	                        return INVALID$3;
	                    if (inner.status === "dirty")
	                        status.dirty();
	                    return executeRefinement(inner.value).then(() => {
	                        return { status: status.value, value: inner.value };
	                    });
	                });
	            }
	        }
	        if (effect.type === "transform") {
	            if (ctx.common.async === false) {
	                const base = this._def.schema._parseSync({
	                    data: ctx.data,
	                    path: ctx.path,
	                    parent: ctx,
	                });
	                // if (base.status === "aborted") return INVALID;
	                // if (base.status === "dirty") {
	                //   return { status: "dirty", value: base.value };
	                // }
	                if (!isValid(base))
	                    return base;
	                const result = effect.transform(base.value);
	                if (result instanceof Promise) {
	                    throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
	                }
	                return OK(result);
	            }
	            else {
	                return this._def.schema
	                    ._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx })
	                    .then((base) => {
	                    if (!isValid(base))
	                        return base;
	                    // if (base.status === "aborted") return INVALID;
	                    // if (base.status === "dirty") {
	                    //   return { status: "dirty", value: base.value };
	                    // }
	                    return Promise.resolve(effect.transform(base.value)).then(OK);
	                });
	            }
	        }
	        util.assertNever(effect);
	    }
	}
	ZodEffects.create = (schema, effect, params) => {
	    return new ZodEffects({
	        schema,
	        typeName: ZodFirstPartyTypeKind.ZodEffects,
	        effect,
	        ...processCreateParams(params),
	    });
	};
	ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
	    return new ZodEffects({
	        schema,
	        effect: { type: "preprocess", transform: preprocess },
	        typeName: ZodFirstPartyTypeKind.ZodEffects,
	        ...processCreateParams(params),
	    });
	};
	class ZodOptional extends ZodType {
	    _parse(input) {
	        const parsedType = this._getType(input);
	        if (parsedType === ZodParsedType.undefined) {
	            return OK(undefined);
	        }
	        return this._def.innerType._parse(input);
	    }
	    unwrap() {
	        return this._def.innerType;
	    }
	}
	ZodOptional.create = (type, params) => {
	    return new ZodOptional({
	        innerType: type,
	        typeName: ZodFirstPartyTypeKind.ZodOptional,
	        ...processCreateParams(params),
	    });
	};
	class ZodNullable extends ZodType {
	    _parse(input) {
	        const parsedType = this._getType(input);
	        if (parsedType === ZodParsedType.null) {
	            return OK(null);
	        }
	        return this._def.innerType._parse(input);
	    }
	    unwrap() {
	        return this._def.innerType;
	    }
	}
	ZodNullable.create = (type, params) => {
	    return new ZodNullable({
	        innerType: type,
	        typeName: ZodFirstPartyTypeKind.ZodNullable,
	        ...processCreateParams(params),
	    });
	};
	class ZodDefault extends ZodType {
	    _parse(input) {
	        const { ctx } = this._processInputParams(input);
	        let data = ctx.data;
	        if (ctx.parsedType === ZodParsedType.undefined) {
	            data = this._def.defaultValue();
	        }
	        return this._def.innerType._parse({
	            data,
	            path: ctx.path,
	            parent: ctx,
	        });
	    }
	    removeDefault() {
	        return this._def.innerType;
	    }
	}
	ZodDefault.create = (type, params) => {
	    return new ZodOptional({
	        innerType: type,
	        typeName: ZodFirstPartyTypeKind.ZodOptional,
	        ...processCreateParams(params),
	    });
	};
	class ZodNaN extends ZodType {
	    _parse(input) {
	        const parsedType = this._getType(input);
	        if (parsedType !== ZodParsedType.nan) {
	            const ctx = this._getOrReturnCtx(input);
	            addIssueToContext(ctx, {
	                code: ZodIssueCode.invalid_type,
	                expected: ZodParsedType.nan,
	                received: ctx.parsedType,
	            });
	            return INVALID$3;
	        }
	        return { status: "valid", value: input.data };
	    }
	}
	ZodNaN.create = (params) => {
	    return new ZodNaN({
	        typeName: ZodFirstPartyTypeKind.ZodNaN,
	        ...processCreateParams(params),
	    });
	};
	const custom = (check, params) => {
	    if (check)
	        return ZodAny.create().refine(check, params);
	    return ZodAny.create();
	};
	const late = {
	    object: ZodObject.lazycreate,
	};
	var ZodFirstPartyTypeKind;
	(function (ZodFirstPartyTypeKind) {
	    ZodFirstPartyTypeKind["ZodString"] = "ZodString";
	    ZodFirstPartyTypeKind["ZodNumber"] = "ZodNumber";
	    ZodFirstPartyTypeKind["ZodNaN"] = "ZodNaN";
	    ZodFirstPartyTypeKind["ZodBigInt"] = "ZodBigInt";
	    ZodFirstPartyTypeKind["ZodBoolean"] = "ZodBoolean";
	    ZodFirstPartyTypeKind["ZodDate"] = "ZodDate";
	    ZodFirstPartyTypeKind["ZodUndefined"] = "ZodUndefined";
	    ZodFirstPartyTypeKind["ZodNull"] = "ZodNull";
	    ZodFirstPartyTypeKind["ZodAny"] = "ZodAny";
	    ZodFirstPartyTypeKind["ZodUnknown"] = "ZodUnknown";
	    ZodFirstPartyTypeKind["ZodNever"] = "ZodNever";
	    ZodFirstPartyTypeKind["ZodVoid"] = "ZodVoid";
	    ZodFirstPartyTypeKind["ZodArray"] = "ZodArray";
	    ZodFirstPartyTypeKind["ZodObject"] = "ZodObject";
	    ZodFirstPartyTypeKind["ZodUnion"] = "ZodUnion";
	    ZodFirstPartyTypeKind["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
	    ZodFirstPartyTypeKind["ZodIntersection"] = "ZodIntersection";
	    ZodFirstPartyTypeKind["ZodTuple"] = "ZodTuple";
	    ZodFirstPartyTypeKind["ZodRecord"] = "ZodRecord";
	    ZodFirstPartyTypeKind["ZodMap"] = "ZodMap";
	    ZodFirstPartyTypeKind["ZodSet"] = "ZodSet";
	    ZodFirstPartyTypeKind["ZodFunction"] = "ZodFunction";
	    ZodFirstPartyTypeKind["ZodLazy"] = "ZodLazy";
	    ZodFirstPartyTypeKind["ZodLiteral"] = "ZodLiteral";
	    ZodFirstPartyTypeKind["ZodEnum"] = "ZodEnum";
	    ZodFirstPartyTypeKind["ZodEffects"] = "ZodEffects";
	    ZodFirstPartyTypeKind["ZodNativeEnum"] = "ZodNativeEnum";
	    ZodFirstPartyTypeKind["ZodOptional"] = "ZodOptional";
	    ZodFirstPartyTypeKind["ZodNullable"] = "ZodNullable";
	    ZodFirstPartyTypeKind["ZodDefault"] = "ZodDefault";
	    ZodFirstPartyTypeKind["ZodPromise"] = "ZodPromise";
	})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
	const instanceOfType = (cls, params = {
	    message: `Input not instance of ${cls.name}`,
	}) => custom((data) => data instanceof cls, params);
	const stringType = ZodString.create;
	const numberType = ZodNumber.create;
	const nanType = ZodNaN.create;
	const bigIntType = ZodBigInt.create;
	const booleanType = ZodBoolean.create;
	const dateType = ZodDate.create;
	const undefinedType = ZodUndefined.create;
	const nullType = ZodNull.create;
	const anyType = ZodAny.create;
	const unknownType = ZodUnknown.create;
	const neverType = ZodNever.create;
	const voidType = ZodVoid.create;
	const arrayType = ZodArray.create;
	const objectType = ZodObject.create;
	const strictObjectType = ZodObject.strictCreate;
	const unionType = ZodUnion.create;
	const discriminatedUnionType = ZodDiscriminatedUnion.create;
	const intersectionType = ZodIntersection.create;
	const tupleType = ZodTuple.create;
	const recordType = ZodRecord.create;
	const mapType = ZodMap.create;
	const setType = ZodSet.create;
	const functionType = ZodFunction.create;
	const lazyType = ZodLazy.create;
	const literalType = ZodLiteral.create;
	const enumType = ZodEnum.create;
	const nativeEnumType = ZodNativeEnum.create;
	const promiseType = ZodPromise.create;
	const effectsType = ZodEffects.create;
	const optionalType = ZodOptional.create;
	const nullableType = ZodNullable.create;
	const preprocessType = ZodEffects.createWithPreprocess;
	const ostring = () => stringType().optional();
	const onumber = () => numberType().optional();
	const oboolean = () => booleanType().optional();

	var mod = /*#__PURE__*/Object.freeze({
	    __proto__: null,
	    ZodParsedType: ZodParsedType,
	    getParsedType: getParsedType,
	    makeIssue: makeIssue,
	    EMPTY_PATH: EMPTY_PATH,
	    addIssueToContext: addIssueToContext,
	    ParseStatus: ParseStatus,
	    INVALID: INVALID$3,
	    DIRTY: DIRTY,
	    OK: OK,
	    isAborted: isAborted,
	    isDirty: isDirty,
	    isValid: isValid,
	    isAsync: isAsync,
	    ZodType: ZodType,
	    ZodString: ZodString,
	    ZodNumber: ZodNumber,
	    ZodBigInt: ZodBigInt,
	    ZodBoolean: ZodBoolean,
	    ZodDate: ZodDate,
	    ZodUndefined: ZodUndefined,
	    ZodNull: ZodNull,
	    ZodAny: ZodAny,
	    ZodUnknown: ZodUnknown,
	    ZodNever: ZodNever,
	    ZodVoid: ZodVoid,
	    ZodArray: ZodArray,
	    get objectUtil () { return objectUtil; },
	    ZodObject: ZodObject,
	    ZodUnion: ZodUnion,
	    ZodDiscriminatedUnion: ZodDiscriminatedUnion,
	    ZodIntersection: ZodIntersection,
	    ZodTuple: ZodTuple,
	    ZodRecord: ZodRecord,
	    ZodMap: ZodMap,
	    ZodSet: ZodSet,
	    ZodFunction: ZodFunction,
	    ZodLazy: ZodLazy,
	    ZodLiteral: ZodLiteral,
	    ZodEnum: ZodEnum,
	    ZodNativeEnum: ZodNativeEnum,
	    ZodPromise: ZodPromise,
	    ZodEffects: ZodEffects,
	    ZodTransformer: ZodEffects,
	    ZodOptional: ZodOptional,
	    ZodNullable: ZodNullable,
	    ZodDefault: ZodDefault,
	    ZodNaN: ZodNaN,
	    custom: custom,
	    Schema: ZodType,
	    ZodSchema: ZodType,
	    late: late,
	    get ZodFirstPartyTypeKind () { return ZodFirstPartyTypeKind; },
	    any: anyType,
	    array: arrayType,
	    bigint: bigIntType,
	    boolean: booleanType,
	    date: dateType,
	    discriminatedUnion: discriminatedUnionType,
	    effect: effectsType,
	    'enum': enumType,
	    'function': functionType,
	    'instanceof': instanceOfType,
	    intersection: intersectionType,
	    lazy: lazyType,
	    literal: literalType,
	    map: mapType,
	    nan: nanType,
	    nativeEnum: nativeEnumType,
	    never: neverType,
	    'null': nullType,
	    nullable: nullableType,
	    number: numberType,
	    object: objectType,
	    oboolean: oboolean,
	    onumber: onumber,
	    optional: optionalType,
	    ostring: ostring,
	    preprocess: preprocessType,
	    promise: promiseType,
	    record: recordType,
	    set: setType,
	    strictObject: strictObjectType,
	    string: stringType,
	    transformer: effectsType,
	    tuple: tupleType,
	    'undefined': undefinedType,
	    union: unionType,
	    unknown: unknownType,
	    'void': voidType,
	    ZodIssueCode: ZodIssueCode,
	    quotelessJson: quotelessJson,
	    ZodError: ZodError,
	    defaultErrorMap: defaultErrorMap,
	    get overrideErrorMap () { return overrideErrorMap; },
	    setErrorMap: setErrorMap
	});

	mod.enum([
	    "application-error",
	    "not-authorized",
	    "not-logged-in",
	    "not-found",
	    "explicitly-disallowed",
	    /** @deprecated */ "object-does-not-exist",
	    "user-does-not-exist",
	    "project-does-not-exist",
	    "post-does-not-exist",
	    "ask-does-not-exist",
	    "listing-does-not-exist",
	    "tag-does-not-exist",
	    "object-is-already-in-state",
	    "invalid-operation",
	    "login-failed",
	    "operation-failed",
	    "illegal-handle",
	    "handle-already-in-use",
	    "email-already-in-use",
	    "user-too-young",
	    "illegal-content-type",
	    "attachment-too-large",
	    "incorrect-totp",
	    "invalid-metadata",
	]);

	class RequiresLoginError extends Error {
	    constructor(
	         message = "Requires login",
	         redirectUrl
	    ) {
	        super(message);this.message = message;this.redirectUrl = redirectUrl;    }
	}

	var luxon = {};

	Object.defineProperty(luxon, '__esModule', { value: true });

	function _defineProperties(target, props) {
	  for (var i = 0; i < props.length; i++) {
	    var descriptor = props[i];
	    descriptor.enumerable = descriptor.enumerable || false;
	    descriptor.configurable = true;
	    if ("value" in descriptor) descriptor.writable = true;
	    Object.defineProperty(target, descriptor.key, descriptor);
	  }
	}

	function _createClass(Constructor, protoProps, staticProps) {
	  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
	  if (staticProps) _defineProperties(Constructor, staticProps);
	  return Constructor;
	}

	function _extends() {
	  _extends = Object.assign || function (target) {
	    for (var i = 1; i < arguments.length; i++) {
	      var source = arguments[i];

	      for (var key in source) {
	        if (Object.prototype.hasOwnProperty.call(source, key)) {
	          target[key] = source[key];
	        }
	      }
	    }

	    return target;
	  };

	  return _extends.apply(this, arguments);
	}

	function _inheritsLoose(subClass, superClass) {
	  subClass.prototype = Object.create(superClass.prototype);
	  subClass.prototype.constructor = subClass;

	  _setPrototypeOf(subClass, superClass);
	}

	function _getPrototypeOf(o) {
	  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
	    return o.__proto__ || Object.getPrototypeOf(o);
	  };
	  return _getPrototypeOf(o);
	}

	function _setPrototypeOf(o, p) {
	  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
	    o.__proto__ = p;
	    return o;
	  };

	  return _setPrototypeOf(o, p);
	}

	function _isNativeReflectConstruct() {
	  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
	  if (Reflect.construct.sham) return false;
	  if (typeof Proxy === "function") return true;

	  try {
	    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
	    return true;
	  } catch (e) {
	    return false;
	  }
	}

	function _construct(Parent, args, Class) {
	  if (_isNativeReflectConstruct()) {
	    _construct = Reflect.construct;
	  } else {
	    _construct = function _construct(Parent, args, Class) {
	      var a = [null];
	      a.push.apply(a, args);
	      var Constructor = Function.bind.apply(Parent, a);
	      var instance = new Constructor();
	      if (Class) _setPrototypeOf(instance, Class.prototype);
	      return instance;
	    };
	  }

	  return _construct.apply(null, arguments);
	}

	function _isNativeFunction(fn) {
	  return Function.toString.call(fn).indexOf("[native code]") !== -1;
	}

	function _wrapNativeSuper(Class) {
	  var _cache = typeof Map === "function" ? new Map() : undefined;

	  _wrapNativeSuper = function _wrapNativeSuper(Class) {
	    if (Class === null || !_isNativeFunction(Class)) return Class;

	    if (typeof Class !== "function") {
	      throw new TypeError("Super expression must either be null or a function");
	    }

	    if (typeof _cache !== "undefined") {
	      if (_cache.has(Class)) return _cache.get(Class);

	      _cache.set(Class, Wrapper);
	    }

	    function Wrapper() {
	      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
	    }

	    Wrapper.prototype = Object.create(Class.prototype, {
	      constructor: {
	        value: Wrapper,
	        enumerable: false,
	        writable: true,
	        configurable: true
	      }
	    });
	    return _setPrototypeOf(Wrapper, Class);
	  };

	  return _wrapNativeSuper(Class);
	}

	function _objectWithoutPropertiesLoose$1(source, excluded) {
	  if (source == null) return {};
	  var target = {};
	  var sourceKeys = Object.keys(source);
	  var key, i;

	  for (i = 0; i < sourceKeys.length; i++) {
	    key = sourceKeys[i];
	    if (excluded.indexOf(key) >= 0) continue;
	    target[key] = source[key];
	  }

	  return target;
	}

	function _unsupportedIterableToArray$3(o, minLen) {
	  if (!o) return;
	  if (typeof o === "string") return _arrayLikeToArray$3(o, minLen);
	  var n = Object.prototype.toString.call(o).slice(8, -1);
	  if (n === "Object" && o.constructor) n = o.constructor.name;
	  if (n === "Map" || n === "Set") return Array.from(o);
	  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$3(o, minLen);
	}

	function _arrayLikeToArray$3(arr, len) {
	  if (len == null || len > arr.length) len = arr.length;

	  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];

	  return arr2;
	}

	function _createForOfIteratorHelperLoose(o, allowArrayLike) {
	  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
	  if (it) return (it = it.call(o)).next.bind(it);

	  if (Array.isArray(o) || (it = _unsupportedIterableToArray$3(o)) || allowArrayLike) {
	    if (it) o = it;
	    var i = 0;
	    return function () {
	      if (i >= o.length) return {
	        done: true
	      };
	      return {
	        done: false,
	        value: o[i++]
	      };
	    };
	  }

	  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
	}

	// these aren't really private, but nor are they really useful to document

	/**
	 * @private
	 */
	var LuxonError = /*#__PURE__*/function (_Error) {
	  _inheritsLoose(LuxonError, _Error);

	  function LuxonError() {
	    return _Error.apply(this, arguments) || this;
	  }

	  return LuxonError;
	}( /*#__PURE__*/_wrapNativeSuper(Error));
	/**
	 * @private
	 */


	var InvalidDateTimeError = /*#__PURE__*/function (_LuxonError) {
	  _inheritsLoose(InvalidDateTimeError, _LuxonError);

	  function InvalidDateTimeError(reason) {
	    return _LuxonError.call(this, "Invalid DateTime: " + reason.toMessage()) || this;
	  }

	  return InvalidDateTimeError;
	}(LuxonError);
	/**
	 * @private
	 */

	var InvalidIntervalError = /*#__PURE__*/function (_LuxonError2) {
	  _inheritsLoose(InvalidIntervalError, _LuxonError2);

	  function InvalidIntervalError(reason) {
	    return _LuxonError2.call(this, "Invalid Interval: " + reason.toMessage()) || this;
	  }

	  return InvalidIntervalError;
	}(LuxonError);
	/**
	 * @private
	 */

	var InvalidDurationError = /*#__PURE__*/function (_LuxonError3) {
	  _inheritsLoose(InvalidDurationError, _LuxonError3);

	  function InvalidDurationError(reason) {
	    return _LuxonError3.call(this, "Invalid Duration: " + reason.toMessage()) || this;
	  }

	  return InvalidDurationError;
	}(LuxonError);
	/**
	 * @private
	 */

	var ConflictingSpecificationError = /*#__PURE__*/function (_LuxonError4) {
	  _inheritsLoose(ConflictingSpecificationError, _LuxonError4);

	  function ConflictingSpecificationError() {
	    return _LuxonError4.apply(this, arguments) || this;
	  }

	  return ConflictingSpecificationError;
	}(LuxonError);
	/**
	 * @private
	 */

	var InvalidUnitError = /*#__PURE__*/function (_LuxonError5) {
	  _inheritsLoose(InvalidUnitError, _LuxonError5);

	  function InvalidUnitError(unit) {
	    return _LuxonError5.call(this, "Invalid unit " + unit) || this;
	  }

	  return InvalidUnitError;
	}(LuxonError);
	/**
	 * @private
	 */

	var InvalidArgumentError = /*#__PURE__*/function (_LuxonError6) {
	  _inheritsLoose(InvalidArgumentError, _LuxonError6);

	  function InvalidArgumentError() {
	    return _LuxonError6.apply(this, arguments) || this;
	  }

	  return InvalidArgumentError;
	}(LuxonError);
	/**
	 * @private
	 */

	var ZoneIsAbstractError = /*#__PURE__*/function (_LuxonError7) {
	  _inheritsLoose(ZoneIsAbstractError, _LuxonError7);

	  function ZoneIsAbstractError() {
	    return _LuxonError7.call(this, "Zone is an abstract class") || this;
	  }

	  return ZoneIsAbstractError;
	}(LuxonError);

	/**
	 * @private
	 */
	var n$c = "numeric",
	    s$f = "short",
	    l$d = "long";
	var DATE_SHORT = {
	  year: n$c,
	  month: n$c,
	  day: n$c
	};
	var DATE_MED = {
	  year: n$c,
	  month: s$f,
	  day: n$c
	};
	var DATE_MED_WITH_WEEKDAY = {
	  year: n$c,
	  month: s$f,
	  day: n$c,
	  weekday: s$f
	};
	var DATE_FULL = {
	  year: n$c,
	  month: l$d,
	  day: n$c
	};
	var DATE_HUGE = {
	  year: n$c,
	  month: l$d,
	  day: n$c,
	  weekday: l$d
	};
	var TIME_SIMPLE = {
	  hour: n$c,
	  minute: n$c
	};
	var TIME_WITH_SECONDS = {
	  hour: n$c,
	  minute: n$c,
	  second: n$c
	};
	var TIME_WITH_SHORT_OFFSET = {
	  hour: n$c,
	  minute: n$c,
	  second: n$c,
	  timeZoneName: s$f
	};
	var TIME_WITH_LONG_OFFSET = {
	  hour: n$c,
	  minute: n$c,
	  second: n$c,
	  timeZoneName: l$d
	};
	var TIME_24_SIMPLE = {
	  hour: n$c,
	  minute: n$c,
	  hourCycle: "h23"
	};
	var TIME_24_WITH_SECONDS = {
	  hour: n$c,
	  minute: n$c,
	  second: n$c,
	  hourCycle: "h23"
	};
	var TIME_24_WITH_SHORT_OFFSET = {
	  hour: n$c,
	  minute: n$c,
	  second: n$c,
	  hourCycle: "h23",
	  timeZoneName: s$f
	};
	var TIME_24_WITH_LONG_OFFSET = {
	  hour: n$c,
	  minute: n$c,
	  second: n$c,
	  hourCycle: "h23",
	  timeZoneName: l$d
	};
	var DATETIME_SHORT = {
	  year: n$c,
	  month: n$c,
	  day: n$c,
	  hour: n$c,
	  minute: n$c
	};
	var DATETIME_SHORT_WITH_SECONDS = {
	  year: n$c,
	  month: n$c,
	  day: n$c,
	  hour: n$c,
	  minute: n$c,
	  second: n$c
	};
	var DATETIME_MED = {
	  year: n$c,
	  month: s$f,
	  day: n$c,
	  hour: n$c,
	  minute: n$c
	};
	var DATETIME_MED_WITH_SECONDS = {
	  year: n$c,
	  month: s$f,
	  day: n$c,
	  hour: n$c,
	  minute: n$c,
	  second: n$c
	};
	var DATETIME_MED_WITH_WEEKDAY = {
	  year: n$c,
	  month: s$f,
	  day: n$c,
	  weekday: s$f,
	  hour: n$c,
	  minute: n$c
	};
	var DATETIME_FULL = {
	  year: n$c,
	  month: l$d,
	  day: n$c,
	  hour: n$c,
	  minute: n$c,
	  timeZoneName: s$f
	};
	var DATETIME_FULL_WITH_SECONDS = {
	  year: n$c,
	  month: l$d,
	  day: n$c,
	  hour: n$c,
	  minute: n$c,
	  second: n$c,
	  timeZoneName: s$f
	};
	var DATETIME_HUGE = {
	  year: n$c,
	  month: l$d,
	  day: n$c,
	  weekday: l$d,
	  hour: n$c,
	  minute: n$c,
	  timeZoneName: l$d
	};
	var DATETIME_HUGE_WITH_SECONDS = {
	  year: n$c,
	  month: l$d,
	  day: n$c,
	  weekday: l$d,
	  hour: n$c,
	  minute: n$c,
	  second: n$c,
	  timeZoneName: l$d
	};

	/**
	 * @private
	 */
	// TYPES

	function isUndefined$1(o) {
	  return typeof o === "undefined";
	}
	function isNumber(o) {
	  return typeof o === "number";
	}
	function isInteger(o) {
	  return typeof o === "number" && o % 1 === 0;
	}
	function isString$2(o) {
	  return typeof o === "string";
	}
	function isDate(o) {
	  return Object.prototype.toString.call(o) === "[object Date]";
	} // CAPABILITIES

	function hasRelative() {
	  try {
	    return typeof Intl !== "undefined" && !!Intl.RelativeTimeFormat;
	  } catch (e) {
	    return false;
	  }
	} // OBJECTS AND ARRAYS

	function maybeArray(thing) {
	  return Array.isArray(thing) ? thing : [thing];
	}
	function bestBy(arr, by, compare) {
	  if (arr.length === 0) {
	    return undefined;
	  }

	  return arr.reduce(function (best, next) {
	    var pair = [by(next), next];

	    if (!best) {
	      return pair;
	    } else if (compare(best[0], pair[0]) === best[0]) {
	      return best;
	    } else {
	      return pair;
	    }
	  }, null)[1];
	}
	function pick(obj, keys) {
	  return keys.reduce(function (a, k) {
	    a[k] = obj[k];
	    return a;
	  }, {});
	}
	function hasOwnProperty$3(obj, prop) {
	  return Object.prototype.hasOwnProperty.call(obj, prop);
	} // NUMBERS AND STRINGS

	function integerBetween(thing, bottom, top) {
	  return isInteger(thing) && thing >= bottom && thing <= top;
	} // x % n but takes the sign of n instead of x

	function floorMod(x, n) {
	  return x - n * Math.floor(x / n);
	}
	function padStart(input, n) {
	  if (n === void 0) {
	    n = 2;
	  }

	  var minus = input < 0 ? "-" : "";
	  var target = minus ? input * -1 : input;
	  var result;

	  if (target.toString().length < n) {
	    result = ("0".repeat(n) + target).slice(-n);
	  } else {
	    result = target.toString();
	  }

	  return "" + minus + result;
	}
	function parseInteger(string) {
	  if (isUndefined$1(string) || string === null || string === "") {
	    return undefined;
	  } else {
	    return parseInt(string, 10);
	  }
	}
	function parseMillis(fraction) {
	  // Return undefined (instead of 0) in these cases, where fraction is not set
	  if (isUndefined$1(fraction) || fraction === null || fraction === "") {
	    return undefined;
	  } else {
	    var f = parseFloat("0." + fraction) * 1000;
	    return Math.floor(f);
	  }
	}
	function roundTo$1(number, digits, towardZero) {
	  if (towardZero === void 0) {
	    towardZero = false;
	  }

	  var factor = Math.pow(10, digits),
	      rounder = towardZero ? Math.trunc : Math.round;
	  return rounder(number * factor) / factor;
	} // DATE BASICS

	function isLeapYear(year) {
	  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
	}
	function daysInYear(year) {
	  return isLeapYear(year) ? 366 : 365;
	}
	function daysInMonth(year, month) {
	  var modMonth = floorMod(month - 1, 12) + 1,
	      modYear = year + (month - modMonth) / 12;

	  if (modMonth === 2) {
	    return isLeapYear(modYear) ? 29 : 28;
	  } else {
	    return [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][modMonth - 1];
	  }
	} // covert a calendar object to a local timestamp (epoch, but with the offset baked in)

	function objToLocalTS(obj) {
	  var d = Date.UTC(obj.year, obj.month - 1, obj.day, obj.hour, obj.minute, obj.second, obj.millisecond); // for legacy reasons, years between 0 and 99 are interpreted as 19XX; revert that

	  if (obj.year < 100 && obj.year >= 0) {
	    d = new Date(d);
	    d.setUTCFullYear(d.getUTCFullYear() - 1900);
	  }

	  return +d;
	}
	function weeksInWeekYear(weekYear) {
	  var p1 = (weekYear + Math.floor(weekYear / 4) - Math.floor(weekYear / 100) + Math.floor(weekYear / 400)) % 7,
	      last = weekYear - 1,
	      p2 = (last + Math.floor(last / 4) - Math.floor(last / 100) + Math.floor(last / 400)) % 7;
	  return p1 === 4 || p2 === 3 ? 53 : 52;
	}
	function untruncateYear(year) {
	  if (year > 99) {
	    return year;
	  } else return year > 60 ? 1900 + year : 2000 + year;
	} // PARSING

	function parseZoneInfo(ts, offsetFormat, locale, timeZone) {
	  if (timeZone === void 0) {
	    timeZone = null;
	  }

	  var date = new Date(ts),
	      intlOpts = {
	    hourCycle: "h23",
	    year: "numeric",
	    month: "2-digit",
	    day: "2-digit",
	    hour: "2-digit",
	    minute: "2-digit"
	  };

	  if (timeZone) {
	    intlOpts.timeZone = timeZone;
	  }

	  var modified = _extends({
	    timeZoneName: offsetFormat
	  }, intlOpts);

	  var parsed = new Intl.DateTimeFormat(locale, modified).formatToParts(date).find(function (m) {
	    return m.type.toLowerCase() === "timezonename";
	  });
	  return parsed ? parsed.value : null;
	} // signedOffset('-5', '30') -> -330

	function signedOffset(offHourStr, offMinuteStr) {
	  var offHour = parseInt(offHourStr, 10); // don't || this because we want to preserve -0

	  if (Number.isNaN(offHour)) {
	    offHour = 0;
	  }

	  var offMin = parseInt(offMinuteStr, 10) || 0,
	      offMinSigned = offHour < 0 || Object.is(offHour, -0) ? -offMin : offMin;
	  return offHour * 60 + offMinSigned;
	} // COERCION

	function asNumber(value) {
	  var numericValue = Number(value);
	  if (typeof value === "boolean" || value === "" || Number.isNaN(numericValue)) throw new InvalidArgumentError("Invalid unit value " + value);
	  return numericValue;
	}
	function normalizeObject(obj, normalizer) {
	  var normalized = {};

	  for (var u in obj) {
	    if (hasOwnProperty$3(obj, u)) {
	      var v = obj[u];
	      if (v === undefined || v === null) continue;
	      normalized[normalizer(u)] = asNumber(v);
	    }
	  }

	  return normalized;
	}
	function formatOffset(offset, format) {
	  var hours = Math.trunc(Math.abs(offset / 60)),
	      minutes = Math.trunc(Math.abs(offset % 60)),
	      sign = offset >= 0 ? "+" : "-";

	  switch (format) {
	    case "short":
	      return "" + sign + padStart(hours, 2) + ":" + padStart(minutes, 2);

	    case "narrow":
	      return "" + sign + hours + (minutes > 0 ? ":" + minutes : "");

	    case "techie":
	      return "" + sign + padStart(hours, 2) + padStart(minutes, 2);

	    default:
	      throw new RangeError("Value format " + format + " is out of range for property format");
	  }
	}
	function timeObject(obj) {
	  return pick(obj, ["hour", "minute", "second", "millisecond"]);
	}
	var ianaRegex = /[A-Za-z_+-]{1,256}(:?\/[A-Za-z_+-]{1,256}(\/[A-Za-z_+-]{1,256})?)?/;

	/**
	 * @private
	 */


	var monthsLong = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
	var monthsShort = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
	var monthsNarrow = ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"];
	function months(length) {
	  switch (length) {
	    case "narrow":
	      return [].concat(monthsNarrow);

	    case "short":
	      return [].concat(monthsShort);

	    case "long":
	      return [].concat(monthsLong);

	    case "numeric":
	      return ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"];

	    case "2-digit":
	      return ["01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12"];

	    default:
	      return null;
	  }
	}
	var weekdaysLong = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
	var weekdaysShort = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
	var weekdaysNarrow = ["M", "T", "W", "T", "F", "S", "S"];
	function weekdays(length) {
	  switch (length) {
	    case "narrow":
	      return [].concat(weekdaysNarrow);

	    case "short":
	      return [].concat(weekdaysShort);

	    case "long":
	      return [].concat(weekdaysLong);

	    case "numeric":
	      return ["1", "2", "3", "4", "5", "6", "7"];

	    default:
	      return null;
	  }
	}
	var meridiems = ["AM", "PM"];
	var erasLong = ["Before Christ", "Anno Domini"];
	var erasShort = ["BC", "AD"];
	var erasNarrow = ["B", "A"];
	function eras(length) {
	  switch (length) {
	    case "narrow":
	      return [].concat(erasNarrow);

	    case "short":
	      return [].concat(erasShort);

	    case "long":
	      return [].concat(erasLong);

	    default:
	      return null;
	  }
	}
	function meridiemForDateTime(dt) {
	  return meridiems[dt.hour < 12 ? 0 : 1];
	}
	function weekdayForDateTime(dt, length) {
	  return weekdays(length)[dt.weekday - 1];
	}
	function monthForDateTime(dt, length) {
	  return months(length)[dt.month - 1];
	}
	function eraForDateTime(dt, length) {
	  return eras(length)[dt.year < 0 ? 0 : 1];
	}
	function formatRelativeTime(unit, count, numeric, narrow) {
	  if (numeric === void 0) {
	    numeric = "always";
	  }

	  if (narrow === void 0) {
	    narrow = false;
	  }

	  var units = {
	    years: ["year", "yr."],
	    quarters: ["quarter", "qtr."],
	    months: ["month", "mo."],
	    weeks: ["week", "wk."],
	    days: ["day", "day", "days"],
	    hours: ["hour", "hr."],
	    minutes: ["minute", "min."],
	    seconds: ["second", "sec."]
	  };
	  var lastable = ["hours", "minutes", "seconds"].indexOf(unit) === -1;

	  if (numeric === "auto" && lastable) {
	    var isDay = unit === "days";

	    switch (count) {
	      case 1:
	        return isDay ? "tomorrow" : "next " + units[unit][0];

	      case -1:
	        return isDay ? "yesterday" : "last " + units[unit][0];

	      case 0:
	        return isDay ? "today" : "this " + units[unit][0];

	    }
	  }

	  var isInPast = Object.is(count, -0) || count < 0,
	      fmtValue = Math.abs(count),
	      singular = fmtValue === 1,
	      lilUnits = units[unit],
	      fmtUnit = narrow ? singular ? lilUnits[1] : lilUnits[2] || lilUnits[1] : singular ? units[unit][0] : unit;
	  return isInPast ? fmtValue + " " + fmtUnit + " ago" : "in " + fmtValue + " " + fmtUnit;
	}

	function stringifyTokens(splits, tokenToString) {
	  var s = "";

	  for (var _iterator = _createForOfIteratorHelperLoose(splits), _step; !(_step = _iterator()).done;) {
	    var token = _step.value;

	    if (token.literal) {
	      s += token.val;
	    } else {
	      s += tokenToString(token.val);
	    }
	  }

	  return s;
	}

	var _macroTokenToFormatOpts = {
	  D: DATE_SHORT,
	  DD: DATE_MED,
	  DDD: DATE_FULL,
	  DDDD: DATE_HUGE,
	  t: TIME_SIMPLE,
	  tt: TIME_WITH_SECONDS,
	  ttt: TIME_WITH_SHORT_OFFSET,
	  tttt: TIME_WITH_LONG_OFFSET,
	  T: TIME_24_SIMPLE,
	  TT: TIME_24_WITH_SECONDS,
	  TTT: TIME_24_WITH_SHORT_OFFSET,
	  TTTT: TIME_24_WITH_LONG_OFFSET,
	  f: DATETIME_SHORT,
	  ff: DATETIME_MED,
	  fff: DATETIME_FULL,
	  ffff: DATETIME_HUGE,
	  F: DATETIME_SHORT_WITH_SECONDS,
	  FF: DATETIME_MED_WITH_SECONDS,
	  FFF: DATETIME_FULL_WITH_SECONDS,
	  FFFF: DATETIME_HUGE_WITH_SECONDS
	};
	/**
	 * @private
	 */

	var Formatter$1 = /*#__PURE__*/function () {
	  Formatter.create = function create(locale, opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    return new Formatter(locale, opts);
	  };

	  Formatter.parseFormat = function parseFormat(fmt) {
	    var current = null,
	        currentFull = "",
	        bracketed = false;
	    var splits = [];

	    for (var i = 0; i < fmt.length; i++) {
	      var c = fmt.charAt(i);

	      if (c === "'") {
	        if (currentFull.length > 0) {
	          splits.push({
	            literal: bracketed,
	            val: currentFull
	          });
	        }

	        current = null;
	        currentFull = "";
	        bracketed = !bracketed;
	      } else if (bracketed) {
	        currentFull += c;
	      } else if (c === current) {
	        currentFull += c;
	      } else {
	        if (currentFull.length > 0) {
	          splits.push({
	            literal: false,
	            val: currentFull
	          });
	        }

	        currentFull = c;
	        current = c;
	      }
	    }

	    if (currentFull.length > 0) {
	      splits.push({
	        literal: bracketed,
	        val: currentFull
	      });
	    }

	    return splits;
	  };

	  Formatter.macroTokenToFormatOpts = function macroTokenToFormatOpts(token) {
	    return _macroTokenToFormatOpts[token];
	  };

	  function Formatter(locale, formatOpts) {
	    this.opts = formatOpts;
	    this.loc = locale;
	    this.systemLoc = null;
	  }

	  var _proto = Formatter.prototype;

	  _proto.formatWithSystemDefault = function formatWithSystemDefault(dt, opts) {
	    if (this.systemLoc === null) {
	      this.systemLoc = this.loc.redefaultToSystem();
	    }

	    var df = this.systemLoc.dtFormatter(dt, _extends({}, this.opts, opts));
	    return df.format();
	  };

	  _proto.formatDateTime = function formatDateTime(dt, opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    var df = this.loc.dtFormatter(dt, _extends({}, this.opts, opts));
	    return df.format();
	  };

	  _proto.formatDateTimeParts = function formatDateTimeParts(dt, opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    var df = this.loc.dtFormatter(dt, _extends({}, this.opts, opts));
	    return df.formatToParts();
	  };

	  _proto.resolvedOptions = function resolvedOptions(dt, opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    var df = this.loc.dtFormatter(dt, _extends({}, this.opts, opts));
	    return df.resolvedOptions();
	  };

	  _proto.num = function num(n, p) {
	    if (p === void 0) {
	      p = 0;
	    }

	    // we get some perf out of doing this here, annoyingly
	    if (this.opts.forceSimple) {
	      return padStart(n, p);
	    }

	    var opts = _extends({}, this.opts);

	    if (p > 0) {
	      opts.padTo = p;
	    }

	    return this.loc.numberFormatter(opts).format(n);
	  };

	  _proto.formatDateTimeFromString = function formatDateTimeFromString(dt, fmt) {
	    var _this = this;

	    var knownEnglish = this.loc.listingMode() === "en",
	        useDateTimeFormatter = this.loc.outputCalendar && this.loc.outputCalendar !== "gregory",
	        string = function string(opts, extract) {
	      return _this.loc.extract(dt, opts, extract);
	    },
	        formatOffset = function formatOffset(opts) {
	      if (dt.isOffsetFixed && dt.offset === 0 && opts.allowZ) {
	        return "Z";
	      }

	      return dt.isValid ? dt.zone.formatOffset(dt.ts, opts.format) : "";
	    },
	        meridiem = function meridiem() {
	      return knownEnglish ? meridiemForDateTime(dt) : string({
	        hour: "numeric",
	        hourCycle: "h12"
	      }, "dayperiod");
	    },
	        month = function month(length, standalone) {
	      return knownEnglish ? monthForDateTime(dt, length) : string(standalone ? {
	        month: length
	      } : {
	        month: length,
	        day: "numeric"
	      }, "month");
	    },
	        weekday = function weekday(length, standalone) {
	      return knownEnglish ? weekdayForDateTime(dt, length) : string(standalone ? {
	        weekday: length
	      } : {
	        weekday: length,
	        month: "long",
	        day: "numeric"
	      }, "weekday");
	    },
	        maybeMacro = function maybeMacro(token) {
	      var formatOpts = Formatter.macroTokenToFormatOpts(token);

	      if (formatOpts) {
	        return _this.formatWithSystemDefault(dt, formatOpts);
	      } else {
	        return token;
	      }
	    },
	        era = function era(length) {
	      return knownEnglish ? eraForDateTime(dt, length) : string({
	        era: length
	      }, "era");
	    },
	        tokenToString = function tokenToString(token) {
	      // Where possible: http://cldr.unicode.org/translation/date-time-1/date-time#TOC-Standalone-vs.-Format-Styles
	      switch (token) {
	        // ms
	        case "S":
	          return _this.num(dt.millisecond);

	        case "u": // falls through

	        case "SSS":
	          return _this.num(dt.millisecond, 3);
	        // seconds

	        case "s":
	          return _this.num(dt.second);

	        case "ss":
	          return _this.num(dt.second, 2);
	        // minutes

	        case "m":
	          return _this.num(dt.minute);

	        case "mm":
	          return _this.num(dt.minute, 2);
	        // hours

	        case "h":
	          return _this.num(dt.hour % 12 === 0 ? 12 : dt.hour % 12);

	        case "hh":
	          return _this.num(dt.hour % 12 === 0 ? 12 : dt.hour % 12, 2);

	        case "H":
	          return _this.num(dt.hour);

	        case "HH":
	          return _this.num(dt.hour, 2);
	        // offset

	        case "Z":
	          // like +6
	          return formatOffset({
	            format: "narrow",
	            allowZ: _this.opts.allowZ
	          });

	        case "ZZ":
	          // like +06:00
	          return formatOffset({
	            format: "short",
	            allowZ: _this.opts.allowZ
	          });

	        case "ZZZ":
	          // like +0600
	          return formatOffset({
	            format: "techie",
	            allowZ: _this.opts.allowZ
	          });

	        case "ZZZZ":
	          // like EST
	          return dt.zone.offsetName(dt.ts, {
	            format: "short",
	            locale: _this.loc.locale
	          });

	        case "ZZZZZ":
	          // like Eastern Standard Time
	          return dt.zone.offsetName(dt.ts, {
	            format: "long",
	            locale: _this.loc.locale
	          });
	        // zone

	        case "z":
	          // like America/New_York
	          return dt.zoneName;
	        // meridiems

	        case "a":
	          return meridiem();
	        // dates

	        case "d":
	          return useDateTimeFormatter ? string({
	            day: "numeric"
	          }, "day") : _this.num(dt.day);

	        case "dd":
	          return useDateTimeFormatter ? string({
	            day: "2-digit"
	          }, "day") : _this.num(dt.day, 2);
	        // weekdays - standalone

	        case "c":
	          // like 1
	          return _this.num(dt.weekday);

	        case "ccc":
	          // like 'Tues'
	          return weekday("short", true);

	        case "cccc":
	          // like 'Tuesday'
	          return weekday("long", true);

	        case "ccccc":
	          // like 'T'
	          return weekday("narrow", true);
	        // weekdays - format

	        case "E":
	          // like 1
	          return _this.num(dt.weekday);

	        case "EEE":
	          // like 'Tues'
	          return weekday("short", false);

	        case "EEEE":
	          // like 'Tuesday'
	          return weekday("long", false);

	        case "EEEEE":
	          // like 'T'
	          return weekday("narrow", false);
	        // months - standalone

	        case "L":
	          // like 1
	          return useDateTimeFormatter ? string({
	            month: "numeric",
	            day: "numeric"
	          }, "month") : _this.num(dt.month);

	        case "LL":
	          // like 01, doesn't seem to work
	          return useDateTimeFormatter ? string({
	            month: "2-digit",
	            day: "numeric"
	          }, "month") : _this.num(dt.month, 2);

	        case "LLL":
	          // like Jan
	          return month("short", true);

	        case "LLLL":
	          // like January
	          return month("long", true);

	        case "LLLLL":
	          // like J
	          return month("narrow", true);
	        // months - format

	        case "M":
	          // like 1
	          return useDateTimeFormatter ? string({
	            month: "numeric"
	          }, "month") : _this.num(dt.month);

	        case "MM":
	          // like 01
	          return useDateTimeFormatter ? string({
	            month: "2-digit"
	          }, "month") : _this.num(dt.month, 2);

	        case "MMM":
	          // like Jan
	          return month("short", false);

	        case "MMMM":
	          // like January
	          return month("long", false);

	        case "MMMMM":
	          // like J
	          return month("narrow", false);
	        // years

	        case "y":
	          // like 2014
	          return useDateTimeFormatter ? string({
	            year: "numeric"
	          }, "year") : _this.num(dt.year);

	        case "yy":
	          // like 14
	          return useDateTimeFormatter ? string({
	            year: "2-digit"
	          }, "year") : _this.num(dt.year.toString().slice(-2), 2);

	        case "yyyy":
	          // like 0012
	          return useDateTimeFormatter ? string({
	            year: "numeric"
	          }, "year") : _this.num(dt.year, 4);

	        case "yyyyyy":
	          // like 000012
	          return useDateTimeFormatter ? string({
	            year: "numeric"
	          }, "year") : _this.num(dt.year, 6);
	        // eras

	        case "G":
	          // like AD
	          return era("short");

	        case "GG":
	          // like Anno Domini
	          return era("long");

	        case "GGGGG":
	          return era("narrow");

	        case "kk":
	          return _this.num(dt.weekYear.toString().slice(-2), 2);

	        case "kkkk":
	          return _this.num(dt.weekYear, 4);

	        case "W":
	          return _this.num(dt.weekNumber);

	        case "WW":
	          return _this.num(dt.weekNumber, 2);

	        case "o":
	          return _this.num(dt.ordinal);

	        case "ooo":
	          return _this.num(dt.ordinal, 3);

	        case "q":
	          // like 1
	          return _this.num(dt.quarter);

	        case "qq":
	          // like 01
	          return _this.num(dt.quarter, 2);

	        case "X":
	          return _this.num(Math.floor(dt.ts / 1000));

	        case "x":
	          return _this.num(dt.ts);

	        default:
	          return maybeMacro(token);
	      }
	    };

	    return stringifyTokens(Formatter.parseFormat(fmt), tokenToString);
	  };

	  _proto.formatDurationFromString = function formatDurationFromString(dur, fmt) {
	    var _this2 = this;

	    var tokenToField = function tokenToField(token) {
	      switch (token[0]) {
	        case "S":
	          return "millisecond";

	        case "s":
	          return "second";

	        case "m":
	          return "minute";

	        case "h":
	          return "hour";

	        case "d":
	          return "day";

	        case "M":
	          return "month";

	        case "y":
	          return "year";

	        default:
	          return null;
	      }
	    },
	        tokenToString = function tokenToString(lildur) {
	      return function (token) {
	        var mapped = tokenToField(token);

	        if (mapped) {
	          return _this2.num(lildur.get(mapped), token.length);
	        } else {
	          return token;
	        }
	      };
	    },
	        tokens = Formatter.parseFormat(fmt),
	        realTokens = tokens.reduce(function (found, _ref) {
	      var literal = _ref.literal,
	          val = _ref.val;
	      return literal ? found : found.concat(val);
	    }, []),
	        collapsed = dur.shiftTo.apply(dur, realTokens.map(tokenToField).filter(function (t) {
	      return t;
	    }));

	    return stringifyTokens(tokens, tokenToString(collapsed));
	  };

	  return Formatter;
	}();

	var Invalid = /*#__PURE__*/function () {
	  function Invalid(reason, explanation) {
	    this.reason = reason;
	    this.explanation = explanation;
	  }

	  var _proto = Invalid.prototype;

	  _proto.toMessage = function toMessage() {
	    if (this.explanation) {
	      return this.reason + ": " + this.explanation;
	    } else {
	      return this.reason;
	    }
	  };

	  return Invalid;
	}();

	/**
	 * @interface
	 */

	var Zone = /*#__PURE__*/function () {
	  function Zone() {}

	  var _proto = Zone.prototype;

	  /**
	   * Returns the offset's common name (such as EST) at the specified timestamp
	   * @abstract
	   * @param {number} ts - Epoch milliseconds for which to get the name
	   * @param {Object} opts - Options to affect the format
	   * @param {string} opts.format - What style of offset to return. Accepts 'long' or 'short'.
	   * @param {string} opts.locale - What locale to return the offset name in.
	   * @return {string}
	   */
	  _proto.offsetName = function offsetName(ts, opts) {
	    throw new ZoneIsAbstractError();
	  }
	  /**
	   * Returns the offset's value as a string
	   * @abstract
	   * @param {number} ts - Epoch milliseconds for which to get the offset
	   * @param {string} format - What style of offset to return.
	   *                          Accepts 'narrow', 'short', or 'techie'. Returning '+6', '+06:00', or '+0600' respectively
	   * @return {string}
	   */
	  ;

	  _proto.formatOffset = function formatOffset(ts, format) {
	    throw new ZoneIsAbstractError();
	  }
	  /**
	   * Return the offset in minutes for this zone at the specified timestamp.
	   * @abstract
	   * @param {number} ts - Epoch milliseconds for which to compute the offset
	   * @return {number}
	   */
	  ;

	  _proto.offset = function offset(ts) {
	    throw new ZoneIsAbstractError();
	  }
	  /**
	   * Return whether this Zone is equal to another zone
	   * @abstract
	   * @param {Zone} otherZone - the zone to compare
	   * @return {boolean}
	   */
	  ;

	  _proto.equals = function equals(otherZone) {
	    throw new ZoneIsAbstractError();
	  }
	  /**
	   * Return whether this Zone is valid.
	   * @abstract
	   * @type {boolean}
	   */
	  ;

	  _createClass(Zone, [{
	    key: "type",
	    get:
	    /**
	     * The type of zone
	     * @abstract
	     * @type {string}
	     */
	    function get() {
	      throw new ZoneIsAbstractError();
	    }
	    /**
	     * The name of this zone.
	     * @abstract
	     * @type {string}
	     */

	  }, {
	    key: "name",
	    get: function get() {
	      throw new ZoneIsAbstractError();
	    }
	    /**
	     * Returns whether the offset is known to be fixed for the whole year.
	     * @abstract
	     * @type {boolean}
	     */

	  }, {
	    key: "isUniversal",
	    get: function get() {
	      throw new ZoneIsAbstractError();
	    }
	  }, {
	    key: "isValid",
	    get: function get() {
	      throw new ZoneIsAbstractError();
	    }
	  }]);

	  return Zone;
	}();

	var singleton$1 = null;
	/**
	 * Represents the local zone for this JavaScript environment.
	 * @implements {Zone}
	 */

	var SystemZone = /*#__PURE__*/function (_Zone) {
	  _inheritsLoose(SystemZone, _Zone);

	  function SystemZone() {
	    return _Zone.apply(this, arguments) || this;
	  }

	  var _proto = SystemZone.prototype;

	  /** @override **/
	  _proto.offsetName = function offsetName(ts, _ref) {
	    var format = _ref.format,
	        locale = _ref.locale;
	    return parseZoneInfo(ts, format, locale);
	  }
	  /** @override **/
	  ;

	  _proto.formatOffset = function formatOffset$1(ts, format) {
	    return formatOffset(this.offset(ts), format);
	  }
	  /** @override **/
	  ;

	  _proto.offset = function offset(ts) {
	    return -new Date(ts).getTimezoneOffset();
	  }
	  /** @override **/
	  ;

	  _proto.equals = function equals(otherZone) {
	    return otherZone.type === "system";
	  }
	  /** @override **/
	  ;

	  _createClass(SystemZone, [{
	    key: "type",
	    get:
	    /** @override **/
	    function get() {
	      return "system";
	    }
	    /** @override **/

	  }, {
	    key: "name",
	    get: function get() {
	      return new Intl.DateTimeFormat().resolvedOptions().timeZone;
	    }
	    /** @override **/

	  }, {
	    key: "isUniversal",
	    get: function get() {
	      return false;
	    }
	  }, {
	    key: "isValid",
	    get: function get() {
	      return true;
	    }
	  }], [{
	    key: "instance",
	    get:
	    /**
	     * Get a singleton instance of the local zone
	     * @return {SystemZone}
	     */
	    function get() {
	      if (singleton$1 === null) {
	        singleton$1 = new SystemZone();
	      }

	      return singleton$1;
	    }
	  }]);

	  return SystemZone;
	}(Zone);

	var matchingRegex = RegExp("^" + ianaRegex.source + "$");
	var dtfCache = {};

	function makeDTF(zone) {
	  if (!dtfCache[zone]) {
	    dtfCache[zone] = new Intl.DateTimeFormat("en-US", {
	      hourCycle: "h23",
	      timeZone: zone,
	      year: "numeric",
	      month: "2-digit",
	      day: "2-digit",
	      hour: "2-digit",
	      minute: "2-digit",
	      second: "2-digit"
	    });
	  }

	  return dtfCache[zone];
	}

	var typeToPos = {
	  year: 0,
	  month: 1,
	  day: 2,
	  hour: 3,
	  minute: 4,
	  second: 5
	};

	function hackyOffset(dtf, date) {
	  var formatted = dtf.format(date).replace(/\u200E/g, ""),
	      parsed = /(\d+)\/(\d+)\/(\d+),? (\d+):(\d+):(\d+)/.exec(formatted),
	      fMonth = parsed[1],
	      fDay = parsed[2],
	      fYear = parsed[3],
	      fHour = parsed[4],
	      fMinute = parsed[5],
	      fSecond = parsed[6];
	  return [fYear, fMonth, fDay, fHour, fMinute, fSecond];
	}

	function partsOffset(dtf, date) {
	  var formatted = dtf.formatToParts(date),
	      filled = [];

	  for (var i = 0; i < formatted.length; i++) {
	    var _formatted$i = formatted[i],
	        type = _formatted$i.type,
	        value = _formatted$i.value,
	        pos = typeToPos[type];

	    if (!isUndefined$1(pos)) {
	      filled[pos] = parseInt(value, 10);
	    }
	  }

	  return filled;
	}

	var ianaZoneCache = {};
	/**
	 * A zone identified by an IANA identifier, like America/New_York
	 * @implements {Zone}
	 */

	var IANAZone = /*#__PURE__*/function (_Zone) {
	  _inheritsLoose(IANAZone, _Zone);

	  /**
	   * @param {string} name - Zone name
	   * @return {IANAZone}
	   */
	  IANAZone.create = function create(name) {
	    if (!ianaZoneCache[name]) {
	      ianaZoneCache[name] = new IANAZone(name);
	    }

	    return ianaZoneCache[name];
	  }
	  /**
	   * Reset local caches. Should only be necessary in testing scenarios.
	   * @return {void}
	   */
	  ;

	  IANAZone.resetCache = function resetCache() {
	    ianaZoneCache = {};
	    dtfCache = {};
	  }
	  /**
	   * Returns whether the provided string is a valid specifier. This only checks the string's format, not that the specifier identifies a known zone; see isValidZone for that.
	   * @param {string} s - The string to check validity on
	   * @example IANAZone.isValidSpecifier("America/New_York") //=> true
	   * @example IANAZone.isValidSpecifier("Fantasia/Castle") //=> true
	   * @example IANAZone.isValidSpecifier("Sport~~blorp") //=> false
	   * @return {boolean}
	   */
	  ;

	  IANAZone.isValidSpecifier = function isValidSpecifier(s) {
	    return !!(s && s.match(matchingRegex));
	  }
	  /**
	   * Returns whether the provided string identifies a real zone
	   * @param {string} zone - The string to check
	   * @example IANAZone.isValidZone("America/New_York") //=> true
	   * @example IANAZone.isValidZone("Fantasia/Castle") //=> false
	   * @example IANAZone.isValidZone("Sport~~blorp") //=> false
	   * @return {boolean}
	   */
	  ;

	  IANAZone.isValidZone = function isValidZone(zone) {
	    try {
	      new Intl.DateTimeFormat("en-US", {
	        timeZone: zone
	      }).format();
	      return true;
	    } catch (e) {
	      return false;
	    }
	  } // Etc/GMT+8 -> -480

	  /** @ignore */
	  ;

	  IANAZone.parseGMTOffset = function parseGMTOffset(specifier) {
	    if (specifier) {
	      var match = specifier.match(/^Etc\/GMT(0|[+-]\d{1,2})$/i);

	      if (match) {
	        return -60 * parseInt(match[1]);
	      }
	    }

	    return null;
	  };

	  function IANAZone(name) {
	    var _this;

	    _this = _Zone.call(this) || this;
	    /** @private **/

	    _this.zoneName = name;
	    /** @private **/

	    _this.valid = IANAZone.isValidZone(name);
	    return _this;
	  }
	  /** @override **/


	  var _proto = IANAZone.prototype;

	  /** @override **/
	  _proto.offsetName = function offsetName(ts, _ref) {
	    var format = _ref.format,
	        locale = _ref.locale;
	    return parseZoneInfo(ts, format, locale, this.name);
	  }
	  /** @override **/
	  ;

	  _proto.formatOffset = function formatOffset$1(ts, format) {
	    return formatOffset(this.offset(ts), format);
	  }
	  /** @override **/
	  ;

	  _proto.offset = function offset(ts) {
	    var date = new Date(ts);
	    if (isNaN(date)) return NaN;

	    var dtf = makeDTF(this.name),
	        _ref2 = dtf.formatToParts ? partsOffset(dtf, date) : hackyOffset(dtf, date),
	        year = _ref2[0],
	        month = _ref2[1],
	        day = _ref2[2],
	        hour = _ref2[3],
	        minute = _ref2[4],
	        second = _ref2[5];

	    var asUTC = objToLocalTS({
	      year: year,
	      month: month,
	      day: day,
	      hour: hour,
	      minute: minute,
	      second: second,
	      millisecond: 0
	    });
	    var asTS = +date;
	    var over = asTS % 1000;
	    asTS -= over >= 0 ? over : 1000 + over;
	    return (asUTC - asTS) / (60 * 1000);
	  }
	  /** @override **/
	  ;

	  _proto.equals = function equals(otherZone) {
	    return otherZone.type === "iana" && otherZone.name === this.name;
	  }
	  /** @override **/
	  ;

	  _createClass(IANAZone, [{
	    key: "type",
	    get: function get() {
	      return "iana";
	    }
	    /** @override **/

	  }, {
	    key: "name",
	    get: function get() {
	      return this.zoneName;
	    }
	    /** @override **/

	  }, {
	    key: "isUniversal",
	    get: function get() {
	      return false;
	    }
	  }, {
	    key: "isValid",
	    get: function get() {
	      return this.valid;
	    }
	  }]);

	  return IANAZone;
	}(Zone);

	var singleton = null;
	/**
	 * A zone with a fixed offset (meaning no DST)
	 * @implements {Zone}
	 */

	var FixedOffsetZone = /*#__PURE__*/function (_Zone) {
	  _inheritsLoose(FixedOffsetZone, _Zone);

	  /**
	   * Get an instance with a specified offset
	   * @param {number} offset - The offset in minutes
	   * @return {FixedOffsetZone}
	   */
	  FixedOffsetZone.instance = function instance(offset) {
	    return offset === 0 ? FixedOffsetZone.utcInstance : new FixedOffsetZone(offset);
	  }
	  /**
	   * Get an instance of FixedOffsetZone from a UTC offset string, like "UTC+6"
	   * @param {string} s - The offset string to parse
	   * @example FixedOffsetZone.parseSpecifier("UTC+6")
	   * @example FixedOffsetZone.parseSpecifier("UTC+06")
	   * @example FixedOffsetZone.parseSpecifier("UTC-6:00")
	   * @return {FixedOffsetZone}
	   */
	  ;

	  FixedOffsetZone.parseSpecifier = function parseSpecifier(s) {
	    if (s) {
	      var r = s.match(/^utc(?:([+-]\d{1,2})(?::(\d{2}))?)?$/i);

	      if (r) {
	        return new FixedOffsetZone(signedOffset(r[1], r[2]));
	      }
	    }

	    return null;
	  };

	  function FixedOffsetZone(offset) {
	    var _this;

	    _this = _Zone.call(this) || this;
	    /** @private **/

	    _this.fixed = offset;
	    return _this;
	  }
	  /** @override **/


	  var _proto = FixedOffsetZone.prototype;

	  /** @override **/
	  _proto.offsetName = function offsetName() {
	    return this.name;
	  }
	  /** @override **/
	  ;

	  _proto.formatOffset = function formatOffset$1(ts, format) {
	    return formatOffset(this.fixed, format);
	  }
	  /** @override **/
	  ;

	  /** @override **/
	  _proto.offset = function offset() {
	    return this.fixed;
	  }
	  /** @override **/
	  ;

	  _proto.equals = function equals(otherZone) {
	    return otherZone.type === "fixed" && otherZone.fixed === this.fixed;
	  }
	  /** @override **/
	  ;

	  _createClass(FixedOffsetZone, [{
	    key: "type",
	    get: function get() {
	      return "fixed";
	    }
	    /** @override **/

	  }, {
	    key: "name",
	    get: function get() {
	      return this.fixed === 0 ? "UTC" : "UTC" + formatOffset(this.fixed, "narrow");
	    }
	  }, {
	    key: "isUniversal",
	    get: function get() {
	      return true;
	    }
	  }, {
	    key: "isValid",
	    get: function get() {
	      return true;
	    }
	  }], [{
	    key: "utcInstance",
	    get:
	    /**
	     * Get a singleton instance of UTC
	     * @return {FixedOffsetZone}
	     */
	    function get() {
	      if (singleton === null) {
	        singleton = new FixedOffsetZone(0);
	      }

	      return singleton;
	    }
	  }]);

	  return FixedOffsetZone;
	}(Zone);

	/**
	 * A zone that failed to parse. You should never need to instantiate this.
	 * @implements {Zone}
	 */

	var InvalidZone = /*#__PURE__*/function (_Zone) {
	  _inheritsLoose(InvalidZone, _Zone);

	  function InvalidZone(zoneName) {
	    var _this;

	    _this = _Zone.call(this) || this;
	    /**  @private */

	    _this.zoneName = zoneName;
	    return _this;
	  }
	  /** @override **/


	  var _proto = InvalidZone.prototype;

	  /** @override **/
	  _proto.offsetName = function offsetName() {
	    return null;
	  }
	  /** @override **/
	  ;

	  _proto.formatOffset = function formatOffset() {
	    return "";
	  }
	  /** @override **/
	  ;

	  _proto.offset = function offset() {
	    return NaN;
	  }
	  /** @override **/
	  ;

	  _proto.equals = function equals() {
	    return false;
	  }
	  /** @override **/
	  ;

	  _createClass(InvalidZone, [{
	    key: "type",
	    get: function get() {
	      return "invalid";
	    }
	    /** @override **/

	  }, {
	    key: "name",
	    get: function get() {
	      return this.zoneName;
	    }
	    /** @override **/

	  }, {
	    key: "isUniversal",
	    get: function get() {
	      return false;
	    }
	  }, {
	    key: "isValid",
	    get: function get() {
	      return false;
	    }
	  }]);

	  return InvalidZone;
	}(Zone);

	/**
	 * @private
	 */
	function normalizeZone(input, defaultZone) {
	  var offset;

	  if (isUndefined$1(input) || input === null) {
	    return defaultZone;
	  } else if (input instanceof Zone) {
	    return input;
	  } else if (isString$2(input)) {
	    var lowered = input.toLowerCase();
	    if (lowered === "local" || lowered === "system") return defaultZone;else if (lowered === "utc" || lowered === "gmt") return FixedOffsetZone.utcInstance;else if ((offset = IANAZone.parseGMTOffset(input)) != null) {
	      // handle Etc/GMT-4, which V8 chokes on
	      return FixedOffsetZone.instance(offset);
	    } else if (IANAZone.isValidSpecifier(lowered)) return IANAZone.create(input);else return FixedOffsetZone.parseSpecifier(lowered) || new InvalidZone(input);
	  } else if (isNumber(input)) {
	    return FixedOffsetZone.instance(input);
	  } else if (typeof input === "object" && input.offset && typeof input.offset === "number") {
	    // This is dumb, but the instanceof check above doesn't seem to really work
	    // so we're duck checking it
	    return input;
	  } else {
	    return new InvalidZone(input);
	  }
	}

	var now$1 = function now() {
	  return Date.now();
	},
	    defaultZone = "system",
	    defaultLocale = null,
	    defaultNumberingSystem = null,
	    defaultOutputCalendar = null,
	    throwOnInvalid;
	/**
	 * Settings contains static getters and setters that control Luxon's overall behavior. Luxon is a simple library with few options, but the ones it does have live here.
	 */


	var Settings = /*#__PURE__*/function () {
	  function Settings() {}

	  /**
	   * Reset Luxon's global caches. Should only be necessary in testing scenarios.
	   * @return {void}
	   */
	  Settings.resetCaches = function resetCaches() {
	    Locale.resetCache();
	    IANAZone.resetCache();
	  };

	  _createClass(Settings, null, [{
	    key: "now",
	    get:
	    /**
	     * Get the callback for returning the current timestamp.
	     * @type {function}
	     */
	    function get() {
	      return now$1;
	    }
	    /**
	     * Set the callback for returning the current timestamp.
	     * The function should return a number, which will be interpreted as an Epoch millisecond count
	     * @type {function}
	     * @example Settings.now = () => Date.now() + 3000 // pretend it is 3 seconds in the future
	     * @example Settings.now = () => 0 // always pretend it's Jan 1, 1970 at midnight in UTC time
	     */
	    ,
	    set: function set(n) {
	      now$1 = n;
	    }
	    /**
	     * Set the default time zone to create DateTimes in. Does not affect existing instances.
	     * Use the value "system" to reset this value to the system's time zone.
	     * @type {string}
	     */

	  }, {
	    key: "defaultZone",
	    get:
	    /**
	     * Get the default time zone object currently used to create DateTimes. Does not affect existing instances.
	     * The default value is the system's time zone (the one set on the machine that runs this code).
	     * @type {Zone}
	     */
	    function get() {
	      return normalizeZone(defaultZone, SystemZone.instance);
	    }
	    /**
	     * Get the default locale to create DateTimes with. Does not affect existing instances.
	     * @type {string}
	     */
	    ,
	    set: function set(zone) {
	      defaultZone = zone;
	    }
	  }, {
	    key: "defaultLocale",
	    get: function get() {
	      return defaultLocale;
	    }
	    /**
	     * Set the default locale to create DateTimes with. Does not affect existing instances.
	     * @type {string}
	     */
	    ,
	    set: function set(locale) {
	      defaultLocale = locale;
	    }
	    /**
	     * Get the default numbering system to create DateTimes with. Does not affect existing instances.
	     * @type {string}
	     */

	  }, {
	    key: "defaultNumberingSystem",
	    get: function get() {
	      return defaultNumberingSystem;
	    }
	    /**
	     * Set the default numbering system to create DateTimes with. Does not affect existing instances.
	     * @type {string}
	     */
	    ,
	    set: function set(numberingSystem) {
	      defaultNumberingSystem = numberingSystem;
	    }
	    /**
	     * Get the default output calendar to create DateTimes with. Does not affect existing instances.
	     * @type {string}
	     */

	  }, {
	    key: "defaultOutputCalendar",
	    get: function get() {
	      return defaultOutputCalendar;
	    }
	    /**
	     * Set the default output calendar to create DateTimes with. Does not affect existing instances.
	     * @type {string}
	     */
	    ,
	    set: function set(outputCalendar) {
	      defaultOutputCalendar = outputCalendar;
	    }
	    /**
	     * Get whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals
	     * @type {boolean}
	     */

	  }, {
	    key: "throwOnInvalid",
	    get: function get() {
	      return throwOnInvalid;
	    }
	    /**
	     * Set whether Luxon will throw when it encounters invalid DateTimes, Durations, or Intervals
	     * @type {boolean}
	     */
	    ,
	    set: function set(t) {
	      throwOnInvalid = t;
	    }
	  }]);

	  return Settings;
	}();

	var _excluded$2 = ["base"];
	var intlDTCache = {};

	function getCachedDTF(locString, opts) {
	  if (opts === void 0) {
	    opts = {};
	  }

	  var key = JSON.stringify([locString, opts]);
	  var dtf = intlDTCache[key];

	  if (!dtf) {
	    dtf = new Intl.DateTimeFormat(locString, opts);
	    intlDTCache[key] = dtf;
	  }

	  return dtf;
	}

	var intlNumCache = {};

	function getCachedINF(locString, opts) {
	  if (opts === void 0) {
	    opts = {};
	  }

	  var key = JSON.stringify([locString, opts]);
	  var inf = intlNumCache[key];

	  if (!inf) {
	    inf = new Intl.NumberFormat(locString, opts);
	    intlNumCache[key] = inf;
	  }

	  return inf;
	}

	var intlRelCache = {};

	function getCachedRTF(locString, opts) {
	  if (opts === void 0) {
	    opts = {};
	  }

	  var _opts = opts;
	      _opts.base;
	      var cacheKeyOpts = _objectWithoutPropertiesLoose$1(_opts, _excluded$2); // exclude `base` from the options


	  var key = JSON.stringify([locString, cacheKeyOpts]);
	  var inf = intlRelCache[key];

	  if (!inf) {
	    inf = new Intl.RelativeTimeFormat(locString, opts);
	    intlRelCache[key] = inf;
	  }

	  return inf;
	}

	var sysLocaleCache = null;

	function systemLocale() {
	  if (sysLocaleCache) {
	    return sysLocaleCache;
	  } else {
	    sysLocaleCache = new Intl.DateTimeFormat().resolvedOptions().locale;
	    return sysLocaleCache;
	  }
	}

	function parseLocaleString(localeStr) {
	  // I really want to avoid writing a BCP 47 parser
	  // see, e.g. https://github.com/wooorm/bcp-47
	  // Instead, we'll do this:
	  // a) if the string has no -u extensions, just leave it alone
	  // b) if it does, use Intl to resolve everything
	  // c) if Intl fails, try again without the -u
	  var uIndex = localeStr.indexOf("-u-");

	  if (uIndex === -1) {
	    return [localeStr];
	  } else {
	    var options;
	    var smaller = localeStr.substring(0, uIndex);

	    try {
	      options = getCachedDTF(localeStr).resolvedOptions();
	    } catch (e) {
	      options = getCachedDTF(smaller).resolvedOptions();
	    }

	    var _options = options,
	        numberingSystem = _options.numberingSystem,
	        calendar = _options.calendar; // return the smaller one so that we can append the calendar and numbering overrides to it

	    return [smaller, numberingSystem, calendar];
	  }
	}

	function intlConfigString(localeStr, numberingSystem, outputCalendar) {
	  if (outputCalendar || numberingSystem) {
	    localeStr += "-u";

	    if (outputCalendar) {
	      localeStr += "-ca-" + outputCalendar;
	    }

	    if (numberingSystem) {
	      localeStr += "-nu-" + numberingSystem;
	    }

	    return localeStr;
	  } else {
	    return localeStr;
	  }
	}

	function mapMonths(f) {
	  var ms = [];

	  for (var i = 1; i <= 12; i++) {
	    var dt = DateTime.utc(2016, i, 1);
	    ms.push(f(dt));
	  }

	  return ms;
	}

	function mapWeekdays(f) {
	  var ms = [];

	  for (var i = 1; i <= 7; i++) {
	    var dt = DateTime.utc(2016, 11, 13 + i);
	    ms.push(f(dt));
	  }

	  return ms;
	}

	function listStuff(loc, length, defaultOK, englishFn, intlFn) {
	  var mode = loc.listingMode(defaultOK);

	  if (mode === "error") {
	    return null;
	  } else if (mode === "en") {
	    return englishFn(length);
	  } else {
	    return intlFn(length);
	  }
	}

	function supportsFastNumbers(loc) {
	  if (loc.numberingSystem && loc.numberingSystem !== "latn") {
	    return false;
	  } else {
	    return loc.numberingSystem === "latn" || !loc.locale || loc.locale.startsWith("en") || new Intl.DateTimeFormat(loc.intl).resolvedOptions().numberingSystem === "latn";
	  }
	}
	/**
	 * @private
	 */


	var PolyNumberFormatter = /*#__PURE__*/function () {
	  function PolyNumberFormatter(intl, forceSimple, opts) {
	    this.padTo = opts.padTo || 0;
	    this.floor = opts.floor || false;

	    if (!forceSimple) {
	      var intlOpts = {
	        useGrouping: false
	      };
	      if (opts.padTo > 0) intlOpts.minimumIntegerDigits = opts.padTo;
	      this.inf = getCachedINF(intl, intlOpts);
	    }
	  }

	  var _proto = PolyNumberFormatter.prototype;

	  _proto.format = function format(i) {
	    if (this.inf) {
	      var fixed = this.floor ? Math.floor(i) : i;
	      return this.inf.format(fixed);
	    } else {
	      // to match the browser's numberformatter defaults
	      var _fixed = this.floor ? Math.floor(i) : roundTo$1(i, 3);

	      return padStart(_fixed, this.padTo);
	    }
	  };

	  return PolyNumberFormatter;
	}();
	/**
	 * @private
	 */


	var PolyDateFormatter = /*#__PURE__*/function () {
	  function PolyDateFormatter(dt, intl, opts) {
	    this.opts = opts;
	    var z;

	    if (dt.zone.isUniversal) {
	      // UTC-8 or Etc/UTC-8 are not part of tzdata, only Etc/GMT+8 and the like.
	      // That is why fixed-offset TZ is set to that unless it is:
	      // 1. Representing offset 0 when UTC is used to maintain previous behavior and does not become GMT.
	      // 2. Unsupported by the browser:
	      //    - some do not support Etc/
	      //    - < Etc/GMT-14, > Etc/GMT+12, and 30-minute or 45-minute offsets are not part of tzdata
	      var gmtOffset = -1 * (dt.offset / 60);
	      var offsetZ = gmtOffset >= 0 ? "Etc/GMT+" + gmtOffset : "Etc/GMT" + gmtOffset;
	      var isOffsetZoneSupported = IANAZone.isValidZone(offsetZ);

	      if (dt.offset !== 0 && isOffsetZoneSupported) {
	        z = offsetZ;
	        this.dt = dt;
	      } else {
	        // Not all fixed-offset zones like Etc/+4:30 are present in tzdata.
	        // So we have to make do. Two cases:
	        // 1. The format options tell us to show the zone. We can't do that, so the best
	        // we can do is format the date in UTC.
	        // 2. The format options don't tell us to show the zone. Then we can adjust them
	        // the time and tell the formatter to show it to us in UTC, so that the time is right
	        // and the bad zone doesn't show up.
	        z = "UTC";

	        if (opts.timeZoneName) {
	          this.dt = dt;
	        } else {
	          this.dt = dt.offset === 0 ? dt : DateTime.fromMillis(dt.ts + dt.offset * 60 * 1000);
	        }
	      }
	    } else if (dt.zone.type === "system") {
	      this.dt = dt;
	    } else {
	      this.dt = dt;
	      z = dt.zone.name;
	    }

	    var intlOpts = _extends({}, this.opts);

	    if (z) {
	      intlOpts.timeZone = z;
	    }

	    this.dtf = getCachedDTF(intl, intlOpts);
	  }

	  var _proto2 = PolyDateFormatter.prototype;

	  _proto2.format = function format() {
	    return this.dtf.format(this.dt.toJSDate());
	  };

	  _proto2.formatToParts = function formatToParts() {
	    return this.dtf.formatToParts(this.dt.toJSDate());
	  };

	  _proto2.resolvedOptions = function resolvedOptions() {
	    return this.dtf.resolvedOptions();
	  };

	  return PolyDateFormatter;
	}();
	/**
	 * @private
	 */


	var PolyRelFormatter = /*#__PURE__*/function () {
	  function PolyRelFormatter(intl, isEnglish, opts) {
	    this.opts = _extends({
	      style: "long"
	    }, opts);

	    if (!isEnglish && hasRelative()) {
	      this.rtf = getCachedRTF(intl, opts);
	    }
	  }

	  var _proto3 = PolyRelFormatter.prototype;

	  _proto3.format = function format(count, unit) {
	    if (this.rtf) {
	      return this.rtf.format(count, unit);
	    } else {
	      return formatRelativeTime(unit, count, this.opts.numeric, this.opts.style !== "long");
	    }
	  };

	  _proto3.formatToParts = function formatToParts(count, unit) {
	    if (this.rtf) {
	      return this.rtf.formatToParts(count, unit);
	    } else {
	      return [];
	    }
	  };

	  return PolyRelFormatter;
	}();
	/**
	 * @private
	 */


	var Locale = /*#__PURE__*/function () {
	  Locale.fromOpts = function fromOpts(opts) {
	    return Locale.create(opts.locale, opts.numberingSystem, opts.outputCalendar, opts.defaultToEN);
	  };

	  Locale.create = function create(locale, numberingSystem, outputCalendar, defaultToEN) {
	    if (defaultToEN === void 0) {
	      defaultToEN = false;
	    }

	    var specifiedLocale = locale || Settings.defaultLocale; // the system locale is useful for human readable strings but annoying for parsing/formatting known formats

	    var localeR = specifiedLocale || (defaultToEN ? "en-US" : systemLocale());
	    var numberingSystemR = numberingSystem || Settings.defaultNumberingSystem;
	    var outputCalendarR = outputCalendar || Settings.defaultOutputCalendar;
	    return new Locale(localeR, numberingSystemR, outputCalendarR, specifiedLocale);
	  };

	  Locale.resetCache = function resetCache() {
	    sysLocaleCache = null;
	    intlDTCache = {};
	    intlNumCache = {};
	    intlRelCache = {};
	  };

	  Locale.fromObject = function fromObject(_temp) {
	    var _ref = _temp === void 0 ? {} : _temp,
	        locale = _ref.locale,
	        numberingSystem = _ref.numberingSystem,
	        outputCalendar = _ref.outputCalendar;

	    return Locale.create(locale, numberingSystem, outputCalendar);
	  };

	  function Locale(locale, numbering, outputCalendar, specifiedLocale) {
	    var _parseLocaleString = parseLocaleString(locale),
	        parsedLocale = _parseLocaleString[0],
	        parsedNumberingSystem = _parseLocaleString[1],
	        parsedOutputCalendar = _parseLocaleString[2];

	    this.locale = parsedLocale;
	    this.numberingSystem = numbering || parsedNumberingSystem || null;
	    this.outputCalendar = outputCalendar || parsedOutputCalendar || null;
	    this.intl = intlConfigString(this.locale, this.numberingSystem, this.outputCalendar);
	    this.weekdaysCache = {
	      format: {},
	      standalone: {}
	    };
	    this.monthsCache = {
	      format: {},
	      standalone: {}
	    };
	    this.meridiemCache = null;
	    this.eraCache = {};
	    this.specifiedLocale = specifiedLocale;
	    this.fastNumbersCached = null;
	  }

	  var _proto4 = Locale.prototype;

	  _proto4.listingMode = function listingMode(defaultOK) {

	    var isActuallyEn = this.isEnglish();
	    var hasNoWeirdness = (this.numberingSystem === null || this.numberingSystem === "latn") && (this.outputCalendar === null || this.outputCalendar === "gregory");
	    return isActuallyEn && hasNoWeirdness ? "en" : "intl";
	  };

	  _proto4.clone = function clone(alts) {
	    if (!alts || Object.getOwnPropertyNames(alts).length === 0) {
	      return this;
	    } else {
	      return Locale.create(alts.locale || this.specifiedLocale, alts.numberingSystem || this.numberingSystem, alts.outputCalendar || this.outputCalendar, alts.defaultToEN || false);
	    }
	  };

	  _proto4.redefaultToEN = function redefaultToEN(alts) {
	    if (alts === void 0) {
	      alts = {};
	    }

	    return this.clone(_extends({}, alts, {
	      defaultToEN: true
	    }));
	  };

	  _proto4.redefaultToSystem = function redefaultToSystem(alts) {
	    if (alts === void 0) {
	      alts = {};
	    }

	    return this.clone(_extends({}, alts, {
	      defaultToEN: false
	    }));
	  };

	  _proto4.months = function months$1(length, format, defaultOK) {
	    var _this = this;

	    if (format === void 0) {
	      format = false;
	    }

	    if (defaultOK === void 0) {
	      defaultOK = true;
	    }

	    return listStuff(this, length, defaultOK, months, function () {
	      var intl = format ? {
	        month: length,
	        day: "numeric"
	      } : {
	        month: length
	      },
	          formatStr = format ? "format" : "standalone";

	      if (!_this.monthsCache[formatStr][length]) {
	        _this.monthsCache[formatStr][length] = mapMonths(function (dt) {
	          return _this.extract(dt, intl, "month");
	        });
	      }

	      return _this.monthsCache[formatStr][length];
	    });
	  };

	  _proto4.weekdays = function weekdays$1(length, format, defaultOK) {
	    var _this2 = this;

	    if (format === void 0) {
	      format = false;
	    }

	    if (defaultOK === void 0) {
	      defaultOK = true;
	    }

	    return listStuff(this, length, defaultOK, weekdays, function () {
	      var intl = format ? {
	        weekday: length,
	        year: "numeric",
	        month: "long",
	        day: "numeric"
	      } : {
	        weekday: length
	      },
	          formatStr = format ? "format" : "standalone";

	      if (!_this2.weekdaysCache[formatStr][length]) {
	        _this2.weekdaysCache[formatStr][length] = mapWeekdays(function (dt) {
	          return _this2.extract(dt, intl, "weekday");
	        });
	      }

	      return _this2.weekdaysCache[formatStr][length];
	    });
	  };

	  _proto4.meridiems = function meridiems$1(defaultOK) {
	    var _this3 = this;

	    if (defaultOK === void 0) {
	      defaultOK = true;
	    }

	    return listStuff(this, undefined, defaultOK, function () {
	      return meridiems;
	    }, function () {
	      // In theory there could be aribitrary day periods. We're gonna assume there are exactly two
	      // for AM and PM. This is probably wrong, but it's makes parsing way easier.
	      if (!_this3.meridiemCache) {
	        var intl = {
	          hour: "numeric",
	          hourCycle: "h12"
	        };
	        _this3.meridiemCache = [DateTime.utc(2016, 11, 13, 9), DateTime.utc(2016, 11, 13, 19)].map(function (dt) {
	          return _this3.extract(dt, intl, "dayperiod");
	        });
	      }

	      return _this3.meridiemCache;
	    });
	  };

	  _proto4.eras = function eras$1(length, defaultOK) {
	    var _this4 = this;

	    if (defaultOK === void 0) {
	      defaultOK = true;
	    }

	    return listStuff(this, length, defaultOK, eras, function () {
	      var intl = {
	        era: length
	      }; // This is problematic. Different calendars are going to define eras totally differently. What I need is the minimum set of dates
	      // to definitely enumerate them.

	      if (!_this4.eraCache[length]) {
	        _this4.eraCache[length] = [DateTime.utc(-40, 1, 1), DateTime.utc(2017, 1, 1)].map(function (dt) {
	          return _this4.extract(dt, intl, "era");
	        });
	      }

	      return _this4.eraCache[length];
	    });
	  };

	  _proto4.extract = function extract(dt, intlOpts, field) {
	    var df = this.dtFormatter(dt, intlOpts),
	        results = df.formatToParts(),
	        matching = results.find(function (m) {
	      return m.type.toLowerCase() === field;
	    });
	    return matching ? matching.value : null;
	  };

	  _proto4.numberFormatter = function numberFormatter(opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    // this forcesimple option is never used (the only caller short-circuits on it, but it seems safer to leave)
	    // (in contrast, the rest of the condition is used heavily)
	    return new PolyNumberFormatter(this.intl, opts.forceSimple || this.fastNumbers, opts);
	  };

	  _proto4.dtFormatter = function dtFormatter(dt, intlOpts) {
	    if (intlOpts === void 0) {
	      intlOpts = {};
	    }

	    return new PolyDateFormatter(dt, this.intl, intlOpts);
	  };

	  _proto4.relFormatter = function relFormatter(opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    return new PolyRelFormatter(this.intl, this.isEnglish(), opts);
	  };

	  _proto4.isEnglish = function isEnglish() {
	    return this.locale === "en" || this.locale.toLowerCase() === "en-us" || new Intl.DateTimeFormat(this.intl).resolvedOptions().locale.startsWith("en-us");
	  };

	  _proto4.equals = function equals(other) {
	    return this.locale === other.locale && this.numberingSystem === other.numberingSystem && this.outputCalendar === other.outputCalendar;
	  };

	  _createClass(Locale, [{
	    key: "fastNumbers",
	    get: function get() {
	      if (this.fastNumbersCached == null) {
	        this.fastNumbersCached = supportsFastNumbers(this);
	      }

	      return this.fastNumbersCached;
	    }
	  }]);

	  return Locale;
	}();

	/*
	 * This file handles parsing for well-specified formats. Here's how it works:
	 * Two things go into parsing: a regex to match with and an extractor to take apart the groups in the match.
	 * An extractor is just a function that takes a regex match array and returns a { year: ..., month: ... } object
	 * parse() does the work of executing the regex and applying the extractor. It takes multiple regex/extractor pairs to try in sequence.
	 * Extractors can take a "cursor" representing the offset in the match to look at. This makes it easy to combine extractors.
	 * combineExtractors() does the work of combining them, keeping track of the cursor through multiple extractions.
	 * Some extractions are super dumb and simpleParse and fromStrings help DRY them.
	 */

	function combineRegexes() {
	  for (var _len = arguments.length, regexes = new Array(_len), _key = 0; _key < _len; _key++) {
	    regexes[_key] = arguments[_key];
	  }

	  var full = regexes.reduce(function (f, r) {
	    return f + r.source;
	  }, "");
	  return RegExp("^" + full + "$");
	}

	function combineExtractors() {
	  for (var _len2 = arguments.length, extractors = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
	    extractors[_key2] = arguments[_key2];
	  }

	  return function (m) {
	    return extractors.reduce(function (_ref, ex) {
	      var mergedVals = _ref[0],
	          mergedZone = _ref[1],
	          cursor = _ref[2];

	      var _ex = ex(m, cursor),
	          val = _ex[0],
	          zone = _ex[1],
	          next = _ex[2];

	      return [_extends({}, mergedVals, val), mergedZone || zone, next];
	    }, [{}, null, 1]).slice(0, 2);
	  };
	}

	function parse$6(s) {
	  if (s == null) {
	    return [null, null];
	  }

	  for (var _len3 = arguments.length, patterns = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
	    patterns[_key3 - 1] = arguments[_key3];
	  }

	  for (var _i = 0, _patterns = patterns; _i < _patterns.length; _i++) {
	    var _patterns$_i = _patterns[_i],
	        regex = _patterns$_i[0],
	        extractor = _patterns$_i[1];
	    var m = regex.exec(s);

	    if (m) {
	      return extractor(m);
	    }
	  }

	  return [null, null];
	}

	function simpleParse() {
	  for (var _len4 = arguments.length, keys = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
	    keys[_key4] = arguments[_key4];
	  }

	  return function (match, cursor) {
	    var ret = {};
	    var i;

	    for (i = 0; i < keys.length; i++) {
	      ret[keys[i]] = parseInteger(match[cursor + i]);
	    }

	    return [ret, null, cursor + i];
	  };
	} // ISO and SQL parsing


	var offsetRegex = /(?:(Z)|([+-]\d\d)(?::?(\d\d))?)/,
	    isoTimeBaseRegex = /(\d\d)(?::?(\d\d)(?::?(\d\d)(?:[.,](\d{1,30}))?)?)?/,
	    isoTimeRegex = RegExp("" + isoTimeBaseRegex.source + offsetRegex.source + "?"),
	    isoTimeExtensionRegex = RegExp("(?:T" + isoTimeRegex.source + ")?"),
	    isoYmdRegex = /([+-]\d{6}|\d{4})(?:-?(\d\d)(?:-?(\d\d))?)?/,
	    isoWeekRegex = /(\d{4})-?W(\d\d)(?:-?(\d))?/,
	    isoOrdinalRegex = /(\d{4})-?(\d{3})/,
	    extractISOWeekData = simpleParse("weekYear", "weekNumber", "weekDay"),
	    extractISOOrdinalData = simpleParse("year", "ordinal"),
	    sqlYmdRegex = /(\d{4})-(\d\d)-(\d\d)/,
	    // dumbed-down version of the ISO one
	sqlTimeRegex = RegExp(isoTimeBaseRegex.source + " ?(?:" + offsetRegex.source + "|(" + ianaRegex.source + "))?"),
	    sqlTimeExtensionRegex = RegExp("(?: " + sqlTimeRegex.source + ")?");

	function int(match, pos, fallback) {
	  var m = match[pos];
	  return isUndefined$1(m) ? fallback : parseInteger(m);
	}

	function extractISOYmd(match, cursor) {
	  var item = {
	    year: int(match, cursor),
	    month: int(match, cursor + 1, 1),
	    day: int(match, cursor + 2, 1)
	  };
	  return [item, null, cursor + 3];
	}

	function extractISOTime(match, cursor) {
	  var item = {
	    hours: int(match, cursor, 0),
	    minutes: int(match, cursor + 1, 0),
	    seconds: int(match, cursor + 2, 0),
	    milliseconds: parseMillis(match[cursor + 3])
	  };
	  return [item, null, cursor + 4];
	}

	function extractISOOffset(match, cursor) {
	  var local = !match[cursor] && !match[cursor + 1],
	      fullOffset = signedOffset(match[cursor + 1], match[cursor + 2]),
	      zone = local ? null : FixedOffsetZone.instance(fullOffset);
	  return [{}, zone, cursor + 3];
	}

	function extractIANAZone(match, cursor) {
	  var zone = match[cursor] ? IANAZone.create(match[cursor]) : null;
	  return [{}, zone, cursor + 1];
	} // ISO time parsing


	var isoTimeOnly = RegExp("^T?" + isoTimeBaseRegex.source + "$"); // ISO duration parsing

	var isoDuration = /^-?P(?:(?:(-?\d{1,9})Y)?(?:(-?\d{1,9})M)?(?:(-?\d{1,9})W)?(?:(-?\d{1,9})D)?(?:T(?:(-?\d{1,9})H)?(?:(-?\d{1,9})M)?(?:(-?\d{1,20})(?:[.,](-?\d{1,9}))?S)?)?)$/;

	function extractISODuration(match) {
	  var s = match[0],
	      yearStr = match[1],
	      monthStr = match[2],
	      weekStr = match[3],
	      dayStr = match[4],
	      hourStr = match[5],
	      minuteStr = match[6],
	      secondStr = match[7],
	      millisecondsStr = match[8];
	  var hasNegativePrefix = s[0] === "-";
	  var negativeSeconds = secondStr && secondStr[0] === "-";

	  var maybeNegate = function maybeNegate(num, force) {
	    if (force === void 0) {
	      force = false;
	    }

	    return num !== undefined && (force || num && hasNegativePrefix) ? -num : num;
	  };

	  return [{
	    years: maybeNegate(parseInteger(yearStr)),
	    months: maybeNegate(parseInteger(monthStr)),
	    weeks: maybeNegate(parseInteger(weekStr)),
	    days: maybeNegate(parseInteger(dayStr)),
	    hours: maybeNegate(parseInteger(hourStr)),
	    minutes: maybeNegate(parseInteger(minuteStr)),
	    seconds: maybeNegate(parseInteger(secondStr), secondStr === "-0"),
	    milliseconds: maybeNegate(parseMillis(millisecondsStr), negativeSeconds)
	  }];
	} // These are a little braindead. EDT *should* tell us that we're in, say, America/New_York
	// and not just that we're in -240 *right now*. But since I don't think these are used that often
	// I'm just going to ignore that


	var obsOffsets = {
	  GMT: 0,
	  EDT: -4 * 60,
	  EST: -5 * 60,
	  CDT: -5 * 60,
	  CST: -6 * 60,
	  MDT: -6 * 60,
	  MST: -7 * 60,
	  PDT: -7 * 60,
	  PST: -8 * 60
	};

	function fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
	  var result = {
	    year: yearStr.length === 2 ? untruncateYear(parseInteger(yearStr)) : parseInteger(yearStr),
	    month: monthsShort.indexOf(monthStr) + 1,
	    day: parseInteger(dayStr),
	    hour: parseInteger(hourStr),
	    minute: parseInteger(minuteStr)
	  };
	  if (secondStr) result.second = parseInteger(secondStr);

	  if (weekdayStr) {
	    result.weekday = weekdayStr.length > 3 ? weekdaysLong.indexOf(weekdayStr) + 1 : weekdaysShort.indexOf(weekdayStr) + 1;
	  }

	  return result;
	} // RFC 2822/5322


	var rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|(?:([+-]\d\d)(\d\d)))$/;

	function extractRFC2822(match) {
	  var weekdayStr = match[1],
	      dayStr = match[2],
	      monthStr = match[3],
	      yearStr = match[4],
	      hourStr = match[5],
	      minuteStr = match[6],
	      secondStr = match[7],
	      obsOffset = match[8],
	      milOffset = match[9],
	      offHourStr = match[10],
	      offMinuteStr = match[11],
	      result = fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr);
	  var offset;

	  if (obsOffset) {
	    offset = obsOffsets[obsOffset];
	  } else if (milOffset) {
	    offset = 0;
	  } else {
	    offset = signedOffset(offHourStr, offMinuteStr);
	  }

	  return [result, new FixedOffsetZone(offset)];
	}

	function preprocessRFC2822(s) {
	  // Remove comments and folding whitespace and replace multiple-spaces with a single space
	  return s.replace(/\([^)]*\)|[\n\t]/g, " ").replace(/(\s\s+)/g, " ").trim();
	} // http date


	var rfc1123 = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d\d) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d\d):(\d\d):(\d\d) GMT$/,
	    rfc850 = /^(Monday|Tuesday|Wedsday|Thursday|Friday|Saturday|Sunday), (\d\d)-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d\d) (\d\d):(\d\d):(\d\d) GMT$/,
	    ascii = /^(Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( \d|\d\d) (\d\d):(\d\d):(\d\d) (\d{4})$/;

	function extractRFC1123Or850(match) {
	  var weekdayStr = match[1],
	      dayStr = match[2],
	      monthStr = match[3],
	      yearStr = match[4],
	      hourStr = match[5],
	      minuteStr = match[6],
	      secondStr = match[7],
	      result = fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr);
	  return [result, FixedOffsetZone.utcInstance];
	}

	function extractASCII(match) {
	  var weekdayStr = match[1],
	      monthStr = match[2],
	      dayStr = match[3],
	      hourStr = match[4],
	      minuteStr = match[5],
	      secondStr = match[6],
	      yearStr = match[7],
	      result = fromStrings(weekdayStr, yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr);
	  return [result, FixedOffsetZone.utcInstance];
	}

	var isoYmdWithTimeExtensionRegex = combineRegexes(isoYmdRegex, isoTimeExtensionRegex);
	var isoWeekWithTimeExtensionRegex = combineRegexes(isoWeekRegex, isoTimeExtensionRegex);
	var isoOrdinalWithTimeExtensionRegex = combineRegexes(isoOrdinalRegex, isoTimeExtensionRegex);
	var isoTimeCombinedRegex = combineRegexes(isoTimeRegex);
	var extractISOYmdTimeAndOffset = combineExtractors(extractISOYmd, extractISOTime, extractISOOffset);
	var extractISOWeekTimeAndOffset = combineExtractors(extractISOWeekData, extractISOTime, extractISOOffset);
	var extractISOOrdinalDateAndTime = combineExtractors(extractISOOrdinalData, extractISOTime, extractISOOffset);
	var extractISOTimeAndOffset = combineExtractors(extractISOTime, extractISOOffset);
	/**
	 * @private
	 */

	function parseISODate(s) {
	  return parse$6(s, [isoYmdWithTimeExtensionRegex, extractISOYmdTimeAndOffset], [isoWeekWithTimeExtensionRegex, extractISOWeekTimeAndOffset], [isoOrdinalWithTimeExtensionRegex, extractISOOrdinalDateAndTime], [isoTimeCombinedRegex, extractISOTimeAndOffset]);
	}
	function parseRFC2822Date(s) {
	  return parse$6(preprocessRFC2822(s), [rfc2822, extractRFC2822]);
	}
	function parseHTTPDate(s) {
	  return parse$6(s, [rfc1123, extractRFC1123Or850], [rfc850, extractRFC1123Or850], [ascii, extractASCII]);
	}
	function parseISODuration(s) {
	  return parse$6(s, [isoDuration, extractISODuration]);
	}
	var extractISOTimeOnly = combineExtractors(extractISOTime);
	function parseISOTimeOnly(s) {
	  return parse$6(s, [isoTimeOnly, extractISOTimeOnly]);
	}
	var sqlYmdWithTimeExtensionRegex = combineRegexes(sqlYmdRegex, sqlTimeExtensionRegex);
	var sqlTimeCombinedRegex = combineRegexes(sqlTimeRegex);
	var extractISOYmdTimeOffsetAndIANAZone = combineExtractors(extractISOYmd, extractISOTime, extractISOOffset, extractIANAZone);
	var extractISOTimeOffsetAndIANAZone = combineExtractors(extractISOTime, extractISOOffset, extractIANAZone);
	function parseSQL(s) {
	  return parse$6(s, [sqlYmdWithTimeExtensionRegex, extractISOYmdTimeOffsetAndIANAZone], [sqlTimeCombinedRegex, extractISOTimeOffsetAndIANAZone]);
	}

	var INVALID$2 = "Invalid Duration"; // unit conversion constants

	var lowOrderMatrix = {
	  weeks: {
	    days: 7,
	    hours: 7 * 24,
	    minutes: 7 * 24 * 60,
	    seconds: 7 * 24 * 60 * 60,
	    milliseconds: 7 * 24 * 60 * 60 * 1000
	  },
	  days: {
	    hours: 24,
	    minutes: 24 * 60,
	    seconds: 24 * 60 * 60,
	    milliseconds: 24 * 60 * 60 * 1000
	  },
	  hours: {
	    minutes: 60,
	    seconds: 60 * 60,
	    milliseconds: 60 * 60 * 1000
	  },
	  minutes: {
	    seconds: 60,
	    milliseconds: 60 * 1000
	  },
	  seconds: {
	    milliseconds: 1000
	  }
	},
	    casualMatrix = _extends({
	  years: {
	    quarters: 4,
	    months: 12,
	    weeks: 52,
	    days: 365,
	    hours: 365 * 24,
	    minutes: 365 * 24 * 60,
	    seconds: 365 * 24 * 60 * 60,
	    milliseconds: 365 * 24 * 60 * 60 * 1000
	  },
	  quarters: {
	    months: 3,
	    weeks: 13,
	    days: 91,
	    hours: 91 * 24,
	    minutes: 91 * 24 * 60,
	    seconds: 91 * 24 * 60 * 60,
	    milliseconds: 91 * 24 * 60 * 60 * 1000
	  },
	  months: {
	    weeks: 4,
	    days: 30,
	    hours: 30 * 24,
	    minutes: 30 * 24 * 60,
	    seconds: 30 * 24 * 60 * 60,
	    milliseconds: 30 * 24 * 60 * 60 * 1000
	  }
	}, lowOrderMatrix),
	    daysInYearAccurate = 146097.0 / 400,
	    daysInMonthAccurate = 146097.0 / 4800,
	    accurateMatrix = _extends({
	  years: {
	    quarters: 4,
	    months: 12,
	    weeks: daysInYearAccurate / 7,
	    days: daysInYearAccurate,
	    hours: daysInYearAccurate * 24,
	    minutes: daysInYearAccurate * 24 * 60,
	    seconds: daysInYearAccurate * 24 * 60 * 60,
	    milliseconds: daysInYearAccurate * 24 * 60 * 60 * 1000
	  },
	  quarters: {
	    months: 3,
	    weeks: daysInYearAccurate / 28,
	    days: daysInYearAccurate / 4,
	    hours: daysInYearAccurate * 24 / 4,
	    minutes: daysInYearAccurate * 24 * 60 / 4,
	    seconds: daysInYearAccurate * 24 * 60 * 60 / 4,
	    milliseconds: daysInYearAccurate * 24 * 60 * 60 * 1000 / 4
	  },
	  months: {
	    weeks: daysInMonthAccurate / 7,
	    days: daysInMonthAccurate,
	    hours: daysInMonthAccurate * 24,
	    minutes: daysInMonthAccurate * 24 * 60,
	    seconds: daysInMonthAccurate * 24 * 60 * 60,
	    milliseconds: daysInMonthAccurate * 24 * 60 * 60 * 1000
	  }
	}, lowOrderMatrix); // units ordered by size


	var orderedUnits$1 = ["years", "quarters", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds"];
	var reverseUnits = orderedUnits$1.slice(0).reverse(); // clone really means "create another instance just like this one, but with these changes"

	function clone$1(dur, alts, clear) {
	  if (clear === void 0) {
	    clear = false;
	  }

	  // deep merge for vals
	  var conf = {
	    values: clear ? alts.values : _extends({}, dur.values, alts.values || {}),
	    loc: dur.loc.clone(alts.loc),
	    conversionAccuracy: alts.conversionAccuracy || dur.conversionAccuracy
	  };
	  return new Duration(conf);
	}

	function antiTrunc(n) {
	  return n < 0 ? Math.floor(n) : Math.ceil(n);
	} // NB: mutates parameters


	function convert$9(matrix, fromMap, fromUnit, toMap, toUnit) {
	  var conv = matrix[toUnit][fromUnit],
	      raw = fromMap[fromUnit] / conv,
	      sameSign = Math.sign(raw) === Math.sign(toMap[toUnit]),
	      // ok, so this is wild, but see the matrix in the tests
	  added = !sameSign && toMap[toUnit] !== 0 && Math.abs(raw) <= 1 ? antiTrunc(raw) : Math.trunc(raw);
	  toMap[toUnit] += added;
	  fromMap[fromUnit] -= added * conv;
	} // NB: mutates parameters


	function normalizeValues(matrix, vals) {
	  reverseUnits.reduce(function (previous, current) {
	    if (!isUndefined$1(vals[current])) {
	      if (previous) {
	        convert$9(matrix, vals, previous, vals, current);
	      }

	      return current;
	    } else {
	      return previous;
	    }
	  }, null);
	}
	/**
	 * A Duration object represents a period of time, like "2 months" or "1 day, 1 hour". Conceptually, it's just a map of units to their quantities, accompanied by some additional configuration and methods for creating, parsing, interrogating, transforming, and formatting them. They can be used on their own or in conjunction with other Luxon types; for example, you can use {@link DateTime.plus} to add a Duration object to a DateTime, producing another DateTime.
	 *
	 * Here is a brief overview of commonly used methods and getters in Duration:
	 *
	 * * **Creation** To create a Duration, use {@link Duration.fromMillis}, {@link Duration.fromObject}, or {@link Duration.fromISO}.
	 * * **Unit values** See the {@link Duration#years}, {@link Duration.months}, {@link Duration#weeks}, {@link Duration#days}, {@link Duration#hours}, {@link Duration#minutes}, {@link Duration#seconds}, {@link Duration#milliseconds} accessors.
	 * * **Configuration** See  {@link Duration#locale} and {@link Duration#numberingSystem} accessors.
	 * * **Transformation** To create new Durations out of old ones use {@link Duration#plus}, {@link Duration#minus}, {@link Duration#normalize}, {@link Duration#set}, {@link Duration#reconfigure}, {@link Duration#shiftTo}, and {@link Duration#negate}.
	 * * **Output** To convert the Duration into other representations, see {@link Duration#as}, {@link Duration#toISO}, {@link Duration#toFormat}, and {@link Duration#toJSON}
	 *
	 * There's are more methods documented below. In addition, for more information on subtler topics like internationalization and validity, see the external documentation.
	 */


	var Duration = /*#__PURE__*/function () {
	  /**
	   * @private
	   */
	  function Duration(config) {
	    var accurate = config.conversionAccuracy === "longterm" || false;
	    /**
	     * @access private
	     */

	    this.values = config.values;
	    /**
	     * @access private
	     */

	    this.loc = config.loc || Locale.create();
	    /**
	     * @access private
	     */

	    this.conversionAccuracy = accurate ? "longterm" : "casual";
	    /**
	     * @access private
	     */

	    this.invalid = config.invalid || null;
	    /**
	     * @access private
	     */

	    this.matrix = accurate ? accurateMatrix : casualMatrix;
	    /**
	     * @access private
	     */

	    this.isLuxonDuration = true;
	  }
	  /**
	   * Create Duration from a number of milliseconds.
	   * @param {number} count of milliseconds
	   * @param {Object} opts - options for parsing
	   * @param {string} [opts.locale='en-US'] - the locale to use
	   * @param {string} opts.numberingSystem - the numbering system to use
	   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
	   * @return {Duration}
	   */


	  Duration.fromMillis = function fromMillis(count, opts) {
	    return Duration.fromObject({
	      milliseconds: count
	    }, opts);
	  }
	  /**
	   * Create a Duration from a JavaScript object with keys like 'years' and 'hours'.
	   * If this object is empty then a zero milliseconds duration is returned.
	   * @param {Object} obj - the object to create the DateTime from
	   * @param {number} obj.years
	   * @param {number} obj.quarters
	   * @param {number} obj.months
	   * @param {number} obj.weeks
	   * @param {number} obj.days
	   * @param {number} obj.hours
	   * @param {number} obj.minutes
	   * @param {number} obj.seconds
	   * @param {number} obj.milliseconds
	   * @param {Object} [opts=[]] - options for creating this Duration
	   * @param {string} [opts.locale='en-US'] - the locale to use
	   * @param {string} opts.numberingSystem - the numbering system to use
	   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
	   * @return {Duration}
	   */
	  ;

	  Duration.fromObject = function fromObject(obj, opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    if (obj == null || typeof obj !== "object") {
	      throw new InvalidArgumentError("Duration.fromObject: argument expected to be an object, got " + (obj === null ? "null" : typeof obj));
	    }

	    return new Duration({
	      values: normalizeObject(obj, Duration.normalizeUnit),
	      loc: Locale.fromObject(opts),
	      conversionAccuracy: opts.conversionAccuracy
	    });
	  }
	  /**
	   * Create a Duration from an ISO 8601 duration string.
	   * @param {string} text - text to parse
	   * @param {Object} opts - options for parsing
	   * @param {string} [opts.locale='en-US'] - the locale to use
	   * @param {string} opts.numberingSystem - the numbering system to use
	   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
	   * @see https://en.wikipedia.org/wiki/ISO_8601#Durations
	   * @example Duration.fromISO('P3Y6M1W4DT12H30M5S').toObject() //=> { years: 3, months: 6, weeks: 1, days: 4, hours: 12, minutes: 30, seconds: 5 }
	   * @example Duration.fromISO('PT23H').toObject() //=> { hours: 23 }
	   * @example Duration.fromISO('P5Y3M').toObject() //=> { years: 5, months: 3 }
	   * @return {Duration}
	   */
	  ;

	  Duration.fromISO = function fromISO(text, opts) {
	    var _parseISODuration = parseISODuration(text),
	        parsed = _parseISODuration[0];

	    if (parsed) {
	      return Duration.fromObject(parsed, opts);
	    } else {
	      return Duration.invalid("unparsable", "the input \"" + text + "\" can't be parsed as ISO 8601");
	    }
	  }
	  /**
	   * Create a Duration from an ISO 8601 time string.
	   * @param {string} text - text to parse
	   * @param {Object} opts - options for parsing
	   * @param {string} [opts.locale='en-US'] - the locale to use
	   * @param {string} opts.numberingSystem - the numbering system to use
	   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
	   * @see https://en.wikipedia.org/wiki/ISO_8601#Times
	   * @example Duration.fromISOTime('11:22:33.444').toObject() //=> { hours: 11, minutes: 22, seconds: 33, milliseconds: 444 }
	   * @example Duration.fromISOTime('11:00').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
	   * @example Duration.fromISOTime('T11:00').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
	   * @example Duration.fromISOTime('1100').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
	   * @example Duration.fromISOTime('T1100').toObject() //=> { hours: 11, minutes: 0, seconds: 0 }
	   * @return {Duration}
	   */
	  ;

	  Duration.fromISOTime = function fromISOTime(text, opts) {
	    var _parseISOTimeOnly = parseISOTimeOnly(text),
	        parsed = _parseISOTimeOnly[0];

	    if (parsed) {
	      return Duration.fromObject(parsed, opts);
	    } else {
	      return Duration.invalid("unparsable", "the input \"" + text + "\" can't be parsed as ISO 8601");
	    }
	  }
	  /**
	   * Create an invalid Duration.
	   * @param {string} reason - simple string of why this datetime is invalid. Should not contain parameters or anything else data-dependent
	   * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information
	   * @return {Duration}
	   */
	  ;

	  Duration.invalid = function invalid(reason, explanation) {
	    if (explanation === void 0) {
	      explanation = null;
	    }

	    if (!reason) {
	      throw new InvalidArgumentError("need to specify a reason the Duration is invalid");
	    }

	    var invalid = reason instanceof Invalid ? reason : new Invalid(reason, explanation);

	    if (Settings.throwOnInvalid) {
	      throw new InvalidDurationError(invalid);
	    } else {
	      return new Duration({
	        invalid: invalid
	      });
	    }
	  }
	  /**
	   * @private
	   */
	  ;

	  Duration.normalizeUnit = function normalizeUnit(unit) {
	    var normalized = {
	      year: "years",
	      years: "years",
	      quarter: "quarters",
	      quarters: "quarters",
	      month: "months",
	      months: "months",
	      week: "weeks",
	      weeks: "weeks",
	      day: "days",
	      days: "days",
	      hour: "hours",
	      hours: "hours",
	      minute: "minutes",
	      minutes: "minutes",
	      second: "seconds",
	      seconds: "seconds",
	      millisecond: "milliseconds",
	      milliseconds: "milliseconds"
	    }[unit ? unit.toLowerCase() : unit];
	    if (!normalized) throw new InvalidUnitError(unit);
	    return normalized;
	  }
	  /**
	   * Check if an object is a Duration. Works across context boundaries
	   * @param {object} o
	   * @return {boolean}
	   */
	  ;

	  Duration.isDuration = function isDuration(o) {
	    return o && o.isLuxonDuration || false;
	  }
	  /**
	   * Get  the locale of a Duration, such 'en-GB'
	   * @type {string}
	   */
	  ;

	  var _proto = Duration.prototype;

	  /**
	   * Returns a string representation of this Duration formatted according to the specified format string. You may use these tokens:
	   * * `S` for milliseconds
	   * * `s` for seconds
	   * * `m` for minutes
	   * * `h` for hours
	   * * `d` for days
	   * * `M` for months
	   * * `y` for years
	   * Notes:
	   * * Add padding by repeating the token, e.g. "yy" pads the years to two digits, "hhhh" pads the hours out to four digits
	   * * The duration will be converted to the set of units in the format string using {@link Duration.shiftTo} and the Durations's conversion accuracy setting.
	   * @param {string} fmt - the format string
	   * @param {Object} opts - options
	   * @param {boolean} [opts.floor=true] - floor numerical values
	   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("y d s") //=> "1 6 2"
	   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("yy dd sss") //=> "01 06 002"
	   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toFormat("M S") //=> "12 518402000"
	   * @return {string}
	   */
	  _proto.toFormat = function toFormat(fmt, opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    // reverse-compat since 1.2; we always round down now, never up, and we do it by default
	    var fmtOpts = _extends({}, opts, {
	      floor: opts.round !== false && opts.floor !== false
	    });

	    return this.isValid ? Formatter$1.create(this.loc, fmtOpts).formatDurationFromString(this, fmt) : INVALID$2;
	  }
	  /**
	   * Returns a JavaScript object with this Duration's values.
	   * @example Duration.fromObject({ years: 1, days: 6, seconds: 2 }).toObject() //=> { years: 1, days: 6, seconds: 2 }
	   * @return {Object}
	   */
	  ;

	  _proto.toObject = function toObject() {
	    if (!this.isValid) return {};
	    return _extends({}, this.values);
	  }
	  /**
	   * Returns an ISO 8601-compliant string representation of this Duration.
	   * @see https://en.wikipedia.org/wiki/ISO_8601#Durations
	   * @example Duration.fromObject({ years: 3, seconds: 45 }).toISO() //=> 'P3YT45S'
	   * @example Duration.fromObject({ months: 4, seconds: 45 }).toISO() //=> 'P4MT45S'
	   * @example Duration.fromObject({ months: 5 }).toISO() //=> 'P5M'
	   * @example Duration.fromObject({ minutes: 5 }).toISO() //=> 'PT5M'
	   * @example Duration.fromObject({ milliseconds: 6 }).toISO() //=> 'PT0.006S'
	   * @return {string}
	   */
	  ;

	  _proto.toISO = function toISO() {
	    // we could use the formatter, but this is an easier way to get the minimum string
	    if (!this.isValid) return null;
	    var s = "P";
	    if (this.years !== 0) s += this.years + "Y";
	    if (this.months !== 0 || this.quarters !== 0) s += this.months + this.quarters * 3 + "M";
	    if (this.weeks !== 0) s += this.weeks + "W";
	    if (this.days !== 0) s += this.days + "D";
	    if (this.hours !== 0 || this.minutes !== 0 || this.seconds !== 0 || this.milliseconds !== 0) s += "T";
	    if (this.hours !== 0) s += this.hours + "H";
	    if (this.minutes !== 0) s += this.minutes + "M";
	    if (this.seconds !== 0 || this.milliseconds !== 0) // this will handle "floating point madness" by removing extra decimal places
	      // https://stackoverflow.com/questions/588004/is-floating-point-math-broken
	      s += roundTo$1(this.seconds + this.milliseconds / 1000, 3) + "S";
	    if (s === "P") s += "T0S";
	    return s;
	  }
	  /**
	   * Returns an ISO 8601-compliant string representation of this Duration, formatted as a time of day.
	   * Note that this will return null if the duration is invalid, negative, or equal to or greater than 24 hours.
	   * @see https://en.wikipedia.org/wiki/ISO_8601#Times
	   * @param {Object} opts - options
	   * @param {boolean} [opts.suppressMilliseconds=false] - exclude milliseconds from the format if they're 0
	   * @param {boolean} [opts.suppressSeconds=false] - exclude seconds from the format if they're 0
	   * @param {boolean} [opts.includePrefix=false] - include the `T` prefix
	   * @param {string} [opts.format='extended'] - choose between the basic and extended format
	   * @example Duration.fromObject({ hours: 11 }).toISOTime() //=> '11:00:00.000'
	   * @example Duration.fromObject({ hours: 11 }).toISOTime({ suppressMilliseconds: true }) //=> '11:00:00'
	   * @example Duration.fromObject({ hours: 11 }).toISOTime({ suppressSeconds: true }) //=> '11:00'
	   * @example Duration.fromObject({ hours: 11 }).toISOTime({ includePrefix: true }) //=> 'T11:00:00.000'
	   * @example Duration.fromObject({ hours: 11 }).toISOTime({ format: 'basic' }) //=> '110000.000'
	   * @return {string}
	   */
	  ;

	  _proto.toISOTime = function toISOTime(opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    if (!this.isValid) return null;
	    var millis = this.toMillis();
	    if (millis < 0 || millis >= 86400000) return null;
	    opts = _extends({
	      suppressMilliseconds: false,
	      suppressSeconds: false,
	      includePrefix: false,
	      format: "extended"
	    }, opts);
	    var value = this.shiftTo("hours", "minutes", "seconds", "milliseconds");
	    var fmt = opts.format === "basic" ? "hhmm" : "hh:mm";

	    if (!opts.suppressSeconds || value.seconds !== 0 || value.milliseconds !== 0) {
	      fmt += opts.format === "basic" ? "ss" : ":ss";

	      if (!opts.suppressMilliseconds || value.milliseconds !== 0) {
	        fmt += ".SSS";
	      }
	    }

	    var str = value.toFormat(fmt);

	    if (opts.includePrefix) {
	      str = "T" + str;
	    }

	    return str;
	  }
	  /**
	   * Returns an ISO 8601 representation of this Duration appropriate for use in JSON.
	   * @return {string}
	   */
	  ;

	  _proto.toJSON = function toJSON() {
	    return this.toISO();
	  }
	  /**
	   * Returns an ISO 8601 representation of this Duration appropriate for use in debugging.
	   * @return {string}
	   */
	  ;

	  _proto.toString = function toString() {
	    return this.toISO();
	  }
	  /**
	   * Returns an milliseconds value of this Duration.
	   * @return {number}
	   */
	  ;

	  _proto.toMillis = function toMillis() {
	    return this.as("milliseconds");
	  }
	  /**
	   * Returns an milliseconds value of this Duration. Alias of {@link toMillis}
	   * @return {number}
	   */
	  ;

	  _proto.valueOf = function valueOf() {
	    return this.toMillis();
	  }
	  /**
	   * Make this Duration longer by the specified amount. Return a newly-constructed Duration.
	   * @param {Duration|Object|number} duration - The amount to add. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
	   * @return {Duration}
	   */
	  ;

	  _proto.plus = function plus(duration) {
	    if (!this.isValid) return this;
	    var dur = friendlyDuration(duration),
	        result = {};

	    for (var _iterator = _createForOfIteratorHelperLoose(orderedUnits$1), _step; !(_step = _iterator()).done;) {
	      var k = _step.value;

	      if (hasOwnProperty$3(dur.values, k) || hasOwnProperty$3(this.values, k)) {
	        result[k] = dur.get(k) + this.get(k);
	      }
	    }

	    return clone$1(this, {
	      values: result
	    }, true);
	  }
	  /**
	   * Make this Duration shorter by the specified amount. Return a newly-constructed Duration.
	   * @param {Duration|Object|number} duration - The amount to subtract. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
	   * @return {Duration}
	   */
	  ;

	  _proto.minus = function minus(duration) {
	    if (!this.isValid) return this;
	    var dur = friendlyDuration(duration);
	    return this.plus(dur.negate());
	  }
	  /**
	   * Scale this Duration by the specified amount. Return a newly-constructed Duration.
	   * @param {function} fn - The function to apply to each unit. Arity is 1 or 2: the value of the unit and, optionally, the unit name. Must return a number.
	   * @example Duration.fromObject({ hours: 1, minutes: 30 }).mapUnits(x => x * 2) //=> { hours: 2, minutes: 60 }
	   * @example Duration.fromObject({ hours: 1, minutes: 30 }).mapUnits((x, u) => u === "hour" ? x * 2 : x) //=> { hours: 2, minutes: 30 }
	   * @return {Duration}
	   */
	  ;

	  _proto.mapUnits = function mapUnits(fn) {
	    if (!this.isValid) return this;
	    var result = {};

	    for (var _i = 0, _Object$keys = Object.keys(this.values); _i < _Object$keys.length; _i++) {
	      var k = _Object$keys[_i];
	      result[k] = asNumber(fn(this.values[k], k));
	    }

	    return clone$1(this, {
	      values: result
	    }, true);
	  }
	  /**
	   * Get the value of unit.
	   * @param {string} unit - a unit such as 'minute' or 'day'
	   * @example Duration.fromObject({years: 2, days: 3}).get('years') //=> 2
	   * @example Duration.fromObject({years: 2, days: 3}).get('months') //=> 0
	   * @example Duration.fromObject({years: 2, days: 3}).get('days') //=> 3
	   * @return {number}
	   */
	  ;

	  _proto.get = function get(unit) {
	    return this[Duration.normalizeUnit(unit)];
	  }
	  /**
	   * "Set" the values of specified units. Return a newly-constructed Duration.
	   * @param {Object} values - a mapping of units to numbers
	   * @example dur.set({ years: 2017 })
	   * @example dur.set({ hours: 8, minutes: 30 })
	   * @return {Duration}
	   */
	  ;

	  _proto.set = function set(values) {
	    if (!this.isValid) return this;

	    var mixed = _extends({}, this.values, normalizeObject(values, Duration.normalizeUnit));

	    return clone$1(this, {
	      values: mixed
	    });
	  }
	  /**
	   * "Set" the locale and/or numberingSystem.  Returns a newly-constructed Duration.
	   * @example dur.reconfigure({ locale: 'en-GB' })
	   * @return {Duration}
	   */
	  ;

	  _proto.reconfigure = function reconfigure(_temp) {
	    var _ref = _temp === void 0 ? {} : _temp,
	        locale = _ref.locale,
	        numberingSystem = _ref.numberingSystem,
	        conversionAccuracy = _ref.conversionAccuracy;

	    var loc = this.loc.clone({
	      locale: locale,
	      numberingSystem: numberingSystem
	    }),
	        opts = {
	      loc: loc
	    };

	    if (conversionAccuracy) {
	      opts.conversionAccuracy = conversionAccuracy;
	    }

	    return clone$1(this, opts);
	  }
	  /**
	   * Return the length of the duration in the specified unit.
	   * @param {string} unit - a unit such as 'minutes' or 'days'
	   * @example Duration.fromObject({years: 1}).as('days') //=> 365
	   * @example Duration.fromObject({years: 1}).as('months') //=> 12
	   * @example Duration.fromObject({hours: 60}).as('days') //=> 2.5
	   * @return {number}
	   */
	  ;

	  _proto.as = function as(unit) {
	    return this.isValid ? this.shiftTo(unit).get(unit) : NaN;
	  }
	  /**
	   * Reduce this Duration to its canonical representation in its current units.
	   * @example Duration.fromObject({ years: 2, days: 5000 }).normalize().toObject() //=> { years: 15, days: 255 }
	   * @example Duration.fromObject({ hours: 12, minutes: -45 }).normalize().toObject() //=> { hours: 11, minutes: 15 }
	   * @return {Duration}
	   */
	  ;

	  _proto.normalize = function normalize() {
	    if (!this.isValid) return this;
	    var vals = this.toObject();
	    normalizeValues(this.matrix, vals);
	    return clone$1(this, {
	      values: vals
	    }, true);
	  }
	  /**
	   * Convert this Duration into its representation in a different set of units.
	   * @example Duration.fromObject({ hours: 1, seconds: 30 }).shiftTo('minutes', 'milliseconds').toObject() //=> { minutes: 60, milliseconds: 30000 }
	   * @return {Duration}
	   */
	  ;

	  _proto.shiftTo = function shiftTo() {
	    for (var _len = arguments.length, units = new Array(_len), _key = 0; _key < _len; _key++) {
	      units[_key] = arguments[_key];
	    }

	    if (!this.isValid) return this;

	    if (units.length === 0) {
	      return this;
	    }

	    units = units.map(function (u) {
	      return Duration.normalizeUnit(u);
	    });
	    var built = {},
	        accumulated = {},
	        vals = this.toObject();
	    var lastUnit;

	    for (var _iterator2 = _createForOfIteratorHelperLoose(orderedUnits$1), _step2; !(_step2 = _iterator2()).done;) {
	      var k = _step2.value;

	      if (units.indexOf(k) >= 0) {
	        lastUnit = k;
	        var own = 0; // anything we haven't boiled down yet should get boiled to this unit

	        for (var ak in accumulated) {
	          own += this.matrix[ak][k] * accumulated[ak];
	          accumulated[ak] = 0;
	        } // plus anything that's already in this unit


	        if (isNumber(vals[k])) {
	          own += vals[k];
	        }

	        var i = Math.trunc(own);
	        built[k] = i;
	        accumulated[k] = own - i; // we'd like to absorb these fractions in another unit
	        // plus anything further down the chain that should be rolled up in to this

	        for (var down in vals) {
	          if (orderedUnits$1.indexOf(down) > orderedUnits$1.indexOf(k)) {
	            convert$9(this.matrix, vals, down, built, k);
	          }
	        } // otherwise, keep it in the wings to boil it later

	      } else if (isNumber(vals[k])) {
	        accumulated[k] = vals[k];
	      }
	    } // anything leftover becomes the decimal for the last unit
	    // lastUnit must be defined since units is not empty


	    for (var key in accumulated) {
	      if (accumulated[key] !== 0) {
	        built[lastUnit] += key === lastUnit ? accumulated[key] : accumulated[key] / this.matrix[lastUnit][key];
	      }
	    }

	    return clone$1(this, {
	      values: built
	    }, true).normalize();
	  }
	  /**
	   * Return the negative of this Duration.
	   * @example Duration.fromObject({ hours: 1, seconds: 30 }).negate().toObject() //=> { hours: -1, seconds: -30 }
	   * @return {Duration}
	   */
	  ;

	  _proto.negate = function negate() {
	    if (!this.isValid) return this;
	    var negated = {};

	    for (var _i2 = 0, _Object$keys2 = Object.keys(this.values); _i2 < _Object$keys2.length; _i2++) {
	      var k = _Object$keys2[_i2];
	      negated[k] = -this.values[k];
	    }

	    return clone$1(this, {
	      values: negated
	    }, true);
	  }
	  /**
	   * Get the years.
	   * @type {number}
	   */
	  ;

	  /**
	   * Equality check
	   * Two Durations are equal iff they have the same units and the same values for each unit.
	   * @param {Duration} other
	   * @return {boolean}
	   */
	  _proto.equals = function equals(other) {
	    if (!this.isValid || !other.isValid) {
	      return false;
	    }

	    if (!this.loc.equals(other.loc)) {
	      return false;
	    }

	    function eq(v1, v2) {
	      // Consider 0 and undefined as equal
	      if (v1 === undefined || v1 === 0) return v2 === undefined || v2 === 0;
	      return v1 === v2;
	    }

	    for (var _iterator3 = _createForOfIteratorHelperLoose(orderedUnits$1), _step3; !(_step3 = _iterator3()).done;) {
	      var u = _step3.value;

	      if (!eq(this.values[u], other.values[u])) {
	        return false;
	      }
	    }

	    return true;
	  };

	  _createClass(Duration, [{
	    key: "locale",
	    get: function get() {
	      return this.isValid ? this.loc.locale : null;
	    }
	    /**
	     * Get the numbering system of a Duration, such 'beng'. The numbering system is used when formatting the Duration
	     *
	     * @type {string}
	     */

	  }, {
	    key: "numberingSystem",
	    get: function get() {
	      return this.isValid ? this.loc.numberingSystem : null;
	    }
	  }, {
	    key: "years",
	    get: function get() {
	      return this.isValid ? this.values.years || 0 : NaN;
	    }
	    /**
	     * Get the quarters.
	     * @type {number}
	     */

	  }, {
	    key: "quarters",
	    get: function get() {
	      return this.isValid ? this.values.quarters || 0 : NaN;
	    }
	    /**
	     * Get the months.
	     * @type {number}
	     */

	  }, {
	    key: "months",
	    get: function get() {
	      return this.isValid ? this.values.months || 0 : NaN;
	    }
	    /**
	     * Get the weeks
	     * @type {number}
	     */

	  }, {
	    key: "weeks",
	    get: function get() {
	      return this.isValid ? this.values.weeks || 0 : NaN;
	    }
	    /**
	     * Get the days.
	     * @type {number}
	     */

	  }, {
	    key: "days",
	    get: function get() {
	      return this.isValid ? this.values.days || 0 : NaN;
	    }
	    /**
	     * Get the hours.
	     * @type {number}
	     */

	  }, {
	    key: "hours",
	    get: function get() {
	      return this.isValid ? this.values.hours || 0 : NaN;
	    }
	    /**
	     * Get the minutes.
	     * @type {number}
	     */

	  }, {
	    key: "minutes",
	    get: function get() {
	      return this.isValid ? this.values.minutes || 0 : NaN;
	    }
	    /**
	     * Get the seconds.
	     * @return {number}
	     */

	  }, {
	    key: "seconds",
	    get: function get() {
	      return this.isValid ? this.values.seconds || 0 : NaN;
	    }
	    /**
	     * Get the milliseconds.
	     * @return {number}
	     */

	  }, {
	    key: "milliseconds",
	    get: function get() {
	      return this.isValid ? this.values.milliseconds || 0 : NaN;
	    }
	    /**
	     * Returns whether the Duration is invalid. Invalid durations are returned by diff operations
	     * on invalid DateTimes or Intervals.
	     * @return {boolean}
	     */

	  }, {
	    key: "isValid",
	    get: function get() {
	      return this.invalid === null;
	    }
	    /**
	     * Returns an error code if this Duration became invalid, or null if the Duration is valid
	     * @return {string}
	     */

	  }, {
	    key: "invalidReason",
	    get: function get() {
	      return this.invalid ? this.invalid.reason : null;
	    }
	    /**
	     * Returns an explanation of why this Duration became invalid, or null if the Duration is valid
	     * @type {string}
	     */

	  }, {
	    key: "invalidExplanation",
	    get: function get() {
	      return this.invalid ? this.invalid.explanation : null;
	    }
	  }]);

	  return Duration;
	}();
	function friendlyDuration(durationish) {
	  if (isNumber(durationish)) {
	    return Duration.fromMillis(durationish);
	  } else if (Duration.isDuration(durationish)) {
	    return durationish;
	  } else if (typeof durationish === "object") {
	    return Duration.fromObject(durationish);
	  } else {
	    throw new InvalidArgumentError("Unknown duration argument " + durationish + " of type " + typeof durationish);
	  }
	}

	var INVALID$1 = "Invalid Interval"; // checks if the start is equal to or before the end

	function validateStartEnd(start, end) {
	  if (!start || !start.isValid) {
	    return Interval.invalid("missing or invalid start");
	  } else if (!end || !end.isValid) {
	    return Interval.invalid("missing or invalid end");
	  } else if (end < start) {
	    return Interval.invalid("end before start", "The end of an interval must be after its start, but you had start=" + start.toISO() + " and end=" + end.toISO());
	  } else {
	    return null;
	  }
	}
	/**
	 * An Interval object represents a half-open interval of time, where each endpoint is a {@link DateTime}. Conceptually, it's a container for those two endpoints, accompanied by methods for creating, parsing, interrogating, comparing, transforming, and formatting them.
	 *
	 * Here is a brief overview of the most commonly used methods and getters in Interval:
	 *
	 * * **Creation** To create an Interval, use {@link Interval.fromDateTimes}, {@link Interval.after}, {@link Interval.before}, or {@link Interval.fromISO}.
	 * * **Accessors** Use {@link Interval#start} and {@link Interval#end} to get the start and end.
	 * * **Interrogation** To analyze the Interval, use {@link Interval#count}, {@link Interval#length}, {@link Interval#hasSame}, {@link Interval#contains}, {@link Interval#isAfter}, or {@link Interval#isBefore}.
	 * * **Transformation** To create other Intervals out of this one, use {@link Interval#set}, {@link Interval#splitAt}, {@link Interval#splitBy}, {@link Interval#divideEqually}, {@link Interval#merge}, {@link Interval#xor}, {@link Interval#union}, {@link Interval#intersection}, or {@link Interval#difference}.
	 * * **Comparison** To compare this Interval to another one, use {@link Interval#equals}, {@link Interval#overlaps}, {@link Interval#abutsStart}, {@link Interval#abutsEnd}, {@link Interval#engulfs}
	 * * **Output** To convert the Interval into other representations, see {@link Interval#toString}, {@link Interval#toISO}, {@link Interval#toISODate}, {@link Interval#toISOTime}, {@link Interval#toFormat}, and {@link Interval#toDuration}.
	 */


	var Interval = /*#__PURE__*/function () {
	  /**
	   * @private
	   */
	  function Interval(config) {
	    /**
	     * @access private
	     */
	    this.s = config.start;
	    /**
	     * @access private
	     */

	    this.e = config.end;
	    /**
	     * @access private
	     */

	    this.invalid = config.invalid || null;
	    /**
	     * @access private
	     */

	    this.isLuxonInterval = true;
	  }
	  /**
	   * Create an invalid Interval.
	   * @param {string} reason - simple string of why this Interval is invalid. Should not contain parameters or anything else data-dependent
	   * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information
	   * @return {Interval}
	   */


	  Interval.invalid = function invalid(reason, explanation) {
	    if (explanation === void 0) {
	      explanation = null;
	    }

	    if (!reason) {
	      throw new InvalidArgumentError("need to specify a reason the Interval is invalid");
	    }

	    var invalid = reason instanceof Invalid ? reason : new Invalid(reason, explanation);

	    if (Settings.throwOnInvalid) {
	      throw new InvalidIntervalError(invalid);
	    } else {
	      return new Interval({
	        invalid: invalid
	      });
	    }
	  }
	  /**
	   * Create an Interval from a start DateTime and an end DateTime. Inclusive of the start but not the end.
	   * @param {DateTime|Date|Object} start
	   * @param {DateTime|Date|Object} end
	   * @return {Interval}
	   */
	  ;

	  Interval.fromDateTimes = function fromDateTimes(start, end) {
	    var builtStart = friendlyDateTime(start),
	        builtEnd = friendlyDateTime(end);
	    var validateError = validateStartEnd(builtStart, builtEnd);

	    if (validateError == null) {
	      return new Interval({
	        start: builtStart,
	        end: builtEnd
	      });
	    } else {
	      return validateError;
	    }
	  }
	  /**
	   * Create an Interval from a start DateTime and a Duration to extend to.
	   * @param {DateTime|Date|Object} start
	   * @param {Duration|Object|number} duration - the length of the Interval.
	   * @return {Interval}
	   */
	  ;

	  Interval.after = function after(start, duration) {
	    var dur = friendlyDuration(duration),
	        dt = friendlyDateTime(start);
	    return Interval.fromDateTimes(dt, dt.plus(dur));
	  }
	  /**
	   * Create an Interval from an end DateTime and a Duration to extend backwards to.
	   * @param {DateTime|Date|Object} end
	   * @param {Duration|Object|number} duration - the length of the Interval.
	   * @return {Interval}
	   */
	  ;

	  Interval.before = function before(end, duration) {
	    var dur = friendlyDuration(duration),
	        dt = friendlyDateTime(end);
	    return Interval.fromDateTimes(dt.minus(dur), dt);
	  }
	  /**
	   * Create an Interval from an ISO 8601 string.
	   * Accepts `<start>/<end>`, `<start>/<duration>`, and `<duration>/<end>` formats.
	   * @param {string} text - the ISO string to parse
	   * @param {Object} [opts] - options to pass {@link DateTime.fromISO} and optionally {@link Duration.fromISO}
	   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
	   * @return {Interval}
	   */
	  ;

	  Interval.fromISO = function fromISO(text, opts) {
	    var _split = (text || "").split("/", 2),
	        s = _split[0],
	        e = _split[1];

	    if (s && e) {
	      var start, startIsValid;

	      try {
	        start = DateTime.fromISO(s, opts);
	        startIsValid = start.isValid;
	      } catch (e) {
	        startIsValid = false;
	      }

	      var end, endIsValid;

	      try {
	        end = DateTime.fromISO(e, opts);
	        endIsValid = end.isValid;
	      } catch (e) {
	        endIsValid = false;
	      }

	      if (startIsValid && endIsValid) {
	        return Interval.fromDateTimes(start, end);
	      }

	      if (startIsValid) {
	        var dur = Duration.fromISO(e, opts);

	        if (dur.isValid) {
	          return Interval.after(start, dur);
	        }
	      } else if (endIsValid) {
	        var _dur = Duration.fromISO(s, opts);

	        if (_dur.isValid) {
	          return Interval.before(end, _dur);
	        }
	      }
	    }

	    return Interval.invalid("unparsable", "the input \"" + text + "\" can't be parsed as ISO 8601");
	  }
	  /**
	   * Check if an object is an Interval. Works across context boundaries
	   * @param {object} o
	   * @return {boolean}
	   */
	  ;

	  Interval.isInterval = function isInterval(o) {
	    return o && o.isLuxonInterval || false;
	  }
	  /**
	   * Returns the start of the Interval
	   * @type {DateTime}
	   */
	  ;

	  var _proto = Interval.prototype;

	  /**
	   * Returns the length of the Interval in the specified unit.
	   * @param {string} unit - the unit (such as 'hours' or 'days') to return the length in.
	   * @return {number}
	   */
	  _proto.length = function length(unit) {
	    if (unit === void 0) {
	      unit = "milliseconds";
	    }

	    return this.isValid ? this.toDuration.apply(this, [unit]).get(unit) : NaN;
	  }
	  /**
	   * Returns the count of minutes, hours, days, months, or years included in the Interval, even in part.
	   * Unlike {@link Interval#length} this counts sections of the calendar, not periods of time, e.g. specifying 'day'
	   * asks 'what dates are included in this interval?', not 'how many days long is this interval?'
	   * @param {string} [unit='milliseconds'] - the unit of time to count.
	   * @return {number}
	   */
	  ;

	  _proto.count = function count(unit) {
	    if (unit === void 0) {
	      unit = "milliseconds";
	    }

	    if (!this.isValid) return NaN;
	    var start = this.start.startOf(unit),
	        end = this.end.startOf(unit);
	    return Math.floor(end.diff(start, unit).get(unit)) + 1;
	  }
	  /**
	   * Returns whether this Interval's start and end are both in the same unit of time
	   * @param {string} unit - the unit of time to check sameness on
	   * @return {boolean}
	   */
	  ;

	  _proto.hasSame = function hasSame(unit) {
	    return this.isValid ? this.isEmpty() || this.e.minus(1).hasSame(this.s, unit) : false;
	  }
	  /**
	   * Return whether this Interval has the same start and end DateTimes.
	   * @return {boolean}
	   */
	  ;

	  _proto.isEmpty = function isEmpty() {
	    return this.s.valueOf() === this.e.valueOf();
	  }
	  /**
	   * Return whether this Interval's start is after the specified DateTime.
	   * @param {DateTime} dateTime
	   * @return {boolean}
	   */
	  ;

	  _proto.isAfter = function isAfter(dateTime) {
	    if (!this.isValid) return false;
	    return this.s > dateTime;
	  }
	  /**
	   * Return whether this Interval's end is before the specified DateTime.
	   * @param {DateTime} dateTime
	   * @return {boolean}
	   */
	  ;

	  _proto.isBefore = function isBefore(dateTime) {
	    if (!this.isValid) return false;
	    return this.e <= dateTime;
	  }
	  /**
	   * Return whether this Interval contains the specified DateTime.
	   * @param {DateTime} dateTime
	   * @return {boolean}
	   */
	  ;

	  _proto.contains = function contains(dateTime) {
	    if (!this.isValid) return false;
	    return this.s <= dateTime && this.e > dateTime;
	  }
	  /**
	   * "Sets" the start and/or end dates. Returns a newly-constructed Interval.
	   * @param {Object} values - the values to set
	   * @param {DateTime} values.start - the starting DateTime
	   * @param {DateTime} values.end - the ending DateTime
	   * @return {Interval}
	   */
	  ;

	  _proto.set = function set(_temp) {
	    var _ref = _temp === void 0 ? {} : _temp,
	        start = _ref.start,
	        end = _ref.end;

	    if (!this.isValid) return this;
	    return Interval.fromDateTimes(start || this.s, end || this.e);
	  }
	  /**
	   * Split this Interval at each of the specified DateTimes
	   * @param {...DateTime} dateTimes - the unit of time to count.
	   * @return {Array}
	   */
	  ;

	  _proto.splitAt = function splitAt() {
	    var _this = this;

	    if (!this.isValid) return [];

	    for (var _len = arguments.length, dateTimes = new Array(_len), _key = 0; _key < _len; _key++) {
	      dateTimes[_key] = arguments[_key];
	    }

	    var sorted = dateTimes.map(friendlyDateTime).filter(function (d) {
	      return _this.contains(d);
	    }).sort(),
	        results = [];
	    var s = this.s,
	        i = 0;

	    while (s < this.e) {
	      var added = sorted[i] || this.e,
	          next = +added > +this.e ? this.e : added;
	      results.push(Interval.fromDateTimes(s, next));
	      s = next;
	      i += 1;
	    }

	    return results;
	  }
	  /**
	   * Split this Interval into smaller Intervals, each of the specified length.
	   * Left over time is grouped into a smaller interval
	   * @param {Duration|Object|number} duration - The length of each resulting interval.
	   * @return {Array}
	   */
	  ;

	  _proto.splitBy = function splitBy(duration) {
	    var dur = friendlyDuration(duration);

	    if (!this.isValid || !dur.isValid || dur.as("milliseconds") === 0) {
	      return [];
	    }

	    var s = this.s,
	        idx = 1,
	        next;
	    var results = [];

	    while (s < this.e) {
	      var added = this.start.plus(dur.mapUnits(function (x) {
	        return x * idx;
	      }));
	      next = +added > +this.e ? this.e : added;
	      results.push(Interval.fromDateTimes(s, next));
	      s = next;
	      idx += 1;
	    }

	    return results;
	  }
	  /**
	   * Split this Interval into the specified number of smaller intervals.
	   * @param {number} numberOfParts - The number of Intervals to divide the Interval into.
	   * @return {Array}
	   */
	  ;

	  _proto.divideEqually = function divideEqually(numberOfParts) {
	    if (!this.isValid) return [];
	    return this.splitBy(this.length() / numberOfParts).slice(0, numberOfParts);
	  }
	  /**
	   * Return whether this Interval overlaps with the specified Interval
	   * @param {Interval} other
	   * @return {boolean}
	   */
	  ;

	  _proto.overlaps = function overlaps(other) {
	    return this.e > other.s && this.s < other.e;
	  }
	  /**
	   * Return whether this Interval's end is adjacent to the specified Interval's start.
	   * @param {Interval} other
	   * @return {boolean}
	   */
	  ;

	  _proto.abutsStart = function abutsStart(other) {
	    if (!this.isValid) return false;
	    return +this.e === +other.s;
	  }
	  /**
	   * Return whether this Interval's start is adjacent to the specified Interval's end.
	   * @param {Interval} other
	   * @return {boolean}
	   */
	  ;

	  _proto.abutsEnd = function abutsEnd(other) {
	    if (!this.isValid) return false;
	    return +other.e === +this.s;
	  }
	  /**
	   * Return whether this Interval engulfs the start and end of the specified Interval.
	   * @param {Interval} other
	   * @return {boolean}
	   */
	  ;

	  _proto.engulfs = function engulfs(other) {
	    if (!this.isValid) return false;
	    return this.s <= other.s && this.e >= other.e;
	  }
	  /**
	   * Return whether this Interval has the same start and end as the specified Interval.
	   * @param {Interval} other
	   * @return {boolean}
	   */
	  ;

	  _proto.equals = function equals(other) {
	    if (!this.isValid || !other.isValid) {
	      return false;
	    }

	    return this.s.equals(other.s) && this.e.equals(other.e);
	  }
	  /**
	   * Return an Interval representing the intersection of this Interval and the specified Interval.
	   * Specifically, the resulting Interval has the maximum start time and the minimum end time of the two Intervals.
	   * Returns null if the intersection is empty, meaning, the intervals don't intersect.
	   * @param {Interval} other
	   * @return {Interval}
	   */
	  ;

	  _proto.intersection = function intersection(other) {
	    if (!this.isValid) return this;
	    var s = this.s > other.s ? this.s : other.s,
	        e = this.e < other.e ? this.e : other.e;

	    if (s >= e) {
	      return null;
	    } else {
	      return Interval.fromDateTimes(s, e);
	    }
	  }
	  /**
	   * Return an Interval representing the union of this Interval and the specified Interval.
	   * Specifically, the resulting Interval has the minimum start time and the maximum end time of the two Intervals.
	   * @param {Interval} other
	   * @return {Interval}
	   */
	  ;

	  _proto.union = function union(other) {
	    if (!this.isValid) return this;
	    var s = this.s < other.s ? this.s : other.s,
	        e = this.e > other.e ? this.e : other.e;
	    return Interval.fromDateTimes(s, e);
	  }
	  /**
	   * Merge an array of Intervals into a equivalent minimal set of Intervals.
	   * Combines overlapping and adjacent Intervals.
	   * @param {Array} intervals
	   * @return {Array}
	   */
	  ;

	  Interval.merge = function merge(intervals) {
	    var _intervals$sort$reduc = intervals.sort(function (a, b) {
	      return a.s - b.s;
	    }).reduce(function (_ref2, item) {
	      var sofar = _ref2[0],
	          current = _ref2[1];

	      if (!current) {
	        return [sofar, item];
	      } else if (current.overlaps(item) || current.abutsStart(item)) {
	        return [sofar, current.union(item)];
	      } else {
	        return [sofar.concat([current]), item];
	      }
	    }, [[], null]),
	        found = _intervals$sort$reduc[0],
	        final = _intervals$sort$reduc[1];

	    if (final) {
	      found.push(final);
	    }

	    return found;
	  }
	  /**
	   * Return an array of Intervals representing the spans of time that only appear in one of the specified Intervals.
	   * @param {Array} intervals
	   * @return {Array}
	   */
	  ;

	  Interval.xor = function xor(intervals) {
	    var _Array$prototype;

	    var start = null,
	        currentCount = 0;

	    var results = [],
	        ends = intervals.map(function (i) {
	      return [{
	        time: i.s,
	        type: "s"
	      }, {
	        time: i.e,
	        type: "e"
	      }];
	    }),
	        flattened = (_Array$prototype = Array.prototype).concat.apply(_Array$prototype, ends),
	        arr = flattened.sort(function (a, b) {
	      return a.time - b.time;
	    });

	    for (var _iterator = _createForOfIteratorHelperLoose(arr), _step; !(_step = _iterator()).done;) {
	      var i = _step.value;
	      currentCount += i.type === "s" ? 1 : -1;

	      if (currentCount === 1) {
	        start = i.time;
	      } else {
	        if (start && +start !== +i.time) {
	          results.push(Interval.fromDateTimes(start, i.time));
	        }

	        start = null;
	      }
	    }

	    return Interval.merge(results);
	  }
	  /**
	   * Return an Interval representing the span of time in this Interval that doesn't overlap with any of the specified Intervals.
	   * @param {...Interval} intervals
	   * @return {Array}
	   */
	  ;

	  _proto.difference = function difference() {
	    var _this2 = this;

	    for (var _len2 = arguments.length, intervals = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
	      intervals[_key2] = arguments[_key2];
	    }

	    return Interval.xor([this].concat(intervals)).map(function (i) {
	      return _this2.intersection(i);
	    }).filter(function (i) {
	      return i && !i.isEmpty();
	    });
	  }
	  /**
	   * Returns a string representation of this Interval appropriate for debugging.
	   * @return {string}
	   */
	  ;

	  _proto.toString = function toString() {
	    if (!this.isValid) return INVALID$1;
	    return "[" + this.s.toISO() + " \u2013 " + this.e.toISO() + ")";
	  }
	  /**
	   * Returns an ISO 8601-compliant string representation of this Interval.
	   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
	   * @param {Object} opts - The same options as {@link DateTime#toISO}
	   * @return {string}
	   */
	  ;

	  _proto.toISO = function toISO(opts) {
	    if (!this.isValid) return INVALID$1;
	    return this.s.toISO(opts) + "/" + this.e.toISO(opts);
	  }
	  /**
	   * Returns an ISO 8601-compliant string representation of date of this Interval.
	   * The time components are ignored.
	   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
	   * @return {string}
	   */
	  ;

	  _proto.toISODate = function toISODate() {
	    if (!this.isValid) return INVALID$1;
	    return this.s.toISODate() + "/" + this.e.toISODate();
	  }
	  /**
	   * Returns an ISO 8601-compliant string representation of time of this Interval.
	   * The date components are ignored.
	   * @see https://en.wikipedia.org/wiki/ISO_8601#Time_intervals
	   * @param {Object} opts - The same options as {@link DateTime.toISO}
	   * @return {string}
	   */
	  ;

	  _proto.toISOTime = function toISOTime(opts) {
	    if (!this.isValid) return INVALID$1;
	    return this.s.toISOTime(opts) + "/" + this.e.toISOTime(opts);
	  }
	  /**
	   * Returns a string representation of this Interval formatted according to the specified format string.
	   * @param {string} dateFormat - the format string. This string formats the start and end time. See {@link DateTime.toFormat} for details.
	   * @param {Object} opts - options
	   * @param {string} [opts.separator =  ' – '] - a separator to place between the start and end representations
	   * @return {string}
	   */
	  ;

	  _proto.toFormat = function toFormat(dateFormat, _temp2) {
	    var _ref3 = _temp2 === void 0 ? {} : _temp2,
	        _ref3$separator = _ref3.separator,
	        separator = _ref3$separator === void 0 ? " – " : _ref3$separator;

	    if (!this.isValid) return INVALID$1;
	    return "" + this.s.toFormat(dateFormat) + separator + this.e.toFormat(dateFormat);
	  }
	  /**
	   * Return a Duration representing the time spanned by this interval.
	   * @param {string|string[]} [unit=['milliseconds']] - the unit or units (such as 'hours' or 'days') to include in the duration.
	   * @param {Object} opts - options that affect the creation of the Duration
	   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
	   * @example Interval.fromDateTimes(dt1, dt2).toDuration().toObject() //=> { milliseconds: 88489257 }
	   * @example Interval.fromDateTimes(dt1, dt2).toDuration('days').toObject() //=> { days: 1.0241812152777778 }
	   * @example Interval.fromDateTimes(dt1, dt2).toDuration(['hours', 'minutes']).toObject() //=> { hours: 24, minutes: 34.82095 }
	   * @example Interval.fromDateTimes(dt1, dt2).toDuration(['hours', 'minutes', 'seconds']).toObject() //=> { hours: 24, minutes: 34, seconds: 49.257 }
	   * @example Interval.fromDateTimes(dt1, dt2).toDuration('seconds').toObject() //=> { seconds: 88489.257 }
	   * @return {Duration}
	   */
	  ;

	  _proto.toDuration = function toDuration(unit, opts) {
	    if (!this.isValid) {
	      return Duration.invalid(this.invalidReason);
	    }

	    return this.e.diff(this.s, unit, opts);
	  }
	  /**
	   * Run mapFn on the interval start and end, returning a new Interval from the resulting DateTimes
	   * @param {function} mapFn
	   * @return {Interval}
	   * @example Interval.fromDateTimes(dt1, dt2).mapEndpoints(endpoint => endpoint.toUTC())
	   * @example Interval.fromDateTimes(dt1, dt2).mapEndpoints(endpoint => endpoint.plus({ hours: 2 }))
	   */
	  ;

	  _proto.mapEndpoints = function mapEndpoints(mapFn) {
	    return Interval.fromDateTimes(mapFn(this.s), mapFn(this.e));
	  };

	  _createClass(Interval, [{
	    key: "start",
	    get: function get() {
	      return this.isValid ? this.s : null;
	    }
	    /**
	     * Returns the end of the Interval
	     * @type {DateTime}
	     */

	  }, {
	    key: "end",
	    get: function get() {
	      return this.isValid ? this.e : null;
	    }
	    /**
	     * Returns whether this Interval's end is at least its start, meaning that the Interval isn't 'backwards'.
	     * @type {boolean}
	     */

	  }, {
	    key: "isValid",
	    get: function get() {
	      return this.invalidReason === null;
	    }
	    /**
	     * Returns an error code if this Interval is invalid, or null if the Interval is valid
	     * @type {string}
	     */

	  }, {
	    key: "invalidReason",
	    get: function get() {
	      return this.invalid ? this.invalid.reason : null;
	    }
	    /**
	     * Returns an explanation of why this Interval became invalid, or null if the Interval is valid
	     * @type {string}
	     */

	  }, {
	    key: "invalidExplanation",
	    get: function get() {
	      return this.invalid ? this.invalid.explanation : null;
	    }
	  }]);

	  return Interval;
	}();

	/**
	 * The Info class contains static methods for retrieving general time and date related data. For example, it has methods for finding out if a time zone has a DST, for listing the months in any supported locale, and for discovering which of Luxon features are available in the current environment.
	 */

	var Info$1 = /*#__PURE__*/function () {
	  function Info() {}

	  /**
	   * Return whether the specified zone contains a DST.
	   * @param {string|Zone} [zone='local'] - Zone to check. Defaults to the environment's local zone.
	   * @return {boolean}
	   */
	  Info.hasDST = function hasDST(zone) {
	    if (zone === void 0) {
	      zone = Settings.defaultZone;
	    }

	    var proto = DateTime.now().setZone(zone).set({
	      month: 12
	    });
	    return !zone.isUniversal && proto.offset !== proto.set({
	      month: 6
	    }).offset;
	  }
	  /**
	   * Return whether the specified zone is a valid IANA specifier.
	   * @param {string} zone - Zone to check
	   * @return {boolean}
	   */
	  ;

	  Info.isValidIANAZone = function isValidIANAZone(zone) {
	    return IANAZone.isValidSpecifier(zone) && IANAZone.isValidZone(zone);
	  }
	  /**
	   * Converts the input into a {@link Zone} instance.
	   *
	   * * If `input` is already a Zone instance, it is returned unchanged.
	   * * If `input` is a string containing a valid time zone name, a Zone instance
	   *   with that name is returned.
	   * * If `input` is a string that doesn't refer to a known time zone, a Zone
	   *   instance with {@link Zone.isValid} == false is returned.
	   * * If `input is a number, a Zone instance with the specified fixed offset
	   *   in minutes is returned.
	   * * If `input` is `null` or `undefined`, the default zone is returned.
	   * @param {string|Zone|number} [input] - the value to be converted
	   * @return {Zone}
	   */
	  ;

	  Info.normalizeZone = function normalizeZone$1(input) {
	    return normalizeZone(input, Settings.defaultZone);
	  }
	  /**
	   * Return an array of standalone month names.
	   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat
	   * @param {string} [length='long'] - the length of the month representation, such as "numeric", "2-digit", "narrow", "short", "long"
	   * @param {Object} opts - options
	   * @param {string} [opts.locale] - the locale code
	   * @param {string} [opts.numberingSystem=null] - the numbering system
	   * @param {string} [opts.locObj=null] - an existing locale object to use
	   * @param {string} [opts.outputCalendar='gregory'] - the calendar
	   * @example Info.months()[0] //=> 'January'
	   * @example Info.months('short')[0] //=> 'Jan'
	   * @example Info.months('numeric')[0] //=> '1'
	   * @example Info.months('short', { locale: 'fr-CA' } )[0] //=> 'janv.'
	   * @example Info.months('numeric', { locale: 'ar' })[0] //=> '١'
	   * @example Info.months('long', { outputCalendar: 'islamic' })[0] //=> 'Rabiʻ I'
	   * @return {Array}
	   */
	  ;

	  Info.months = function months(length, _temp) {
	    if (length === void 0) {
	      length = "long";
	    }

	    var _ref = _temp === void 0 ? {} : _temp,
	        _ref$locale = _ref.locale,
	        locale = _ref$locale === void 0 ? null : _ref$locale,
	        _ref$numberingSystem = _ref.numberingSystem,
	        numberingSystem = _ref$numberingSystem === void 0 ? null : _ref$numberingSystem,
	        _ref$locObj = _ref.locObj,
	        locObj = _ref$locObj === void 0 ? null : _ref$locObj,
	        _ref$outputCalendar = _ref.outputCalendar,
	        outputCalendar = _ref$outputCalendar === void 0 ? "gregory" : _ref$outputCalendar;

	    return (locObj || Locale.create(locale, numberingSystem, outputCalendar)).months(length);
	  }
	  /**
	   * Return an array of format month names.
	   * Format months differ from standalone months in that they're meant to appear next to the day of the month. In some languages, that
	   * changes the string.
	   * See {@link Info#months}
	   * @param {string} [length='long'] - the length of the month representation, such as "numeric", "2-digit", "narrow", "short", "long"
	   * @param {Object} opts - options
	   * @param {string} [opts.locale] - the locale code
	   * @param {string} [opts.numberingSystem=null] - the numbering system
	   * @param {string} [opts.locObj=null] - an existing locale object to use
	   * @param {string} [opts.outputCalendar='gregory'] - the calendar
	   * @return {Array}
	   */
	  ;

	  Info.monthsFormat = function monthsFormat(length, _temp2) {
	    if (length === void 0) {
	      length = "long";
	    }

	    var _ref2 = _temp2 === void 0 ? {} : _temp2,
	        _ref2$locale = _ref2.locale,
	        locale = _ref2$locale === void 0 ? null : _ref2$locale,
	        _ref2$numberingSystem = _ref2.numberingSystem,
	        numberingSystem = _ref2$numberingSystem === void 0 ? null : _ref2$numberingSystem,
	        _ref2$locObj = _ref2.locObj,
	        locObj = _ref2$locObj === void 0 ? null : _ref2$locObj,
	        _ref2$outputCalendar = _ref2.outputCalendar,
	        outputCalendar = _ref2$outputCalendar === void 0 ? "gregory" : _ref2$outputCalendar;

	    return (locObj || Locale.create(locale, numberingSystem, outputCalendar)).months(length, true);
	  }
	  /**
	   * Return an array of standalone week names.
	   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat
	   * @param {string} [length='long'] - the length of the weekday representation, such as "narrow", "short", "long".
	   * @param {Object} opts - options
	   * @param {string} [opts.locale] - the locale code
	   * @param {string} [opts.numberingSystem=null] - the numbering system
	   * @param {string} [opts.locObj=null] - an existing locale object to use
	   * @example Info.weekdays()[0] //=> 'Monday'
	   * @example Info.weekdays('short')[0] //=> 'Mon'
	   * @example Info.weekdays('short', { locale: 'fr-CA' })[0] //=> 'lun.'
	   * @example Info.weekdays('short', { locale: 'ar' })[0] //=> 'الاثنين'
	   * @return {Array}
	   */
	  ;

	  Info.weekdays = function weekdays(length, _temp3) {
	    if (length === void 0) {
	      length = "long";
	    }

	    var _ref3 = _temp3 === void 0 ? {} : _temp3,
	        _ref3$locale = _ref3.locale,
	        locale = _ref3$locale === void 0 ? null : _ref3$locale,
	        _ref3$numberingSystem = _ref3.numberingSystem,
	        numberingSystem = _ref3$numberingSystem === void 0 ? null : _ref3$numberingSystem,
	        _ref3$locObj = _ref3.locObj,
	        locObj = _ref3$locObj === void 0 ? null : _ref3$locObj;

	    return (locObj || Locale.create(locale, numberingSystem, null)).weekdays(length);
	  }
	  /**
	   * Return an array of format week names.
	   * Format weekdays differ from standalone weekdays in that they're meant to appear next to more date information. In some languages, that
	   * changes the string.
	   * See {@link Info#weekdays}
	   * @param {string} [length='long'] - the length of the month representation, such as "narrow", "short", "long".
	   * @param {Object} opts - options
	   * @param {string} [opts.locale=null] - the locale code
	   * @param {string} [opts.numberingSystem=null] - the numbering system
	   * @param {string} [opts.locObj=null] - an existing locale object to use
	   * @return {Array}
	   */
	  ;

	  Info.weekdaysFormat = function weekdaysFormat(length, _temp4) {
	    if (length === void 0) {
	      length = "long";
	    }

	    var _ref4 = _temp4 === void 0 ? {} : _temp4,
	        _ref4$locale = _ref4.locale,
	        locale = _ref4$locale === void 0 ? null : _ref4$locale,
	        _ref4$numberingSystem = _ref4.numberingSystem,
	        numberingSystem = _ref4$numberingSystem === void 0 ? null : _ref4$numberingSystem,
	        _ref4$locObj = _ref4.locObj,
	        locObj = _ref4$locObj === void 0 ? null : _ref4$locObj;

	    return (locObj || Locale.create(locale, numberingSystem, null)).weekdays(length, true);
	  }
	  /**
	   * Return an array of meridiems.
	   * @param {Object} opts - options
	   * @param {string} [opts.locale] - the locale code
	   * @example Info.meridiems() //=> [ 'AM', 'PM' ]
	   * @example Info.meridiems({ locale: 'my' }) //=> [ 'နံနက်', 'ညနေ' ]
	   * @return {Array}
	   */
	  ;

	  Info.meridiems = function meridiems(_temp5) {
	    var _ref5 = _temp5 === void 0 ? {} : _temp5,
	        _ref5$locale = _ref5.locale,
	        locale = _ref5$locale === void 0 ? null : _ref5$locale;

	    return Locale.create(locale).meridiems();
	  }
	  /**
	   * Return an array of eras, such as ['BC', 'AD']. The locale can be specified, but the calendar system is always Gregorian.
	   * @param {string} [length='short'] - the length of the era representation, such as "short" or "long".
	   * @param {Object} opts - options
	   * @param {string} [opts.locale] - the locale code
	   * @example Info.eras() //=> [ 'BC', 'AD' ]
	   * @example Info.eras('long') //=> [ 'Before Christ', 'Anno Domini' ]
	   * @example Info.eras('long', { locale: 'fr' }) //=> [ 'avant Jésus-Christ', 'après Jésus-Christ' ]
	   * @return {Array}
	   */
	  ;

	  Info.eras = function eras(length, _temp6) {
	    if (length === void 0) {
	      length = "short";
	    }

	    var _ref6 = _temp6 === void 0 ? {} : _temp6,
	        _ref6$locale = _ref6.locale,
	        locale = _ref6$locale === void 0 ? null : _ref6$locale;

	    return Locale.create(locale, null, "gregory").eras(length);
	  }
	  /**
	   * Return the set of available features in this environment.
	   * Some features of Luxon are not available in all environments. For example, on older browsers, timezone support is not available. Use this function to figure out if that's the case.
	   * Keys:
	   * * `relative`: whether this environment supports relative time formatting
	   * @example Info.features() //=> { intl: true, intlTokens: false, zones: true, relative: false }
	   * @return {Object}
	   */
	  ;

	  Info.features = function features() {
	    return {
	      relative: hasRelative()
	    };
	  };

	  return Info;
	}();

	function dayDiff(earlier, later) {
	  var utcDayStart = function utcDayStart(dt) {
	    return dt.toUTC(0, {
	      keepLocalTime: true
	    }).startOf("day").valueOf();
	  },
	      ms = utcDayStart(later) - utcDayStart(earlier);

	  return Math.floor(Duration.fromMillis(ms).as("days"));
	}

	function highOrderDiffs(cursor, later, units) {
	  var differs = [["years", function (a, b) {
	    return b.year - a.year;
	  }], ["quarters", function (a, b) {
	    return b.quarter - a.quarter;
	  }], ["months", function (a, b) {
	    return b.month - a.month + (b.year - a.year) * 12;
	  }], ["weeks", function (a, b) {
	    var days = dayDiff(a, b);
	    return (days - days % 7) / 7;
	  }], ["days", dayDiff]];
	  var results = {};
	  var lowestOrder, highWater;

	  for (var _i = 0, _differs = differs; _i < _differs.length; _i++) {
	    var _differs$_i = _differs[_i],
	        unit = _differs$_i[0],
	        differ = _differs$_i[1];

	    if (units.indexOf(unit) >= 0) {
	      var _cursor$plus;

	      lowestOrder = unit;
	      var delta = differ(cursor, later);
	      highWater = cursor.plus((_cursor$plus = {}, _cursor$plus[unit] = delta, _cursor$plus));

	      if (highWater > later) {
	        var _cursor$plus2;

	        cursor = cursor.plus((_cursor$plus2 = {}, _cursor$plus2[unit] = delta - 1, _cursor$plus2));
	        delta -= 1;
	      } else {
	        cursor = highWater;
	      }

	      results[unit] = delta;
	    }
	  }

	  return [cursor, results, highWater, lowestOrder];
	}

	function _diff (earlier, later, units, opts) {
	  var _highOrderDiffs = highOrderDiffs(earlier, later, units),
	      cursor = _highOrderDiffs[0],
	      results = _highOrderDiffs[1],
	      highWater = _highOrderDiffs[2],
	      lowestOrder = _highOrderDiffs[3];

	  var remainingMillis = later - cursor;
	  var lowerOrderUnits = units.filter(function (u) {
	    return ["hours", "minutes", "seconds", "milliseconds"].indexOf(u) >= 0;
	  });

	  if (lowerOrderUnits.length === 0) {
	    if (highWater < later) {
	      var _cursor$plus3;

	      highWater = cursor.plus((_cursor$plus3 = {}, _cursor$plus3[lowestOrder] = 1, _cursor$plus3));
	    }

	    if (highWater !== cursor) {
	      results[lowestOrder] = (results[lowestOrder] || 0) + remainingMillis / (highWater - cursor);
	    }
	  }

	  var duration = Duration.fromObject(results, opts);

	  if (lowerOrderUnits.length > 0) {
	    var _Duration$fromMillis;

	    return (_Duration$fromMillis = Duration.fromMillis(remainingMillis, opts)).shiftTo.apply(_Duration$fromMillis, lowerOrderUnits).plus(duration);
	  } else {
	    return duration;
	  }
	}

	var numberingSystems = {
	  arab: "[\u0660-\u0669]",
	  arabext: "[\u06F0-\u06F9]",
	  bali: "[\u1B50-\u1B59]",
	  beng: "[\u09E6-\u09EF]",
	  deva: "[\u0966-\u096F]",
	  fullwide: "[\uFF10-\uFF19]",
	  gujr: "[\u0AE6-\u0AEF]",
	  hanidec: "[〇|一|二|三|四|五|六|七|八|九]",
	  khmr: "[\u17E0-\u17E9]",
	  knda: "[\u0CE6-\u0CEF]",
	  laoo: "[\u0ED0-\u0ED9]",
	  limb: "[\u1946-\u194F]",
	  mlym: "[\u0D66-\u0D6F]",
	  mong: "[\u1810-\u1819]",
	  mymr: "[\u1040-\u1049]",
	  orya: "[\u0B66-\u0B6F]",
	  tamldec: "[\u0BE6-\u0BEF]",
	  telu: "[\u0C66-\u0C6F]",
	  thai: "[\u0E50-\u0E59]",
	  tibt: "[\u0F20-\u0F29]",
	  latn: "\\d"
	};
	var numberingSystemsUTF16 = {
	  arab: [1632, 1641],
	  arabext: [1776, 1785],
	  bali: [6992, 7001],
	  beng: [2534, 2543],
	  deva: [2406, 2415],
	  fullwide: [65296, 65303],
	  gujr: [2790, 2799],
	  khmr: [6112, 6121],
	  knda: [3302, 3311],
	  laoo: [3792, 3801],
	  limb: [6470, 6479],
	  mlym: [3430, 3439],
	  mong: [6160, 6169],
	  mymr: [4160, 4169],
	  orya: [2918, 2927],
	  tamldec: [3046, 3055],
	  telu: [3174, 3183],
	  thai: [3664, 3673],
	  tibt: [3872, 3881]
	};
	var hanidecChars = numberingSystems.hanidec.replace(/[\[|\]]/g, "").split("");
	function parseDigits(str) {
	  var value = parseInt(str, 10);

	  if (isNaN(value)) {
	    value = "";

	    for (var i = 0; i < str.length; i++) {
	      var code = str.charCodeAt(i);

	      if (str[i].search(numberingSystems.hanidec) !== -1) {
	        value += hanidecChars.indexOf(str[i]);
	      } else {
	        for (var key in numberingSystemsUTF16) {
	          var _numberingSystemsUTF = numberingSystemsUTF16[key],
	              min = _numberingSystemsUTF[0],
	              max = _numberingSystemsUTF[1];

	          if (code >= min && code <= max) {
	            value += code - min;
	          }
	        }
	      }
	    }

	    return parseInt(value, 10);
	  } else {
	    return value;
	  }
	}
	function digitRegex(_ref, append) {
	  var numberingSystem = _ref.numberingSystem;

	  if (append === void 0) {
	    append = "";
	  }

	  return new RegExp("" + numberingSystems[numberingSystem || "latn"] + append);
	}

	var MISSING_FTP = "missing Intl.DateTimeFormat.formatToParts support";

	function intUnit(regex, post) {
	  if (post === void 0) {
	    post = function post(i) {
	      return i;
	    };
	  }

	  return {
	    regex: regex,
	    deser: function deser(_ref) {
	      var s = _ref[0];
	      return post(parseDigits(s));
	    }
	  };
	}

	var NBSP = String.fromCharCode(160);
	var spaceOrNBSP = "( |" + NBSP + ")";
	var spaceOrNBSPRegExp = new RegExp(spaceOrNBSP, "g");

	function fixListRegex(s) {
	  // make dots optional and also make them literal
	  // make space and non breakable space characters interchangeable
	  return s.replace(/\./g, "\\.?").replace(spaceOrNBSPRegExp, spaceOrNBSP);
	}

	function stripInsensitivities(s) {
	  return s.replace(/\./g, "") // ignore dots that were made optional
	  .replace(spaceOrNBSPRegExp, " ") // interchange space and nbsp
	  .toLowerCase();
	}

	function oneOf(strings, startIndex) {
	  if (strings === null) {
	    return null;
	  } else {
	    return {
	      regex: RegExp(strings.map(fixListRegex).join("|")),
	      deser: function deser(_ref2) {
	        var s = _ref2[0];
	        return strings.findIndex(function (i) {
	          return stripInsensitivities(s) === stripInsensitivities(i);
	        }) + startIndex;
	      }
	    };
	  }
	}

	function offset(regex, groups) {
	  return {
	    regex: regex,
	    deser: function deser(_ref3) {
	      var h = _ref3[1],
	          m = _ref3[2];
	      return signedOffset(h, m);
	    },
	    groups: groups
	  };
	}

	function simple(regex) {
	  return {
	    regex: regex,
	    deser: function deser(_ref4) {
	      var s = _ref4[0];
	      return s;
	    }
	  };
	}

	function escapeToken(value) {
	  return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
	}

	function unitForToken(token, loc) {
	  var one = digitRegex(loc),
	      two = digitRegex(loc, "{2}"),
	      three = digitRegex(loc, "{3}"),
	      four = digitRegex(loc, "{4}"),
	      six = digitRegex(loc, "{6}"),
	      oneOrTwo = digitRegex(loc, "{1,2}"),
	      oneToThree = digitRegex(loc, "{1,3}"),
	      oneToSix = digitRegex(loc, "{1,6}"),
	      oneToNine = digitRegex(loc, "{1,9}"),
	      twoToFour = digitRegex(loc, "{2,4}"),
	      fourToSix = digitRegex(loc, "{4,6}"),
	      literal = function literal(t) {
	    return {
	      regex: RegExp(escapeToken(t.val)),
	      deser: function deser(_ref5) {
	        var s = _ref5[0];
	        return s;
	      },
	      literal: true
	    };
	  },
	      unitate = function unitate(t) {
	    if (token.literal) {
	      return literal(t);
	    }

	    switch (t.val) {
	      // era
	      case "G":
	        return oneOf(loc.eras("short", false), 0);

	      case "GG":
	        return oneOf(loc.eras("long", false), 0);
	      // years

	      case "y":
	        return intUnit(oneToSix);

	      case "yy":
	        return intUnit(twoToFour, untruncateYear);

	      case "yyyy":
	        return intUnit(four);

	      case "yyyyy":
	        return intUnit(fourToSix);

	      case "yyyyyy":
	        return intUnit(six);
	      // months

	      case "M":
	        return intUnit(oneOrTwo);

	      case "MM":
	        return intUnit(two);

	      case "MMM":
	        return oneOf(loc.months("short", true, false), 1);

	      case "MMMM":
	        return oneOf(loc.months("long", true, false), 1);

	      case "L":
	        return intUnit(oneOrTwo);

	      case "LL":
	        return intUnit(two);

	      case "LLL":
	        return oneOf(loc.months("short", false, false), 1);

	      case "LLLL":
	        return oneOf(loc.months("long", false, false), 1);
	      // dates

	      case "d":
	        return intUnit(oneOrTwo);

	      case "dd":
	        return intUnit(two);
	      // ordinals

	      case "o":
	        return intUnit(oneToThree);

	      case "ooo":
	        return intUnit(three);
	      // time

	      case "HH":
	        return intUnit(two);

	      case "H":
	        return intUnit(oneOrTwo);

	      case "hh":
	        return intUnit(two);

	      case "h":
	        return intUnit(oneOrTwo);

	      case "mm":
	        return intUnit(two);

	      case "m":
	        return intUnit(oneOrTwo);

	      case "q":
	        return intUnit(oneOrTwo);

	      case "qq":
	        return intUnit(two);

	      case "s":
	        return intUnit(oneOrTwo);

	      case "ss":
	        return intUnit(two);

	      case "S":
	        return intUnit(oneToThree);

	      case "SSS":
	        return intUnit(three);

	      case "u":
	        return simple(oneToNine);
	      // meridiem

	      case "a":
	        return oneOf(loc.meridiems(), 0);
	      // weekYear (k)

	      case "kkkk":
	        return intUnit(four);

	      case "kk":
	        return intUnit(twoToFour, untruncateYear);
	      // weekNumber (W)

	      case "W":
	        return intUnit(oneOrTwo);

	      case "WW":
	        return intUnit(two);
	      // weekdays

	      case "E":
	      case "c":
	        return intUnit(one);

	      case "EEE":
	        return oneOf(loc.weekdays("short", false, false), 1);

	      case "EEEE":
	        return oneOf(loc.weekdays("long", false, false), 1);

	      case "ccc":
	        return oneOf(loc.weekdays("short", true, false), 1);

	      case "cccc":
	        return oneOf(loc.weekdays("long", true, false), 1);
	      // offset/zone

	      case "Z":
	      case "ZZ":
	        return offset(new RegExp("([+-]" + oneOrTwo.source + ")(?::(" + two.source + "))?"), 2);

	      case "ZZZ":
	        return offset(new RegExp("([+-]" + oneOrTwo.source + ")(" + two.source + ")?"), 2);
	      // we don't support ZZZZ (PST) or ZZZZZ (Pacific Standard Time) in parsing
	      // because we don't have any way to figure out what they are

	      case "z":
	        return simple(/[a-z_+-/]{1,256}?/i);

	      default:
	        return literal(t);
	    }
	  };

	  var unit = unitate(token) || {
	    invalidReason: MISSING_FTP
	  };
	  unit.token = token;
	  return unit;
	}

	var partTypeStyleToTokenVal = {
	  year: {
	    "2-digit": "yy",
	    numeric: "yyyyy"
	  },
	  month: {
	    numeric: "M",
	    "2-digit": "MM",
	    short: "MMM",
	    long: "MMMM"
	  },
	  day: {
	    numeric: "d",
	    "2-digit": "dd"
	  },
	  weekday: {
	    short: "EEE",
	    long: "EEEE"
	  },
	  dayperiod: "a",
	  dayPeriod: "a",
	  hour: {
	    numeric: "h",
	    "2-digit": "hh"
	  },
	  minute: {
	    numeric: "m",
	    "2-digit": "mm"
	  },
	  second: {
	    numeric: "s",
	    "2-digit": "ss"
	  }
	};

	function tokenForPart(part, locale, formatOpts) {
	  var type = part.type,
	      value = part.value;

	  if (type === "literal") {
	    return {
	      literal: true,
	      val: value
	    };
	  }

	  var style = formatOpts[type];
	  var val = partTypeStyleToTokenVal[type];

	  if (typeof val === "object") {
	    val = val[style];
	  }

	  if (val) {
	    return {
	      literal: false,
	      val: val
	    };
	  }

	  return undefined;
	}

	function buildRegex(units) {
	  var re = units.map(function (u) {
	    return u.regex;
	  }).reduce(function (f, r) {
	    return f + "(" + r.source + ")";
	  }, "");
	  return ["^" + re + "$", units];
	}

	function match(input, regex, handlers) {
	  var matches = input.match(regex);

	  if (matches) {
	    var all = {};
	    var matchIndex = 1;

	    for (var i in handlers) {
	      if (hasOwnProperty$3(handlers, i)) {
	        var h = handlers[i],
	            groups = h.groups ? h.groups + 1 : 1;

	        if (!h.literal && h.token) {
	          all[h.token.val[0]] = h.deser(matches.slice(matchIndex, matchIndex + groups));
	        }

	        matchIndex += groups;
	      }
	    }

	    return [matches, all];
	  } else {
	    return [matches, {}];
	  }
	}

	function dateTimeFromMatches(matches) {
	  var toField = function toField(token) {
	    switch (token) {
	      case "S":
	        return "millisecond";

	      case "s":
	        return "second";

	      case "m":
	        return "minute";

	      case "h":
	      case "H":
	        return "hour";

	      case "d":
	        return "day";

	      case "o":
	        return "ordinal";

	      case "L":
	      case "M":
	        return "month";

	      case "y":
	        return "year";

	      case "E":
	      case "c":
	        return "weekday";

	      case "W":
	        return "weekNumber";

	      case "k":
	        return "weekYear";

	      case "q":
	        return "quarter";

	      default:
	        return null;
	    }
	  };

	  var zone;

	  if (!isUndefined$1(matches.Z)) {
	    zone = new FixedOffsetZone(matches.Z);
	  } else if (!isUndefined$1(matches.z)) {
	    zone = IANAZone.create(matches.z);
	  } else {
	    zone = null;
	  }

	  if (!isUndefined$1(matches.q)) {
	    matches.M = (matches.q - 1) * 3 + 1;
	  }

	  if (!isUndefined$1(matches.h)) {
	    if (matches.h < 12 && matches.a === 1) {
	      matches.h += 12;
	    } else if (matches.h === 12 && matches.a === 0) {
	      matches.h = 0;
	    }
	  }

	  if (matches.G === 0 && matches.y) {
	    matches.y = -matches.y;
	  }

	  if (!isUndefined$1(matches.u)) {
	    matches.S = parseMillis(matches.u);
	  }

	  var vals = Object.keys(matches).reduce(function (r, k) {
	    var f = toField(k);

	    if (f) {
	      r[f] = matches[k];
	    }

	    return r;
	  }, {});
	  return [vals, zone];
	}

	var dummyDateTimeCache = null;

	function getDummyDateTime() {
	  if (!dummyDateTimeCache) {
	    dummyDateTimeCache = DateTime.fromMillis(1555555555555);
	  }

	  return dummyDateTimeCache;
	}

	function maybeExpandMacroToken(token, locale) {
	  if (token.literal) {
	    return token;
	  }

	  var formatOpts = Formatter$1.macroTokenToFormatOpts(token.val);

	  if (!formatOpts) {
	    return token;
	  }

	  var formatter = Formatter$1.create(locale, formatOpts);
	  var parts = formatter.formatDateTimeParts(getDummyDateTime());
	  var tokens = parts.map(function (p) {
	    return tokenForPart(p, locale, formatOpts);
	  });

	  if (tokens.includes(undefined)) {
	    return token;
	  }

	  return tokens;
	}

	function expandMacroTokens(tokens, locale) {
	  var _Array$prototype;

	  return (_Array$prototype = Array.prototype).concat.apply(_Array$prototype, tokens.map(function (t) {
	    return maybeExpandMacroToken(t, locale);
	  }));
	}
	/**
	 * @private
	 */


	function explainFromTokens(locale, input, format) {
	  var tokens = expandMacroTokens(Formatter$1.parseFormat(format), locale),
	      units = tokens.map(function (t) {
	    return unitForToken(t, locale);
	  }),
	      disqualifyingUnit = units.find(function (t) {
	    return t.invalidReason;
	  });

	  if (disqualifyingUnit) {
	    return {
	      input: input,
	      tokens: tokens,
	      invalidReason: disqualifyingUnit.invalidReason
	    };
	  } else {
	    var _buildRegex = buildRegex(units),
	        regexString = _buildRegex[0],
	        handlers = _buildRegex[1],
	        regex = RegExp(regexString, "i"),
	        _match = match(input, regex, handlers),
	        rawMatches = _match[0],
	        matches = _match[1],
	        _ref6 = matches ? dateTimeFromMatches(matches) : [null, null],
	        result = _ref6[0],
	        zone = _ref6[1];

	    if (hasOwnProperty$3(matches, "a") && hasOwnProperty$3(matches, "H")) {
	      throw new ConflictingSpecificationError("Can't include meridiem when specifying 24-hour format");
	    }

	    return {
	      input: input,
	      tokens: tokens,
	      regex: regex,
	      rawMatches: rawMatches,
	      matches: matches,
	      result: result,
	      zone: zone
	    };
	  }
	}
	function parseFromTokens(locale, input, format) {
	  var _explainFromTokens = explainFromTokens(locale, input, format),
	      result = _explainFromTokens.result,
	      zone = _explainFromTokens.zone,
	      invalidReason = _explainFromTokens.invalidReason;

	  return [result, zone, invalidReason];
	}

	var nonLeapLadder = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
	    leapLadder = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335];

	function unitOutOfRange(unit, value) {
	  return new Invalid("unit out of range", "you specified " + value + " (of type " + typeof value + ") as a " + unit + ", which is invalid");
	}

	function dayOfWeek(year, month, day) {
	  var js = new Date(Date.UTC(year, month - 1, day)).getUTCDay();
	  return js === 0 ? 7 : js;
	}

	function computeOrdinal(year, month, day) {
	  return day + (isLeapYear(year) ? leapLadder : nonLeapLadder)[month - 1];
	}

	function uncomputeOrdinal(year, ordinal) {
	  var table = isLeapYear(year) ? leapLadder : nonLeapLadder,
	      month0 = table.findIndex(function (i) {
	    return i < ordinal;
	  }),
	      day = ordinal - table[month0];
	  return {
	    month: month0 + 1,
	    day: day
	  };
	}
	/**
	 * @private
	 */


	function gregorianToWeek(gregObj) {
	  var year = gregObj.year,
	      month = gregObj.month,
	      day = gregObj.day,
	      ordinal = computeOrdinal(year, month, day),
	      weekday = dayOfWeek(year, month, day);
	  var weekNumber = Math.floor((ordinal - weekday + 10) / 7),
	      weekYear;

	  if (weekNumber < 1) {
	    weekYear = year - 1;
	    weekNumber = weeksInWeekYear(weekYear);
	  } else if (weekNumber > weeksInWeekYear(year)) {
	    weekYear = year + 1;
	    weekNumber = 1;
	  } else {
	    weekYear = year;
	  }

	  return _extends({
	    weekYear: weekYear,
	    weekNumber: weekNumber,
	    weekday: weekday
	  }, timeObject(gregObj));
	}
	function weekToGregorian(weekData) {
	  var weekYear = weekData.weekYear,
	      weekNumber = weekData.weekNumber,
	      weekday = weekData.weekday,
	      weekdayOfJan4 = dayOfWeek(weekYear, 1, 4),
	      yearInDays = daysInYear(weekYear);
	  var ordinal = weekNumber * 7 + weekday - weekdayOfJan4 - 3,
	      year;

	  if (ordinal < 1) {
	    year = weekYear - 1;
	    ordinal += daysInYear(year);
	  } else if (ordinal > yearInDays) {
	    year = weekYear + 1;
	    ordinal -= daysInYear(weekYear);
	  } else {
	    year = weekYear;
	  }

	  var _uncomputeOrdinal = uncomputeOrdinal(year, ordinal),
	      month = _uncomputeOrdinal.month,
	      day = _uncomputeOrdinal.day;

	  return _extends({
	    year: year,
	    month: month,
	    day: day
	  }, timeObject(weekData));
	}
	function gregorianToOrdinal(gregData) {
	  var year = gregData.year,
	      month = gregData.month,
	      day = gregData.day;
	  var ordinal = computeOrdinal(year, month, day);
	  return _extends({
	    year: year,
	    ordinal: ordinal
	  }, timeObject(gregData));
	}
	function ordinalToGregorian(ordinalData) {
	  var year = ordinalData.year,
	      ordinal = ordinalData.ordinal;

	  var _uncomputeOrdinal2 = uncomputeOrdinal(year, ordinal),
	      month = _uncomputeOrdinal2.month,
	      day = _uncomputeOrdinal2.day;

	  return _extends({
	    year: year,
	    month: month,
	    day: day
	  }, timeObject(ordinalData));
	}
	function hasInvalidWeekData(obj) {
	  var validYear = isInteger(obj.weekYear),
	      validWeek = integerBetween(obj.weekNumber, 1, weeksInWeekYear(obj.weekYear)),
	      validWeekday = integerBetween(obj.weekday, 1, 7);

	  if (!validYear) {
	    return unitOutOfRange("weekYear", obj.weekYear);
	  } else if (!validWeek) {
	    return unitOutOfRange("week", obj.week);
	  } else if (!validWeekday) {
	    return unitOutOfRange("weekday", obj.weekday);
	  } else return false;
	}
	function hasInvalidOrdinalData(obj) {
	  var validYear = isInteger(obj.year),
	      validOrdinal = integerBetween(obj.ordinal, 1, daysInYear(obj.year));

	  if (!validYear) {
	    return unitOutOfRange("year", obj.year);
	  } else if (!validOrdinal) {
	    return unitOutOfRange("ordinal", obj.ordinal);
	  } else return false;
	}
	function hasInvalidGregorianData(obj) {
	  var validYear = isInteger(obj.year),
	      validMonth = integerBetween(obj.month, 1, 12),
	      validDay = integerBetween(obj.day, 1, daysInMonth(obj.year, obj.month));

	  if (!validYear) {
	    return unitOutOfRange("year", obj.year);
	  } else if (!validMonth) {
	    return unitOutOfRange("month", obj.month);
	  } else if (!validDay) {
	    return unitOutOfRange("day", obj.day);
	  } else return false;
	}
	function hasInvalidTimeData(obj) {
	  var hour = obj.hour,
	      minute = obj.minute,
	      second = obj.second,
	      millisecond = obj.millisecond;
	  var validHour = integerBetween(hour, 0, 23) || hour === 24 && minute === 0 && second === 0 && millisecond === 0,
	      validMinute = integerBetween(minute, 0, 59),
	      validSecond = integerBetween(second, 0, 59),
	      validMillisecond = integerBetween(millisecond, 0, 999);

	  if (!validHour) {
	    return unitOutOfRange("hour", hour);
	  } else if (!validMinute) {
	    return unitOutOfRange("minute", minute);
	  } else if (!validSecond) {
	    return unitOutOfRange("second", second);
	  } else if (!validMillisecond) {
	    return unitOutOfRange("millisecond", millisecond);
	  } else return false;
	}

	var INVALID = "Invalid DateTime";
	var MAX_DATE = 8.64e15;

	function unsupportedZone(zone) {
	  return new Invalid("unsupported zone", "the zone \"" + zone.name + "\" is not supported");
	} // we cache week data on the DT object and this intermediates the cache


	function possiblyCachedWeekData(dt) {
	  if (dt.weekData === null) {
	    dt.weekData = gregorianToWeek(dt.c);
	  }

	  return dt.weekData;
	} // clone really means, "make a new object with these modifications". all "setters" really use this
	// to create a new object while only changing some of the properties


	function clone(inst, alts) {
	  var current = {
	    ts: inst.ts,
	    zone: inst.zone,
	    c: inst.c,
	    o: inst.o,
	    loc: inst.loc,
	    invalid: inst.invalid
	  };
	  return new DateTime(_extends({}, current, alts, {
	    old: current
	  }));
	} // find the right offset a given local time. The o input is our guess, which determines which
	// offset we'll pick in ambiguous cases (e.g. there are two 3 AMs b/c Fallback DST)


	function fixOffset(localTS, o, tz) {
	  // Our UTC time is just a guess because our offset is just a guess
	  var utcGuess = localTS - o * 60 * 1000; // Test whether the zone matches the offset for this ts

	  var o2 = tz.offset(utcGuess); // If so, offset didn't change and we're done

	  if (o === o2) {
	    return [utcGuess, o];
	  } // If not, change the ts by the difference in the offset


	  utcGuess -= (o2 - o) * 60 * 1000; // If that gives us the local time we want, we're done

	  var o3 = tz.offset(utcGuess);

	  if (o2 === o3) {
	    return [utcGuess, o2];
	  } // If it's different, we're in a hole time. The offset has changed, but the we don't adjust the time


	  return [localTS - Math.min(o2, o3) * 60 * 1000, Math.max(o2, o3)];
	} // convert an epoch timestamp into a calendar object with the given offset


	function tsToObj(ts, offset) {
	  ts += offset * 60 * 1000;
	  var d = new Date(ts);
	  return {
	    year: d.getUTCFullYear(),
	    month: d.getUTCMonth() + 1,
	    day: d.getUTCDate(),
	    hour: d.getUTCHours(),
	    minute: d.getUTCMinutes(),
	    second: d.getUTCSeconds(),
	    millisecond: d.getUTCMilliseconds()
	  };
	} // convert a calendar object to a epoch timestamp


	function objToTS(obj, offset, zone) {
	  return fixOffset(objToLocalTS(obj), offset, zone);
	} // create a new DT instance by adding a duration, adjusting for DSTs


	function adjustTime(inst, dur) {
	  var oPre = inst.o,
	      year = inst.c.year + Math.trunc(dur.years),
	      month = inst.c.month + Math.trunc(dur.months) + Math.trunc(dur.quarters) * 3,
	      c = _extends({}, inst.c, {
	    year: year,
	    month: month,
	    day: Math.min(inst.c.day, daysInMonth(year, month)) + Math.trunc(dur.days) + Math.trunc(dur.weeks) * 7
	  }),
	      millisToAdd = Duration.fromObject({
	    years: dur.years - Math.trunc(dur.years),
	    quarters: dur.quarters - Math.trunc(dur.quarters),
	    months: dur.months - Math.trunc(dur.months),
	    weeks: dur.weeks - Math.trunc(dur.weeks),
	    days: dur.days - Math.trunc(dur.days),
	    hours: dur.hours,
	    minutes: dur.minutes,
	    seconds: dur.seconds,
	    milliseconds: dur.milliseconds
	  }).as("milliseconds"),
	      localTS = objToLocalTS(c);

	  var _fixOffset = fixOffset(localTS, oPre, inst.zone),
	      ts = _fixOffset[0],
	      o = _fixOffset[1];

	  if (millisToAdd !== 0) {
	    ts += millisToAdd; // that could have changed the offset by going over a DST, but we want to keep the ts the same

	    o = inst.zone.offset(ts);
	  }

	  return {
	    ts: ts,
	    o: o
	  };
	} // helper useful in turning the results of parsing into real dates
	// by handling the zone options


	function parseDataToDateTime(parsed, parsedZone, opts, format, text) {
	  var setZone = opts.setZone,
	      zone = opts.zone;

	  if (parsed && Object.keys(parsed).length !== 0) {
	    var interpretationZone = parsedZone || zone,
	        inst = DateTime.fromObject(parsed, _extends({}, opts, {
	      zone: interpretationZone
	    }));
	    return setZone ? inst : inst.setZone(zone);
	  } else {
	    return DateTime.invalid(new Invalid("unparsable", "the input \"" + text + "\" can't be parsed as " + format));
	  }
	} // if you want to output a technical format (e.g. RFC 2822), this helper
	// helps handle the details


	function toTechFormat(dt, format, allowZ) {
	  if (allowZ === void 0) {
	    allowZ = true;
	  }

	  return dt.isValid ? Formatter$1.create(Locale.create("en-US"), {
	    allowZ: allowZ,
	    forceSimple: true
	  }).formatDateTimeFromString(dt, format) : null;
	} // technical time formats (e.g. the time part of ISO 8601), take some options
	// and this commonizes their handling


	function toTechTimeFormat(dt, _ref) {
	  var _ref$suppressSeconds = _ref.suppressSeconds,
	      suppressSeconds = _ref$suppressSeconds === void 0 ? false : _ref$suppressSeconds,
	      _ref$suppressMillisec = _ref.suppressMilliseconds,
	      suppressMilliseconds = _ref$suppressMillisec === void 0 ? false : _ref$suppressMillisec,
	      includeOffset = _ref.includeOffset,
	      _ref$includePrefix = _ref.includePrefix,
	      includePrefix = _ref$includePrefix === void 0 ? false : _ref$includePrefix,
	      _ref$includeZone = _ref.includeZone,
	      includeZone = _ref$includeZone === void 0 ? false : _ref$includeZone,
	      _ref$spaceZone = _ref.spaceZone,
	      spaceZone = _ref$spaceZone === void 0 ? false : _ref$spaceZone,
	      _ref$format = _ref.format,
	      format = _ref$format === void 0 ? "extended" : _ref$format;
	  var fmt = format === "basic" ? "HHmm" : "HH:mm";

	  if (!suppressSeconds || dt.second !== 0 || dt.millisecond !== 0) {
	    fmt += format === "basic" ? "ss" : ":ss";

	    if (!suppressMilliseconds || dt.millisecond !== 0) {
	      fmt += ".SSS";
	    }
	  }

	  if ((includeZone || includeOffset) && spaceZone) {
	    fmt += " ";
	  }

	  if (includeZone) {
	    fmt += "z";
	  } else if (includeOffset) {
	    fmt += format === "basic" ? "ZZZ" : "ZZ";
	  }

	  var str = toTechFormat(dt, fmt);

	  if (includePrefix) {
	    str = "T" + str;
	  }

	  return str;
	} // defaults for unspecified units in the supported calendars


	var defaultUnitValues = {
	  month: 1,
	  day: 1,
	  hour: 0,
	  minute: 0,
	  second: 0,
	  millisecond: 0
	},
	    defaultWeekUnitValues = {
	  weekNumber: 1,
	  weekday: 1,
	  hour: 0,
	  minute: 0,
	  second: 0,
	  millisecond: 0
	},
	    defaultOrdinalUnitValues = {
	  ordinal: 1,
	  hour: 0,
	  minute: 0,
	  second: 0,
	  millisecond: 0
	}; // Units in the supported calendars, sorted by bigness

	var orderedUnits = ["year", "month", "day", "hour", "minute", "second", "millisecond"],
	    orderedWeekUnits = ["weekYear", "weekNumber", "weekday", "hour", "minute", "second", "millisecond"],
	    orderedOrdinalUnits = ["year", "ordinal", "hour", "minute", "second", "millisecond"]; // standardize case and plurality in units

	function normalizeUnit(unit) {
	  var normalized = {
	    year: "year",
	    years: "year",
	    month: "month",
	    months: "month",
	    day: "day",
	    days: "day",
	    hour: "hour",
	    hours: "hour",
	    minute: "minute",
	    minutes: "minute",
	    quarter: "quarter",
	    quarters: "quarter",
	    second: "second",
	    seconds: "second",
	    millisecond: "millisecond",
	    milliseconds: "millisecond",
	    weekday: "weekday",
	    weekdays: "weekday",
	    weeknumber: "weekNumber",
	    weeksnumber: "weekNumber",
	    weeknumbers: "weekNumber",
	    weekyear: "weekYear",
	    weekyears: "weekYear",
	    ordinal: "ordinal"
	  }[unit.toLowerCase()];
	  if (!normalized) throw new InvalidUnitError(unit);
	  return normalized;
	} // this is a dumbed down version of fromObject() that runs about 60% faster
	// but doesn't do any validation, makes a bunch of assumptions about what units
	// are present, and so on.
	// this is a dumbed down version of fromObject() that runs about 60% faster
	// but doesn't do any validation, makes a bunch of assumptions about what units
	// are present, and so on.


	function quickDT(obj, opts) {
	  var zone = normalizeZone(opts.zone, Settings.defaultZone),
	      loc = Locale.fromObject(opts),
	      tsNow = Settings.now();
	  var ts, o; // assume we have the higher-order units

	  if (!isUndefined$1(obj.year)) {
	    for (var _iterator = _createForOfIteratorHelperLoose(orderedUnits), _step; !(_step = _iterator()).done;) {
	      var u = _step.value;

	      if (isUndefined$1(obj[u])) {
	        obj[u] = defaultUnitValues[u];
	      }
	    }

	    var invalid = hasInvalidGregorianData(obj) || hasInvalidTimeData(obj);

	    if (invalid) {
	      return DateTime.invalid(invalid);
	    }

	    var offsetProvis = zone.offset(tsNow);

	    var _objToTS = objToTS(obj, offsetProvis, zone);

	    ts = _objToTS[0];
	    o = _objToTS[1];
	  } else {
	    ts = tsNow;
	  }

	  return new DateTime({
	    ts: ts,
	    zone: zone,
	    loc: loc,
	    o: o
	  });
	}

	function diffRelative(start, end, opts) {
	  var round = isUndefined$1(opts.round) ? true : opts.round,
	      format = function format(c, unit) {
	    c = roundTo$1(c, round || opts.calendary ? 0 : 2, true);
	    var formatter = end.loc.clone(opts).relFormatter(opts);
	    return formatter.format(c, unit);
	  },
	      differ = function differ(unit) {
	    if (opts.calendary) {
	      if (!end.hasSame(start, unit)) {
	        return end.startOf(unit).diff(start.startOf(unit), unit).get(unit);
	      } else return 0;
	    } else {
	      return end.diff(start, unit).get(unit);
	    }
	  };

	  if (opts.unit) {
	    return format(differ(opts.unit), opts.unit);
	  }

	  for (var _iterator2 = _createForOfIteratorHelperLoose(opts.units), _step2; !(_step2 = _iterator2()).done;) {
	    var unit = _step2.value;
	    var count = differ(unit);

	    if (Math.abs(count) >= 1) {
	      return format(count, unit);
	    }
	  }

	  return format(start > end ? -0 : 0, opts.units[opts.units.length - 1]);
	}

	function lastOpts(argList) {
	  var opts = {},
	      args;

	  if (argList.length > 0 && typeof argList[argList.length - 1] === "object") {
	    opts = argList[argList.length - 1];
	    args = Array.from(argList).slice(0, argList.length - 1);
	  } else {
	    args = Array.from(argList);
	  }

	  return [opts, args];
	}
	/**
	 * A DateTime is an immutable data structure representing a specific date and time and accompanying methods. It contains class and instance methods for creating, parsing, interrogating, transforming, and formatting them.
	 *
	 * A DateTime comprises of:
	 * * A timestamp. Each DateTime instance refers to a specific millisecond of the Unix epoch.
	 * * A time zone. Each instance is considered in the context of a specific zone (by default the local system's zone).
	 * * Configuration properties that effect how output strings are formatted, such as `locale`, `numberingSystem`, and `outputCalendar`.
	 *
	 * Here is a brief overview of the most commonly used functionality it provides:
	 *
	 * * **Creation**: To create a DateTime from its components, use one of its factory class methods: {@link DateTime.local}, {@link DateTime.utc}, and (most flexibly) {@link DateTime.fromObject}. To create one from a standard string format, use {@link DateTime.fromISO}, {@link DateTime.fromHTTP}, and {@link DateTime.fromRFC2822}. To create one from a custom string format, use {@link DateTime.fromFormat}. To create one from a native JS date, use {@link DateTime.fromJSDate}.
	 * * **Gregorian calendar and time**: To examine the Gregorian properties of a DateTime individually (i.e as opposed to collectively through {@link DateTime#toObject}), use the {@link DateTime#year}, {@link DateTime#month},
	 * {@link DateTime#day}, {@link DateTime#hour}, {@link DateTime#minute}, {@link DateTime#second}, {@link DateTime#millisecond} accessors.
	 * * **Week calendar**: For ISO week calendar attributes, see the {@link DateTime#weekYear}, {@link DateTime#weekNumber}, and {@link DateTime#weekday} accessors.
	 * * **Configuration** See the {@link DateTime#locale} and {@link DateTime#numberingSystem} accessors.
	 * * **Transformation**: To transform the DateTime into other DateTimes, use {@link DateTime#set}, {@link DateTime#reconfigure}, {@link DateTime#setZone}, {@link DateTime#setLocale}, {@link DateTime.plus}, {@link DateTime#minus}, {@link DateTime#endOf}, {@link DateTime#startOf}, {@link DateTime#toUTC}, and {@link DateTime#toLocal}.
	 * * **Output**: To convert the DateTime to other representations, use the {@link DateTime#toRelative}, {@link DateTime#toRelativeCalendar}, {@link DateTime#toJSON}, {@link DateTime#toISO}, {@link DateTime#toHTTP}, {@link DateTime#toObject}, {@link DateTime#toRFC2822}, {@link DateTime#toString}, {@link DateTime#toLocaleString}, {@link DateTime#toFormat}, {@link DateTime#toMillis} and {@link DateTime#toJSDate}.
	 *
	 * There's plenty others documented below. In addition, for more information on subtler topics like internationalization, time zones, alternative calendars, validity, and so on, see the external documentation.
	 */


	var DateTime = /*#__PURE__*/function () {
	  /**
	   * @access private
	   */
	  function DateTime(config) {
	    var zone = config.zone || Settings.defaultZone;
	    var invalid = config.invalid || (Number.isNaN(config.ts) ? new Invalid("invalid input") : null) || (!zone.isValid ? unsupportedZone(zone) : null);
	    /**
	     * @access private
	     */

	    this.ts = isUndefined$1(config.ts) ? Settings.now() : config.ts;
	    var c = null,
	        o = null;

	    if (!invalid) {
	      var unchanged = config.old && config.old.ts === this.ts && config.old.zone.equals(zone);

	      if (unchanged) {
	        var _ref2 = [config.old.c, config.old.o];
	        c = _ref2[0];
	        o = _ref2[1];
	      } else {
	        var ot = zone.offset(this.ts);
	        c = tsToObj(this.ts, ot);
	        invalid = Number.isNaN(c.year) ? new Invalid("invalid input") : null;
	        c = invalid ? null : c;
	        o = invalid ? null : ot;
	      }
	    }
	    /**
	     * @access private
	     */


	    this._zone = zone;
	    /**
	     * @access private
	     */

	    this.loc = config.loc || Locale.create();
	    /**
	     * @access private
	     */

	    this.invalid = invalid;
	    /**
	     * @access private
	     */

	    this.weekData = null;
	    /**
	     * @access private
	     */

	    this.c = c;
	    /**
	     * @access private
	     */

	    this.o = o;
	    /**
	     * @access private
	     */

	    this.isLuxonDateTime = true;
	  } // CONSTRUCT

	  /**
	   * Create a DateTime for the current instant, in the system's time zone.
	   *
	   * Use Settings to override these default values if needed.
	   * @example DateTime.now().toISO() //~> now in the ISO format
	   * @return {DateTime}
	   */


	  DateTime.now = function now() {
	    return new DateTime({});
	  }
	  /**
	   * Create a local DateTime
	   * @param {number} [year] - The calendar year. If omitted (as in, call `local()` with no arguments), the current time will be used
	   * @param {number} [month=1] - The month, 1-indexed
	   * @param {number} [day=1] - The day of the month, 1-indexed
	   * @param {number} [hour=0] - The hour of the day, in 24-hour time
	   * @param {number} [minute=0] - The minute of the hour, meaning a number between 0 and 59
	   * @param {number} [second=0] - The second of the minute, meaning a number between 0 and 59
	   * @param {number} [millisecond=0] - The millisecond of the second, meaning a number between 0 and 999
	   * @example DateTime.local()                                  //~> now
	   * @example DateTime.local({ zone: "America/New_York" })      //~> now, in US east coast time
	   * @example DateTime.local(2017)                              //~> 2017-01-01T00:00:00
	   * @example DateTime.local(2017, 3)                           //~> 2017-03-01T00:00:00
	   * @example DateTime.local(2017, 3, 12, { locale: "fr" })     //~> 2017-03-12T00:00:00, with a French locale
	   * @example DateTime.local(2017, 3, 12, 5)                    //~> 2017-03-12T05:00:00
	   * @example DateTime.local(2017, 3, 12, 5, { zone: "utc" })   //~> 2017-03-12T05:00:00, in UTC
	   * @example DateTime.local(2017, 3, 12, 5, 45)                //~> 2017-03-12T05:45:00
	   * @example DateTime.local(2017, 3, 12, 5, 45, 10)            //~> 2017-03-12T05:45:10
	   * @example DateTime.local(2017, 3, 12, 5, 45, 10, 765)       //~> 2017-03-12T05:45:10.765
	   * @return {DateTime}
	   */
	  ;

	  DateTime.local = function local() {
	    var _lastOpts = lastOpts(arguments),
	        opts = _lastOpts[0],
	        args = _lastOpts[1],
	        year = args[0],
	        month = args[1],
	        day = args[2],
	        hour = args[3],
	        minute = args[4],
	        second = args[5],
	        millisecond = args[6];

	    return quickDT({
	      year: year,
	      month: month,
	      day: day,
	      hour: hour,
	      minute: minute,
	      second: second,
	      millisecond: millisecond
	    }, opts);
	  }
	  /**
	   * Create a DateTime in UTC
	   * @param {number} [year] - The calendar year. If omitted (as in, call `utc()` with no arguments), the current time will be used
	   * @param {number} [month=1] - The month, 1-indexed
	   * @param {number} [day=1] - The day of the month
	   * @param {number} [hour=0] - The hour of the day, in 24-hour time
	   * @param {number} [minute=0] - The minute of the hour, meaning a number between 0 and 59
	   * @param {number} [second=0] - The second of the minute, meaning a number between 0 and 59
	   * @param {number} [millisecond=0] - The millisecond of the second, meaning a number between 0 and 999
	   * @param {Object} options - configuration options for the DateTime
	   * @param {string} [options.locale] - a locale to set on the resulting DateTime instance
	   * @param {string} [options.outputCalendar] - the output calendar to set on the resulting DateTime instance
	   * @param {string} [options.numberingSystem] - the numbering system to set on the resulting DateTime instance
	   * @example DateTime.utc()                                              //~> now
	   * @example DateTime.utc(2017)                                          //~> 2017-01-01T00:00:00Z
	   * @example DateTime.utc(2017, 3)                                       //~> 2017-03-01T00:00:00Z
	   * @example DateTime.utc(2017, 3, 12)                                   //~> 2017-03-12T00:00:00Z
	   * @example DateTime.utc(2017, 3, 12, 5)                                //~> 2017-03-12T05:00:00Z
	   * @example DateTime.utc(2017, 3, 12, 5, 45)                            //~> 2017-03-12T05:45:00Z
	   * @example DateTime.utc(2017, 3, 12, 5, 45, { locale: "fr" })          //~> 2017-03-12T05:45:00Z with a French locale
	   * @example DateTime.utc(2017, 3, 12, 5, 45, 10)                        //~> 2017-03-12T05:45:10Z
	   * @example DateTime.utc(2017, 3, 12, 5, 45, 10, 765, { locale: "fr" }) //~> 2017-03-12T05:45:10.765Z with a French locale
	   * @return {DateTime}
	   */
	  ;

	  DateTime.utc = function utc() {
	    var _lastOpts2 = lastOpts(arguments),
	        opts = _lastOpts2[0],
	        args = _lastOpts2[1],
	        year = args[0],
	        month = args[1],
	        day = args[2],
	        hour = args[3],
	        minute = args[4],
	        second = args[5],
	        millisecond = args[6];

	    opts.zone = FixedOffsetZone.utcInstance;
	    return quickDT({
	      year: year,
	      month: month,
	      day: day,
	      hour: hour,
	      minute: minute,
	      second: second,
	      millisecond: millisecond
	    }, opts);
	  }
	  /**
	   * Create a DateTime from a JavaScript Date object. Uses the default zone.
	   * @param {Date} date - a JavaScript Date object
	   * @param {Object} options - configuration options for the DateTime
	   * @param {string|Zone} [options.zone='local'] - the zone to place the DateTime into
	   * @return {DateTime}
	   */
	  ;

	  DateTime.fromJSDate = function fromJSDate(date, options) {
	    if (options === void 0) {
	      options = {};
	    }

	    var ts = isDate(date) ? date.valueOf() : NaN;

	    if (Number.isNaN(ts)) {
	      return DateTime.invalid("invalid input");
	    }

	    var zoneToUse = normalizeZone(options.zone, Settings.defaultZone);

	    if (!zoneToUse.isValid) {
	      return DateTime.invalid(unsupportedZone(zoneToUse));
	    }

	    return new DateTime({
	      ts: ts,
	      zone: zoneToUse,
	      loc: Locale.fromObject(options)
	    });
	  }
	  /**
	   * Create a DateTime from a number of milliseconds since the epoch (meaning since 1 January 1970 00:00:00 UTC). Uses the default zone.
	   * @param {number} milliseconds - a number of milliseconds since 1970 UTC
	   * @param {Object} options - configuration options for the DateTime
	   * @param {string|Zone} [options.zone='local'] - the zone to place the DateTime into
	   * @param {string} [options.locale] - a locale to set on the resulting DateTime instance
	   * @param {string} options.outputCalendar - the output calendar to set on the resulting DateTime instance
	   * @param {string} options.numberingSystem - the numbering system to set on the resulting DateTime instance
	   * @return {DateTime}
	   */
	  ;

	  DateTime.fromMillis = function fromMillis(milliseconds, options) {
	    if (options === void 0) {
	      options = {};
	    }

	    if (!isNumber(milliseconds)) {
	      throw new InvalidArgumentError("fromMillis requires a numerical input, but received a " + typeof milliseconds + " with value " + milliseconds);
	    } else if (milliseconds < -MAX_DATE || milliseconds > MAX_DATE) {
	      // this isn't perfect because because we can still end up out of range because of additional shifting, but it's a start
	      return DateTime.invalid("Timestamp out of range");
	    } else {
	      return new DateTime({
	        ts: milliseconds,
	        zone: normalizeZone(options.zone, Settings.defaultZone),
	        loc: Locale.fromObject(options)
	      });
	    }
	  }
	  /**
	   * Create a DateTime from a number of seconds since the epoch (meaning since 1 January 1970 00:00:00 UTC). Uses the default zone.
	   * @param {number} seconds - a number of seconds since 1970 UTC
	   * @param {Object} options - configuration options for the DateTime
	   * @param {string|Zone} [options.zone='local'] - the zone to place the DateTime into
	   * @param {string} [options.locale] - a locale to set on the resulting DateTime instance
	   * @param {string} options.outputCalendar - the output calendar to set on the resulting DateTime instance
	   * @param {string} options.numberingSystem - the numbering system to set on the resulting DateTime instance
	   * @return {DateTime}
	   */
	  ;

	  DateTime.fromSeconds = function fromSeconds(seconds, options) {
	    if (options === void 0) {
	      options = {};
	    }

	    if (!isNumber(seconds)) {
	      throw new InvalidArgumentError("fromSeconds requires a numerical input");
	    } else {
	      return new DateTime({
	        ts: seconds * 1000,
	        zone: normalizeZone(options.zone, Settings.defaultZone),
	        loc: Locale.fromObject(options)
	      });
	    }
	  }
	  /**
	   * Create a DateTime from a JavaScript object with keys like 'year' and 'hour' with reasonable defaults.
	   * @param {Object} obj - the object to create the DateTime from
	   * @param {number} obj.year - a year, such as 1987
	   * @param {number} obj.month - a month, 1-12
	   * @param {number} obj.day - a day of the month, 1-31, depending on the month
	   * @param {number} obj.ordinal - day of the year, 1-365 or 366
	   * @param {number} obj.weekYear - an ISO week year
	   * @param {number} obj.weekNumber - an ISO week number, between 1 and 52 or 53, depending on the year
	   * @param {number} obj.weekday - an ISO weekday, 1-7, where 1 is Monday and 7 is Sunday
	   * @param {number} obj.hour - hour of the day, 0-23
	   * @param {number} obj.minute - minute of the hour, 0-59
	   * @param {number} obj.second - second of the minute, 0-59
	   * @param {number} obj.millisecond - millisecond of the second, 0-999
	   * @param {Object} opts - options for creating this DateTime
	   * @param {string|Zone} [opts.zone='local'] - interpret the numbers in the context of a particular zone. Can take any value taken as the first argument to setZone()
	   * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
	   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
	   * @param {string} opts.numberingSystem - the numbering system to set on the resulting DateTime instance
	   * @example DateTime.fromObject({ year: 1982, month: 5, day: 25}).toISODate() //=> '1982-05-25'
	   * @example DateTime.fromObject({ year: 1982 }).toISODate() //=> '1982-01-01'
	   * @example DateTime.fromObject({ hour: 10, minute: 26, second: 6 }) //~> today at 10:26:06
	   * @example DateTime.fromObject({ hour: 10, minute: 26, second: 6 }, { zone: 'utc' }),
	   * @example DateTime.fromObject({ hour: 10, minute: 26, second: 6 }, { zone: 'local' })
	   * @example DateTime.fromObject({ hour: 10, minute: 26, second: 6 }, { zone: 'America/New_York' })
	   * @example DateTime.fromObject({ weekYear: 2016, weekNumber: 2, weekday: 3 }).toISODate() //=> '2016-01-13'
	   * @return {DateTime}
	   */
	  ;

	  DateTime.fromObject = function fromObject(obj, opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    obj = obj || {};
	    var zoneToUse = normalizeZone(opts.zone, Settings.defaultZone);

	    if (!zoneToUse.isValid) {
	      return DateTime.invalid(unsupportedZone(zoneToUse));
	    }

	    var tsNow = Settings.now(),
	        offsetProvis = zoneToUse.offset(tsNow),
	        normalized = normalizeObject(obj, normalizeUnit),
	        containsOrdinal = !isUndefined$1(normalized.ordinal),
	        containsGregorYear = !isUndefined$1(normalized.year),
	        containsGregorMD = !isUndefined$1(normalized.month) || !isUndefined$1(normalized.day),
	        containsGregor = containsGregorYear || containsGregorMD,
	        definiteWeekDef = normalized.weekYear || normalized.weekNumber,
	        loc = Locale.fromObject(opts); // cases:
	    // just a weekday -> this week's instance of that weekday, no worries
	    // (gregorian data or ordinal) + (weekYear or weekNumber) -> error
	    // (gregorian month or day) + ordinal -> error
	    // otherwise just use weeks or ordinals or gregorian, depending on what's specified

	    if ((containsGregor || containsOrdinal) && definiteWeekDef) {
	      throw new ConflictingSpecificationError("Can't mix weekYear/weekNumber units with year/month/day or ordinals");
	    }

	    if (containsGregorMD && containsOrdinal) {
	      throw new ConflictingSpecificationError("Can't mix ordinal dates with month/day");
	    }

	    var useWeekData = definiteWeekDef || normalized.weekday && !containsGregor; // configure ourselves to deal with gregorian dates or week stuff

	    var units,
	        defaultValues,
	        objNow = tsToObj(tsNow, offsetProvis);

	    if (useWeekData) {
	      units = orderedWeekUnits;
	      defaultValues = defaultWeekUnitValues;
	      objNow = gregorianToWeek(objNow);
	    } else if (containsOrdinal) {
	      units = orderedOrdinalUnits;
	      defaultValues = defaultOrdinalUnitValues;
	      objNow = gregorianToOrdinal(objNow);
	    } else {
	      units = orderedUnits;
	      defaultValues = defaultUnitValues;
	    } // set default values for missing stuff


	    var foundFirst = false;

	    for (var _iterator3 = _createForOfIteratorHelperLoose(units), _step3; !(_step3 = _iterator3()).done;) {
	      var u = _step3.value;
	      var v = normalized[u];

	      if (!isUndefined$1(v)) {
	        foundFirst = true;
	      } else if (foundFirst) {
	        normalized[u] = defaultValues[u];
	      } else {
	        normalized[u] = objNow[u];
	      }
	    } // make sure the values we have are in range


	    var higherOrderInvalid = useWeekData ? hasInvalidWeekData(normalized) : containsOrdinal ? hasInvalidOrdinalData(normalized) : hasInvalidGregorianData(normalized),
	        invalid = higherOrderInvalid || hasInvalidTimeData(normalized);

	    if (invalid) {
	      return DateTime.invalid(invalid);
	    } // compute the actual time


	    var gregorian = useWeekData ? weekToGregorian(normalized) : containsOrdinal ? ordinalToGregorian(normalized) : normalized,
	        _objToTS2 = objToTS(gregorian, offsetProvis, zoneToUse),
	        tsFinal = _objToTS2[0],
	        offsetFinal = _objToTS2[1],
	        inst = new DateTime({
	      ts: tsFinal,
	      zone: zoneToUse,
	      o: offsetFinal,
	      loc: loc
	    }); // gregorian data + weekday serves only to validate


	    if (normalized.weekday && containsGregor && obj.weekday !== inst.weekday) {
	      return DateTime.invalid("mismatched weekday", "you can't specify both a weekday of " + normalized.weekday + " and a date of " + inst.toISO());
	    }

	    return inst;
	  }
	  /**
	   * Create a DateTime from an ISO 8601 string
	   * @param {string} text - the ISO string
	   * @param {Object} opts - options to affect the creation
	   * @param {string|Zone} [opts.zone='local'] - use this zone if no offset is specified in the input string itself. Will also convert the time to this zone
	   * @param {boolean} [opts.setZone=false] - override the zone with a fixed-offset zone specified in the string itself, if it specifies one
	   * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
	   * @param {string} [opts.outputCalendar] - the output calendar to set on the resulting DateTime instance
	   * @param {string} [opts.numberingSystem] - the numbering system to set on the resulting DateTime instance
	   * @example DateTime.fromISO('2016-05-25T09:08:34.123')
	   * @example DateTime.fromISO('2016-05-25T09:08:34.123+06:00')
	   * @example DateTime.fromISO('2016-05-25T09:08:34.123+06:00', {setZone: true})
	   * @example DateTime.fromISO('2016-05-25T09:08:34.123', {zone: 'utc'})
	   * @example DateTime.fromISO('2016-W05-4')
	   * @return {DateTime}
	   */
	  ;

	  DateTime.fromISO = function fromISO(text, opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    var _parseISODate = parseISODate(text),
	        vals = _parseISODate[0],
	        parsedZone = _parseISODate[1];

	    return parseDataToDateTime(vals, parsedZone, opts, "ISO 8601", text);
	  }
	  /**
	   * Create a DateTime from an RFC 2822 string
	   * @param {string} text - the RFC 2822 string
	   * @param {Object} opts - options to affect the creation
	   * @param {string|Zone} [opts.zone='local'] - convert the time to this zone. Since the offset is always specified in the string itself, this has no effect on the interpretation of string, merely the zone the resulting DateTime is expressed in.
	   * @param {boolean} [opts.setZone=false] - override the zone with a fixed-offset zone specified in the string itself, if it specifies one
	   * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
	   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
	   * @param {string} opts.numberingSystem - the numbering system to set on the resulting DateTime instance
	   * @example DateTime.fromRFC2822('25 Nov 2016 13:23:12 GMT')
	   * @example DateTime.fromRFC2822('Fri, 25 Nov 2016 13:23:12 +0600')
	   * @example DateTime.fromRFC2822('25 Nov 2016 13:23 Z')
	   * @return {DateTime}
	   */
	  ;

	  DateTime.fromRFC2822 = function fromRFC2822(text, opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    var _parseRFC2822Date = parseRFC2822Date(text),
	        vals = _parseRFC2822Date[0],
	        parsedZone = _parseRFC2822Date[1];

	    return parseDataToDateTime(vals, parsedZone, opts, "RFC 2822", text);
	  }
	  /**
	   * Create a DateTime from an HTTP header date
	   * @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1
	   * @param {string} text - the HTTP header date
	   * @param {Object} opts - options to affect the creation
	   * @param {string|Zone} [opts.zone='local'] - convert the time to this zone. Since HTTP dates are always in UTC, this has no effect on the interpretation of string, merely the zone the resulting DateTime is expressed in.
	   * @param {boolean} [opts.setZone=false] - override the zone with the fixed-offset zone specified in the string. For HTTP dates, this is always UTC, so this option is equivalent to setting the `zone` option to 'utc', but this option is included for consistency with similar methods.
	   * @param {string} [opts.locale='system's locale'] - a locale to set on the resulting DateTime instance
	   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
	   * @param {string} opts.numberingSystem - the numbering system to set on the resulting DateTime instance
	   * @example DateTime.fromHTTP('Sun, 06 Nov 1994 08:49:37 GMT')
	   * @example DateTime.fromHTTP('Sunday, 06-Nov-94 08:49:37 GMT')
	   * @example DateTime.fromHTTP('Sun Nov  6 08:49:37 1994')
	   * @return {DateTime}
	   */
	  ;

	  DateTime.fromHTTP = function fromHTTP(text, opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    var _parseHTTPDate = parseHTTPDate(text),
	        vals = _parseHTTPDate[0],
	        parsedZone = _parseHTTPDate[1];

	    return parseDataToDateTime(vals, parsedZone, opts, "HTTP", opts);
	  }
	  /**
	   * Create a DateTime from an input string and format string.
	   * Defaults to en-US if no locale has been specified, regardless of the system's locale. For a table of tokens and their interpretations, see [here](https://moment.github.io/luxon/#/parsing?id=table-of-tokens).
	   * @param {string} text - the string to parse
	   * @param {string} fmt - the format the string is expected to be in (see the link below for the formats)
	   * @param {Object} opts - options to affect the creation
	   * @param {string|Zone} [opts.zone='local'] - use this zone if no offset is specified in the input string itself. Will also convert the DateTime to this zone
	   * @param {boolean} [opts.setZone=false] - override the zone with a zone specified in the string itself, if it specifies one
	   * @param {string} [opts.locale='en-US'] - a locale string to use when parsing. Will also set the DateTime to this locale
	   * @param {string} opts.numberingSystem - the numbering system to use when parsing. Will also set the resulting DateTime to this numbering system
	   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
	   * @return {DateTime}
	   */
	  ;

	  DateTime.fromFormat = function fromFormat(text, fmt, opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    if (isUndefined$1(text) || isUndefined$1(fmt)) {
	      throw new InvalidArgumentError("fromFormat requires an input string and a format");
	    }

	    var _opts = opts,
	        _opts$locale = _opts.locale,
	        locale = _opts$locale === void 0 ? null : _opts$locale,
	        _opts$numberingSystem = _opts.numberingSystem,
	        numberingSystem = _opts$numberingSystem === void 0 ? null : _opts$numberingSystem,
	        localeToUse = Locale.fromOpts({
	      locale: locale,
	      numberingSystem: numberingSystem,
	      defaultToEN: true
	    }),
	        _parseFromTokens = parseFromTokens(localeToUse, text, fmt),
	        vals = _parseFromTokens[0],
	        parsedZone = _parseFromTokens[1],
	        invalid = _parseFromTokens[2];

	    if (invalid) {
	      return DateTime.invalid(invalid);
	    } else {
	      return parseDataToDateTime(vals, parsedZone, opts, "format " + fmt, text);
	    }
	  }
	  /**
	   * @deprecated use fromFormat instead
	   */
	  ;

	  DateTime.fromString = function fromString(text, fmt, opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    return DateTime.fromFormat(text, fmt, opts);
	  }
	  /**
	   * Create a DateTime from a SQL date, time, or datetime
	   * Defaults to en-US if no locale has been specified, regardless of the system's locale
	   * @param {string} text - the string to parse
	   * @param {Object} opts - options to affect the creation
	   * @param {string|Zone} [opts.zone='local'] - use this zone if no offset is specified in the input string itself. Will also convert the DateTime to this zone
	   * @param {boolean} [opts.setZone=false] - override the zone with a zone specified in the string itself, if it specifies one
	   * @param {string} [opts.locale='en-US'] - a locale string to use when parsing. Will also set the DateTime to this locale
	   * @param {string} opts.numberingSystem - the numbering system to use when parsing. Will also set the resulting DateTime to this numbering system
	   * @param {string} opts.outputCalendar - the output calendar to set on the resulting DateTime instance
	   * @example DateTime.fromSQL('2017-05-15')
	   * @example DateTime.fromSQL('2017-05-15 09:12:34')
	   * @example DateTime.fromSQL('2017-05-15 09:12:34.342')
	   * @example DateTime.fromSQL('2017-05-15 09:12:34.342+06:00')
	   * @example DateTime.fromSQL('2017-05-15 09:12:34.342 America/Los_Angeles')
	   * @example DateTime.fromSQL('2017-05-15 09:12:34.342 America/Los_Angeles', { setZone: true })
	   * @example DateTime.fromSQL('2017-05-15 09:12:34.342', { zone: 'America/Los_Angeles' })
	   * @example DateTime.fromSQL('09:12:34.342')
	   * @return {DateTime}
	   */
	  ;

	  DateTime.fromSQL = function fromSQL(text, opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    var _parseSQL = parseSQL(text),
	        vals = _parseSQL[0],
	        parsedZone = _parseSQL[1];

	    return parseDataToDateTime(vals, parsedZone, opts, "SQL", text);
	  }
	  /**
	   * Create an invalid DateTime.
	   * @param {string} reason - simple string of why this DateTime is invalid. Should not contain parameters or anything else data-dependent
	   * @param {string} [explanation=null] - longer explanation, may include parameters and other useful debugging information
	   * @return {DateTime}
	   */
	  ;

	  DateTime.invalid = function invalid(reason, explanation) {
	    if (explanation === void 0) {
	      explanation = null;
	    }

	    if (!reason) {
	      throw new InvalidArgumentError("need to specify a reason the DateTime is invalid");
	    }

	    var invalid = reason instanceof Invalid ? reason : new Invalid(reason, explanation);

	    if (Settings.throwOnInvalid) {
	      throw new InvalidDateTimeError(invalid);
	    } else {
	      return new DateTime({
	        invalid: invalid
	      });
	    }
	  }
	  /**
	   * Check if an object is a DateTime. Works across context boundaries
	   * @param {object} o
	   * @return {boolean}
	   */
	  ;

	  DateTime.isDateTime = function isDateTime(o) {
	    return o && o.isLuxonDateTime || false;
	  } // INFO

	  /**
	   * Get the value of unit.
	   * @param {string} unit - a unit such as 'minute' or 'day'
	   * @example DateTime.local(2017, 7, 4).get('month'); //=> 7
	   * @example DateTime.local(2017, 7, 4).get('day'); //=> 4
	   * @return {number}
	   */
	  ;

	  var _proto = DateTime.prototype;

	  _proto.get = function get(unit) {
	    return this[unit];
	  }
	  /**
	   * Returns whether the DateTime is valid. Invalid DateTimes occur when:
	   * * The DateTime was created from invalid calendar information, such as the 13th month or February 30
	   * * The DateTime was created by an operation on another invalid date
	   * @type {boolean}
	   */
	  ;

	  /**
	   * Returns the resolved Intl options for this DateTime.
	   * This is useful in understanding the behavior of formatting methods
	   * @param {Object} opts - the same options as toLocaleString
	   * @return {Object}
	   */
	  _proto.resolvedLocaleOptions = function resolvedLocaleOptions(opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    var _Formatter$create$res = Formatter$1.create(this.loc.clone(opts), opts).resolvedOptions(this),
	        locale = _Formatter$create$res.locale,
	        numberingSystem = _Formatter$create$res.numberingSystem,
	        calendar = _Formatter$create$res.calendar;

	    return {
	      locale: locale,
	      numberingSystem: numberingSystem,
	      outputCalendar: calendar
	    };
	  } // TRANSFORM

	  /**
	   * "Set" the DateTime's zone to UTC. Returns a newly-constructed DateTime.
	   *
	   * Equivalent to {@link DateTime.setZone}('utc')
	   * @param {number} [offset=0] - optionally, an offset from UTC in minutes
	   * @param {Object} [opts={}] - options to pass to `setZone()`
	   * @return {DateTime}
	   */
	  ;

	  _proto.toUTC = function toUTC(offset, opts) {
	    if (offset === void 0) {
	      offset = 0;
	    }

	    if (opts === void 0) {
	      opts = {};
	    }

	    return this.setZone(FixedOffsetZone.instance(offset), opts);
	  }
	  /**
	   * "Set" the DateTime's zone to the host's local zone. Returns a newly-constructed DateTime.
	   *
	   * Equivalent to `setZone('local')`
	   * @return {DateTime}
	   */
	  ;

	  _proto.toLocal = function toLocal() {
	    return this.setZone(Settings.defaultZone);
	  }
	  /**
	   * "Set" the DateTime's zone to specified zone. Returns a newly-constructed DateTime.
	   *
	   * By default, the setter keeps the underlying time the same (as in, the same timestamp), but the new instance will report different local times and consider DSTs when making computations, as with {@link DateTime.plus}. You may wish to use {@link DateTime.toLocal} and {@link DateTime.toUTC} which provide simple convenience wrappers for commonly used zones.
	   * @param {string|Zone} [zone='local'] - a zone identifier. As a string, that can be any IANA zone supported by the host environment, or a fixed-offset name of the form 'UTC+3', or the strings 'local' or 'utc'. You may also supply an instance of a {@link DateTime.Zone} class.
	   * @param {Object} opts - options
	   * @param {boolean} [opts.keepLocalTime=false] - If true, adjust the underlying time so that the local time stays the same, but in the target zone. You should rarely need this.
	   * @return {DateTime}
	   */
	  ;

	  _proto.setZone = function setZone(zone, _temp) {
	    var _ref3 = _temp === void 0 ? {} : _temp,
	        _ref3$keepLocalTime = _ref3.keepLocalTime,
	        keepLocalTime = _ref3$keepLocalTime === void 0 ? false : _ref3$keepLocalTime,
	        _ref3$keepCalendarTim = _ref3.keepCalendarTime,
	        keepCalendarTime = _ref3$keepCalendarTim === void 0 ? false : _ref3$keepCalendarTim;

	    zone = normalizeZone(zone, Settings.defaultZone);

	    if (zone.equals(this.zone)) {
	      return this;
	    } else if (!zone.isValid) {
	      return DateTime.invalid(unsupportedZone(zone));
	    } else {
	      var newTS = this.ts;

	      if (keepLocalTime || keepCalendarTime) {
	        var offsetGuess = zone.offset(this.ts);
	        var asObj = this.toObject();

	        var _objToTS3 = objToTS(asObj, offsetGuess, zone);

	        newTS = _objToTS3[0];
	      }

	      return clone(this, {
	        ts: newTS,
	        zone: zone
	      });
	    }
	  }
	  /**
	   * "Set" the locale, numberingSystem, or outputCalendar. Returns a newly-constructed DateTime.
	   * @param {Object} properties - the properties to set
	   * @example DateTime.local(2017, 5, 25).reconfigure({ locale: 'en-GB' })
	   * @return {DateTime}
	   */
	  ;

	  _proto.reconfigure = function reconfigure(_temp2) {
	    var _ref4 = _temp2 === void 0 ? {} : _temp2,
	        locale = _ref4.locale,
	        numberingSystem = _ref4.numberingSystem,
	        outputCalendar = _ref4.outputCalendar;

	    var loc = this.loc.clone({
	      locale: locale,
	      numberingSystem: numberingSystem,
	      outputCalendar: outputCalendar
	    });
	    return clone(this, {
	      loc: loc
	    });
	  }
	  /**
	   * "Set" the locale. Returns a newly-constructed DateTime.
	   * Just a convenient alias for reconfigure({ locale })
	   * @example DateTime.local(2017, 5, 25).setLocale('en-GB')
	   * @return {DateTime}
	   */
	  ;

	  _proto.setLocale = function setLocale(locale) {
	    return this.reconfigure({
	      locale: locale
	    });
	  }
	  /**
	   * "Set" the values of specified units. Returns a newly-constructed DateTime.
	   * You can only set units with this method; for "setting" metadata, see {@link DateTime.reconfigure} and {@link DateTime.setZone}.
	   * @param {Object} values - a mapping of units to numbers
	   * @example dt.set({ year: 2017 })
	   * @example dt.set({ hour: 8, minute: 30 })
	   * @example dt.set({ weekday: 5 })
	   * @example dt.set({ year: 2005, ordinal: 234 })
	   * @return {DateTime}
	   */
	  ;

	  _proto.set = function set(values) {
	    if (!this.isValid) return this;
	    var normalized = normalizeObject(values, normalizeUnit),
	        settingWeekStuff = !isUndefined$1(normalized.weekYear) || !isUndefined$1(normalized.weekNumber) || !isUndefined$1(normalized.weekday),
	        containsOrdinal = !isUndefined$1(normalized.ordinal),
	        containsGregorYear = !isUndefined$1(normalized.year),
	        containsGregorMD = !isUndefined$1(normalized.month) || !isUndefined$1(normalized.day),
	        containsGregor = containsGregorYear || containsGregorMD,
	        definiteWeekDef = normalized.weekYear || normalized.weekNumber;

	    if ((containsGregor || containsOrdinal) && definiteWeekDef) {
	      throw new ConflictingSpecificationError("Can't mix weekYear/weekNumber units with year/month/day or ordinals");
	    }

	    if (containsGregorMD && containsOrdinal) {
	      throw new ConflictingSpecificationError("Can't mix ordinal dates with month/day");
	    }

	    var mixed;

	    if (settingWeekStuff) {
	      mixed = weekToGregorian(_extends({}, gregorianToWeek(this.c), normalized));
	    } else if (!isUndefined$1(normalized.ordinal)) {
	      mixed = ordinalToGregorian(_extends({}, gregorianToOrdinal(this.c), normalized));
	    } else {
	      mixed = _extends({}, this.toObject(), normalized); // if we didn't set the day but we ended up on an overflow date,
	      // use the last day of the right month

	      if (isUndefined$1(normalized.day)) {
	        mixed.day = Math.min(daysInMonth(mixed.year, mixed.month), mixed.day);
	      }
	    }

	    var _objToTS4 = objToTS(mixed, this.o, this.zone),
	        ts = _objToTS4[0],
	        o = _objToTS4[1];

	    return clone(this, {
	      ts: ts,
	      o: o
	    });
	  }
	  /**
	   * Add a period of time to this DateTime and return the resulting DateTime
	   *
	   * Adding hours, minutes, seconds, or milliseconds increases the timestamp by the right number of milliseconds. Adding days, months, or years shifts the calendar, accounting for DSTs and leap years along the way. Thus, `dt.plus({ hours: 24 })` may result in a different time than `dt.plus({ days: 1 })` if there's a DST shift in between.
	   * @param {Duration|Object|number} duration - The amount to add. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
	   * @example DateTime.now().plus(123) //~> in 123 milliseconds
	   * @example DateTime.now().plus({ minutes: 15 }) //~> in 15 minutes
	   * @example DateTime.now().plus({ days: 1 }) //~> this time tomorrow
	   * @example DateTime.now().plus({ days: -1 }) //~> this time yesterday
	   * @example DateTime.now().plus({ hours: 3, minutes: 13 }) //~> in 3 hr, 13 min
	   * @example DateTime.now().plus(Duration.fromObject({ hours: 3, minutes: 13 })) //~> in 3 hr, 13 min
	   * @return {DateTime}
	   */
	  ;

	  _proto.plus = function plus(duration) {
	    if (!this.isValid) return this;
	    var dur = friendlyDuration(duration);
	    return clone(this, adjustTime(this, dur));
	  }
	  /**
	   * Subtract a period of time to this DateTime and return the resulting DateTime
	   * See {@link DateTime.plus}
	   * @param {Duration|Object|number} duration - The amount to subtract. Either a Luxon Duration, a number of milliseconds, the object argument to Duration.fromObject()
	   @return {DateTime}
	  */
	  ;

	  _proto.minus = function minus(duration) {
	    if (!this.isValid) return this;
	    var dur = friendlyDuration(duration).negate();
	    return clone(this, adjustTime(this, dur));
	  }
	  /**
	   * "Set" this DateTime to the beginning of a unit of time.
	   * @param {string} unit - The unit to go to the beginning of. Can be 'year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', or 'millisecond'.
	   * @example DateTime.local(2014, 3, 3).startOf('month').toISODate(); //=> '2014-03-01'
	   * @example DateTime.local(2014, 3, 3).startOf('year').toISODate(); //=> '2014-01-01'
	   * @example DateTime.local(2014, 3, 3).startOf('week').toISODate(); //=> '2014-03-03', weeks always start on Mondays
	   * @example DateTime.local(2014, 3, 3, 5, 30).startOf('day').toISOTime(); //=> '00:00.000-05:00'
	   * @example DateTime.local(2014, 3, 3, 5, 30).startOf('hour').toISOTime(); //=> '05:00:00.000-05:00'
	   * @return {DateTime}
	   */
	  ;

	  _proto.startOf = function startOf(unit) {
	    if (!this.isValid) return this;
	    var o = {},
	        normalizedUnit = Duration.normalizeUnit(unit);

	    switch (normalizedUnit) {
	      case "years":
	        o.month = 1;
	      // falls through

	      case "quarters":
	      case "months":
	        o.day = 1;
	      // falls through

	      case "weeks":
	      case "days":
	        o.hour = 0;
	      // falls through

	      case "hours":
	        o.minute = 0;
	      // falls through

	      case "minutes":
	        o.second = 0;
	      // falls through

	      case "seconds":
	        o.millisecond = 0;
	        break;
	      // no default, invalid units throw in normalizeUnit()
	    }

	    if (normalizedUnit === "weeks") {
	      o.weekday = 1;
	    }

	    if (normalizedUnit === "quarters") {
	      var q = Math.ceil(this.month / 3);
	      o.month = (q - 1) * 3 + 1;
	    }

	    return this.set(o);
	  }
	  /**
	   * "Set" this DateTime to the end (meaning the last millisecond) of a unit of time
	   * @param {string} unit - The unit to go to the end of. Can be 'year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', or 'millisecond'.
	   * @example DateTime.local(2014, 3, 3).endOf('month').toISO(); //=> '2014-03-31T23:59:59.999-05:00'
	   * @example DateTime.local(2014, 3, 3).endOf('year').toISO(); //=> '2014-12-31T23:59:59.999-05:00'
	   * @example DateTime.local(2014, 3, 3).endOf('week').toISO(); // => '2014-03-09T23:59:59.999-05:00', weeks start on Mondays
	   * @example DateTime.local(2014, 3, 3, 5, 30).endOf('day').toISO(); //=> '2014-03-03T23:59:59.999-05:00'
	   * @example DateTime.local(2014, 3, 3, 5, 30).endOf('hour').toISO(); //=> '2014-03-03T05:59:59.999-05:00'
	   * @return {DateTime}
	   */
	  ;

	  _proto.endOf = function endOf(unit) {
	    var _this$plus;

	    return this.isValid ? this.plus((_this$plus = {}, _this$plus[unit] = 1, _this$plus)).startOf(unit).minus(1) : this;
	  } // OUTPUT

	  /**
	   * Returns a string representation of this DateTime formatted according to the specified format string.
	   * **You may not want this.** See {@link DateTime.toLocaleString} for a more flexible formatting tool. For a table of tokens and their interpretations, see [here](https://moment.github.io/luxon/#/formatting?id=table-of-tokens).
	   * Defaults to en-US if no locale has been specified, regardless of the system's locale.
	   * @param {string} fmt - the format string
	   * @param {Object} opts - opts to override the configuration options on this DateTime
	   * @example DateTime.now().toFormat('yyyy LLL dd') //=> '2017 Apr 22'
	   * @example DateTime.now().setLocale('fr').toFormat('yyyy LLL dd') //=> '2017 avr. 22'
	   * @example DateTime.now().toFormat('yyyy LLL dd', { locale: "fr" }) //=> '2017 avr. 22'
	   * @example DateTime.now().toFormat("HH 'hours and' mm 'minutes'") //=> '20 hours and 55 minutes'
	   * @return {string}
	   */
	  ;

	  _proto.toFormat = function toFormat(fmt, opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    return this.isValid ? Formatter$1.create(this.loc.redefaultToEN(opts)).formatDateTimeFromString(this, fmt) : INVALID;
	  }
	  /**
	   * Returns a localized string representing this date. Accepts the same options as the Intl.DateTimeFormat constructor and any presets defined by Luxon, such as `DateTime.DATE_FULL` or `DateTime.TIME_SIMPLE`.
	   * The exact behavior of this method is browser-specific, but in general it will return an appropriate representation
	   * of the DateTime in the assigned locale.
	   * Defaults to the system's locale if no locale has been specified
	   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat
	   * @param formatOpts {Object} - Intl.DateTimeFormat constructor options and configuration options
	   * @param {Object} opts - opts to override the configuration options on this DateTime
	   * @example DateTime.now().toLocaleString(); //=> 4/20/2017
	   * @example DateTime.now().setLocale('en-gb').toLocaleString(); //=> '20/04/2017'
	   * @example DateTime.now().toLocaleString({ locale: 'en-gb' }); //=> '20/04/2017'
	   * @example DateTime.now().toLocaleString(DateTime.DATE_FULL); //=> 'April 20, 2017'
	   * @example DateTime.now().toLocaleString(DateTime.TIME_SIMPLE); //=> '11:32 AM'
	   * @example DateTime.now().toLocaleString(DateTime.DATETIME_SHORT); //=> '4/20/2017, 11:32 AM'
	   * @example DateTime.now().toLocaleString({ weekday: 'long', month: 'long', day: '2-digit' }); //=> 'Thursday, April 20'
	   * @example DateTime.now().toLocaleString({ weekday: 'short', month: 'short', day: '2-digit', hour: '2-digit', minute: '2-digit' }); //=> 'Thu, Apr 20, 11:27 AM'
	   * @example DateTime.now().toLocaleString({ hour: '2-digit', minute: '2-digit', hourCycle: 'h23' }); //=> '11:32'
	   * @return {string}
	   */
	  ;

	  _proto.toLocaleString = function toLocaleString(formatOpts, opts) {
	    if (formatOpts === void 0) {
	      formatOpts = DATE_SHORT;
	    }

	    if (opts === void 0) {
	      opts = {};
	    }

	    return this.isValid ? Formatter$1.create(this.loc.clone(opts), formatOpts).formatDateTime(this) : INVALID;
	  }
	  /**
	   * Returns an array of format "parts", meaning individual tokens along with metadata. This is allows callers to post-process individual sections of the formatted output.
	   * Defaults to the system's locale if no locale has been specified
	   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/formatToParts
	   * @param opts {Object} - Intl.DateTimeFormat constructor options, same as `toLocaleString`.
	   * @example DateTime.now().toLocaleParts(); //=> [
	   *                                   //=>   { type: 'day', value: '25' },
	   *                                   //=>   { type: 'literal', value: '/' },
	   *                                   //=>   { type: 'month', value: '05' },
	   *                                   //=>   { type: 'literal', value: '/' },
	   *                                   //=>   { type: 'year', value: '1982' }
	   *                                   //=> ]
	   */
	  ;

	  _proto.toLocaleParts = function toLocaleParts(opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    return this.isValid ? Formatter$1.create(this.loc.clone(opts), opts).formatDateTimeParts(this) : [];
	  }
	  /**
	   * Returns an ISO 8601-compliant string representation of this DateTime
	   * @param {Object} opts - options
	   * @param {boolean} [opts.suppressMilliseconds=false] - exclude milliseconds from the format if they're 0
	   * @param {boolean} [opts.suppressSeconds=false] - exclude seconds from the format if they're 0
	   * @param {boolean} [opts.includeOffset=true] - include the offset, such as 'Z' or '-04:00'
	   * @param {string} [opts.format='extended'] - choose between the basic and extended format
	   * @example DateTime.utc(1982, 5, 25).toISO() //=> '1982-05-25T00:00:00.000Z'
	   * @example DateTime.now().toISO() //=> '2017-04-22T20:47:05.335-04:00'
	   * @example DateTime.now().toISO({ includeOffset: false }) //=> '2017-04-22T20:47:05.335'
	   * @example DateTime.now().toISO({ format: 'basic' }) //=> '20170422T204705.335-0400'
	   * @return {string}
	   */
	  ;

	  _proto.toISO = function toISO(opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    if (!this.isValid) {
	      return null;
	    }

	    return this.toISODate(opts) + "T" + this.toISOTime(opts);
	  }
	  /**
	   * Returns an ISO 8601-compliant string representation of this DateTime's date component
	   * @param {Object} opts - options
	   * @param {string} [opts.format='extended'] - choose between the basic and extended format
	   * @example DateTime.utc(1982, 5, 25).toISODate() //=> '1982-05-25'
	   * @example DateTime.utc(1982, 5, 25).toISODate({ format: 'basic' }) //=> '19820525'
	   * @return {string}
	   */
	  ;

	  _proto.toISODate = function toISODate(_temp3) {
	    var _ref5 = _temp3 === void 0 ? {} : _temp3,
	        _ref5$format = _ref5.format,
	        format = _ref5$format === void 0 ? "extended" : _ref5$format;

	    var fmt = format === "basic" ? "yyyyMMdd" : "yyyy-MM-dd";

	    if (this.year > 9999) {
	      fmt = "+" + fmt;
	    }

	    return toTechFormat(this, fmt);
	  }
	  /**
	   * Returns an ISO 8601-compliant string representation of this DateTime's week date
	   * @example DateTime.utc(1982, 5, 25).toISOWeekDate() //=> '1982-W21-2'
	   * @return {string}
	   */
	  ;

	  _proto.toISOWeekDate = function toISOWeekDate() {
	    return toTechFormat(this, "kkkk-'W'WW-c");
	  }
	  /**
	   * Returns an ISO 8601-compliant string representation of this DateTime's time component
	   * @param {Object} opts - options
	   * @param {boolean} [opts.suppressMilliseconds=false] - exclude milliseconds from the format if they're 0
	   * @param {boolean} [opts.suppressSeconds=false] - exclude seconds from the format if they're 0
	   * @param {boolean} [opts.includeOffset=true] - include the offset, such as 'Z' or '-04:00'
	   * @param {boolean} [opts.includePrefix=false] - include the `T` prefix
	   * @param {string} [opts.format='extended'] - choose between the basic and extended format
	   * @example DateTime.utc().set({ hour: 7, minute: 34 }).toISOTime() //=> '07:34:19.361Z'
	   * @example DateTime.utc().set({ hour: 7, minute: 34, seconds: 0, milliseconds: 0 }).toISOTime({ suppressSeconds: true }) //=> '07:34Z'
	   * @example DateTime.utc().set({ hour: 7, minute: 34 }).toISOTime({ format: 'basic' }) //=> '073419.361Z'
	   * @example DateTime.utc().set({ hour: 7, minute: 34 }).toISOTime({ includePrefix: true }) //=> 'T07:34:19.361Z'
	   * @return {string}
	   */
	  ;

	  _proto.toISOTime = function toISOTime(_temp4) {
	    var _ref6 = _temp4 === void 0 ? {} : _temp4,
	        _ref6$suppressMillise = _ref6.suppressMilliseconds,
	        suppressMilliseconds = _ref6$suppressMillise === void 0 ? false : _ref6$suppressMillise,
	        _ref6$suppressSeconds = _ref6.suppressSeconds,
	        suppressSeconds = _ref6$suppressSeconds === void 0 ? false : _ref6$suppressSeconds,
	        _ref6$includeOffset = _ref6.includeOffset,
	        includeOffset = _ref6$includeOffset === void 0 ? true : _ref6$includeOffset,
	        _ref6$includePrefix = _ref6.includePrefix,
	        includePrefix = _ref6$includePrefix === void 0 ? false : _ref6$includePrefix,
	        _ref6$format = _ref6.format,
	        format = _ref6$format === void 0 ? "extended" : _ref6$format;

	    return toTechTimeFormat(this, {
	      suppressSeconds: suppressSeconds,
	      suppressMilliseconds: suppressMilliseconds,
	      includeOffset: includeOffset,
	      includePrefix: includePrefix,
	      format: format
	    });
	  }
	  /**
	   * Returns an RFC 2822-compatible string representation of this DateTime, always in UTC
	   * @example DateTime.utc(2014, 7, 13).toRFC2822() //=> 'Sun, 13 Jul 2014 00:00:00 +0000'
	   * @example DateTime.local(2014, 7, 13).toRFC2822() //=> 'Sun, 13 Jul 2014 00:00:00 -0400'
	   * @return {string}
	   */
	  ;

	  _proto.toRFC2822 = function toRFC2822() {
	    return toTechFormat(this, "EEE, dd LLL yyyy HH:mm:ss ZZZ", false);
	  }
	  /**
	   * Returns a string representation of this DateTime appropriate for use in HTTP headers.
	   * Specifically, the string conforms to RFC 1123.
	   * @see https://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3.1
	   * @example DateTime.utc(2014, 7, 13).toHTTP() //=> 'Sun, 13 Jul 2014 00:00:00 GMT'
	   * @example DateTime.utc(2014, 7, 13, 19).toHTTP() //=> 'Sun, 13 Jul 2014 19:00:00 GMT'
	   * @return {string}
	   */
	  ;

	  _proto.toHTTP = function toHTTP() {
	    return toTechFormat(this.toUTC(), "EEE, dd LLL yyyy HH:mm:ss 'GMT'");
	  }
	  /**
	   * Returns a string representation of this DateTime appropriate for use in SQL Date
	   * @example DateTime.utc(2014, 7, 13).toSQLDate() //=> '2014-07-13'
	   * @return {string}
	   */
	  ;

	  _proto.toSQLDate = function toSQLDate() {
	    return toTechFormat(this, "yyyy-MM-dd");
	  }
	  /**
	   * Returns a string representation of this DateTime appropriate for use in SQL Time
	   * @param {Object} opts - options
	   * @param {boolean} [opts.includeZone=false] - include the zone, such as 'America/New_York'. Overrides includeOffset.
	   * @param {boolean} [opts.includeOffset=true] - include the offset, such as 'Z' or '-04:00'
	   * @example DateTime.utc().toSQL() //=> '05:15:16.345'
	   * @example DateTime.now().toSQL() //=> '05:15:16.345 -04:00'
	   * @example DateTime.now().toSQL({ includeOffset: false }) //=> '05:15:16.345'
	   * @example DateTime.now().toSQL({ includeZone: false }) //=> '05:15:16.345 America/New_York'
	   * @return {string}
	   */
	  ;

	  _proto.toSQLTime = function toSQLTime(_temp5) {
	    var _ref7 = _temp5 === void 0 ? {} : _temp5,
	        _ref7$includeOffset = _ref7.includeOffset,
	        includeOffset = _ref7$includeOffset === void 0 ? true : _ref7$includeOffset,
	        _ref7$includeZone = _ref7.includeZone,
	        includeZone = _ref7$includeZone === void 0 ? false : _ref7$includeZone;

	    return toTechTimeFormat(this, {
	      includeOffset: includeOffset,
	      includeZone: includeZone,
	      spaceZone: true
	    });
	  }
	  /**
	   * Returns a string representation of this DateTime appropriate for use in SQL DateTime
	   * @param {Object} opts - options
	   * @param {boolean} [opts.includeZone=false] - include the zone, such as 'America/New_York'. Overrides includeOffset.
	   * @param {boolean} [opts.includeOffset=true] - include the offset, such as 'Z' or '-04:00'
	   * @example DateTime.utc(2014, 7, 13).toSQL() //=> '2014-07-13 00:00:00.000 Z'
	   * @example DateTime.local(2014, 7, 13).toSQL() //=> '2014-07-13 00:00:00.000 -04:00'
	   * @example DateTime.local(2014, 7, 13).toSQL({ includeOffset: false }) //=> '2014-07-13 00:00:00.000'
	   * @example DateTime.local(2014, 7, 13).toSQL({ includeZone: true }) //=> '2014-07-13 00:00:00.000 America/New_York'
	   * @return {string}
	   */
	  ;

	  _proto.toSQL = function toSQL(opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    if (!this.isValid) {
	      return null;
	    }

	    return this.toSQLDate() + " " + this.toSQLTime(opts);
	  }
	  /**
	   * Returns a string representation of this DateTime appropriate for debugging
	   * @return {string}
	   */
	  ;

	  _proto.toString = function toString() {
	    return this.isValid ? this.toISO() : INVALID;
	  }
	  /**
	   * Returns the epoch milliseconds of this DateTime. Alias of {@link DateTime.toMillis}
	   * @return {number}
	   */
	  ;

	  _proto.valueOf = function valueOf() {
	    return this.toMillis();
	  }
	  /**
	   * Returns the epoch milliseconds of this DateTime.
	   * @return {number}
	   */
	  ;

	  _proto.toMillis = function toMillis() {
	    return this.isValid ? this.ts : NaN;
	  }
	  /**
	   * Returns the epoch seconds of this DateTime.
	   * @return {number}
	   */
	  ;

	  _proto.toSeconds = function toSeconds() {
	    return this.isValid ? this.ts / 1000 : NaN;
	  }
	  /**
	   * Returns an ISO 8601 representation of this DateTime appropriate for use in JSON.
	   * @return {string}
	   */
	  ;

	  _proto.toJSON = function toJSON() {
	    return this.toISO();
	  }
	  /**
	   * Returns a BSON serializable equivalent to this DateTime.
	   * @return {Date}
	   */
	  ;

	  _proto.toBSON = function toBSON() {
	    return this.toJSDate();
	  }
	  /**
	   * Returns a JavaScript object with this DateTime's year, month, day, and so on.
	   * @param opts - options for generating the object
	   * @param {boolean} [opts.includeConfig=false] - include configuration attributes in the output
	   * @example DateTime.now().toObject() //=> { year: 2017, month: 4, day: 22, hour: 20, minute: 49, second: 42, millisecond: 268 }
	   * @return {Object}
	   */
	  ;

	  _proto.toObject = function toObject(opts) {
	    if (opts === void 0) {
	      opts = {};
	    }

	    if (!this.isValid) return {};

	    var base = _extends({}, this.c);

	    if (opts.includeConfig) {
	      base.outputCalendar = this.outputCalendar;
	      base.numberingSystem = this.loc.numberingSystem;
	      base.locale = this.loc.locale;
	    }

	    return base;
	  }
	  /**
	   * Returns a JavaScript Date equivalent to this DateTime.
	   * @return {Date}
	   */
	  ;

	  _proto.toJSDate = function toJSDate() {
	    return new Date(this.isValid ? this.ts : NaN);
	  } // COMPARE

	  /**
	   * Return the difference between two DateTimes as a Duration.
	   * @param {DateTime} otherDateTime - the DateTime to compare this one to
	   * @param {string|string[]} [unit=['milliseconds']] - the unit or array of units (such as 'hours' or 'days') to include in the duration.
	   * @param {Object} opts - options that affect the creation of the Duration
	   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
	   * @example
	   * var i1 = DateTime.fromISO('1982-05-25T09:45'),
	   *     i2 = DateTime.fromISO('1983-10-14T10:30');
	   * i2.diff(i1).toObject() //=> { milliseconds: 43807500000 }
	   * i2.diff(i1, 'hours').toObject() //=> { hours: 12168.75 }
	   * i2.diff(i1, ['months', 'days']).toObject() //=> { months: 16, days: 19.03125 }
	   * i2.diff(i1, ['months', 'days', 'hours']).toObject() //=> { months: 16, days: 19, hours: 0.75 }
	   * @return {Duration}
	   */
	  ;

	  _proto.diff = function diff(otherDateTime, unit, opts) {
	    if (unit === void 0) {
	      unit = "milliseconds";
	    }

	    if (opts === void 0) {
	      opts = {};
	    }

	    if (!this.isValid || !otherDateTime.isValid) {
	      return Duration.invalid("created by diffing an invalid DateTime");
	    }

	    var durOpts = _extends({
	      locale: this.locale,
	      numberingSystem: this.numberingSystem
	    }, opts);

	    var units = maybeArray(unit).map(Duration.normalizeUnit),
	        otherIsLater = otherDateTime.valueOf() > this.valueOf(),
	        earlier = otherIsLater ? this : otherDateTime,
	        later = otherIsLater ? otherDateTime : this,
	        diffed = _diff(earlier, later, units, durOpts);

	    return otherIsLater ? diffed.negate() : diffed;
	  }
	  /**
	   * Return the difference between this DateTime and right now.
	   * See {@link DateTime.diff}
	   * @param {string|string[]} [unit=['milliseconds']] - the unit or units units (such as 'hours' or 'days') to include in the duration
	   * @param {Object} opts - options that affect the creation of the Duration
	   * @param {string} [opts.conversionAccuracy='casual'] - the conversion system to use
	   * @return {Duration}
	   */
	  ;

	  _proto.diffNow = function diffNow(unit, opts) {
	    if (unit === void 0) {
	      unit = "milliseconds";
	    }

	    if (opts === void 0) {
	      opts = {};
	    }

	    return this.diff(DateTime.now(), unit, opts);
	  }
	  /**
	   * Return an Interval spanning between this DateTime and another DateTime
	   * @param {DateTime} otherDateTime - the other end point of the Interval
	   * @return {Interval}
	   */
	  ;

	  _proto.until = function until(otherDateTime) {
	    return this.isValid ? Interval.fromDateTimes(this, otherDateTime) : this;
	  }
	  /**
	   * Return whether this DateTime is in the same unit of time as another DateTime.
	   * Higher-order units must also be identical for this function to return `true`.
	   * Note that time zones are **ignored** in this comparison, which compares the **local** calendar time. Use {@link DateTime.setZone} to convert one of the dates if needed.
	   * @param {DateTime} otherDateTime - the other DateTime
	   * @param {string} unit - the unit of time to check sameness on
	   * @example DateTime.now().hasSame(otherDT, 'day'); //~> true if otherDT is in the same current calendar day
	   * @return {boolean}
	   */
	  ;

	  _proto.hasSame = function hasSame(otherDateTime, unit) {
	    if (!this.isValid) return false;
	    var inputMs = otherDateTime.valueOf();
	    var otherZoneDateTime = this.setZone(otherDateTime.zone, {
	      keepLocalTime: true
	    });
	    return otherZoneDateTime.startOf(unit) <= inputMs && inputMs <= otherZoneDateTime.endOf(unit);
	  }
	  /**
	   * Equality check
	   * Two DateTimes are equal iff they represent the same millisecond, have the same zone and location, and are both valid.
	   * To compare just the millisecond values, use `+dt1 === +dt2`.
	   * @param {DateTime} other - the other DateTime
	   * @return {boolean}
	   */
	  ;

	  _proto.equals = function equals(other) {
	    return this.isValid && other.isValid && this.valueOf() === other.valueOf() && this.zone.equals(other.zone) && this.loc.equals(other.loc);
	  }
	  /**
	   * Returns a string representation of a this time relative to now, such as "in two days". Can only internationalize if your
	   * platform supports Intl.RelativeTimeFormat. Rounds down by default.
	   * @param {Object} options - options that affect the output
	   * @param {DateTime} [options.base=DateTime.now()] - the DateTime to use as the basis to which this time is compared. Defaults to now.
	   * @param {string} [options.style="long"] - the style of units, must be "long", "short", or "narrow"
	   * @param {string|string[]} options.unit - use a specific unit or array of units; if omitted, or an array, the method will pick the best unit. Use an array or one of "years", "quarters", "months", "weeks", "days", "hours", "minutes", or "seconds"
	   * @param {boolean} [options.round=true] - whether to round the numbers in the output.
	   * @param {number} [options.padding=0] - padding in milliseconds. This allows you to round up the result if it fits inside the threshold. Don't use in combination with {round: false} because the decimal output will include the padding.
	   * @param {string} options.locale - override the locale of this DateTime
	   * @param {string} options.numberingSystem - override the numberingSystem of this DateTime. The Intl system may choose not to honor this
	   * @example DateTime.now().plus({ days: 1 }).toRelative() //=> "in 1 day"
	   * @example DateTime.now().setLocale("es").toRelative({ days: 1 }) //=> "dentro de 1 día"
	   * @example DateTime.now().plus({ days: 1 }).toRelative({ locale: "fr" }) //=> "dans 23 heures"
	   * @example DateTime.now().minus({ days: 2 }).toRelative() //=> "2 days ago"
	   * @example DateTime.now().minus({ days: 2 }).toRelative({ unit: "hours" }) //=> "48 hours ago"
	   * @example DateTime.now().minus({ hours: 36 }).toRelative({ round: false }) //=> "1.5 days ago"
	   */
	  ;

	  _proto.toRelative = function toRelative(options) {
	    if (options === void 0) {
	      options = {};
	    }

	    if (!this.isValid) return null;
	    var base = options.base || DateTime.fromObject({}, {
	      zone: this.zone
	    }),
	        padding = options.padding ? this < base ? -options.padding : options.padding : 0;
	    var units = ["years", "months", "days", "hours", "minutes", "seconds"];
	    var unit = options.unit;

	    if (Array.isArray(options.unit)) {
	      units = options.unit;
	      unit = undefined;
	    }

	    return diffRelative(base, this.plus(padding), _extends({}, options, {
	      numeric: "always",
	      units: units,
	      unit: unit
	    }));
	  }
	  /**
	   * Returns a string representation of this date relative to today, such as "yesterday" or "next month".
	   * Only internationalizes on platforms that supports Intl.RelativeTimeFormat.
	   * @param {Object} options - options that affect the output
	   * @param {DateTime} [options.base=DateTime.now()] - the DateTime to use as the basis to which this time is compared. Defaults to now.
	   * @param {string} options.locale - override the locale of this DateTime
	   * @param {string} options.unit - use a specific unit; if omitted, the method will pick the unit. Use one of "years", "quarters", "months", "weeks", or "days"
	   * @param {string} options.numberingSystem - override the numberingSystem of this DateTime. The Intl system may choose not to honor this
	   * @example DateTime.now().plus({ days: 1 }).toRelativeCalendar() //=> "tomorrow"
	   * @example DateTime.now().setLocale("es").plus({ days: 1 }).toRelative() //=> ""mañana"
	   * @example DateTime.now().plus({ days: 1 }).toRelativeCalendar({ locale: "fr" }) //=> "demain"
	   * @example DateTime.now().minus({ days: 2 }).toRelativeCalendar() //=> "2 days ago"
	   */
	  ;

	  _proto.toRelativeCalendar = function toRelativeCalendar(options) {
	    if (options === void 0) {
	      options = {};
	    }

	    if (!this.isValid) return null;
	    return diffRelative(options.base || DateTime.fromObject({}, {
	      zone: this.zone
	    }), this, _extends({}, options, {
	      numeric: "auto",
	      units: ["years", "months", "days"],
	      calendary: true
	    }));
	  }
	  /**
	   * Return the min of several date times
	   * @param {...DateTime} dateTimes - the DateTimes from which to choose the minimum
	   * @return {DateTime} the min DateTime, or undefined if called with no argument
	   */
	  ;

	  DateTime.min = function min() {
	    for (var _len = arguments.length, dateTimes = new Array(_len), _key = 0; _key < _len; _key++) {
	      dateTimes[_key] = arguments[_key];
	    }

	    if (!dateTimes.every(DateTime.isDateTime)) {
	      throw new InvalidArgumentError("min requires all arguments be DateTimes");
	    }

	    return bestBy(dateTimes, function (i) {
	      return i.valueOf();
	    }, Math.min);
	  }
	  /**
	   * Return the max of several date times
	   * @param {...DateTime} dateTimes - the DateTimes from which to choose the maximum
	   * @return {DateTime} the max DateTime, or undefined if called with no argument
	   */
	  ;

	  DateTime.max = function max() {
	    for (var _len2 = arguments.length, dateTimes = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
	      dateTimes[_key2] = arguments[_key2];
	    }

	    if (!dateTimes.every(DateTime.isDateTime)) {
	      throw new InvalidArgumentError("max requires all arguments be DateTimes");
	    }

	    return bestBy(dateTimes, function (i) {
	      return i.valueOf();
	    }, Math.max);
	  } // MISC

	  /**
	   * Explain how a string would be parsed by fromFormat()
	   * @param {string} text - the string to parse
	   * @param {string} fmt - the format the string is expected to be in (see description)
	   * @param {Object} options - options taken by fromFormat()
	   * @return {Object}
	   */
	  ;

	  DateTime.fromFormatExplain = function fromFormatExplain(text, fmt, options) {
	    if (options === void 0) {
	      options = {};
	    }

	    var _options = options,
	        _options$locale = _options.locale,
	        locale = _options$locale === void 0 ? null : _options$locale,
	        _options$numberingSys = _options.numberingSystem,
	        numberingSystem = _options$numberingSys === void 0 ? null : _options$numberingSys,
	        localeToUse = Locale.fromOpts({
	      locale: locale,
	      numberingSystem: numberingSystem,
	      defaultToEN: true
	    });
	    return explainFromTokens(localeToUse, text, fmt);
	  }
	  /**
	   * @deprecated use fromFormatExplain instead
	   */
	  ;

	  DateTime.fromStringExplain = function fromStringExplain(text, fmt, options) {
	    if (options === void 0) {
	      options = {};
	    }

	    return DateTime.fromFormatExplain(text, fmt, options);
	  } // FORMAT PRESETS

	  /**
	   * {@link DateTime.toLocaleString} format like 10/14/1983
	   * @type {Object}
	   */
	  ;

	  _createClass(DateTime, [{
	    key: "isValid",
	    get: function get() {
	      return this.invalid === null;
	    }
	    /**
	     * Returns an error code if this DateTime is invalid, or null if the DateTime is valid
	     * @type {string}
	     */

	  }, {
	    key: "invalidReason",
	    get: function get() {
	      return this.invalid ? this.invalid.reason : null;
	    }
	    /**
	     * Returns an explanation of why this DateTime became invalid, or null if the DateTime is valid
	     * @type {string}
	     */

	  }, {
	    key: "invalidExplanation",
	    get: function get() {
	      return this.invalid ? this.invalid.explanation : null;
	    }
	    /**
	     * Get the locale of a DateTime, such 'en-GB'. The locale is used when formatting the DateTime
	     *
	     * @type {string}
	     */

	  }, {
	    key: "locale",
	    get: function get() {
	      return this.isValid ? this.loc.locale : null;
	    }
	    /**
	     * Get the numbering system of a DateTime, such 'beng'. The numbering system is used when formatting the DateTime
	     *
	     * @type {string}
	     */

	  }, {
	    key: "numberingSystem",
	    get: function get() {
	      return this.isValid ? this.loc.numberingSystem : null;
	    }
	    /**
	     * Get the output calendar of a DateTime, such 'islamic'. The output calendar is used when formatting the DateTime
	     *
	     * @type {string}
	     */

	  }, {
	    key: "outputCalendar",
	    get: function get() {
	      return this.isValid ? this.loc.outputCalendar : null;
	    }
	    /**
	     * Get the time zone associated with this DateTime.
	     * @type {Zone}
	     */

	  }, {
	    key: "zone",
	    get: function get() {
	      return this._zone;
	    }
	    /**
	     * Get the name of the time zone.
	     * @type {string}
	     */

	  }, {
	    key: "zoneName",
	    get: function get() {
	      return this.isValid ? this.zone.name : null;
	    }
	    /**
	     * Get the year
	     * @example DateTime.local(2017, 5, 25).year //=> 2017
	     * @type {number}
	     */

	  }, {
	    key: "year",
	    get: function get() {
	      return this.isValid ? this.c.year : NaN;
	    }
	    /**
	     * Get the quarter
	     * @example DateTime.local(2017, 5, 25).quarter //=> 2
	     * @type {number}
	     */

	  }, {
	    key: "quarter",
	    get: function get() {
	      return this.isValid ? Math.ceil(this.c.month / 3) : NaN;
	    }
	    /**
	     * Get the month (1-12).
	     * @example DateTime.local(2017, 5, 25).month //=> 5
	     * @type {number}
	     */

	  }, {
	    key: "month",
	    get: function get() {
	      return this.isValid ? this.c.month : NaN;
	    }
	    /**
	     * Get the day of the month (1-30ish).
	     * @example DateTime.local(2017, 5, 25).day //=> 25
	     * @type {number}
	     */

	  }, {
	    key: "day",
	    get: function get() {
	      return this.isValid ? this.c.day : NaN;
	    }
	    /**
	     * Get the hour of the day (0-23).
	     * @example DateTime.local(2017, 5, 25, 9).hour //=> 9
	     * @type {number}
	     */

	  }, {
	    key: "hour",
	    get: function get() {
	      return this.isValid ? this.c.hour : NaN;
	    }
	    /**
	     * Get the minute of the hour (0-59).
	     * @example DateTime.local(2017, 5, 25, 9, 30).minute //=> 30
	     * @type {number}
	     */

	  }, {
	    key: "minute",
	    get: function get() {
	      return this.isValid ? this.c.minute : NaN;
	    }
	    /**
	     * Get the second of the minute (0-59).
	     * @example DateTime.local(2017, 5, 25, 9, 30, 52).second //=> 52
	     * @type {number}
	     */

	  }, {
	    key: "second",
	    get: function get() {
	      return this.isValid ? this.c.second : NaN;
	    }
	    /**
	     * Get the millisecond of the second (0-999).
	     * @example DateTime.local(2017, 5, 25, 9, 30, 52, 654).millisecond //=> 654
	     * @type {number}
	     */

	  }, {
	    key: "millisecond",
	    get: function get() {
	      return this.isValid ? this.c.millisecond : NaN;
	    }
	    /**
	     * Get the week year
	     * @see https://en.wikipedia.org/wiki/ISO_week_date
	     * @example DateTime.local(2014, 12, 31).weekYear //=> 2015
	     * @type {number}
	     */

	  }, {
	    key: "weekYear",
	    get: function get() {
	      return this.isValid ? possiblyCachedWeekData(this).weekYear : NaN;
	    }
	    /**
	     * Get the week number of the week year (1-52ish).
	     * @see https://en.wikipedia.org/wiki/ISO_week_date
	     * @example DateTime.local(2017, 5, 25).weekNumber //=> 21
	     * @type {number}
	     */

	  }, {
	    key: "weekNumber",
	    get: function get() {
	      return this.isValid ? possiblyCachedWeekData(this).weekNumber : NaN;
	    }
	    /**
	     * Get the day of the week.
	     * 1 is Monday and 7 is Sunday
	     * @see https://en.wikipedia.org/wiki/ISO_week_date
	     * @example DateTime.local(2014, 11, 31).weekday //=> 4
	     * @type {number}
	     */

	  }, {
	    key: "weekday",
	    get: function get() {
	      return this.isValid ? possiblyCachedWeekData(this).weekday : NaN;
	    }
	    /**
	     * Get the ordinal (meaning the day of the year)
	     * @example DateTime.local(2017, 5, 25).ordinal //=> 145
	     * @type {number|DateTime}
	     */

	  }, {
	    key: "ordinal",
	    get: function get() {
	      return this.isValid ? gregorianToOrdinal(this.c).ordinal : NaN;
	    }
	    /**
	     * Get the human readable short month name, such as 'Oct'.
	     * Defaults to the system's locale if no locale has been specified
	     * @example DateTime.local(2017, 10, 30).monthShort //=> Oct
	     * @type {string}
	     */

	  }, {
	    key: "monthShort",
	    get: function get() {
	      return this.isValid ? Info$1.months("short", {
	        locObj: this.loc
	      })[this.month - 1] : null;
	    }
	    /**
	     * Get the human readable long month name, such as 'October'.
	     * Defaults to the system's locale if no locale has been specified
	     * @example DateTime.local(2017, 10, 30).monthLong //=> October
	     * @type {string}
	     */

	  }, {
	    key: "monthLong",
	    get: function get() {
	      return this.isValid ? Info$1.months("long", {
	        locObj: this.loc
	      })[this.month - 1] : null;
	    }
	    /**
	     * Get the human readable short weekday, such as 'Mon'.
	     * Defaults to the system's locale if no locale has been specified
	     * @example DateTime.local(2017, 10, 30).weekdayShort //=> Mon
	     * @type {string}
	     */

	  }, {
	    key: "weekdayShort",
	    get: function get() {
	      return this.isValid ? Info$1.weekdays("short", {
	        locObj: this.loc
	      })[this.weekday - 1] : null;
	    }
	    /**
	     * Get the human readable long weekday, such as 'Monday'.
	     * Defaults to the system's locale if no locale has been specified
	     * @example DateTime.local(2017, 10, 30).weekdayLong //=> Monday
	     * @type {string}
	     */

	  }, {
	    key: "weekdayLong",
	    get: function get() {
	      return this.isValid ? Info$1.weekdays("long", {
	        locObj: this.loc
	      })[this.weekday - 1] : null;
	    }
	    /**
	     * Get the UTC offset of this DateTime in minutes
	     * @example DateTime.now().offset //=> -240
	     * @example DateTime.utc().offset //=> 0
	     * @type {number}
	     */

	  }, {
	    key: "offset",
	    get: function get() {
	      return this.isValid ? +this.o : NaN;
	    }
	    /**
	     * Get the short human name for the zone's current offset, for example "EST" or "EDT".
	     * Defaults to the system's locale if no locale has been specified
	     * @type {string}
	     */

	  }, {
	    key: "offsetNameShort",
	    get: function get() {
	      if (this.isValid) {
	        return this.zone.offsetName(this.ts, {
	          format: "short",
	          locale: this.locale
	        });
	      } else {
	        return null;
	      }
	    }
	    /**
	     * Get the long human name for the zone's current offset, for example "Eastern Standard Time" or "Eastern Daylight Time".
	     * Defaults to the system's locale if no locale has been specified
	     * @type {string}
	     */

	  }, {
	    key: "offsetNameLong",
	    get: function get() {
	      if (this.isValid) {
	        return this.zone.offsetName(this.ts, {
	          format: "long",
	          locale: this.locale
	        });
	      } else {
	        return null;
	      }
	    }
	    /**
	     * Get whether this zone's offset ever changes, as in a DST.
	     * @type {boolean}
	     */

	  }, {
	    key: "isOffsetFixed",
	    get: function get() {
	      return this.isValid ? this.zone.isUniversal : null;
	    }
	    /**
	     * Get whether the DateTime is in a DST.
	     * @type {boolean}
	     */

	  }, {
	    key: "isInDST",
	    get: function get() {
	      if (this.isOffsetFixed) {
	        return false;
	      } else {
	        return this.offset > this.set({
	          month: 1
	        }).offset || this.offset > this.set({
	          month: 5
	        }).offset;
	      }
	    }
	    /**
	     * Returns true if this DateTime is in a leap year, false otherwise
	     * @example DateTime.local(2016).isInLeapYear //=> true
	     * @example DateTime.local(2013).isInLeapYear //=> false
	     * @type {boolean}
	     */

	  }, {
	    key: "isInLeapYear",
	    get: function get() {
	      return isLeapYear(this.year);
	    }
	    /**
	     * Returns the number of days in this DateTime's month
	     * @example DateTime.local(2016, 2).daysInMonth //=> 29
	     * @example DateTime.local(2016, 3).daysInMonth //=> 31
	     * @type {number}
	     */

	  }, {
	    key: "daysInMonth",
	    get: function get() {
	      return daysInMonth(this.year, this.month);
	    }
	    /**
	     * Returns the number of days in this DateTime's year
	     * @example DateTime.local(2016).daysInYear //=> 366
	     * @example DateTime.local(2013).daysInYear //=> 365
	     * @type {number}
	     */

	  }, {
	    key: "daysInYear",
	    get: function get() {
	      return this.isValid ? daysInYear(this.year) : NaN;
	    }
	    /**
	     * Returns the number of weeks in this DateTime's year
	     * @see https://en.wikipedia.org/wiki/ISO_week_date
	     * @example DateTime.local(2004).weeksInWeekYear //=> 53
	     * @example DateTime.local(2013).weeksInWeekYear //=> 52
	     * @type {number}
	     */

	  }, {
	    key: "weeksInWeekYear",
	    get: function get() {
	      return this.isValid ? weeksInWeekYear(this.weekYear) : NaN;
	    }
	  }], [{
	    key: "DATE_SHORT",
	    get: function get() {
	      return DATE_SHORT;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like 'Oct 14, 1983'
	     * @type {Object}
	     */

	  }, {
	    key: "DATE_MED",
	    get: function get() {
	      return DATE_MED;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like 'Fri, Oct 14, 1983'
	     * @type {Object}
	     */

	  }, {
	    key: "DATE_MED_WITH_WEEKDAY",
	    get: function get() {
	      return DATE_MED_WITH_WEEKDAY;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like 'October 14, 1983'
	     * @type {Object}
	     */

	  }, {
	    key: "DATE_FULL",
	    get: function get() {
	      return DATE_FULL;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like 'Tuesday, October 14, 1983'
	     * @type {Object}
	     */

	  }, {
	    key: "DATE_HUGE",
	    get: function get() {
	      return DATE_HUGE;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like '09:30 AM'. Only 12-hour if the locale is.
	     * @type {Object}
	     */

	  }, {
	    key: "TIME_SIMPLE",
	    get: function get() {
	      return TIME_SIMPLE;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like '09:30:23 AM'. Only 12-hour if the locale is.
	     * @type {Object}
	     */

	  }, {
	    key: "TIME_WITH_SECONDS",
	    get: function get() {
	      return TIME_WITH_SECONDS;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like '09:30:23 AM EDT'. Only 12-hour if the locale is.
	     * @type {Object}
	     */

	  }, {
	    key: "TIME_WITH_SHORT_OFFSET",
	    get: function get() {
	      return TIME_WITH_SHORT_OFFSET;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like '09:30:23 AM Eastern Daylight Time'. Only 12-hour if the locale is.
	     * @type {Object}
	     */

	  }, {
	    key: "TIME_WITH_LONG_OFFSET",
	    get: function get() {
	      return TIME_WITH_LONG_OFFSET;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like '09:30', always 24-hour.
	     * @type {Object}
	     */

	  }, {
	    key: "TIME_24_SIMPLE",
	    get: function get() {
	      return TIME_24_SIMPLE;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like '09:30:23', always 24-hour.
	     * @type {Object}
	     */

	  }, {
	    key: "TIME_24_WITH_SECONDS",
	    get: function get() {
	      return TIME_24_WITH_SECONDS;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like '09:30:23 EDT', always 24-hour.
	     * @type {Object}
	     */

	  }, {
	    key: "TIME_24_WITH_SHORT_OFFSET",
	    get: function get() {
	      return TIME_24_WITH_SHORT_OFFSET;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like '09:30:23 Eastern Daylight Time', always 24-hour.
	     * @type {Object}
	     */

	  }, {
	    key: "TIME_24_WITH_LONG_OFFSET",
	    get: function get() {
	      return TIME_24_WITH_LONG_OFFSET;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like '10/14/1983, 9:30 AM'. Only 12-hour if the locale is.
	     * @type {Object}
	     */

	  }, {
	    key: "DATETIME_SHORT",
	    get: function get() {
	      return DATETIME_SHORT;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like '10/14/1983, 9:30:33 AM'. Only 12-hour if the locale is.
	     * @type {Object}
	     */

	  }, {
	    key: "DATETIME_SHORT_WITH_SECONDS",
	    get: function get() {
	      return DATETIME_SHORT_WITH_SECONDS;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like 'Oct 14, 1983, 9:30 AM'. Only 12-hour if the locale is.
	     * @type {Object}
	     */

	  }, {
	    key: "DATETIME_MED",
	    get: function get() {
	      return DATETIME_MED;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like 'Oct 14, 1983, 9:30:33 AM'. Only 12-hour if the locale is.
	     * @type {Object}
	     */

	  }, {
	    key: "DATETIME_MED_WITH_SECONDS",
	    get: function get() {
	      return DATETIME_MED_WITH_SECONDS;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like 'Fri, 14 Oct 1983, 9:30 AM'. Only 12-hour if the locale is.
	     * @type {Object}
	     */

	  }, {
	    key: "DATETIME_MED_WITH_WEEKDAY",
	    get: function get() {
	      return DATETIME_MED_WITH_WEEKDAY;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like 'October 14, 1983, 9:30 AM EDT'. Only 12-hour if the locale is.
	     * @type {Object}
	     */

	  }, {
	    key: "DATETIME_FULL",
	    get: function get() {
	      return DATETIME_FULL;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like 'October 14, 1983, 9:30:33 AM EDT'. Only 12-hour if the locale is.
	     * @type {Object}
	     */

	  }, {
	    key: "DATETIME_FULL_WITH_SECONDS",
	    get: function get() {
	      return DATETIME_FULL_WITH_SECONDS;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like 'Friday, October 14, 1983, 9:30 AM Eastern Daylight Time'. Only 12-hour if the locale is.
	     * @type {Object}
	     */

	  }, {
	    key: "DATETIME_HUGE",
	    get: function get() {
	      return DATETIME_HUGE;
	    }
	    /**
	     * {@link DateTime.toLocaleString} format like 'Friday, October 14, 1983, 9:30:33 AM Eastern Daylight Time'. Only 12-hour if the locale is.
	     * @type {Object}
	     */

	  }, {
	    key: "DATETIME_HUGE_WITH_SECONDS",
	    get: function get() {
	      return DATETIME_HUGE_WITH_SECONDS;
	    }
	  }]);

	  return DateTime;
	}();
	function friendlyDateTime(dateTimeish) {
	  if (DateTime.isDateTime(dateTimeish)) {
	    return dateTimeish;
	  } else if (dateTimeish && dateTimeish.valueOf && isNumber(dateTimeish.valueOf())) {
	    return DateTime.fromJSDate(dateTimeish);
	  } else if (dateTimeish && typeof dateTimeish === "object") {
	    return DateTime.fromObject(dateTimeish);
	  } else {
	    throw new InvalidArgumentError("Unknown datetime argument: " + dateTimeish + ", of type " + typeof dateTimeish);
	  }
	}

	var VERSION = "2.0.2";

	var DateTime_1 = luxon.DateTime = DateTime;
	var Duration_1 = luxon.Duration = Duration;
	luxon.FixedOffsetZone = FixedOffsetZone;
	luxon.IANAZone = IANAZone;
	luxon.Info = Info$1;
	luxon.Interval = Interval;
	luxon.InvalidZone = InvalidZone;
	luxon.Settings = Settings;
	luxon.SystemZone = SystemZone;
	luxon.VERSION = VERSION;
	luxon.Zone = Zone;

	const UserInfoContext = React$2.createContext({
	    loggedIn: false,
	    email: null,
	    modMode: false,
	    projectId: null,
	    userId: null,
	    activated: false,
	    readOnly: true,
	    emailVerifyCanceled: null,
	    emailVerified: null,
	    twoFactorActive: false,
	    deleteAfter: null,
	});

	const UserInfoProvider

	 = ({ children }) => {
	    const { data: wireUserInfo } = trpc.login.loggedIn.useQuery(undefined, {
	        refetchInterval: false, refetchOnReconnect: false, refetchOnWindowFocus: false, refetchIntervalInBackground: false,
	        suspense: true,
	        notifyOnChangeProps: ["data", "error"],
	    });

	    // convert delete-after from string to date object
	    let userInfo;

	    if (wireUserInfo && wireUserInfo.loggedIn) {
	        userInfo = {
	            ...wireUserInfo,
	            deleteAfter: wireUserInfo.deleteAfter
	                ? DateTime_1.fromISO(wireUserInfo.deleteAfter)
	                : null,
	        };
	    } else if (wireUserInfo) {
	        userInfo = wireUserInfo;
	    }

	    const updateContext = index_browserExports.useUnleashContext() 

	;

	    /**
	     * refresh if we log out or the active project/user changes.
	     * this helps prevent stale requests from going out, helping prevent
	     * unintended behavior for users and keeping things Fresh.
	     * we don't reload on `logged out -> logged in` b/c on the subdomain this
	     * defaults to logged out and we would just reload every time.
	     */
	    const previousUserInfo = usePrevious(userInfo);
	    reactExports.useEffect(() => {
	        // type check to logged in
	        if (userInfo?.loggedIn === true) {
	            if (previousUserInfo?.loggedIn) {
	                if (
	                    userInfo.projectId !== previousUserInfo.projectId ||
	                    userInfo.userId !== previousUserInfo.userId
	                ) {
	                    // we're someone else! refresh
	                    window.location.reload();
	                }
	            }
	        } else {
	            if (previousUserInfo?.loggedIn) {
	                // we logged out! refresh
	                window.location.reload();
	            }
	        }
	    }, [
	        previousUserInfo,
	        previousUserInfo?.loggedIn,
	        userInfo?.loggedIn,
	        userInfo?.projectId,
	        userInfo?.userId,
	    ]);

	    reactExports.useEffect(() => {
	        reactExports.startTransition(() => {
	            void updateContext({
	                userId: userInfo?.loggedIn
	                    ? userInfo.userId.toString() ?? undefined
	                    : undefined,
	            });
	        });
	    }, [updateContext, userInfo, userInfo?.loggedIn]);

	    return (
	        // we're using `suspense: true` in the fetcher so userInfo will never
	        // actually be undefined.
	        // we can only get away with this b/c we're pre-fetching in the server!
	        React$2.createElement(UserInfoContext.Provider, { value: userInfo,}
	            , children
	        )
	    );
	};

	const useUserInfo = () => reactExports.useContext(UserInfoContext);

	const useRequiresLogin = () => {
	    const userInfo = useUserInfo();
	    const location = useLocation();

	    if (!userInfo.loggedIn) {
	        throw new RequiresLoginError("Requires login", location.pathname);
	    }
	};

	// ensure the broken attachment icon actually gets its hash icon in /static/

	const App = ({
	    children,
	}) => {
	    const siteConfig = loadJSONFromID(
	        ClientStateID$1.SITE_CONFIG
	    );
	    const initialI18nStore = loadJSONFromID(
	        ClientStateID$1.INITIAL_I18N_STORE
	    );
	    const initialLanguage = loadJSONFromID(
	        ClientStateID$1.INITIAL_LANGUAGE
	    );

	    const flashes = loadJSONFromID(
	        ClientStateID$1.FLASHES
	    );

	    const rollbarConfig = loadJSONFromID(
	        ClientStateID$1.ROLLBAR_CONFIG
	    );

	    const unleashBootstrap = loadJSONFromID(
	        ClientStateID$1.UNLEASH_BOOTSTRAP
	    );

	    const mutableStore = loadJSONFromID(
	        ClientStateID$1.INITIAL_MUTABLE_STORE
	    );

	    const unleashConfig = {
	        appName: siteConfig.UNLEASH_APP_NAME,
	        url: sitemap.public.unleashProxy().toString(),
	        clientKey: siteConfig.UNLEASH_CLIENT_KEY,
	        bootstrap: unleashBootstrap,
	        disableRefresh: true,
	    };
	    const dehyrdatedState = loadJSONFromID(ClientStateID$1.TRPC_DEHYRDATED_STATE);

	    useSSR$1(initialI18nStore, initialLanguage);

	    const [queryClient] = reactExports.useState(() => new QueryClient());
	    const [trpcClient] = reactExports.useState(() =>
	        trpc.createClient({
	            links: [
	                httpBatchLink({
	                    url: sitemap.public.apiV1.trpc().toString(),
	                    maxURLLength: 2083,
	                    fetch(url, options) {
	                        return fetch(url, {
	                            ...options,
	                            credentials: "include",
	                        });
	                    },
	                }),
	            ],
	        })
	    );

	    return (
	        React$2.createElement(React$2.StrictMode, null
	            , React$2.createElement(trpc.Provider, { client: trpcClient, queryClient: queryClient,}
	                , React$2.createElement(QueryClientProvider, { client: queryClient,}
	                    , React$2.createElement(Hydrate, { state: dehyrdatedState,}
	                        , React$2.createElement(HelmetProvider, null
	                            , React$2.createElement(RollbarProvider, { config: rollbarConfig,}
	                                , React$2.createElement(FlagsProvider, { config: unleashConfig,}
	                                    , React$2.createElement(UserInfoProvider, null
	                                        , React$2.createElement(FlashesProvider.Provider, {
	                                            value: flashes,}

	                                            , React$2.createElement(SiteConfigProvider.Provider, {
	                                                value: siteConfig,}

	                                                , React$2.createElement(ReqMutableStoreProvider, {
	                                                    store: mutableStore,}

	                                                    , children
	                                                )
	                                            )
	                                        )
	                                    )
	                                )
	                            )
	                        )
	                    )
	                )
	            )
	        )
	    );
	};

	var createPlugin$2 = {};

	var createPlugin$1 = {};

	(function (exports) {
		Object.defineProperty(exports, "__esModule", {
		    value: true
		});
		Object.defineProperty(exports, "default", {
		    enumerable: true,
		    get: function() {
		        return _default;
		    }
		});
		function createPlugin(plugin, config) {
		    return {
		        handler: plugin,
		        config
		    };
		}
		createPlugin.withOptions = function(pluginFunction, configFunction = ()=>({})) {
		    const optionsFunction = function(options) {
		        return {
		            __options: options,
		            handler: pluginFunction(options),
		            config: configFunction(options)
		        };
		    };
		    optionsFunction.__isOptionsFunction = true;
		    // Expose plugin dependencies so that `object-hash` returns a different
		    // value if anything here changes, to ensure a rebuild is triggered.
		    optionsFunction.__pluginFunction = pluginFunction;
		    optionsFunction.__configFunction = configFunction;
		    return optionsFunction;
		};
		const _default = createPlugin; 
	} (createPlugin$1));

	(function (exports) {
		Object.defineProperty(exports, "__esModule", {
		    value: true
		});
		Object.defineProperty(exports, "default", {
		    enumerable: true,
		    get: function() {
		        return _default;
		    }
		});
		const _createPlugin = /*#__PURE__*/ _interop_require_default(createPlugin$1);
		function _interop_require_default(obj) {
		    return obj && obj.__esModule ? obj : {
		        default: obj
		    };
		}
		const _default = _createPlugin.default; 
	} (createPlugin$2));

	let createPlugin = createPlugin$2;
	var plugin$3 = (createPlugin.__esModule ? createPlugin : { default: createPlugin }).default;

	var colors$2 = {};

	var log$1 = {};

	var picocolors_browser = {exports: {}};

	var x$5=String;
	var create$1=function() {return {isColorSupported:false,reset:x$5,bold:x$5,dim:x$5,italic:x$5,underline:x$5,inverse:x$5,hidden:x$5,strikethrough:x$5,black:x$5,red:x$5,green:x$5,yellow:x$5,blue:x$5,magenta:x$5,cyan:x$5,white:x$5,gray:x$5,bgBlack:x$5,bgRed:x$5,bgGreen:x$5,bgYellow:x$5,bgBlue:x$5,bgMagenta:x$5,bgCyan:x$5,bgWhite:x$5}};
	picocolors_browser.exports=create$1();
	picocolors_browser.exports.createColors = create$1;

	var picocolors_browserExports = picocolors_browser.exports;

	(function (exports) {
		Object.defineProperty(exports, "__esModule", {
		    value: true
		});
		function _export(target, all) {
		    for(var name in all)Object.defineProperty(target, name, {
		        enumerable: true,
		        get: all[name]
		    });
		}
		_export(exports, {
		    dim: function() {
		        return dim;
		    },
		    default: function() {
		        return _default;
		    }
		});
		const _picocolors = /*#__PURE__*/ _interop_require_default(picocolors_browserExports);
		function _interop_require_default(obj) {
		    return obj && obj.__esModule ? obj : {
		        default: obj
		    };
		}
		let alreadyShown = new Set();
		function log(type, messages, key) {
		    if (typeof process !== "undefined" && process.env.JEST_WORKER_ID) return;
		    if (key && alreadyShown.has(key)) return;
		    if (key) alreadyShown.add(key);
		    console.warn("");
		    messages.forEach((message)=>console.warn(type, "-", message));
		}
		function dim(input) {
		    return _picocolors.default.dim(input);
		}
		const _default = {
		    info (key, messages) {
		        log(_picocolors.default.bold(_picocolors.default.cyan("info")), ...Array.isArray(key) ? [
		            key
		        ] : [
		            messages,
		            key
		        ]);
		    },
		    warn (key, messages) {
		        log(_picocolors.default.bold(_picocolors.default.yellow("warn")), ...Array.isArray(key) ? [
		            key
		        ] : [
		            messages,
		            key
		        ]);
		    },
		    risk (key, messages) {
		        log(_picocolors.default.bold(_picocolors.default.magenta("risk")), ...Array.isArray(key) ? [
		            key
		        ] : [
		            messages,
		            key
		        ]);
		    }
		}; 
	} (log$1));

	(function (exports) {
		Object.defineProperty(exports, "__esModule", {
		    value: true
		});
		Object.defineProperty(exports, "default", {
		    enumerable: true,
		    get: function() {
		        return _default;
		    }
		});
		const _log = /*#__PURE__*/ _interop_require_default(log$1);
		function _interop_require_default(obj) {
		    return obj && obj.__esModule ? obj : {
		        default: obj
		    };
		}
		function warn({ version , from , to  }) {
		    _log.default.warn(`${from}-color-renamed`, [
		        `As of Tailwind CSS ${version}, \`${from}\` has been renamed to \`${to}\`.`,
		        "Update your configuration file to silence this warning."
		    ]);
		}
		const _default = {
		    inherit: "inherit",
		    current: "currentColor",
		    transparent: "transparent",
		    black: "#000",
		    white: "#fff",
		    slate: {
		        50: "#f8fafc",
		        100: "#f1f5f9",
		        200: "#e2e8f0",
		        300: "#cbd5e1",
		        400: "#94a3b8",
		        500: "#64748b",
		        600: "#475569",
		        700: "#334155",
		        800: "#1e293b",
		        900: "#0f172a",
		        950: "#020617"
		    },
		    gray: {
		        50: "#f9fafb",
		        100: "#f3f4f6",
		        200: "#e5e7eb",
		        300: "#d1d5db",
		        400: "#9ca3af",
		        500: "#6b7280",
		        600: "#4b5563",
		        700: "#374151",
		        800: "#1f2937",
		        900: "#111827",
		        950: "#030712"
		    },
		    zinc: {
		        50: "#fafafa",
		        100: "#f4f4f5",
		        200: "#e4e4e7",
		        300: "#d4d4d8",
		        400: "#a1a1aa",
		        500: "#71717a",
		        600: "#52525b",
		        700: "#3f3f46",
		        800: "#27272a",
		        900: "#18181b",
		        950: "#09090b"
		    },
		    neutral: {
		        50: "#fafafa",
		        100: "#f5f5f5",
		        200: "#e5e5e5",
		        300: "#d4d4d4",
		        400: "#a3a3a3",
		        500: "#737373",
		        600: "#525252",
		        700: "#404040",
		        800: "#262626",
		        900: "#171717",
		        950: "#0a0a0a"
		    },
		    stone: {
		        50: "#fafaf9",
		        100: "#f5f5f4",
		        200: "#e7e5e4",
		        300: "#d6d3d1",
		        400: "#a8a29e",
		        500: "#78716c",
		        600: "#57534e",
		        700: "#44403c",
		        800: "#292524",
		        900: "#1c1917",
		        950: "#0c0a09"
		    },
		    red: {
		        50: "#fef2f2",
		        100: "#fee2e2",
		        200: "#fecaca",
		        300: "#fca5a5",
		        400: "#f87171",
		        500: "#ef4444",
		        600: "#dc2626",
		        700: "#b91c1c",
		        800: "#991b1b",
		        900: "#7f1d1d",
		        950: "#450a0a"
		    },
		    orange: {
		        50: "#fff7ed",
		        100: "#ffedd5",
		        200: "#fed7aa",
		        300: "#fdba74",
		        400: "#fb923c",
		        500: "#f97316",
		        600: "#ea580c",
		        700: "#c2410c",
		        800: "#9a3412",
		        900: "#7c2d12",
		        950: "#431407"
		    },
		    amber: {
		        50: "#fffbeb",
		        100: "#fef3c7",
		        200: "#fde68a",
		        300: "#fcd34d",
		        400: "#fbbf24",
		        500: "#f59e0b",
		        600: "#d97706",
		        700: "#b45309",
		        800: "#92400e",
		        900: "#78350f",
		        950: "#451a03"
		    },
		    yellow: {
		        50: "#fefce8",
		        100: "#fef9c3",
		        200: "#fef08a",
		        300: "#fde047",
		        400: "#facc15",
		        500: "#eab308",
		        600: "#ca8a04",
		        700: "#a16207",
		        800: "#854d0e",
		        900: "#713f12",
		        950: "#422006"
		    },
		    lime: {
		        50: "#f7fee7",
		        100: "#ecfccb",
		        200: "#d9f99d",
		        300: "#bef264",
		        400: "#a3e635",
		        500: "#84cc16",
		        600: "#65a30d",
		        700: "#4d7c0f",
		        800: "#3f6212",
		        900: "#365314",
		        950: "#1a2e05"
		    },
		    green: {
		        50: "#f0fdf4",
		        100: "#dcfce7",
		        200: "#bbf7d0",
		        300: "#86efac",
		        400: "#4ade80",
		        500: "#22c55e",
		        600: "#16a34a",
		        700: "#15803d",
		        800: "#166534",
		        900: "#14532d",
		        950: "#052e16"
		    },
		    emerald: {
		        50: "#ecfdf5",
		        100: "#d1fae5",
		        200: "#a7f3d0",
		        300: "#6ee7b7",
		        400: "#34d399",
		        500: "#10b981",
		        600: "#059669",
		        700: "#047857",
		        800: "#065f46",
		        900: "#064e3b",
		        950: "#022c22"
		    },
		    teal: {
		        50: "#f0fdfa",
		        100: "#ccfbf1",
		        200: "#99f6e4",
		        300: "#5eead4",
		        400: "#2dd4bf",
		        500: "#14b8a6",
		        600: "#0d9488",
		        700: "#0f766e",
		        800: "#115e59",
		        900: "#134e4a",
		        950: "#042f2e"
		    },
		    cyan: {
		        50: "#ecfeff",
		        100: "#cffafe",
		        200: "#a5f3fc",
		        300: "#67e8f9",
		        400: "#22d3ee",
		        500: "#06b6d4",
		        600: "#0891b2",
		        700: "#0e7490",
		        800: "#155e75",
		        900: "#164e63",
		        950: "#083344"
		    },
		    sky: {
		        50: "#f0f9ff",
		        100: "#e0f2fe",
		        200: "#bae6fd",
		        300: "#7dd3fc",
		        400: "#38bdf8",
		        500: "#0ea5e9",
		        600: "#0284c7",
		        700: "#0369a1",
		        800: "#075985",
		        900: "#0c4a6e",
		        950: "#082f49"
		    },
		    blue: {
		        50: "#eff6ff",
		        100: "#dbeafe",
		        200: "#bfdbfe",
		        300: "#93c5fd",
		        400: "#60a5fa",
		        500: "#3b82f6",
		        600: "#2563eb",
		        700: "#1d4ed8",
		        800: "#1e40af",
		        900: "#1e3a8a",
		        950: "#172554"
		    },
		    indigo: {
		        50: "#eef2ff",
		        100: "#e0e7ff",
		        200: "#c7d2fe",
		        300: "#a5b4fc",
		        400: "#818cf8",
		        500: "#6366f1",
		        600: "#4f46e5",
		        700: "#4338ca",
		        800: "#3730a3",
		        900: "#312e81",
		        950: "#1e1b4b"
		    },
		    violet: {
		        50: "#f5f3ff",
		        100: "#ede9fe",
		        200: "#ddd6fe",
		        300: "#c4b5fd",
		        400: "#a78bfa",
		        500: "#8b5cf6",
		        600: "#7c3aed",
		        700: "#6d28d9",
		        800: "#5b21b6",
		        900: "#4c1d95",
		        950: "#2e1065"
		    },
		    purple: {
		        50: "#faf5ff",
		        100: "#f3e8ff",
		        200: "#e9d5ff",
		        300: "#d8b4fe",
		        400: "#c084fc",
		        500: "#a855f7",
		        600: "#9333ea",
		        700: "#7e22ce",
		        800: "#6b21a8",
		        900: "#581c87",
		        950: "#3b0764"
		    },
		    fuchsia: {
		        50: "#fdf4ff",
		        100: "#fae8ff",
		        200: "#f5d0fe",
		        300: "#f0abfc",
		        400: "#e879f9",
		        500: "#d946ef",
		        600: "#c026d3",
		        700: "#a21caf",
		        800: "#86198f",
		        900: "#701a75",
		        950: "#4a044e"
		    },
		    pink: {
		        50: "#fdf2f8",
		        100: "#fce7f3",
		        200: "#fbcfe8",
		        300: "#f9a8d4",
		        400: "#f472b6",
		        500: "#ec4899",
		        600: "#db2777",
		        700: "#be185d",
		        800: "#9d174d",
		        900: "#831843",
		        950: "#500724"
		    },
		    rose: {
		        50: "#fff1f2",
		        100: "#ffe4e6",
		        200: "#fecdd3",
		        300: "#fda4af",
		        400: "#fb7185",
		        500: "#f43f5e",
		        600: "#e11d48",
		        700: "#be123c",
		        800: "#9f1239",
		        900: "#881337",
		        950: "#4c0519"
		    },
		    get lightBlue () {
		        warn({
		            version: "v2.2",
		            from: "lightBlue",
		            to: "sky"
		        });
		        return this.sky;
		    },
		    get warmGray () {
		        warn({
		            version: "v3.0",
		            from: "warmGray",
		            to: "stone"
		        });
		        return this.stone;
		    },
		    get trueGray () {
		        warn({
		            version: "v3.0",
		            from: "trueGray",
		            to: "neutral"
		        });
		        return this.neutral;
		    },
		    get coolGray () {
		        warn({
		            version: "v3.0",
		            from: "coolGray",
		            to: "gray"
		        });
		        return this.gray;
		    },
		    get blueGray () {
		        warn({
		            version: "v3.0",
		            from: "blueGray",
		            to: "slate"
		        });
		        return this.slate;
		    }
		}; 
	} (colors$2));

	let colors$1 = colors$2;
	(colors$1.__esModule ? colors$1 : { default: colors$1 }).default;

	var defaultTheme$2 = {};

	var cloneDeep = {};

	(function (exports) {
		Object.defineProperty(exports, "__esModule", {
		    value: true
		});
		Object.defineProperty(exports, "cloneDeep", {
		    enumerable: true,
		    get: function() {
		        return cloneDeep;
		    }
		});
		function cloneDeep(value) {
		    if (Array.isArray(value)) {
		        return value.map((child)=>cloneDeep(child));
		    }
		    if (typeof value === "object" && value !== null) {
		        return Object.fromEntries(Object.entries(value).map(([k, v])=>[
		                k,
		                cloneDeep(v)
		            ]));
		    }
		    return value;
		} 
	} (cloneDeep));

	var config_full = {
	  content: [],
	  presets: [],
	  darkMode: 'media', // or 'class'
	  theme: {
	    accentColor: ({ theme }) => ({
	      ...theme('colors'),
	      auto: 'auto',
	    }),
	    animation: {
	      none: 'none',
	      spin: 'spin 1s linear infinite',
	      ping: 'ping 1s cubic-bezier(0, 0, 0.2, 1) infinite',
	      pulse: 'pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite',
	      bounce: 'bounce 1s infinite',
	    },
	    aria: {
	      busy: 'busy="true"',
	      checked: 'checked="true"',
	      disabled: 'disabled="true"',
	      expanded: 'expanded="true"',
	      hidden: 'hidden="true"',
	      pressed: 'pressed="true"',
	      readonly: 'readonly="true"',
	      required: 'required="true"',
	      selected: 'selected="true"',
	    },
	    aspectRatio: {
	      auto: 'auto',
	      square: '1 / 1',
	      video: '16 / 9',
	    },
	    backdropBlur: ({ theme }) => theme('blur'),
	    backdropBrightness: ({ theme }) => theme('brightness'),
	    backdropContrast: ({ theme }) => theme('contrast'),
	    backdropGrayscale: ({ theme }) => theme('grayscale'),
	    backdropHueRotate: ({ theme }) => theme('hueRotate'),
	    backdropInvert: ({ theme }) => theme('invert'),
	    backdropOpacity: ({ theme }) => theme('opacity'),
	    backdropSaturate: ({ theme }) => theme('saturate'),
	    backdropSepia: ({ theme }) => theme('sepia'),
	    backgroundColor: ({ theme }) => theme('colors'),
	    backgroundImage: {
	      none: 'none',
	      'gradient-to-t': 'linear-gradient(to top, var(--tw-gradient-stops))',
	      'gradient-to-tr': 'linear-gradient(to top right, var(--tw-gradient-stops))',
	      'gradient-to-r': 'linear-gradient(to right, var(--tw-gradient-stops))',
	      'gradient-to-br': 'linear-gradient(to bottom right, var(--tw-gradient-stops))',
	      'gradient-to-b': 'linear-gradient(to bottom, var(--tw-gradient-stops))',
	      'gradient-to-bl': 'linear-gradient(to bottom left, var(--tw-gradient-stops))',
	      'gradient-to-l': 'linear-gradient(to left, var(--tw-gradient-stops))',
	      'gradient-to-tl': 'linear-gradient(to top left, var(--tw-gradient-stops))',
	    },
	    backgroundOpacity: ({ theme }) => theme('opacity'),
	    backgroundPosition: {
	      bottom: 'bottom',
	      center: 'center',
	      left: 'left',
	      'left-bottom': 'left bottom',
	      'left-top': 'left top',
	      right: 'right',
	      'right-bottom': 'right bottom',
	      'right-top': 'right top',
	      top: 'top',
	    },
	    backgroundSize: {
	      auto: 'auto',
	      cover: 'cover',
	      contain: 'contain',
	    },
	    blur: {
	      0: '0',
	      none: '0',
	      sm: '4px',
	      DEFAULT: '8px',
	      md: '12px',
	      lg: '16px',
	      xl: '24px',
	      '2xl': '40px',
	      '3xl': '64px',
	    },
	    borderColor: ({ theme }) => ({
	      ...theme('colors'),
	      DEFAULT: theme('colors.gray.200', 'currentColor'),
	    }),
	    borderOpacity: ({ theme }) => theme('opacity'),
	    borderRadius: {
	      none: '0px',
	      sm: '0.125rem',
	      DEFAULT: '0.25rem',
	      md: '0.375rem',
	      lg: '0.5rem',
	      xl: '0.75rem',
	      '2xl': '1rem',
	      '3xl': '1.5rem',
	      full: '9999px',
	    },
	    borderSpacing: ({ theme }) => ({
	      ...theme('spacing'),
	    }),
	    borderWidth: {
	      DEFAULT: '1px',
	      0: '0px',
	      2: '2px',
	      4: '4px',
	      8: '8px',
	    },
	    boxShadow: {
	      sm: '0 1px 2px 0 rgb(0 0 0 / 0.05)',
	      DEFAULT: '0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1)',
	      md: '0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1)',
	      lg: '0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1)',
	      xl: '0 20px 25px -5px rgb(0 0 0 / 0.1), 0 8px 10px -6px rgb(0 0 0 / 0.1)',
	      '2xl': '0 25px 50px -12px rgb(0 0 0 / 0.25)',
	      inner: 'inset 0 2px 4px 0 rgb(0 0 0 / 0.05)',
	      none: 'none',
	    },
	    boxShadowColor: ({ theme }) => theme('colors'),
	    brightness: {
	      0: '0',
	      50: '.5',
	      75: '.75',
	      90: '.9',
	      95: '.95',
	      100: '1',
	      105: '1.05',
	      110: '1.1',
	      125: '1.25',
	      150: '1.5',
	      200: '2',
	    },
	    caretColor: ({ theme }) => theme('colors'),
	    colors: ({ colors }) => ({
	      inherit: colors.inherit,
	      current: colors.current,
	      transparent: colors.transparent,
	      black: colors.black,
	      white: colors.white,
	      slate: colors.slate,
	      gray: colors.gray,
	      zinc: colors.zinc,
	      neutral: colors.neutral,
	      stone: colors.stone,
	      red: colors.red,
	      orange: colors.orange,
	      amber: colors.amber,
	      yellow: colors.yellow,
	      lime: colors.lime,
	      green: colors.green,
	      emerald: colors.emerald,
	      teal: colors.teal,
	      cyan: colors.cyan,
	      sky: colors.sky,
	      blue: colors.blue,
	      indigo: colors.indigo,
	      violet: colors.violet,
	      purple: colors.purple,
	      fuchsia: colors.fuchsia,
	      pink: colors.pink,
	      rose: colors.rose,
	    }),
	    columns: {
	      auto: 'auto',
	      1: '1',
	      2: '2',
	      3: '3',
	      4: '4',
	      5: '5',
	      6: '6',
	      7: '7',
	      8: '8',
	      9: '9',
	      10: '10',
	      11: '11',
	      12: '12',
	      '3xs': '16rem',
	      '2xs': '18rem',
	      xs: '20rem',
	      sm: '24rem',
	      md: '28rem',
	      lg: '32rem',
	      xl: '36rem',
	      '2xl': '42rem',
	      '3xl': '48rem',
	      '4xl': '56rem',
	      '5xl': '64rem',
	      '6xl': '72rem',
	      '7xl': '80rem',
	    },
	    container: {},
	    content: {
	      none: 'none',
	    },
	    contrast: {
	      0: '0',
	      50: '.5',
	      75: '.75',
	      100: '1',
	      125: '1.25',
	      150: '1.5',
	      200: '2',
	    },
	    cursor: {
	      auto: 'auto',
	      default: 'default',
	      pointer: 'pointer',
	      wait: 'wait',
	      text: 'text',
	      move: 'move',
	      help: 'help',
	      'not-allowed': 'not-allowed',
	      none: 'none',
	      'context-menu': 'context-menu',
	      progress: 'progress',
	      cell: 'cell',
	      crosshair: 'crosshair',
	      'vertical-text': 'vertical-text',
	      alias: 'alias',
	      copy: 'copy',
	      'no-drop': 'no-drop',
	      grab: 'grab',
	      grabbing: 'grabbing',
	      'all-scroll': 'all-scroll',
	      'col-resize': 'col-resize',
	      'row-resize': 'row-resize',
	      'n-resize': 'n-resize',
	      'e-resize': 'e-resize',
	      's-resize': 's-resize',
	      'w-resize': 'w-resize',
	      'ne-resize': 'ne-resize',
	      'nw-resize': 'nw-resize',
	      'se-resize': 'se-resize',
	      'sw-resize': 'sw-resize',
	      'ew-resize': 'ew-resize',
	      'ns-resize': 'ns-resize',
	      'nesw-resize': 'nesw-resize',
	      'nwse-resize': 'nwse-resize',
	      'zoom-in': 'zoom-in',
	      'zoom-out': 'zoom-out',
	    },
	    divideColor: ({ theme }) => theme('borderColor'),
	    divideOpacity: ({ theme }) => theme('borderOpacity'),
	    divideWidth: ({ theme }) => theme('borderWidth'),
	    dropShadow: {
	      sm: '0 1px 1px rgb(0 0 0 / 0.05)',
	      DEFAULT: ['0 1px 2px rgb(0 0 0 / 0.1)', '0 1px 1px rgb(0 0 0 / 0.06)'],
	      md: ['0 4px 3px rgb(0 0 0 / 0.07)', '0 2px 2px rgb(0 0 0 / 0.06)'],
	      lg: ['0 10px 8px rgb(0 0 0 / 0.04)', '0 4px 3px rgb(0 0 0 / 0.1)'],
	      xl: ['0 20px 13px rgb(0 0 0 / 0.03)', '0 8px 5px rgb(0 0 0 / 0.08)'],
	      '2xl': '0 25px 25px rgb(0 0 0 / 0.15)',
	      none: '0 0 #0000',
	    },
	    fill: ({ theme }) => ({
	      none: 'none',
	      ...theme('colors'),
	    }),
	    flex: {
	      1: '1 1 0%',
	      auto: '1 1 auto',
	      initial: '0 1 auto',
	      none: 'none',
	    },
	    flexBasis: ({ theme }) => ({
	      auto: 'auto',
	      ...theme('spacing'),
	      '1/2': '50%',
	      '1/3': '33.333333%',
	      '2/3': '66.666667%',
	      '1/4': '25%',
	      '2/4': '50%',
	      '3/4': '75%',
	      '1/5': '20%',
	      '2/5': '40%',
	      '3/5': '60%',
	      '4/5': '80%',
	      '1/6': '16.666667%',
	      '2/6': '33.333333%',
	      '3/6': '50%',
	      '4/6': '66.666667%',
	      '5/6': '83.333333%',
	      '1/12': '8.333333%',
	      '2/12': '16.666667%',
	      '3/12': '25%',
	      '4/12': '33.333333%',
	      '5/12': '41.666667%',
	      '6/12': '50%',
	      '7/12': '58.333333%',
	      '8/12': '66.666667%',
	      '9/12': '75%',
	      '10/12': '83.333333%',
	      '11/12': '91.666667%',
	      full: '100%',
	    }),
	    flexGrow: {
	      0: '0',
	      DEFAULT: '1',
	    },
	    flexShrink: {
	      0: '0',
	      DEFAULT: '1',
	    },
	    fontFamily: {
	      sans: [
	        'ui-sans-serif',
	        'system-ui',
	        'sans-serif',
	        '"Apple Color Emoji"',
	        '"Segoe UI Emoji"',
	        '"Segoe UI Symbol"',
	        '"Noto Color Emoji"',
	      ],
	      serif: ['ui-serif', 'Georgia', 'Cambria', '"Times New Roman"', 'Times', 'serif'],
	      mono: [
	        'ui-monospace',
	        'SFMono-Regular',
	        'Menlo',
	        'Monaco',
	        'Consolas',
	        '"Liberation Mono"',
	        '"Courier New"',
	        'monospace',
	      ],
	    },
	    fontSize: {
	      xs: ['0.75rem', { lineHeight: '1rem' }],
	      sm: ['0.875rem', { lineHeight: '1.25rem' }],
	      base: ['1rem', { lineHeight: '1.5rem' }],
	      lg: ['1.125rem', { lineHeight: '1.75rem' }],
	      xl: ['1.25rem', { lineHeight: '1.75rem' }],
	      '2xl': ['1.5rem', { lineHeight: '2rem' }],
	      '3xl': ['1.875rem', { lineHeight: '2.25rem' }],
	      '4xl': ['2.25rem', { lineHeight: '2.5rem' }],
	      '5xl': ['3rem', { lineHeight: '1' }],
	      '6xl': ['3.75rem', { lineHeight: '1' }],
	      '7xl': ['4.5rem', { lineHeight: '1' }],
	      '8xl': ['6rem', { lineHeight: '1' }],
	      '9xl': ['8rem', { lineHeight: '1' }],
	    },
	    fontWeight: {
	      thin: '100',
	      extralight: '200',
	      light: '300',
	      normal: '400',
	      medium: '500',
	      semibold: '600',
	      bold: '700',
	      extrabold: '800',
	      black: '900',
	    },
	    gap: ({ theme }) => theme('spacing'),
	    gradientColorStops: ({ theme }) => theme('colors'),
	    gradientColorStopPositions: {
	      '0%': '0%',
	      '5%': '5%',
	      '10%': '10%',
	      '15%': '15%',
	      '20%': '20%',
	      '25%': '25%',
	      '30%': '30%',
	      '35%': '35%',
	      '40%': '40%',
	      '45%': '45%',
	      '50%': '50%',
	      '55%': '55%',
	      '60%': '60%',
	      '65%': '65%',
	      '70%': '70%',
	      '75%': '75%',
	      '80%': '80%',
	      '85%': '85%',
	      '90%': '90%',
	      '95%': '95%',
	      '100%': '100%',
	    },
	    grayscale: {
	      0: '0',
	      DEFAULT: '100%',
	    },
	    gridAutoColumns: {
	      auto: 'auto',
	      min: 'min-content',
	      max: 'max-content',
	      fr: 'minmax(0, 1fr)',
	    },
	    gridAutoRows: {
	      auto: 'auto',
	      min: 'min-content',
	      max: 'max-content',
	      fr: 'minmax(0, 1fr)',
	    },
	    gridColumn: {
	      auto: 'auto',
	      'span-1': 'span 1 / span 1',
	      'span-2': 'span 2 / span 2',
	      'span-3': 'span 3 / span 3',
	      'span-4': 'span 4 / span 4',
	      'span-5': 'span 5 / span 5',
	      'span-6': 'span 6 / span 6',
	      'span-7': 'span 7 / span 7',
	      'span-8': 'span 8 / span 8',
	      'span-9': 'span 9 / span 9',
	      'span-10': 'span 10 / span 10',
	      'span-11': 'span 11 / span 11',
	      'span-12': 'span 12 / span 12',
	      'span-full': '1 / -1',
	    },
	    gridColumnEnd: {
	      auto: 'auto',
	      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',
	    },
	    gridColumnStart: {
	      auto: 'auto',
	      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',
	    },
	    gridRow: {
	      auto: 'auto',
	      'span-1': 'span 1 / span 1',
	      'span-2': 'span 2 / span 2',
	      'span-3': 'span 3 / span 3',
	      'span-4': 'span 4 / span 4',
	      'span-5': 'span 5 / span 5',
	      'span-6': 'span 6 / span 6',
	      'span-7': 'span 7 / span 7',
	      'span-8': 'span 8 / span 8',
	      'span-9': 'span 9 / span 9',
	      'span-10': 'span 10 / span 10',
	      'span-11': 'span 11 / span 11',
	      'span-12': 'span 12 / span 12',
	      'span-full': '1 / -1',
	    },
	    gridRowEnd: {
	      auto: 'auto',
	      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',
	    },
	    gridRowStart: {
	      auto: 'auto',
	      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',
	    },
	    gridTemplateColumns: {
	      none: 'none',
	      subgrid: 'subgrid',
	      1: 'repeat(1, minmax(0, 1fr))',
	      2: 'repeat(2, minmax(0, 1fr))',
	      3: 'repeat(3, minmax(0, 1fr))',
	      4: 'repeat(4, minmax(0, 1fr))',
	      5: 'repeat(5, minmax(0, 1fr))',
	      6: 'repeat(6, minmax(0, 1fr))',
	      7: 'repeat(7, minmax(0, 1fr))',
	      8: 'repeat(8, minmax(0, 1fr))',
	      9: 'repeat(9, minmax(0, 1fr))',
	      10: 'repeat(10, minmax(0, 1fr))',
	      11: 'repeat(11, minmax(0, 1fr))',
	      12: 'repeat(12, minmax(0, 1fr))',
	    },
	    gridTemplateRows: {
	      none: 'none',
	      subgrid: 'subgrid',
	      1: 'repeat(1, minmax(0, 1fr))',
	      2: 'repeat(2, minmax(0, 1fr))',
	      3: 'repeat(3, minmax(0, 1fr))',
	      4: 'repeat(4, minmax(0, 1fr))',
	      5: 'repeat(5, minmax(0, 1fr))',
	      6: 'repeat(6, minmax(0, 1fr))',
	      7: 'repeat(7, minmax(0, 1fr))',
	      8: 'repeat(8, minmax(0, 1fr))',
	      9: 'repeat(9, minmax(0, 1fr))',
	      10: 'repeat(10, minmax(0, 1fr))',
	      11: 'repeat(11, minmax(0, 1fr))',
	      12: 'repeat(12, minmax(0, 1fr))',
	    },
	    height: ({ theme }) => ({
	      auto: 'auto',
	      ...theme('spacing'),
	      '1/2': '50%',
	      '1/3': '33.333333%',
	      '2/3': '66.666667%',
	      '1/4': '25%',
	      '2/4': '50%',
	      '3/4': '75%',
	      '1/5': '20%',
	      '2/5': '40%',
	      '3/5': '60%',
	      '4/5': '80%',
	      '1/6': '16.666667%',
	      '2/6': '33.333333%',
	      '3/6': '50%',
	      '4/6': '66.666667%',
	      '5/6': '83.333333%',
	      full: '100%',
	      screen: '100vh',
	      svh: '100svh',
	      lvh: '100lvh',
	      dvh: '100dvh',
	      min: 'min-content',
	      max: 'max-content',
	      fit: 'fit-content',
	    }),
	    hueRotate: {
	      0: '0deg',
	      15: '15deg',
	      30: '30deg',
	      60: '60deg',
	      90: '90deg',
	      180: '180deg',
	    },
	    inset: ({ theme }) => ({
	      auto: 'auto',
	      ...theme('spacing'),
	      '1/2': '50%',
	      '1/3': '33.333333%',
	      '2/3': '66.666667%',
	      '1/4': '25%',
	      '2/4': '50%',
	      '3/4': '75%',
	      full: '100%',
	    }),
	    invert: {
	      0: '0',
	      DEFAULT: '100%',
	    },
	    keyframes: {
	      spin: {
	        to: {
	          transform: 'rotate(360deg)',
	        },
	      },
	      ping: {
	        '75%, 100%': {
	          transform: 'scale(2)',
	          opacity: '0',
	        },
	      },
	      pulse: {
	        '50%': {
	          opacity: '.5',
	        },
	      },
	      bounce: {
	        '0%, 100%': {
	          transform: 'translateY(-25%)',
	          animationTimingFunction: 'cubic-bezier(0.8,0,1,1)',
	        },
	        '50%': {
	          transform: 'none',
	          animationTimingFunction: 'cubic-bezier(0,0,0.2,1)',
	        },
	      },
	    },
	    letterSpacing: {
	      tighter: '-0.05em',
	      tight: '-0.025em',
	      normal: '0em',
	      wide: '0.025em',
	      wider: '0.05em',
	      widest: '0.1em',
	    },
	    lineHeight: {
	      none: '1',
	      tight: '1.25',
	      snug: '1.375',
	      normal: '1.5',
	      relaxed: '1.625',
	      loose: '2',
	      3: '.75rem',
	      4: '1rem',
	      5: '1.25rem',
	      6: '1.5rem',
	      7: '1.75rem',
	      8: '2rem',
	      9: '2.25rem',
	      10: '2.5rem',
	    },
	    listStyleType: {
	      none: 'none',
	      disc: 'disc',
	      decimal: 'decimal',
	    },
	    listStyleImage: {
	      none: 'none',
	    },
	    margin: ({ theme }) => ({
	      auto: 'auto',
	      ...theme('spacing'),
	    }),
	    lineClamp: {
	      1: '1',
	      2: '2',
	      3: '3',
	      4: '4',
	      5: '5',
	      6: '6',
	    },
	    maxHeight: ({ theme }) => ({
	      ...theme('spacing'),
	      none: 'none',
	      full: '100%',
	      screen: '100vh',
	      svh: '100svh',
	      lvh: '100lvh',
	      dvh: '100dvh',
	      min: 'min-content',
	      max: 'max-content',
	      fit: 'fit-content',
	    }),
	    maxWidth: ({ theme, breakpoints }) => ({
	      ...theme('spacing'),
	      none: 'none',
	      xs: '20rem',
	      sm: '24rem',
	      md: '28rem',
	      lg: '32rem',
	      xl: '36rem',
	      '2xl': '42rem',
	      '3xl': '48rem',
	      '4xl': '56rem',
	      '5xl': '64rem',
	      '6xl': '72rem',
	      '7xl': '80rem',
	      full: '100%',
	      min: 'min-content',
	      max: 'max-content',
	      fit: 'fit-content',
	      prose: '65ch',
	      ...breakpoints(theme('screens')),
	    }),
	    minHeight: ({ theme }) => ({
	      ...theme('spacing'),
	      full: '100%',
	      screen: '100vh',
	      svh: '100svh',
	      lvh: '100lvh',
	      dvh: '100dvh',
	      min: 'min-content',
	      max: 'max-content',
	      fit: 'fit-content',
	    }),
	    minWidth: ({ theme }) => ({
	      ...theme('spacing'),
	      full: '100%',
	      min: 'min-content',
	      max: 'max-content',
	      fit: 'fit-content',
	    }),
	    objectPosition: {
	      bottom: 'bottom',
	      center: 'center',
	      left: 'left',
	      'left-bottom': 'left bottom',
	      'left-top': 'left top',
	      right: 'right',
	      'right-bottom': 'right bottom',
	      'right-top': 'right top',
	      top: 'top',
	    },
	    opacity: {
	      0: '0',
	      5: '0.05',
	      10: '0.1',
	      15: '0.15',
	      20: '0.2',
	      25: '0.25',
	      30: '0.3',
	      35: '0.35',
	      40: '0.4',
	      45: '0.45',
	      50: '0.5',
	      55: '0.55',
	      60: '0.6',
	      65: '0.65',
	      70: '0.7',
	      75: '0.75',
	      80: '0.8',
	      85: '0.85',
	      90: '0.9',
	      95: '0.95',
	      100: '1',
	    },
	    order: {
	      first: '-9999',
	      last: '9999',
	      none: '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',
	    },
	    outlineColor: ({ theme }) => theme('colors'),
	    outlineOffset: {
	      0: '0px',
	      1: '1px',
	      2: '2px',
	      4: '4px',
	      8: '8px',
	    },
	    outlineWidth: {
	      0: '0px',
	      1: '1px',
	      2: '2px',
	      4: '4px',
	      8: '8px',
	    },
	    padding: ({ theme }) => theme('spacing'),
	    placeholderColor: ({ theme }) => theme('colors'),
	    placeholderOpacity: ({ theme }) => theme('opacity'),
	    ringColor: ({ theme }) => ({
	      DEFAULT: theme('colors.blue.500', '#3b82f6'),
	      ...theme('colors'),
	    }),
	    ringOffsetColor: ({ theme }) => theme('colors'),
	    ringOffsetWidth: {
	      0: '0px',
	      1: '1px',
	      2: '2px',
	      4: '4px',
	      8: '8px',
	    },
	    ringOpacity: ({ theme }) => ({
	      DEFAULT: '0.5',
	      ...theme('opacity'),
	    }),
	    ringWidth: {
	      DEFAULT: '3px',
	      0: '0px',
	      1: '1px',
	      2: '2px',
	      4: '4px',
	      8: '8px',
	    },
	    rotate: {
	      0: '0deg',
	      1: '1deg',
	      2: '2deg',
	      3: '3deg',
	      6: '6deg',
	      12: '12deg',
	      45: '45deg',
	      90: '90deg',
	      180: '180deg',
	    },
	    saturate: {
	      0: '0',
	      50: '.5',
	      100: '1',
	      150: '1.5',
	      200: '2',
	    },
	    scale: {
	      0: '0',
	      50: '.5',
	      75: '.75',
	      90: '.9',
	      95: '.95',
	      100: '1',
	      105: '1.05',
	      110: '1.1',
	      125: '1.25',
	      150: '1.5',
	    },
	    screens: {
	      sm: '640px',
	      md: '768px',
	      lg: '1024px',
	      xl: '1280px',
	      '2xl': '1536px',
	    },
	    scrollMargin: ({ theme }) => ({
	      ...theme('spacing'),
	    }),
	    scrollPadding: ({ theme }) => theme('spacing'),
	    sepia: {
	      0: '0',
	      DEFAULT: '100%',
	    },
	    skew: {
	      0: '0deg',
	      1: '1deg',
	      2: '2deg',
	      3: '3deg',
	      6: '6deg',
	      12: '12deg',
	    },
	    space: ({ theme }) => ({
	      ...theme('spacing'),
	    }),
	    spacing: {
	      px: '1px',
	      0: '0px',
	      0.5: '0.125rem',
	      1: '0.25rem',
	      1.5: '0.375rem',
	      2: '0.5rem',
	      2.5: '0.625rem',
	      3: '0.75rem',
	      3.5: '0.875rem',
	      4: '1rem',
	      5: '1.25rem',
	      6: '1.5rem',
	      7: '1.75rem',
	      8: '2rem',
	      9: '2.25rem',
	      10: '2.5rem',
	      11: '2.75rem',
	      12: '3rem',
	      14: '3.5rem',
	      16: '4rem',
	      20: '5rem',
	      24: '6rem',
	      28: '7rem',
	      32: '8rem',
	      36: '9rem',
	      40: '10rem',
	      44: '11rem',
	      48: '12rem',
	      52: '13rem',
	      56: '14rem',
	      60: '15rem',
	      64: '16rem',
	      72: '18rem',
	      80: '20rem',
	      96: '24rem',
	    },
	    stroke: ({ theme }) => ({
	      none: 'none',
	      ...theme('colors'),
	    }),
	    strokeWidth: {
	      0: '0',
	      1: '1',
	      2: '2',
	    },
	    supports: {},
	    data: {},
	    textColor: ({ theme }) => theme('colors'),
	    textDecorationColor: ({ theme }) => theme('colors'),
	    textDecorationThickness: {
	      auto: 'auto',
	      'from-font': 'from-font',
	      0: '0px',
	      1: '1px',
	      2: '2px',
	      4: '4px',
	      8: '8px',
	    },
	    textIndent: ({ theme }) => ({
	      ...theme('spacing'),
	    }),
	    textOpacity: ({ theme }) => theme('opacity'),
	    textUnderlineOffset: {
	      auto: 'auto',
	      0: '0px',
	      1: '1px',
	      2: '2px',
	      4: '4px',
	      8: '8px',
	    },
	    transformOrigin: {
	      center: 'center',
	      top: 'top',
	      'top-right': 'top right',
	      right: 'right',
	      'bottom-right': 'bottom right',
	      bottom: 'bottom',
	      'bottom-left': 'bottom left',
	      left: 'left',
	      'top-left': 'top left',
	    },
	    transitionDelay: {
	      0: '0s',
	      75: '75ms',
	      100: '100ms',
	      150: '150ms',
	      200: '200ms',
	      300: '300ms',
	      500: '500ms',
	      700: '700ms',
	      1000: '1000ms',
	    },
	    transitionDuration: {
	      DEFAULT: '150ms',
	      0: '0s',
	      75: '75ms',
	      100: '100ms',
	      150: '150ms',
	      200: '200ms',
	      300: '300ms',
	      500: '500ms',
	      700: '700ms',
	      1000: '1000ms',
	    },
	    transitionProperty: {
	      none: 'none',
	      all: 'all',
	      DEFAULT:
	        'color, background-color, border-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, filter, backdrop-filter',
	      colors: 'color, background-color, border-color, text-decoration-color, fill, stroke',
	      opacity: 'opacity',
	      shadow: 'box-shadow',
	      transform: 'transform',
	    },
	    transitionTimingFunction: {
	      DEFAULT: 'cubic-bezier(0.4, 0, 0.2, 1)',
	      linear: 'linear',
	      in: 'cubic-bezier(0.4, 0, 1, 1)',
	      out: 'cubic-bezier(0, 0, 0.2, 1)',
	      'in-out': 'cubic-bezier(0.4, 0, 0.2, 1)',
	    },
	    translate: ({ theme }) => ({
	      ...theme('spacing'),
	      '1/2': '50%',
	      '1/3': '33.333333%',
	      '2/3': '66.666667%',
	      '1/4': '25%',
	      '2/4': '50%',
	      '3/4': '75%',
	      full: '100%',
	    }),
	    size: ({ theme }) => ({
	      auto: 'auto',
	      ...theme('spacing'),
	      '1/2': '50%',
	      '1/3': '33.333333%',
	      '2/3': '66.666667%',
	      '1/4': '25%',
	      '2/4': '50%',
	      '3/4': '75%',
	      '1/5': '20%',
	      '2/5': '40%',
	      '3/5': '60%',
	      '4/5': '80%',
	      '1/6': '16.666667%',
	      '2/6': '33.333333%',
	      '3/6': '50%',
	      '4/6': '66.666667%',
	      '5/6': '83.333333%',
	      '1/12': '8.333333%',
	      '2/12': '16.666667%',
	      '3/12': '25%',
	      '4/12': '33.333333%',
	      '5/12': '41.666667%',
	      '6/12': '50%',
	      '7/12': '58.333333%',
	      '8/12': '66.666667%',
	      '9/12': '75%',
	      '10/12': '83.333333%',
	      '11/12': '91.666667%',
	      full: '100%',
	      min: 'min-content',
	      max: 'max-content',
	      fit: 'fit-content',
	    }),
	    width: ({ theme }) => ({
	      auto: 'auto',
	      ...theme('spacing'),
	      '1/2': '50%',
	      '1/3': '33.333333%',
	      '2/3': '66.666667%',
	      '1/4': '25%',
	      '2/4': '50%',
	      '3/4': '75%',
	      '1/5': '20%',
	      '2/5': '40%',
	      '3/5': '60%',
	      '4/5': '80%',
	      '1/6': '16.666667%',
	      '2/6': '33.333333%',
	      '3/6': '50%',
	      '4/6': '66.666667%',
	      '5/6': '83.333333%',
	      '1/12': '8.333333%',
	      '2/12': '16.666667%',
	      '3/12': '25%',
	      '4/12': '33.333333%',
	      '5/12': '41.666667%',
	      '6/12': '50%',
	      '7/12': '58.333333%',
	      '8/12': '66.666667%',
	      '9/12': '75%',
	      '10/12': '83.333333%',
	      '11/12': '91.666667%',
	      full: '100%',
	      screen: '100vw',
	      svw: '100svw',
	      lvw: '100lvw',
	      dvw: '100dvw',
	      min: 'min-content',
	      max: 'max-content',
	      fit: 'fit-content',
	    }),
	    willChange: {
	      auto: 'auto',
	      scroll: 'scroll-position',
	      contents: 'contents',
	      transform: 'transform',
	    },
	    zIndex: {
	      auto: 'auto',
	      0: '0',
	      10: '10',
	      20: '20',
	      30: '30',
	      40: '40',
	      50: '50',
	    },
	  },
	  plugins: [],
	};

	(function (exports) {
		Object.defineProperty(exports, "__esModule", {
		    value: true
		});
		Object.defineProperty(exports, "default", {
		    enumerable: true,
		    get: function() {
		        return _default;
		    }
		});
		const _cloneDeep = cloneDeep;
		const _configfull = /*#__PURE__*/ _interop_require_default(config_full);
		function _interop_require_default(obj) {
		    return obj && obj.__esModule ? obj : {
		        default: obj
		    };
		}
		const _default = (0, _cloneDeep.cloneDeep)(_configfull.default.theme); 
	} (defaultTheme$2));

	let defaultTheme$1 = defaultTheme$2;
	var defaultTheme_1 = (defaultTheme$1.__esModule ? defaultTheme$1 : { default: defaultTheme$1 }).default;

	var require$$4 = /*@__PURE__*/getAugmentedNamespace(nothing);

	var prefixNegativeModifiers$2 = {};

	var lodash = {exports: {}};

	/**
	 * @license
	 * Lodash <https://lodash.com/>
	 * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
	 * Released under MIT license <https://lodash.com/license>
	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
	 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
	 */
	lodash.exports;

	(function (module, exports) {
	(function() {

		  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
		  var undefined$1;

		  /** Used as the semantic version number. */
		  var VERSION = '4.17.21';

		  /** Used as the size to enable large array optimizations. */
		  var LARGE_ARRAY_SIZE = 200;

		  /** Error message constants. */
		  var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',
		      FUNC_ERROR_TEXT = 'Expected a function',
		      INVALID_TEMPL_VAR_ERROR_TEXT = 'Invalid `variable` option passed into `_.template`';

		  /** Used to stand-in for `undefined` hash values. */
		  var HASH_UNDEFINED = '__lodash_hash_undefined__';

		  /** Used as the maximum memoize cache size. */
		  var MAX_MEMOIZE_SIZE = 500;

		  /** Used as the internal argument placeholder. */
		  var PLACEHOLDER = '__lodash_placeholder__';

		  /** Used to compose bitmasks for cloning. */
		  var CLONE_DEEP_FLAG = 1,
		      CLONE_FLAT_FLAG = 2,
		      CLONE_SYMBOLS_FLAG = 4;

		  /** Used to compose bitmasks for value comparisons. */
		  var COMPARE_PARTIAL_FLAG = 1,
		      COMPARE_UNORDERED_FLAG = 2;

		  /** Used to compose bitmasks for function metadata. */
		  var WRAP_BIND_FLAG = 1,
		      WRAP_BIND_KEY_FLAG = 2,
		      WRAP_CURRY_BOUND_FLAG = 4,
		      WRAP_CURRY_FLAG = 8,
		      WRAP_CURRY_RIGHT_FLAG = 16,
		      WRAP_PARTIAL_FLAG = 32,
		      WRAP_PARTIAL_RIGHT_FLAG = 64,
		      WRAP_ARY_FLAG = 128,
		      WRAP_REARG_FLAG = 256,
		      WRAP_FLIP_FLAG = 512;

		  /** Used as default options for `_.truncate`. */
		  var DEFAULT_TRUNC_LENGTH = 30,
		      DEFAULT_TRUNC_OMISSION = '...';

		  /** Used to detect hot functions by number of calls within a span of milliseconds. */
		  var HOT_COUNT = 800,
		      HOT_SPAN = 16;

		  /** Used to indicate the type of lazy iteratees. */
		  var LAZY_FILTER_FLAG = 1,
		      LAZY_MAP_FLAG = 2,
		      LAZY_WHILE_FLAG = 3;

		  /** Used as references for various `Number` constants. */
		  var INFINITY = 1 / 0,
		      MAX_SAFE_INTEGER = 9007199254740991,
		      MAX_INTEGER = 1.7976931348623157e+308,
		      NAN = 0 / 0;

		  /** Used as references for the maximum length and index of an array. */
		  var MAX_ARRAY_LENGTH = 4294967295,
		      MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,
		      HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;

		  /** Used to associate wrap methods with their bit flags. */
		  var wrapFlags = [
		    ['ary', WRAP_ARY_FLAG],
		    ['bind', WRAP_BIND_FLAG],
		    ['bindKey', WRAP_BIND_KEY_FLAG],
		    ['curry', WRAP_CURRY_FLAG],
		    ['curryRight', WRAP_CURRY_RIGHT_FLAG],
		    ['flip', WRAP_FLIP_FLAG],
		    ['partial', WRAP_PARTIAL_FLAG],
		    ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],
		    ['rearg', WRAP_REARG_FLAG]
		  ];

		  /** `Object#toString` result references. */
		  var argsTag = '[object Arguments]',
		      arrayTag = '[object Array]',
		      asyncTag = '[object AsyncFunction]',
		      boolTag = '[object Boolean]',
		      dateTag = '[object Date]',
		      domExcTag = '[object DOMException]',
		      errorTag = '[object Error]',
		      funcTag = '[object Function]',
		      genTag = '[object GeneratorFunction]',
		      mapTag = '[object Map]',
		      numberTag = '[object Number]',
		      nullTag = '[object Null]',
		      objectTag = '[object Object]',
		      promiseTag = '[object Promise]',
		      proxyTag = '[object Proxy]',
		      regexpTag = '[object RegExp]',
		      setTag = '[object Set]',
		      stringTag = '[object String]',
		      symbolTag = '[object Symbol]',
		      undefinedTag = '[object Undefined]',
		      weakMapTag = '[object WeakMap]',
		      weakSetTag = '[object WeakSet]';

		  var arrayBufferTag = '[object ArrayBuffer]',
		      dataViewTag = '[object DataView]',
		      float32Tag = '[object Float32Array]',
		      float64Tag = '[object Float64Array]',
		      int8Tag = '[object Int8Array]',
		      int16Tag = '[object Int16Array]',
		      int32Tag = '[object Int32Array]',
		      uint8Tag = '[object Uint8Array]',
		      uint8ClampedTag = '[object Uint8ClampedArray]',
		      uint16Tag = '[object Uint16Array]',
		      uint32Tag = '[object Uint32Array]';

		  /** Used to match empty string literals in compiled template source. */
		  var reEmptyStringLeading = /\b__p \+= '';/g,
		      reEmptyStringMiddle = /\b(__p \+=) '' \+/g,
		      reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;

		  /** Used to match HTML entities and HTML characters. */
		  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,
		      reUnescapedHtml = /[&<>"']/g,
		      reHasEscapedHtml = RegExp(reEscapedHtml.source),
		      reHasUnescapedHtml = RegExp(reUnescapedHtml.source);

		  /** Used to match template delimiters. */
		  var reEscape = /<%-([\s\S]+?)%>/g,
		      reEvaluate = /<%([\s\S]+?)%>/g,
		      reInterpolate = /<%=([\s\S]+?)%>/g;

		  /** Used to match property names within property paths. */
		  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
		      reIsPlainProp = /^\w*$/,
		      rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;

		  /**
		   * Used to match `RegExp`
		   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
		   */
		  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g,
		      reHasRegExpChar = RegExp(reRegExpChar.source);

		  /** Used to match leading whitespace. */
		  var reTrimStart = /^\s+/;

		  /** Used to match a single whitespace character. */
		  var reWhitespace = /\s/;

		  /** Used to match wrap detail comments. */
		  var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,
		      reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/,
		      reSplitDetails = /,? & /;

		  /** Used to match words composed of alphanumeric characters. */
		  var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;

		  /**
		   * Used to validate the `validate` option in `_.template` variable.
		   *
		   * Forbids characters which could potentially change the meaning of the function argument definition:
		   * - "()," (modification of function parameters)
		   * - "=" (default value)
		   * - "[]{}" (destructuring of function parameters)
		   * - "/" (beginning of a comment)
		   * - whitespace
		   */
		  var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/;

		  /** Used to match backslashes in property paths. */
		  var reEscapeChar = /\\(\\)?/g;

		  /**
		   * Used to match
		   * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).
		   */
		  var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;

		  /** Used to match `RegExp` flags from their coerced string values. */
		  var reFlags = /\w*$/;

		  /** Used to detect bad signed hexadecimal string values. */
		  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;

		  /** Used to detect binary string values. */
		  var reIsBinary = /^0b[01]+$/i;

		  /** Used to detect host constructors (Safari). */
		  var reIsHostCtor = /^\[object .+?Constructor\]$/;

		  /** Used to detect octal string values. */
		  var reIsOctal = /^0o[0-7]+$/i;

		  /** Used to detect unsigned integer values. */
		  var reIsUint = /^(?:0|[1-9]\d*)$/;

		  /** Used to match Latin Unicode letters (excluding mathematical operators). */
		  var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;

		  /** Used to ensure capturing order of template delimiters. */
		  var reNoMatch = /($^)/;

		  /** Used to match unescaped characters in compiled string literals. */
		  var reUnescapedString = /['\n\r\u2028\u2029\\]/g;

		  /** Used to compose unicode character classes. */
		  var rsAstralRange = '\\ud800-\\udfff',
		      rsComboMarksRange = '\\u0300-\\u036f',
		      reComboHalfMarksRange = '\\ufe20-\\ufe2f',
		      rsComboSymbolsRange = '\\u20d0-\\u20ff',
		      rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
		      rsDingbatRange = '\\u2700-\\u27bf',
		      rsLowerRange = 'a-z\\xdf-\\xf6\\xf8-\\xff',
		      rsMathOpRange = '\\xac\\xb1\\xd7\\xf7',
		      rsNonCharRange = '\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf',
		      rsPunctuationRange = '\\u2000-\\u206f',
		      rsSpaceRange = ' \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000',
		      rsUpperRange = 'A-Z\\xc0-\\xd6\\xd8-\\xde',
		      rsVarRange = '\\ufe0e\\ufe0f',
		      rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;

		  /** Used to compose unicode capture groups. */
		  var rsApos = "['\u2019]",
		      rsAstral = '[' + rsAstralRange + ']',
		      rsBreak = '[' + rsBreakRange + ']',
		      rsCombo = '[' + rsComboRange + ']',
		      rsDigits = '\\d+',
		      rsDingbat = '[' + rsDingbatRange + ']',
		      rsLower = '[' + rsLowerRange + ']',
		      rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',
		      rsFitz = '\\ud83c[\\udffb-\\udfff]',
		      rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
		      rsNonAstral = '[^' + rsAstralRange + ']',
		      rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
		      rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
		      rsUpper = '[' + rsUpperRange + ']',
		      rsZWJ = '\\u200d';

		  /** Used to compose unicode regexes. */
		  var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',
		      rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',
		      rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',
		      rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',
		      reOptMod = rsModifier + '?',
		      rsOptVar = '[' + rsVarRange + ']?',
		      rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
		      rsOrdLower = '\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])',
		      rsOrdUpper = '\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])',
		      rsSeq = rsOptVar + reOptMod + rsOptJoin,
		      rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,
		      rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';

		  /** Used to match apostrophes. */
		  var reApos = RegExp(rsApos, 'g');

		  /**
		   * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
		   * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
		   */
		  var reComboMark = RegExp(rsCombo, 'g');

		  /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
		  var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');

		  /** Used to match complex or compound words. */
		  var reUnicodeWord = RegExp([
		    rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',
		    rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',
		    rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,
		    rsUpper + '+' + rsOptContrUpper,
		    rsOrdUpper,
		    rsOrdLower,
		    rsDigits,
		    rsEmoji
		  ].join('|'), 'g');

		  /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
		  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');

		  /** Used to detect strings that need a more robust regexp to match words. */
		  var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;

		  /** Used to assign default `context` object properties. */
		  var contextProps = [
		    'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',
		    'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',
		    'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',
		    'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',
		    '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'
		  ];

		  /** Used to make template sourceURLs easier to identify. */
		  var templateCounter = -1;

		  /** Used to identify `toStringTag` values of typed arrays. */
		  var typedArrayTags = {};
		  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
		  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
		  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
		  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
		  typedArrayTags[uint32Tag] = true;
		  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =
		  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
		  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
		  typedArrayTags[errorTag] = typedArrayTags[funcTag] =
		  typedArrayTags[mapTag] = typedArrayTags[numberTag] =
		  typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
		  typedArrayTags[setTag] = typedArrayTags[stringTag] =
		  typedArrayTags[weakMapTag] = false;

		  /** Used to identify `toStringTag` values supported by `_.clone`. */
		  var cloneableTags = {};
		  cloneableTags[argsTag] = cloneableTags[arrayTag] =
		  cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
		  cloneableTags[boolTag] = cloneableTags[dateTag] =
		  cloneableTags[float32Tag] = cloneableTags[float64Tag] =
		  cloneableTags[int8Tag] = cloneableTags[int16Tag] =
		  cloneableTags[int32Tag] = cloneableTags[mapTag] =
		  cloneableTags[numberTag] = cloneableTags[objectTag] =
		  cloneableTags[regexpTag] = cloneableTags[setTag] =
		  cloneableTags[stringTag] = cloneableTags[symbolTag] =
		  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
		  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
		  cloneableTags[errorTag] = cloneableTags[funcTag] =
		  cloneableTags[weakMapTag] = false;

		  /** Used to map Latin Unicode letters to basic Latin letters. */
		  var deburredLetters = {
		    // Latin-1 Supplement block.
		    '\xc0': 'A',  '\xc1': 'A', '\xc2': 'A', '\xc3': 'A', '\xc4': 'A', '\xc5': 'A',
		    '\xe0': 'a',  '\xe1': 'a', '\xe2': 'a', '\xe3': 'a', '\xe4': 'a', '\xe5': 'a',
		    '\xc7': 'C',  '\xe7': 'c',
		    '\xd0': 'D',  '\xf0': 'd',
		    '\xc8': 'E',  '\xc9': 'E', '\xca': 'E', '\xcb': 'E',
		    '\xe8': 'e',  '\xe9': 'e', '\xea': 'e', '\xeb': 'e',
		    '\xcc': 'I',  '\xcd': 'I', '\xce': 'I', '\xcf': 'I',
		    '\xec': 'i',  '\xed': 'i', '\xee': 'i', '\xef': 'i',
		    '\xd1': 'N',  '\xf1': 'n',
		    '\xd2': 'O',  '\xd3': 'O', '\xd4': 'O', '\xd5': 'O', '\xd6': 'O', '\xd8': 'O',
		    '\xf2': 'o',  '\xf3': 'o', '\xf4': 'o', '\xf5': 'o', '\xf6': 'o', '\xf8': 'o',
		    '\xd9': 'U',  '\xda': 'U', '\xdb': 'U', '\xdc': 'U',
		    '\xf9': 'u',  '\xfa': 'u', '\xfb': 'u', '\xfc': 'u',
		    '\xdd': 'Y',  '\xfd': 'y', '\xff': 'y',
		    '\xc6': 'Ae', '\xe6': 'ae',
		    '\xde': 'Th', '\xfe': 'th',
		    '\xdf': 'ss',
		    // Latin Extended-A block.
		    '\u0100': 'A',  '\u0102': 'A', '\u0104': 'A',
		    '\u0101': 'a',  '\u0103': 'a', '\u0105': 'a',
		    '\u0106': 'C',  '\u0108': 'C', '\u010a': 'C', '\u010c': 'C',
		    '\u0107': 'c',  '\u0109': 'c', '\u010b': 'c', '\u010d': 'c',
		    '\u010e': 'D',  '\u0110': 'D', '\u010f': 'd', '\u0111': 'd',
		    '\u0112': 'E',  '\u0114': 'E', '\u0116': 'E', '\u0118': 'E', '\u011a': 'E',
		    '\u0113': 'e',  '\u0115': 'e', '\u0117': 'e', '\u0119': 'e', '\u011b': 'e',
		    '\u011c': 'G',  '\u011e': 'G', '\u0120': 'G', '\u0122': 'G',
		    '\u011d': 'g',  '\u011f': 'g', '\u0121': 'g', '\u0123': 'g',
		    '\u0124': 'H',  '\u0126': 'H', '\u0125': 'h', '\u0127': 'h',
		    '\u0128': 'I',  '\u012a': 'I', '\u012c': 'I', '\u012e': 'I', '\u0130': 'I',
		    '\u0129': 'i',  '\u012b': 'i', '\u012d': 'i', '\u012f': 'i', '\u0131': 'i',
		    '\u0134': 'J',  '\u0135': 'j',
		    '\u0136': 'K',  '\u0137': 'k', '\u0138': 'k',
		    '\u0139': 'L',  '\u013b': 'L', '\u013d': 'L', '\u013f': 'L', '\u0141': 'L',
		    '\u013a': 'l',  '\u013c': 'l', '\u013e': 'l', '\u0140': 'l', '\u0142': 'l',
		    '\u0143': 'N',  '\u0145': 'N', '\u0147': 'N', '\u014a': 'N',
		    '\u0144': 'n',  '\u0146': 'n', '\u0148': 'n', '\u014b': 'n',
		    '\u014c': 'O',  '\u014e': 'O', '\u0150': 'O',
		    '\u014d': 'o',  '\u014f': 'o', '\u0151': 'o',
		    '\u0154': 'R',  '\u0156': 'R', '\u0158': 'R',
		    '\u0155': 'r',  '\u0157': 'r', '\u0159': 'r',
		    '\u015a': 'S',  '\u015c': 'S', '\u015e': 'S', '\u0160': 'S',
		    '\u015b': 's',  '\u015d': 's', '\u015f': 's', '\u0161': 's',
		    '\u0162': 'T',  '\u0164': 'T', '\u0166': 'T',
		    '\u0163': 't',  '\u0165': 't', '\u0167': 't',
		    '\u0168': 'U',  '\u016a': 'U', '\u016c': 'U', '\u016e': 'U', '\u0170': 'U', '\u0172': 'U',
		    '\u0169': 'u',  '\u016b': 'u', '\u016d': 'u', '\u016f': 'u', '\u0171': 'u', '\u0173': 'u',
		    '\u0174': 'W',  '\u0175': 'w',
		    '\u0176': 'Y',  '\u0177': 'y', '\u0178': 'Y',
		    '\u0179': 'Z',  '\u017b': 'Z', '\u017d': 'Z',
		    '\u017a': 'z',  '\u017c': 'z', '\u017e': 'z',
		    '\u0132': 'IJ', '\u0133': 'ij',
		    '\u0152': 'Oe', '\u0153': 'oe',
		    '\u0149': "'n", '\u017f': 's'
		  };

		  /** Used to map characters to HTML entities. */
		  var htmlEscapes = {
		    '&': '&amp;',
		    '<': '&lt;',
		    '>': '&gt;',
		    '"': '&quot;',
		    "'": '&#39;'
		  };

		  /** Used to map HTML entities to characters. */
		  var htmlUnescapes = {
		    '&amp;': '&',
		    '&lt;': '<',
		    '&gt;': '>',
		    '&quot;': '"',
		    '&#39;': "'"
		  };

		  /** Used to escape characters for inclusion in compiled string literals. */
		  var stringEscapes = {
		    '\\': '\\',
		    "'": "'",
		    '\n': 'n',
		    '\r': 'r',
		    '\u2028': 'u2028',
		    '\u2029': 'u2029'
		  };

		  /** Built-in method references without a dependency on `root`. */
		  var freeParseFloat = parseFloat,
		      freeParseInt = parseInt;

		  /** Detect free variable `global` from Node.js. */
		  var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;

		  /** Detect free variable `self`. */
		  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

		  /** Used as a reference to the global object. */
		  var root = freeGlobal || freeSelf || Function('return this')();

		  /** Detect free variable `exports`. */
		  var freeExports = exports && !exports.nodeType && exports;

		  /** Detect free variable `module`. */
		  var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;

		  /** Detect the popular CommonJS extension `module.exports`. */
		  var moduleExports = freeModule && freeModule.exports === freeExports;

		  /** Detect free variable `process` from Node.js. */
		  var freeProcess = moduleExports && freeGlobal.process;

		  /** Used to access faster Node.js helpers. */
		  var nodeUtil = (function() {
		    try {
		      // Use `util.types` for Node.js 10+.
		      var types = freeModule && freeModule.require && freeModule.require('util').types;

		      if (types) {
		        return types;
		      }

		      // Legacy `process.binding('util')` for Node.js < 10.
		      return freeProcess && freeProcess.binding && freeProcess.binding('util');
		    } catch (e) {}
		  }());

		  /* Node.js helper references. */
		  var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,
		      nodeIsDate = nodeUtil && nodeUtil.isDate,
		      nodeIsMap = nodeUtil && nodeUtil.isMap,
		      nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,
		      nodeIsSet = nodeUtil && nodeUtil.isSet,
		      nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;

		  /*--------------------------------------------------------------------------*/

		  /**
		   * A faster alternative to `Function#apply`, this function invokes `func`
		   * with the `this` binding of `thisArg` and the arguments of `args`.
		   *
		   * @private
		   * @param {Function} func The function to invoke.
		   * @param {*} thisArg The `this` binding of `func`.
		   * @param {Array} args The arguments to invoke `func` with.
		   * @returns {*} Returns the result of `func`.
		   */
		  function apply(func, thisArg, args) {
		    switch (args.length) {
		      case 0: return func.call(thisArg);
		      case 1: return func.call(thisArg, args[0]);
		      case 2: return func.call(thisArg, args[0], args[1]);
		      case 3: return func.call(thisArg, args[0], args[1], args[2]);
		    }
		    return func.apply(thisArg, args);
		  }

		  /**
		   * A specialized version of `baseAggregator` for arrays.
		   *
		   * @private
		   * @param {Array} [array] The array to iterate over.
		   * @param {Function} setter The function to set `accumulator` values.
		   * @param {Function} iteratee The iteratee to transform keys.
		   * @param {Object} accumulator The initial aggregated object.
		   * @returns {Function} Returns `accumulator`.
		   */
		  function arrayAggregator(array, setter, iteratee, accumulator) {
		    var index = -1,
		        length = array == null ? 0 : array.length;

		    while (++index < length) {
		      var value = array[index];
		      setter(accumulator, value, iteratee(value), array);
		    }
		    return accumulator;
		  }

		  /**
		   * A specialized version of `_.forEach` for arrays without support for
		   * iteratee shorthands.
		   *
		   * @private
		   * @param {Array} [array] The array to iterate over.
		   * @param {Function} iteratee The function invoked per iteration.
		   * @returns {Array} Returns `array`.
		   */
		  function arrayEach(array, iteratee) {
		    var index = -1,
		        length = array == null ? 0 : array.length;

		    while (++index < length) {
		      if (iteratee(array[index], index, array) === false) {
		        break;
		      }
		    }
		    return array;
		  }

		  /**
		   * A specialized version of `_.forEachRight` for arrays without support for
		   * iteratee shorthands.
		   *
		   * @private
		   * @param {Array} [array] The array to iterate over.
		   * @param {Function} iteratee The function invoked per iteration.
		   * @returns {Array} Returns `array`.
		   */
		  function arrayEachRight(array, iteratee) {
		    var length = array == null ? 0 : array.length;

		    while (length--) {
		      if (iteratee(array[length], length, array) === false) {
		        break;
		      }
		    }
		    return array;
		  }

		  /**
		   * A specialized version of `_.every` for arrays without support for
		   * iteratee shorthands.
		   *
		   * @private
		   * @param {Array} [array] The array to iterate over.
		   * @param {Function} predicate The function invoked per iteration.
		   * @returns {boolean} Returns `true` if all elements pass the predicate check,
		   *  else `false`.
		   */
		  function arrayEvery(array, predicate) {
		    var index = -1,
		        length = array == null ? 0 : array.length;

		    while (++index < length) {
		      if (!predicate(array[index], index, array)) {
		        return false;
		      }
		    }
		    return true;
		  }

		  /**
		   * A specialized version of `_.filter` for arrays without support for
		   * iteratee shorthands.
		   *
		   * @private
		   * @param {Array} [array] The array to iterate over.
		   * @param {Function} predicate The function invoked per iteration.
		   * @returns {Array} Returns the new filtered array.
		   */
		  function arrayFilter(array, predicate) {
		    var index = -1,
		        length = array == null ? 0 : array.length,
		        resIndex = 0,
		        result = [];

		    while (++index < length) {
		      var value = array[index];
		      if (predicate(value, index, array)) {
		        result[resIndex++] = value;
		      }
		    }
		    return result;
		  }

		  /**
		   * A specialized version of `_.includes` for arrays without support for
		   * specifying an index to search from.
		   *
		   * @private
		   * @param {Array} [array] The array to inspect.
		   * @param {*} target The value to search for.
		   * @returns {boolean} Returns `true` if `target` is found, else `false`.
		   */
		  function arrayIncludes(array, value) {
		    var length = array == null ? 0 : array.length;
		    return !!length && baseIndexOf(array, value, 0) > -1;
		  }

		  /**
		   * This function is like `arrayIncludes` except that it accepts a comparator.
		   *
		   * @private
		   * @param {Array} [array] The array to inspect.
		   * @param {*} target The value to search for.
		   * @param {Function} comparator The comparator invoked per element.
		   * @returns {boolean} Returns `true` if `target` is found, else `false`.
		   */
		  function arrayIncludesWith(array, value, comparator) {
		    var index = -1,
		        length = array == null ? 0 : array.length;

		    while (++index < length) {
		      if (comparator(value, array[index])) {
		        return true;
		      }
		    }
		    return false;
		  }

		  /**
		   * A specialized version of `_.map` for arrays without support for iteratee
		   * shorthands.
		   *
		   * @private
		   * @param {Array} [array] The array to iterate over.
		   * @param {Function} iteratee The function invoked per iteration.
		   * @returns {Array} Returns the new mapped array.
		   */
		  function arrayMap(array, iteratee) {
		    var index = -1,
		        length = array == null ? 0 : array.length,
		        result = Array(length);

		    while (++index < length) {
		      result[index] = iteratee(array[index], index, array);
		    }
		    return result;
		  }

		  /**
		   * Appends the elements of `values` to `array`.
		   *
		   * @private
		   * @param {Array} array The array to modify.
		   * @param {Array} values The values to append.
		   * @returns {Array} Returns `array`.
		   */
		  function arrayPush(array, values) {
		    var index = -1,
		        length = values.length,
		        offset = array.length;

		    while (++index < length) {
		      array[offset + index] = values[index];
		    }
		    return array;
		  }

		  /**
		   * A specialized version of `_.reduce` for arrays without support for
		   * iteratee shorthands.
		   *
		   * @private
		   * @param {Array} [array] The array to iterate over.
		   * @param {Function} iteratee The function invoked per iteration.
		   * @param {*} [accumulator] The initial value.
		   * @param {boolean} [initAccum] Specify using the first element of `array` as
		   *  the initial value.
		   * @returns {*} Returns the accumulated value.
		   */
		  function arrayReduce(array, iteratee, accumulator, initAccum) {
		    var index = -1,
		        length = array == null ? 0 : array.length;

		    if (initAccum && length) {
		      accumulator = array[++index];
		    }
		    while (++index < length) {
		      accumulator = iteratee(accumulator, array[index], index, array);
		    }
		    return accumulator;
		  }

		  /**
		   * A specialized version of `_.reduceRight` for arrays without support for
		   * iteratee shorthands.
		   *
		   * @private
		   * @param {Array} [array] The array to iterate over.
		   * @param {Function} iteratee The function invoked per iteration.
		   * @param {*} [accumulator] The initial value.
		   * @param {boolean} [initAccum] Specify using the last element of `array` as
		   *  the initial value.
		   * @returns {*} Returns the accumulated value.
		   */
		  function arrayReduceRight(array, iteratee, accumulator, initAccum) {
		    var length = array == null ? 0 : array.length;
		    if (initAccum && length) {
		      accumulator = array[--length];
		    }
		    while (length--) {
		      accumulator = iteratee(accumulator, array[length], length, array);
		    }
		    return accumulator;
		  }

		  /**
		   * A specialized version of `_.some` for arrays without support for iteratee
		   * shorthands.
		   *
		   * @private
		   * @param {Array} [array] The array to iterate over.
		   * @param {Function} predicate The function invoked per iteration.
		   * @returns {boolean} Returns `true` if any element passes the predicate check,
		   *  else `false`.
		   */
		  function arraySome(array, predicate) {
		    var index = -1,
		        length = array == null ? 0 : array.length;

		    while (++index < length) {
		      if (predicate(array[index], index, array)) {
		        return true;
		      }
		    }
		    return false;
		  }

		  /**
		   * Gets the size of an ASCII `string`.
		   *
		   * @private
		   * @param {string} string The string inspect.
		   * @returns {number} Returns the string size.
		   */
		  var asciiSize = baseProperty('length');

		  /**
		   * Converts an ASCII `string` to an array.
		   *
		   * @private
		   * @param {string} string The string to convert.
		   * @returns {Array} Returns the converted array.
		   */
		  function asciiToArray(string) {
		    return string.split('');
		  }

		  /**
		   * Splits an ASCII `string` into an array of its words.
		   *
		   * @private
		   * @param {string} The string to inspect.
		   * @returns {Array} Returns the words of `string`.
		   */
		  function asciiWords(string) {
		    return string.match(reAsciiWord) || [];
		  }

		  /**
		   * The base implementation of methods like `_.findKey` and `_.findLastKey`,
		   * without support for iteratee shorthands, which iterates over `collection`
		   * using `eachFunc`.
		   *
		   * @private
		   * @param {Array|Object} collection The collection to inspect.
		   * @param {Function} predicate The function invoked per iteration.
		   * @param {Function} eachFunc The function to iterate over `collection`.
		   * @returns {*} Returns the found element or its key, else `undefined`.
		   */
		  function baseFindKey(collection, predicate, eachFunc) {
		    var result;
		    eachFunc(collection, function(value, key, collection) {
		      if (predicate(value, key, collection)) {
		        result = key;
		        return false;
		      }
		    });
		    return result;
		  }

		  /**
		   * The base implementation of `_.findIndex` and `_.findLastIndex` without
		   * support for iteratee shorthands.
		   *
		   * @private
		   * @param {Array} array The array to inspect.
		   * @param {Function} predicate The function invoked per iteration.
		   * @param {number} fromIndex The index to search from.
		   * @param {boolean} [fromRight] Specify iterating from right to left.
		   * @returns {number} Returns the index of the matched value, else `-1`.
		   */
		  function baseFindIndex(array, predicate, fromIndex, fromRight) {
		    var length = array.length,
		        index = fromIndex + (fromRight ? 1 : -1);

		    while ((fromRight ? index-- : ++index < length)) {
		      if (predicate(array[index], index, array)) {
		        return index;
		      }
		    }
		    return -1;
		  }

		  /**
		   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
		   *
		   * @private
		   * @param {Array} array The array to inspect.
		   * @param {*} value The value to search for.
		   * @param {number} fromIndex The index to search from.
		   * @returns {number} Returns the index of the matched value, else `-1`.
		   */
		  function baseIndexOf(array, value, fromIndex) {
		    return value === value
		      ? strictIndexOf(array, value, fromIndex)
		      : baseFindIndex(array, baseIsNaN, fromIndex);
		  }

		  /**
		   * This function is like `baseIndexOf` except that it accepts a comparator.
		   *
		   * @private
		   * @param {Array} array The array to inspect.
		   * @param {*} value The value to search for.
		   * @param {number} fromIndex The index to search from.
		   * @param {Function} comparator The comparator invoked per element.
		   * @returns {number} Returns the index of the matched value, else `-1`.
		   */
		  function baseIndexOfWith(array, value, fromIndex, comparator) {
		    var index = fromIndex - 1,
		        length = array.length;

		    while (++index < length) {
		      if (comparator(array[index], value)) {
		        return index;
		      }
		    }
		    return -1;
		  }

		  /**
		   * The base implementation of `_.isNaN` without support for number objects.
		   *
		   * @private
		   * @param {*} value The value to check.
		   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
		   */
		  function baseIsNaN(value) {
		    return value !== value;
		  }

		  /**
		   * The base implementation of `_.mean` and `_.meanBy` without support for
		   * iteratee shorthands.
		   *
		   * @private
		   * @param {Array} array The array to iterate over.
		   * @param {Function} iteratee The function invoked per iteration.
		   * @returns {number} Returns the mean.
		   */
		  function baseMean(array, iteratee) {
		    var length = array == null ? 0 : array.length;
		    return length ? (baseSum(array, iteratee) / length) : NAN;
		  }

		  /**
		   * The base implementation of `_.property` without support for deep paths.
		   *
		   * @private
		   * @param {string} key The key of the property to get.
		   * @returns {Function} Returns the new accessor function.
		   */
		  function baseProperty(key) {
		    return function(object) {
		      return object == null ? undefined$1 : object[key];
		    };
		  }

		  /**
		   * The base implementation of `_.propertyOf` without support for deep paths.
		   *
		   * @private
		   * @param {Object} object The object to query.
		   * @returns {Function} Returns the new accessor function.
		   */
		  function basePropertyOf(object) {
		    return function(key) {
		      return object == null ? undefined$1 : object[key];
		    };
		  }

		  /**
		   * The base implementation of `_.reduce` and `_.reduceRight`, without support
		   * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
		   *
		   * @private
		   * @param {Array|Object} collection The collection to iterate over.
		   * @param {Function} iteratee The function invoked per iteration.
		   * @param {*} accumulator The initial value.
		   * @param {boolean} initAccum Specify using the first or last element of
		   *  `collection` as the initial value.
		   * @param {Function} eachFunc The function to iterate over `collection`.
		   * @returns {*} Returns the accumulated value.
		   */
		  function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
		    eachFunc(collection, function(value, index, collection) {
		      accumulator = initAccum
		        ? (initAccum = false, value)
		        : iteratee(accumulator, value, index, collection);
		    });
		    return accumulator;
		  }

		  /**
		   * The base implementation of `_.sortBy` which uses `comparer` to define the
		   * sort order of `array` and replaces criteria objects with their corresponding
		   * values.
		   *
		   * @private
		   * @param {Array} array The array to sort.
		   * @param {Function} comparer The function to define sort order.
		   * @returns {Array} Returns `array`.
		   */
		  function baseSortBy(array, comparer) {
		    var length = array.length;

		    array.sort(comparer);
		    while (length--) {
		      array[length] = array[length].value;
		    }
		    return array;
		  }

		  /**
		   * The base implementation of `_.sum` and `_.sumBy` without support for
		   * iteratee shorthands.
		   *
		   * @private
		   * @param {Array} array The array to iterate over.
		   * @param {Function} iteratee The function invoked per iteration.
		   * @returns {number} Returns the sum.
		   */
		  function baseSum(array, iteratee) {
		    var result,
		        index = -1,
		        length = array.length;

		    while (++index < length) {
		      var current = iteratee(array[index]);
		      if (current !== undefined$1) {
		        result = result === undefined$1 ? current : (result + current);
		      }
		    }
		    return result;
		  }

		  /**
		   * The base implementation of `_.times` without support for iteratee shorthands
		   * or max array length checks.
		   *
		   * @private
		   * @param {number} n The number of times to invoke `iteratee`.
		   * @param {Function} iteratee The function invoked per iteration.
		   * @returns {Array} Returns the array of results.
		   */
		  function baseTimes(n, iteratee) {
		    var index = -1,
		        result = Array(n);

		    while (++index < n) {
		      result[index] = iteratee(index);
		    }
		    return result;
		  }

		  /**
		   * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array
		   * of key-value pairs for `object` corresponding to the property names of `props`.
		   *
		   * @private
		   * @param {Object} object The object to query.
		   * @param {Array} props The property names to get values for.
		   * @returns {Object} Returns the key-value pairs.
		   */
		  function baseToPairs(object, props) {
		    return arrayMap(props, function(key) {
		      return [key, object[key]];
		    });
		  }

		  /**
		   * The base implementation of `_.trim`.
		   *
		   * @private
		   * @param {string} string The string to trim.
		   * @returns {string} Returns the trimmed string.
		   */
		  function baseTrim(string) {
		    return string
		      ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')
		      : string;
		  }

		  /**
		   * The base implementation of `_.unary` without support for storing metadata.
		   *
		   * @private
		   * @param {Function} func The function to cap arguments for.
		   * @returns {Function} Returns the new capped function.
		   */
		  function baseUnary(func) {
		    return function(value) {
		      return func(value);
		    };
		  }

		  /**
		   * The base implementation of `_.values` and `_.valuesIn` which creates an
		   * array of `object` property values corresponding to the property names
		   * of `props`.
		   *
		   * @private
		   * @param {Object} object The object to query.
		   * @param {Array} props The property names to get values for.
		   * @returns {Object} Returns the array of property values.
		   */
		  function baseValues(object, props) {
		    return arrayMap(props, function(key) {
		      return object[key];
		    });
		  }

		  /**
		   * Checks if a `cache` value for `key` exists.
		   *
		   * @private
		   * @param {Object} cache The cache to query.
		   * @param {string} key The key of the entry to check.
		   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
		   */
		  function cacheHas(cache, key) {
		    return cache.has(key);
		  }

		  /**
		   * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol
		   * that is not found in the character symbols.
		   *
		   * @private
		   * @param {Array} strSymbols The string symbols to inspect.
		   * @param {Array} chrSymbols The character symbols to find.
		   * @returns {number} Returns the index of the first unmatched string symbol.
		   */
		  function charsStartIndex(strSymbols, chrSymbols) {
		    var index = -1,
		        length = strSymbols.length;

		    while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
		    return index;
		  }

		  /**
		   * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol
		   * that is not found in the character symbols.
		   *
		   * @private
		   * @param {Array} strSymbols The string symbols to inspect.
		   * @param {Array} chrSymbols The character symbols to find.
		   * @returns {number} Returns the index of the last unmatched string symbol.
		   */
		  function charsEndIndex(strSymbols, chrSymbols) {
		    var index = strSymbols.length;

		    while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
		    return index;
		  }

		  /**
		   * Gets the number of `placeholder` occurrences in `array`.
		   *
		   * @private
		   * @param {Array} array The array to inspect.
		   * @param {*} placeholder The placeholder to search for.
		   * @returns {number} Returns the placeholder count.
		   */
		  function countHolders(array, placeholder) {
		    var length = array.length,
		        result = 0;

		    while (length--) {
		      if (array[length] === placeholder) {
		        ++result;
		      }
		    }
		    return result;
		  }

		  /**
		   * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
		   * letters to basic Latin letters.
		   *
		   * @private
		   * @param {string} letter The matched letter to deburr.
		   * @returns {string} Returns the deburred letter.
		   */
		  var deburrLetter = basePropertyOf(deburredLetters);

		  /**
		   * Used by `_.escape` to convert characters to HTML entities.
		   *
		   * @private
		   * @param {string} chr The matched character to escape.
		   * @returns {string} Returns the escaped character.
		   */
		  var escapeHtmlChar = basePropertyOf(htmlEscapes);

		  /**
		   * Used by `_.template` to escape characters for inclusion in compiled string literals.
		   *
		   * @private
		   * @param {string} chr The matched character to escape.
		   * @returns {string} Returns the escaped character.
		   */
		  function escapeStringChar(chr) {
		    return '\\' + stringEscapes[chr];
		  }

		  /**
		   * Gets the value at `key` of `object`.
		   *
		   * @private
		   * @param {Object} [object] The object to query.
		   * @param {string} key The key of the property to get.
		   * @returns {*} Returns the property value.
		   */
		  function getValue(object, key) {
		    return object == null ? undefined$1 : object[key];
		  }

		  /**
		   * Checks if `string` contains Unicode symbols.
		   *
		   * @private
		   * @param {string} string The string to inspect.
		   * @returns {boolean} Returns `true` if a symbol is found, else `false`.
		   */
		  function hasUnicode(string) {
		    return reHasUnicode.test(string);
		  }

		  /**
		   * Checks if `string` contains a word composed of Unicode symbols.
		   *
		   * @private
		   * @param {string} string The string to inspect.
		   * @returns {boolean} Returns `true` if a word is found, else `false`.
		   */
		  function hasUnicodeWord(string) {
		    return reHasUnicodeWord.test(string);
		  }

		  /**
		   * Converts `iterator` to an array.
		   *
		   * @private
		   * @param {Object} iterator The iterator to convert.
		   * @returns {Array} Returns the converted array.
		   */
		  function iteratorToArray(iterator) {
		    var data,
		        result = [];

		    while (!(data = iterator.next()).done) {
		      result.push(data.value);
		    }
		    return result;
		  }

		  /**
		   * Converts `map` to its key-value pairs.
		   *
		   * @private
		   * @param {Object} map The map to convert.
		   * @returns {Array} Returns the key-value pairs.
		   */
		  function mapToArray(map) {
		    var index = -1,
		        result = Array(map.size);

		    map.forEach(function(value, key) {
		      result[++index] = [key, value];
		    });
		    return result;
		  }

		  /**
		   * Creates a unary function that invokes `func` with its argument transformed.
		   *
		   * @private
		   * @param {Function} func The function to wrap.
		   * @param {Function} transform The argument transform.
		   * @returns {Function} Returns the new function.
		   */
		  function overArg(func, transform) {
		    return function(arg) {
		      return func(transform(arg));
		    };
		  }

		  /**
		   * Replaces all `placeholder` elements in `array` with an internal placeholder
		   * and returns an array of their indexes.
		   *
		   * @private
		   * @param {Array} array The array to modify.
		   * @param {*} placeholder The placeholder to replace.
		   * @returns {Array} Returns the new array of placeholder indexes.
		   */
		  function replaceHolders(array, placeholder) {
		    var index = -1,
		        length = array.length,
		        resIndex = 0,
		        result = [];

		    while (++index < length) {
		      var value = array[index];
		      if (value === placeholder || value === PLACEHOLDER) {
		        array[index] = PLACEHOLDER;
		        result[resIndex++] = index;
		      }
		    }
		    return result;
		  }

		  /**
		   * Converts `set` to an array of its values.
		   *
		   * @private
		   * @param {Object} set The set to convert.
		   * @returns {Array} Returns the values.
		   */
		  function setToArray(set) {
		    var index = -1,
		        result = Array(set.size);

		    set.forEach(function(value) {
		      result[++index] = value;
		    });
		    return result;
		  }

		  /**
		   * Converts `set` to its value-value pairs.
		   *
		   * @private
		   * @param {Object} set The set to convert.
		   * @returns {Array} Returns the value-value pairs.
		   */
		  function setToPairs(set) {
		    var index = -1,
		        result = Array(set.size);

		    set.forEach(function(value) {
		      result[++index] = [value, value];
		    });
		    return result;
		  }

		  /**
		   * A specialized version of `_.indexOf` which performs strict equality
		   * comparisons of values, i.e. `===`.
		   *
		   * @private
		   * @param {Array} array The array to inspect.
		   * @param {*} value The value to search for.
		   * @param {number} fromIndex The index to search from.
		   * @returns {number} Returns the index of the matched value, else `-1`.
		   */
		  function strictIndexOf(array, value, fromIndex) {
		    var index = fromIndex - 1,
		        length = array.length;

		    while (++index < length) {
		      if (array[index] === value) {
		        return index;
		      }
		    }
		    return -1;
		  }

		  /**
		   * A specialized version of `_.lastIndexOf` which performs strict equality
		   * comparisons of values, i.e. `===`.
		   *
		   * @private
		   * @param {Array} array The array to inspect.
		   * @param {*} value The value to search for.
		   * @param {number} fromIndex The index to search from.
		   * @returns {number} Returns the index of the matched value, else `-1`.
		   */
		  function strictLastIndexOf(array, value, fromIndex) {
		    var index = fromIndex + 1;
		    while (index--) {
		      if (array[index] === value) {
		        return index;
		      }
		    }
		    return index;
		  }

		  /**
		   * Gets the number of symbols in `string`.
		   *
		   * @private
		   * @param {string} string The string to inspect.
		   * @returns {number} Returns the string size.
		   */
		  function stringSize(string) {
		    return hasUnicode(string)
		      ? unicodeSize(string)
		      : asciiSize(string);
		  }

		  /**
		   * Converts `string` to an array.
		   *
		   * @private
		   * @param {string} string The string to convert.
		   * @returns {Array} Returns the converted array.
		   */
		  function stringToArray(string) {
		    return hasUnicode(string)
		      ? unicodeToArray(string)
		      : asciiToArray(string);
		  }

		  /**
		   * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
		   * character of `string`.
		   *
		   * @private
		   * @param {string} string The string to inspect.
		   * @returns {number} Returns the index of the last non-whitespace character.
		   */
		  function trimmedEndIndex(string) {
		    var index = string.length;

		    while (index-- && reWhitespace.test(string.charAt(index))) {}
		    return index;
		  }

		  /**
		   * Used by `_.unescape` to convert HTML entities to characters.
		   *
		   * @private
		   * @param {string} chr The matched character to unescape.
		   * @returns {string} Returns the unescaped character.
		   */
		  var unescapeHtmlChar = basePropertyOf(htmlUnescapes);

		  /**
		   * Gets the size of a Unicode `string`.
		   *
		   * @private
		   * @param {string} string The string inspect.
		   * @returns {number} Returns the string size.
		   */
		  function unicodeSize(string) {
		    var result = reUnicode.lastIndex = 0;
		    while (reUnicode.test(string)) {
		      ++result;
		    }
		    return result;
		  }

		  /**
		   * Converts a Unicode `string` to an array.
		   *
		   * @private
		   * @param {string} string The string to convert.
		   * @returns {Array} Returns the converted array.
		   */
		  function unicodeToArray(string) {
		    return string.match(reUnicode) || [];
		  }

		  /**
		   * Splits a Unicode `string` into an array of its words.
		   *
		   * @private
		   * @param {string} The string to inspect.
		   * @returns {Array} Returns the words of `string`.
		   */
		  function unicodeWords(string) {
		    return string.match(reUnicodeWord) || [];
		  }

		  /*--------------------------------------------------------------------------*/

		  /**
		   * Create a new pristine `lodash` function using the `context` object.
		   *
		   * @static
		   * @memberOf _
		   * @since 1.1.0
		   * @category Util
		   * @param {Object} [context=root] The context object.
		   * @returns {Function} Returns a new `lodash` function.
		   * @example
		   *
		   * _.mixin({ 'foo': _.constant('foo') });
		   *
		   * var lodash = _.runInContext();
		   * lodash.mixin({ 'bar': lodash.constant('bar') });
		   *
		   * _.isFunction(_.foo);
		   * // => true
		   * _.isFunction(_.bar);
		   * // => false
		   *
		   * lodash.isFunction(lodash.foo);
		   * // => false
		   * lodash.isFunction(lodash.bar);
		   * // => true
		   *
		   * // Create a suped-up `defer` in Node.js.
		   * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;
		   */
		  var runInContext = (function runInContext(context) {
		    context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));

		    /** Built-in constructor references. */
		    var Array = context.Array,
		        Date = context.Date,
		        Error = context.Error,
		        Function = context.Function,
		        Math = context.Math,
		        Object = context.Object,
		        RegExp = context.RegExp,
		        String = context.String,
		        TypeError = context.TypeError;

		    /** Used for built-in method references. */
		    var arrayProto = Array.prototype,
		        funcProto = Function.prototype,
		        objectProto = Object.prototype;

		    /** Used to detect overreaching core-js shims. */
		    var coreJsData = context['__core-js_shared__'];

		    /** Used to resolve the decompiled source of functions. */
		    var funcToString = funcProto.toString;

		    /** Used to check objects for own properties. */
		    var hasOwnProperty = objectProto.hasOwnProperty;

		    /** Used to generate unique IDs. */
		    var idCounter = 0;

		    /** Used to detect methods masquerading as native. */
		    var maskSrcKey = (function() {
		      var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
		      return uid ? ('Symbol(src)_1.' + uid) : '';
		    }());

		    /**
		     * Used to resolve the
		     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
		     * of values.
		     */
		    var nativeObjectToString = objectProto.toString;

		    /** Used to infer the `Object` constructor. */
		    var objectCtorString = funcToString.call(Object);

		    /** Used to restore the original `_` reference in `_.noConflict`. */
		    var oldDash = root._;

		    /** Used to detect if a method is native. */
		    var reIsNative = RegExp('^' +
		      funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
		      .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
		    );

		    /** Built-in value references. */
		    var Buffer = moduleExports ? context.Buffer : undefined$1,
		        Symbol = context.Symbol,
		        Uint8Array = context.Uint8Array,
		        allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined$1,
		        getPrototype = overArg(Object.getPrototypeOf, Object),
		        objectCreate = Object.create,
		        propertyIsEnumerable = objectProto.propertyIsEnumerable,
		        splice = arrayProto.splice,
		        spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined$1,
		        symIterator = Symbol ? Symbol.iterator : undefined$1,
		        symToStringTag = Symbol ? Symbol.toStringTag : undefined$1;

		    var defineProperty = (function() {
		      try {
		        var func = getNative(Object, 'defineProperty');
		        func({}, '', {});
		        return func;
		      } catch (e) {}
		    }());

		    /** Mocked built-ins. */
		    var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,
		        ctxNow = Date && Date.now !== root.Date.now && Date.now,
		        ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;

		    /* Built-in method references for those with the same name as other `lodash` methods. */
		    var nativeCeil = Math.ceil,
		        nativeFloor = Math.floor,
		        nativeGetSymbols = Object.getOwnPropertySymbols,
		        nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined$1,
		        nativeIsFinite = context.isFinite,
		        nativeJoin = arrayProto.join,
		        nativeKeys = overArg(Object.keys, Object),
		        nativeMax = Math.max,
		        nativeMin = Math.min,
		        nativeNow = Date.now,
		        nativeParseInt = context.parseInt,
		        nativeRandom = Math.random,
		        nativeReverse = arrayProto.reverse;

		    /* Built-in method references that are verified to be native. */
		    var DataView = getNative(context, 'DataView'),
		        Map = getNative(context, 'Map'),
		        Promise = getNative(context, 'Promise'),
		        Set = getNative(context, 'Set'),
		        WeakMap = getNative(context, 'WeakMap'),
		        nativeCreate = getNative(Object, 'create');

		    /** Used to store function metadata. */
		    var metaMap = WeakMap && new WeakMap;

		    /** Used to lookup unminified function names. */
		    var realNames = {};

		    /** Used to detect maps, sets, and weakmaps. */
		    var dataViewCtorString = toSource(DataView),
		        mapCtorString = toSource(Map),
		        promiseCtorString = toSource(Promise),
		        setCtorString = toSource(Set),
		        weakMapCtorString = toSource(WeakMap);

		    /** Used to convert symbols to primitives and strings. */
		    var symbolProto = Symbol ? Symbol.prototype : undefined$1,
		        symbolValueOf = symbolProto ? symbolProto.valueOf : undefined$1,
		        symbolToString = symbolProto ? symbolProto.toString : undefined$1;

		    /*------------------------------------------------------------------------*/

		    /**
		     * Creates a `lodash` object which wraps `value` to enable implicit method
		     * chain sequences. Methods that operate on and return arrays, collections,
		     * and functions can be chained together. Methods that retrieve a single value
		     * or may return a primitive value will automatically end the chain sequence
		     * and return the unwrapped value. Otherwise, the value must be unwrapped
		     * with `_#value`.
		     *
		     * Explicit chain sequences, which must be unwrapped with `_#value`, may be
		     * enabled using `_.chain`.
		     *
		     * The execution of chained methods is lazy, that is, it's deferred until
		     * `_#value` is implicitly or explicitly called.
		     *
		     * Lazy evaluation allows several methods to support shortcut fusion.
		     * Shortcut fusion is an optimization to merge iteratee calls; this avoids
		     * the creation of intermediate arrays and can greatly reduce the number of
		     * iteratee executions. Sections of a chain sequence qualify for shortcut
		     * fusion if the section is applied to an array and iteratees accept only
		     * one argument. The heuristic for whether a section qualifies for shortcut
		     * fusion is subject to change.
		     *
		     * Chaining is supported in custom builds as long as the `_#value` method is
		     * directly or indirectly included in the build.
		     *
		     * In addition to lodash methods, wrappers have `Array` and `String` methods.
		     *
		     * The wrapper `Array` methods are:
		     * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`
		     *
		     * The wrapper `String` methods are:
		     * `replace` and `split`
		     *
		     * The wrapper methods that support shortcut fusion are:
		     * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,
		     * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,
		     * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`
		     *
		     * The chainable wrapper methods are:
		     * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,
		     * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,
		     * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,
		     * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,
		     * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,
		     * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,
		     * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,
		     * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,
		     * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,
		     * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,
		     * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,
		     * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,
		     * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,
		     * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,
		     * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,
		     * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,
		     * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,
		     * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,
		     * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,
		     * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,
		     * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,
		     * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,
		     * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,
		     * `zipObject`, `zipObjectDeep`, and `zipWith`
		     *
		     * The wrapper methods that are **not** chainable by default are:
		     * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,
		     * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,
		     * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,
		     * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,
		     * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,
		     * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,
		     * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,
		     * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,
		     * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,
		     * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,
		     * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,
		     * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,
		     * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,
		     * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,
		     * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,
		     * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,
		     * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,
		     * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,
		     * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,
		     * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,
		     * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,
		     * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,
		     * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,
		     * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,
		     * `upperFirst`, `value`, and `words`
		     *
		     * @name _
		     * @constructor
		     * @category Seq
		     * @param {*} value The value to wrap in a `lodash` instance.
		     * @returns {Object} Returns the new `lodash` wrapper instance.
		     * @example
		     *
		     * function square(n) {
		     *   return n * n;
		     * }
		     *
		     * var wrapped = _([1, 2, 3]);
		     *
		     * // Returns an unwrapped value.
		     * wrapped.reduce(_.add);
		     * // => 6
		     *
		     * // Returns a wrapped value.
		     * var squares = wrapped.map(square);
		     *
		     * _.isArray(squares);
		     * // => false
		     *
		     * _.isArray(squares.value());
		     * // => true
		     */
		    function lodash(value) {
		      if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {
		        if (value instanceof LodashWrapper) {
		          return value;
		        }
		        if (hasOwnProperty.call(value, '__wrapped__')) {
		          return wrapperClone(value);
		        }
		      }
		      return new LodashWrapper(value);
		    }

		    /**
		     * The base implementation of `_.create` without support for assigning
		     * properties to the created object.
		     *
		     * @private
		     * @param {Object} proto The object to inherit from.
		     * @returns {Object} Returns the new object.
		     */
		    var baseCreate = (function() {
		      function object() {}
		      return function(proto) {
		        if (!isObject(proto)) {
		          return {};
		        }
		        if (objectCreate) {
		          return objectCreate(proto);
		        }
		        object.prototype = proto;
		        var result = new object;
		        object.prototype = undefined$1;
		        return result;
		      };
		    }());

		    /**
		     * The function whose prototype chain sequence wrappers inherit from.
		     *
		     * @private
		     */
		    function baseLodash() {
		      // No operation performed.
		    }

		    /**
		     * The base constructor for creating `lodash` wrapper objects.
		     *
		     * @private
		     * @param {*} value The value to wrap.
		     * @param {boolean} [chainAll] Enable explicit method chain sequences.
		     */
		    function LodashWrapper(value, chainAll) {
		      this.__wrapped__ = value;
		      this.__actions__ = [];
		      this.__chain__ = !!chainAll;
		      this.__index__ = 0;
		      this.__values__ = undefined$1;
		    }

		    /**
		     * By default, the template delimiters used by lodash are like those in
		     * embedded Ruby (ERB) as well as ES2015 template strings. Change the
		     * following template settings to use alternative delimiters.
		     *
		     * @static
		     * @memberOf _
		     * @type {Object}
		     */
		    lodash.templateSettings = {

		      /**
		       * Used to detect `data` property values to be HTML-escaped.
		       *
		       * @memberOf _.templateSettings
		       * @type {RegExp}
		       */
		      'escape': reEscape,

		      /**
		       * Used to detect code to be evaluated.
		       *
		       * @memberOf _.templateSettings
		       * @type {RegExp}
		       */
		      'evaluate': reEvaluate,

		      /**
		       * Used to detect `data` property values to inject.
		       *
		       * @memberOf _.templateSettings
		       * @type {RegExp}
		       */
		      'interpolate': reInterpolate,

		      /**
		       * Used to reference the data object in the template text.
		       *
		       * @memberOf _.templateSettings
		       * @type {string}
		       */
		      'variable': '',

		      /**
		       * Used to import variables into the compiled template.
		       *
		       * @memberOf _.templateSettings
		       * @type {Object}
		       */
		      'imports': {

		        /**
		         * A reference to the `lodash` function.
		         *
		         * @memberOf _.templateSettings.imports
		         * @type {Function}
		         */
		        '_': lodash
		      }
		    };

		    // Ensure wrappers are instances of `baseLodash`.
		    lodash.prototype = baseLodash.prototype;
		    lodash.prototype.constructor = lodash;

		    LodashWrapper.prototype = baseCreate(baseLodash.prototype);
		    LodashWrapper.prototype.constructor = LodashWrapper;

		    /*------------------------------------------------------------------------*/

		    /**
		     * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
		     *
		     * @private
		     * @constructor
		     * @param {*} value The value to wrap.
		     */
		    function LazyWrapper(value) {
		      this.__wrapped__ = value;
		      this.__actions__ = [];
		      this.__dir__ = 1;
		      this.__filtered__ = false;
		      this.__iteratees__ = [];
		      this.__takeCount__ = MAX_ARRAY_LENGTH;
		      this.__views__ = [];
		    }

		    /**
		     * Creates a clone of the lazy wrapper object.
		     *
		     * @private
		     * @name clone
		     * @memberOf LazyWrapper
		     * @returns {Object} Returns the cloned `LazyWrapper` object.
		     */
		    function lazyClone() {
		      var result = new LazyWrapper(this.__wrapped__);
		      result.__actions__ = copyArray(this.__actions__);
		      result.__dir__ = this.__dir__;
		      result.__filtered__ = this.__filtered__;
		      result.__iteratees__ = copyArray(this.__iteratees__);
		      result.__takeCount__ = this.__takeCount__;
		      result.__views__ = copyArray(this.__views__);
		      return result;
		    }

		    /**
		     * Reverses the direction of lazy iteration.
		     *
		     * @private
		     * @name reverse
		     * @memberOf LazyWrapper
		     * @returns {Object} Returns the new reversed `LazyWrapper` object.
		     */
		    function lazyReverse() {
		      if (this.__filtered__) {
		        var result = new LazyWrapper(this);
		        result.__dir__ = -1;
		        result.__filtered__ = true;
		      } else {
		        result = this.clone();
		        result.__dir__ *= -1;
		      }
		      return result;
		    }

		    /**
		     * Extracts the unwrapped value from its lazy wrapper.
		     *
		     * @private
		     * @name value
		     * @memberOf LazyWrapper
		     * @returns {*} Returns the unwrapped value.
		     */
		    function lazyValue() {
		      var array = this.__wrapped__.value(),
		          dir = this.__dir__,
		          isArr = isArray(array),
		          isRight = dir < 0,
		          arrLength = isArr ? array.length : 0,
		          view = getView(0, arrLength, this.__views__),
		          start = view.start,
		          end = view.end,
		          length = end - start,
		          index = isRight ? end : (start - 1),
		          iteratees = this.__iteratees__,
		          iterLength = iteratees.length,
		          resIndex = 0,
		          takeCount = nativeMin(length, this.__takeCount__);

		      if (!isArr || (!isRight && arrLength == length && takeCount == length)) {
		        return baseWrapperValue(array, this.__actions__);
		      }
		      var result = [];

		      outer:
		      while (length-- && resIndex < takeCount) {
		        index += dir;

		        var iterIndex = -1,
		            value = array[index];

		        while (++iterIndex < iterLength) {
		          var data = iteratees[iterIndex],
		              iteratee = data.iteratee,
		              type = data.type,
		              computed = iteratee(value);

		          if (type == LAZY_MAP_FLAG) {
		            value = computed;
		          } else if (!computed) {
		            if (type == LAZY_FILTER_FLAG) {
		              continue outer;
		            } else {
		              break outer;
		            }
		          }
		        }
		        result[resIndex++] = value;
		      }
		      return result;
		    }

		    // Ensure `LazyWrapper` is an instance of `baseLodash`.
		    LazyWrapper.prototype = baseCreate(baseLodash.prototype);
		    LazyWrapper.prototype.constructor = LazyWrapper;

		    /*------------------------------------------------------------------------*/

		    /**
		     * Creates a hash object.
		     *
		     * @private
		     * @constructor
		     * @param {Array} [entries] The key-value pairs to cache.
		     */
		    function Hash(entries) {
		      var index = -1,
		          length = entries == null ? 0 : entries.length;

		      this.clear();
		      while (++index < length) {
		        var entry = entries[index];
		        this.set(entry[0], entry[1]);
		      }
		    }

		    /**
		     * Removes all key-value entries from the hash.
		     *
		     * @private
		     * @name clear
		     * @memberOf Hash
		     */
		    function hashClear() {
		      this.__data__ = nativeCreate ? nativeCreate(null) : {};
		      this.size = 0;
		    }

		    /**
		     * Removes `key` and its value from the hash.
		     *
		     * @private
		     * @name delete
		     * @memberOf Hash
		     * @param {Object} hash The hash to modify.
		     * @param {string} key The key of the value to remove.
		     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
		     */
		    function hashDelete(key) {
		      var result = this.has(key) && delete this.__data__[key];
		      this.size -= result ? 1 : 0;
		      return result;
		    }

		    /**
		     * Gets the hash value for `key`.
		     *
		     * @private
		     * @name get
		     * @memberOf Hash
		     * @param {string} key The key of the value to get.
		     * @returns {*} Returns the entry value.
		     */
		    function hashGet(key) {
		      var data = this.__data__;
		      if (nativeCreate) {
		        var result = data[key];
		        return result === HASH_UNDEFINED ? undefined$1 : result;
		      }
		      return hasOwnProperty.call(data, key) ? data[key] : undefined$1;
		    }

		    /**
		     * Checks if a hash value for `key` exists.
		     *
		     * @private
		     * @name has
		     * @memberOf Hash
		     * @param {string} key The key of the entry to check.
		     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
		     */
		    function hashHas(key) {
		      var data = this.__data__;
		      return nativeCreate ? (data[key] !== undefined$1) : hasOwnProperty.call(data, key);
		    }

		    /**
		     * Sets the hash `key` to `value`.
		     *
		     * @private
		     * @name set
		     * @memberOf Hash
		     * @param {string} key The key of the value to set.
		     * @param {*} value The value to set.
		     * @returns {Object} Returns the hash instance.
		     */
		    function hashSet(key, value) {
		      var data = this.__data__;
		      this.size += this.has(key) ? 0 : 1;
		      data[key] = (nativeCreate && value === undefined$1) ? HASH_UNDEFINED : value;
		      return this;
		    }

		    // Add methods to `Hash`.
		    Hash.prototype.clear = hashClear;
		    Hash.prototype['delete'] = hashDelete;
		    Hash.prototype.get = hashGet;
		    Hash.prototype.has = hashHas;
		    Hash.prototype.set = hashSet;

		    /*------------------------------------------------------------------------*/

		    /**
		     * Creates an list cache object.
		     *
		     * @private
		     * @constructor
		     * @param {Array} [entries] The key-value pairs to cache.
		     */
		    function ListCache(entries) {
		      var index = -1,
		          length = entries == null ? 0 : entries.length;

		      this.clear();
		      while (++index < length) {
		        var entry = entries[index];
		        this.set(entry[0], entry[1]);
		      }
		    }

		    /**
		     * Removes all key-value entries from the list cache.
		     *
		     * @private
		     * @name clear
		     * @memberOf ListCache
		     */
		    function listCacheClear() {
		      this.__data__ = [];
		      this.size = 0;
		    }

		    /**
		     * Removes `key` and its value from the list cache.
		     *
		     * @private
		     * @name delete
		     * @memberOf ListCache
		     * @param {string} key The key of the value to remove.
		     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
		     */
		    function listCacheDelete(key) {
		      var data = this.__data__,
		          index = assocIndexOf(data, key);

		      if (index < 0) {
		        return false;
		      }
		      var lastIndex = data.length - 1;
		      if (index == lastIndex) {
		        data.pop();
		      } else {
		        splice.call(data, index, 1);
		      }
		      --this.size;
		      return true;
		    }

		    /**
		     * Gets the list cache value for `key`.
		     *
		     * @private
		     * @name get
		     * @memberOf ListCache
		     * @param {string} key The key of the value to get.
		     * @returns {*} Returns the entry value.
		     */
		    function listCacheGet(key) {
		      var data = this.__data__,
		          index = assocIndexOf(data, key);

		      return index < 0 ? undefined$1 : data[index][1];
		    }

		    /**
		     * Checks if a list cache value for `key` exists.
		     *
		     * @private
		     * @name has
		     * @memberOf ListCache
		     * @param {string} key The key of the entry to check.
		     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
		     */
		    function listCacheHas(key) {
		      return assocIndexOf(this.__data__, key) > -1;
		    }

		    /**
		     * Sets the list cache `key` to `value`.
		     *
		     * @private
		     * @name set
		     * @memberOf ListCache
		     * @param {string} key The key of the value to set.
		     * @param {*} value The value to set.
		     * @returns {Object} Returns the list cache instance.
		     */
		    function listCacheSet(key, value) {
		      var data = this.__data__,
		          index = assocIndexOf(data, key);

		      if (index < 0) {
		        ++this.size;
		        data.push([key, value]);
		      } else {
		        data[index][1] = value;
		      }
		      return this;
		    }

		    // Add methods to `ListCache`.
		    ListCache.prototype.clear = listCacheClear;
		    ListCache.prototype['delete'] = listCacheDelete;
		    ListCache.prototype.get = listCacheGet;
		    ListCache.prototype.has = listCacheHas;
		    ListCache.prototype.set = listCacheSet;

		    /*------------------------------------------------------------------------*/

		    /**
		     * Creates a map cache object to store key-value pairs.
		     *
		     * @private
		     * @constructor
		     * @param {Array} [entries] The key-value pairs to cache.
		     */
		    function MapCache(entries) {
		      var index = -1,
		          length = entries == null ? 0 : entries.length;

		      this.clear();
		      while (++index < length) {
		        var entry = entries[index];
		        this.set(entry[0], entry[1]);
		      }
		    }

		    /**
		     * Removes all key-value entries from the map.
		     *
		     * @private
		     * @name clear
		     * @memberOf MapCache
		     */
		    function mapCacheClear() {
		      this.size = 0;
		      this.__data__ = {
		        'hash': new Hash,
		        'map': new (Map || ListCache),
		        'string': new Hash
		      };
		    }

		    /**
		     * Removes `key` and its value from the map.
		     *
		     * @private
		     * @name delete
		     * @memberOf MapCache
		     * @param {string} key The key of the value to remove.
		     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
		     */
		    function mapCacheDelete(key) {
		      var result = getMapData(this, key)['delete'](key);
		      this.size -= result ? 1 : 0;
		      return result;
		    }

		    /**
		     * Gets the map value for `key`.
		     *
		     * @private
		     * @name get
		     * @memberOf MapCache
		     * @param {string} key The key of the value to get.
		     * @returns {*} Returns the entry value.
		     */
		    function mapCacheGet(key) {
		      return getMapData(this, key).get(key);
		    }

		    /**
		     * Checks if a map value for `key` exists.
		     *
		     * @private
		     * @name has
		     * @memberOf MapCache
		     * @param {string} key The key of the entry to check.
		     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
		     */
		    function mapCacheHas(key) {
		      return getMapData(this, key).has(key);
		    }

		    /**
		     * Sets the map `key` to `value`.
		     *
		     * @private
		     * @name set
		     * @memberOf MapCache
		     * @param {string} key The key of the value to set.
		     * @param {*} value The value to set.
		     * @returns {Object} Returns the map cache instance.
		     */
		    function mapCacheSet(key, value) {
		      var data = getMapData(this, key),
		          size = data.size;

		      data.set(key, value);
		      this.size += data.size == size ? 0 : 1;
		      return this;
		    }

		    // Add methods to `MapCache`.
		    MapCache.prototype.clear = mapCacheClear;
		    MapCache.prototype['delete'] = mapCacheDelete;
		    MapCache.prototype.get = mapCacheGet;
		    MapCache.prototype.has = mapCacheHas;
		    MapCache.prototype.set = mapCacheSet;

		    /*------------------------------------------------------------------------*/

		    /**
		     *
		     * Creates an array cache object to store unique values.
		     *
		     * @private
		     * @constructor
		     * @param {Array} [values] The values to cache.
		     */
		    function SetCache(values) {
		      var index = -1,
		          length = values == null ? 0 : values.length;

		      this.__data__ = new MapCache;
		      while (++index < length) {
		        this.add(values[index]);
		      }
		    }

		    /**
		     * Adds `value` to the array cache.
		     *
		     * @private
		     * @name add
		     * @memberOf SetCache
		     * @alias push
		     * @param {*} value The value to cache.
		     * @returns {Object} Returns the cache instance.
		     */
		    function setCacheAdd(value) {
		      this.__data__.set(value, HASH_UNDEFINED);
		      return this;
		    }

		    /**
		     * Checks if `value` is in the array cache.
		     *
		     * @private
		     * @name has
		     * @memberOf SetCache
		     * @param {*} value The value to search for.
		     * @returns {number} Returns `true` if `value` is found, else `false`.
		     */
		    function setCacheHas(value) {
		      return this.__data__.has(value);
		    }

		    // Add methods to `SetCache`.
		    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
		    SetCache.prototype.has = setCacheHas;

		    /*------------------------------------------------------------------------*/

		    /**
		     * Creates a stack cache object to store key-value pairs.
		     *
		     * @private
		     * @constructor
		     * @param {Array} [entries] The key-value pairs to cache.
		     */
		    function Stack(entries) {
		      var data = this.__data__ = new ListCache(entries);
		      this.size = data.size;
		    }

		    /**
		     * Removes all key-value entries from the stack.
		     *
		     * @private
		     * @name clear
		     * @memberOf Stack
		     */
		    function stackClear() {
		      this.__data__ = new ListCache;
		      this.size = 0;
		    }

		    /**
		     * Removes `key` and its value from the stack.
		     *
		     * @private
		     * @name delete
		     * @memberOf Stack
		     * @param {string} key The key of the value to remove.
		     * @returns {boolean} Returns `true` if the entry was removed, else `false`.
		     */
		    function stackDelete(key) {
		      var data = this.__data__,
		          result = data['delete'](key);

		      this.size = data.size;
		      return result;
		    }

		    /**
		     * Gets the stack value for `key`.
		     *
		     * @private
		     * @name get
		     * @memberOf Stack
		     * @param {string} key The key of the value to get.
		     * @returns {*} Returns the entry value.
		     */
		    function stackGet(key) {
		      return this.__data__.get(key);
		    }

		    /**
		     * Checks if a stack value for `key` exists.
		     *
		     * @private
		     * @name has
		     * @memberOf Stack
		     * @param {string} key The key of the entry to check.
		     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
		     */
		    function stackHas(key) {
		      return this.__data__.has(key);
		    }

		    /**
		     * Sets the stack `key` to `value`.
		     *
		     * @private
		     * @name set
		     * @memberOf Stack
		     * @param {string} key The key of the value to set.
		     * @param {*} value The value to set.
		     * @returns {Object} Returns the stack cache instance.
		     */
		    function stackSet(key, value) {
		      var data = this.__data__;
		      if (data instanceof ListCache) {
		        var pairs = data.__data__;
		        if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
		          pairs.push([key, value]);
		          this.size = ++data.size;
		          return this;
		        }
		        data = this.__data__ = new MapCache(pairs);
		      }
		      data.set(key, value);
		      this.size = data.size;
		      return this;
		    }

		    // Add methods to `Stack`.
		    Stack.prototype.clear = stackClear;
		    Stack.prototype['delete'] = stackDelete;
		    Stack.prototype.get = stackGet;
		    Stack.prototype.has = stackHas;
		    Stack.prototype.set = stackSet;

		    /*------------------------------------------------------------------------*/

		    /**
		     * Creates an array of the enumerable property names of the array-like `value`.
		     *
		     * @private
		     * @param {*} value The value to query.
		     * @param {boolean} inherited Specify returning inherited property names.
		     * @returns {Array} Returns the array of property names.
		     */
		    function arrayLikeKeys(value, inherited) {
		      var isArr = isArray(value),
		          isArg = !isArr && isArguments(value),
		          isBuff = !isArr && !isArg && isBuffer(value),
		          isType = !isArr && !isArg && !isBuff && isTypedArray(value),
		          skipIndexes = isArr || isArg || isBuff || isType,
		          result = skipIndexes ? baseTimes(value.length, String) : [],
		          length = result.length;

		      for (var key in value) {
		        if ((inherited || hasOwnProperty.call(value, key)) &&
		            !(skipIndexes && (
		               // Safari 9 has enumerable `arguments.length` in strict mode.
		               key == 'length' ||
		               // Node.js 0.10 has enumerable non-index properties on buffers.
		               (isBuff && (key == 'offset' || key == 'parent')) ||
		               // PhantomJS 2 has enumerable non-index properties on typed arrays.
		               (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
		               // Skip index properties.
		               isIndex(key, length)
		            ))) {
		          result.push(key);
		        }
		      }
		      return result;
		    }

		    /**
		     * A specialized version of `_.sample` for arrays.
		     *
		     * @private
		     * @param {Array} array The array to sample.
		     * @returns {*} Returns the random element.
		     */
		    function arraySample(array) {
		      var length = array.length;
		      return length ? array[baseRandom(0, length - 1)] : undefined$1;
		    }

		    /**
		     * A specialized version of `_.sampleSize` for arrays.
		     *
		     * @private
		     * @param {Array} array The array to sample.
		     * @param {number} n The number of elements to sample.
		     * @returns {Array} Returns the random elements.
		     */
		    function arraySampleSize(array, n) {
		      return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
		    }

		    /**
		     * A specialized version of `_.shuffle` for arrays.
		     *
		     * @private
		     * @param {Array} array The array to shuffle.
		     * @returns {Array} Returns the new shuffled array.
		     */
		    function arrayShuffle(array) {
		      return shuffleSelf(copyArray(array));
		    }

		    /**
		     * This function is like `assignValue` except that it doesn't assign
		     * `undefined` values.
		     *
		     * @private
		     * @param {Object} object The object to modify.
		     * @param {string} key The key of the property to assign.
		     * @param {*} value The value to assign.
		     */
		    function assignMergeValue(object, key, value) {
		      if ((value !== undefined$1 && !eq(object[key], value)) ||
		          (value === undefined$1 && !(key in object))) {
		        baseAssignValue(object, key, value);
		      }
		    }

		    /**
		     * Assigns `value` to `key` of `object` if the existing value is not equivalent
		     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
		     * for equality comparisons.
		     *
		     * @private
		     * @param {Object} object The object to modify.
		     * @param {string} key The key of the property to assign.
		     * @param {*} value The value to assign.
		     */
		    function assignValue(object, key, value) {
		      var objValue = object[key];
		      if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
		          (value === undefined$1 && !(key in object))) {
		        baseAssignValue(object, key, value);
		      }
		    }

		    /**
		     * Gets the index at which the `key` is found in `array` of key-value pairs.
		     *
		     * @private
		     * @param {Array} array The array to inspect.
		     * @param {*} key The key to search for.
		     * @returns {number} Returns the index of the matched value, else `-1`.
		     */
		    function assocIndexOf(array, key) {
		      var length = array.length;
		      while (length--) {
		        if (eq(array[length][0], key)) {
		          return length;
		        }
		      }
		      return -1;
		    }

		    /**
		     * Aggregates elements of `collection` on `accumulator` with keys transformed
		     * by `iteratee` and values set by `setter`.
		     *
		     * @private
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} setter The function to set `accumulator` values.
		     * @param {Function} iteratee The iteratee to transform keys.
		     * @param {Object} accumulator The initial aggregated object.
		     * @returns {Function} Returns `accumulator`.
		     */
		    function baseAggregator(collection, setter, iteratee, accumulator) {
		      baseEach(collection, function(value, key, collection) {
		        setter(accumulator, value, iteratee(value), collection);
		      });
		      return accumulator;
		    }

		    /**
		     * The base implementation of `_.assign` without support for multiple sources
		     * or `customizer` functions.
		     *
		     * @private
		     * @param {Object} object The destination object.
		     * @param {Object} source The source object.
		     * @returns {Object} Returns `object`.
		     */
		    function baseAssign(object, source) {
		      return object && copyObject(source, keys(source), object);
		    }

		    /**
		     * The base implementation of `_.assignIn` without support for multiple sources
		     * or `customizer` functions.
		     *
		     * @private
		     * @param {Object} object The destination object.
		     * @param {Object} source The source object.
		     * @returns {Object} Returns `object`.
		     */
		    function baseAssignIn(object, source) {
		      return object && copyObject(source, keysIn(source), object);
		    }

		    /**
		     * The base implementation of `assignValue` and `assignMergeValue` without
		     * value checks.
		     *
		     * @private
		     * @param {Object} object The object to modify.
		     * @param {string} key The key of the property to assign.
		     * @param {*} value The value to assign.
		     */
		    function baseAssignValue(object, key, value) {
		      if (key == '__proto__' && defineProperty) {
		        defineProperty(object, key, {
		          'configurable': true,
		          'enumerable': true,
		          'value': value,
		          'writable': true
		        });
		      } else {
		        object[key] = value;
		      }
		    }

		    /**
		     * The base implementation of `_.at` without support for individual paths.
		     *
		     * @private
		     * @param {Object} object The object to iterate over.
		     * @param {string[]} paths The property paths to pick.
		     * @returns {Array} Returns the picked elements.
		     */
		    function baseAt(object, paths) {
		      var index = -1,
		          length = paths.length,
		          result = Array(length),
		          skip = object == null;

		      while (++index < length) {
		        result[index] = skip ? undefined$1 : get(object, paths[index]);
		      }
		      return result;
		    }

		    /**
		     * The base implementation of `_.clamp` which doesn't coerce arguments.
		     *
		     * @private
		     * @param {number} number The number to clamp.
		     * @param {number} [lower] The lower bound.
		     * @param {number} upper The upper bound.
		     * @returns {number} Returns the clamped number.
		     */
		    function baseClamp(number, lower, upper) {
		      if (number === number) {
		        if (upper !== undefined$1) {
		          number = number <= upper ? number : upper;
		        }
		        if (lower !== undefined$1) {
		          number = number >= lower ? number : lower;
		        }
		      }
		      return number;
		    }

		    /**
		     * The base implementation of `_.clone` and `_.cloneDeep` which tracks
		     * traversed objects.
		     *
		     * @private
		     * @param {*} value The value to clone.
		     * @param {boolean} bitmask The bitmask flags.
		     *  1 - Deep clone
		     *  2 - Flatten inherited properties
		     *  4 - Clone symbols
		     * @param {Function} [customizer] The function to customize cloning.
		     * @param {string} [key] The key of `value`.
		     * @param {Object} [object] The parent object of `value`.
		     * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
		     * @returns {*} Returns the cloned value.
		     */
		    function baseClone(value, bitmask, customizer, key, object, stack) {
		      var result,
		          isDeep = bitmask & CLONE_DEEP_FLAG,
		          isFlat = bitmask & CLONE_FLAT_FLAG,
		          isFull = bitmask & CLONE_SYMBOLS_FLAG;

		      if (customizer) {
		        result = object ? customizer(value, key, object, stack) : customizer(value);
		      }
		      if (result !== undefined$1) {
		        return result;
		      }
		      if (!isObject(value)) {
		        return value;
		      }
		      var isArr = isArray(value);
		      if (isArr) {
		        result = initCloneArray(value);
		        if (!isDeep) {
		          return copyArray(value, result);
		        }
		      } else {
		        var tag = getTag(value),
		            isFunc = tag == funcTag || tag == genTag;

		        if (isBuffer(value)) {
		          return cloneBuffer(value, isDeep);
		        }
		        if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
		          result = (isFlat || isFunc) ? {} : initCloneObject(value);
		          if (!isDeep) {
		            return isFlat
		              ? copySymbolsIn(value, baseAssignIn(result, value))
		              : copySymbols(value, baseAssign(result, value));
		          }
		        } else {
		          if (!cloneableTags[tag]) {
		            return object ? value : {};
		          }
		          result = initCloneByTag(value, tag, isDeep);
		        }
		      }
		      // Check for circular references and return its corresponding clone.
		      stack || (stack = new Stack);
		      var stacked = stack.get(value);
		      if (stacked) {
		        return stacked;
		      }
		      stack.set(value, result);

		      if (isSet(value)) {
		        value.forEach(function(subValue) {
		          result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
		        });
		      } else if (isMap(value)) {
		        value.forEach(function(subValue, key) {
		          result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
		        });
		      }

		      var keysFunc = isFull
		        ? (isFlat ? getAllKeysIn : getAllKeys)
		        : (isFlat ? keysIn : keys);

		      var props = isArr ? undefined$1 : keysFunc(value);
		      arrayEach(props || value, function(subValue, key) {
		        if (props) {
		          key = subValue;
		          subValue = value[key];
		        }
		        // Recursively populate clone (susceptible to call stack limits).
		        assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
		      });
		      return result;
		    }

		    /**
		     * The base implementation of `_.conforms` which doesn't clone `source`.
		     *
		     * @private
		     * @param {Object} source The object of property predicates to conform to.
		     * @returns {Function} Returns the new spec function.
		     */
		    function baseConforms(source) {
		      var props = keys(source);
		      return function(object) {
		        return baseConformsTo(object, source, props);
		      };
		    }

		    /**
		     * The base implementation of `_.conformsTo` which accepts `props` to check.
		     *
		     * @private
		     * @param {Object} object The object to inspect.
		     * @param {Object} source The object of property predicates to conform to.
		     * @returns {boolean} Returns `true` if `object` conforms, else `false`.
		     */
		    function baseConformsTo(object, source, props) {
		      var length = props.length;
		      if (object == null) {
		        return !length;
		      }
		      object = Object(object);
		      while (length--) {
		        var key = props[length],
		            predicate = source[key],
		            value = object[key];

		        if ((value === undefined$1 && !(key in object)) || !predicate(value)) {
		          return false;
		        }
		      }
		      return true;
		    }

		    /**
		     * The base implementation of `_.delay` and `_.defer` which accepts `args`
		     * to provide to `func`.
		     *
		     * @private
		     * @param {Function} func The function to delay.
		     * @param {number} wait The number of milliseconds to delay invocation.
		     * @param {Array} args The arguments to provide to `func`.
		     * @returns {number|Object} Returns the timer id or timeout object.
		     */
		    function baseDelay(func, wait, args) {
		      if (typeof func != 'function') {
		        throw new TypeError(FUNC_ERROR_TEXT);
		      }
		      return setTimeout(function() { func.apply(undefined$1, args); }, wait);
		    }

		    /**
		     * The base implementation of methods like `_.difference` without support
		     * for excluding multiple arrays or iteratee shorthands.
		     *
		     * @private
		     * @param {Array} array The array to inspect.
		     * @param {Array} values The values to exclude.
		     * @param {Function} [iteratee] The iteratee invoked per element.
		     * @param {Function} [comparator] The comparator invoked per element.
		     * @returns {Array} Returns the new array of filtered values.
		     */
		    function baseDifference(array, values, iteratee, comparator) {
		      var index = -1,
		          includes = arrayIncludes,
		          isCommon = true,
		          length = array.length,
		          result = [],
		          valuesLength = values.length;

		      if (!length) {
		        return result;
		      }
		      if (iteratee) {
		        values = arrayMap(values, baseUnary(iteratee));
		      }
		      if (comparator) {
		        includes = arrayIncludesWith;
		        isCommon = false;
		      }
		      else if (values.length >= LARGE_ARRAY_SIZE) {
		        includes = cacheHas;
		        isCommon = false;
		        values = new SetCache(values);
		      }
		      outer:
		      while (++index < length) {
		        var value = array[index],
		            computed = iteratee == null ? value : iteratee(value);

		        value = (comparator || value !== 0) ? value : 0;
		        if (isCommon && computed === computed) {
		          var valuesIndex = valuesLength;
		          while (valuesIndex--) {
		            if (values[valuesIndex] === computed) {
		              continue outer;
		            }
		          }
		          result.push(value);
		        }
		        else if (!includes(values, computed, comparator)) {
		          result.push(value);
		        }
		      }
		      return result;
		    }

		    /**
		     * The base implementation of `_.forEach` without support for iteratee shorthands.
		     *
		     * @private
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} iteratee The function invoked per iteration.
		     * @returns {Array|Object} Returns `collection`.
		     */
		    var baseEach = createBaseEach(baseForOwn);

		    /**
		     * The base implementation of `_.forEachRight` without support for iteratee shorthands.
		     *
		     * @private
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} iteratee The function invoked per iteration.
		     * @returns {Array|Object} Returns `collection`.
		     */
		    var baseEachRight = createBaseEach(baseForOwnRight, true);

		    /**
		     * The base implementation of `_.every` without support for iteratee shorthands.
		     *
		     * @private
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} predicate The function invoked per iteration.
		     * @returns {boolean} Returns `true` if all elements pass the predicate check,
		     *  else `false`
		     */
		    function baseEvery(collection, predicate) {
		      var result = true;
		      baseEach(collection, function(value, index, collection) {
		        result = !!predicate(value, index, collection);
		        return result;
		      });
		      return result;
		    }

		    /**
		     * The base implementation of methods like `_.max` and `_.min` which accepts a
		     * `comparator` to determine the extremum value.
		     *
		     * @private
		     * @param {Array} array The array to iterate over.
		     * @param {Function} iteratee The iteratee invoked per iteration.
		     * @param {Function} comparator The comparator used to compare values.
		     * @returns {*} Returns the extremum value.
		     */
		    function baseExtremum(array, iteratee, comparator) {
		      var index = -1,
		          length = array.length;

		      while (++index < length) {
		        var value = array[index],
		            current = iteratee(value);

		        if (current != null && (computed === undefined$1
		              ? (current === current && !isSymbol(current))
		              : comparator(current, computed)
		            )) {
		          var computed = current,
		              result = value;
		        }
		      }
		      return result;
		    }

		    /**
		     * The base implementation of `_.fill` without an iteratee call guard.
		     *
		     * @private
		     * @param {Array} array The array to fill.
		     * @param {*} value The value to fill `array` with.
		     * @param {number} [start=0] The start position.
		     * @param {number} [end=array.length] The end position.
		     * @returns {Array} Returns `array`.
		     */
		    function baseFill(array, value, start, end) {
		      var length = array.length;

		      start = toInteger(start);
		      if (start < 0) {
		        start = -start > length ? 0 : (length + start);
		      }
		      end = (end === undefined$1 || end > length) ? length : toInteger(end);
		      if (end < 0) {
		        end += length;
		      }
		      end = start > end ? 0 : toLength(end);
		      while (start < end) {
		        array[start++] = value;
		      }
		      return array;
		    }

		    /**
		     * The base implementation of `_.filter` without support for iteratee shorthands.
		     *
		     * @private
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} predicate The function invoked per iteration.
		     * @returns {Array} Returns the new filtered array.
		     */
		    function baseFilter(collection, predicate) {
		      var result = [];
		      baseEach(collection, function(value, index, collection) {
		        if (predicate(value, index, collection)) {
		          result.push(value);
		        }
		      });
		      return result;
		    }

		    /**
		     * The base implementation of `_.flatten` with support for restricting flattening.
		     *
		     * @private
		     * @param {Array} array The array to flatten.
		     * @param {number} depth The maximum recursion depth.
		     * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
		     * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
		     * @param {Array} [result=[]] The initial result value.
		     * @returns {Array} Returns the new flattened array.
		     */
		    function baseFlatten(array, depth, predicate, isStrict, result) {
		      var index = -1,
		          length = array.length;

		      predicate || (predicate = isFlattenable);
		      result || (result = []);

		      while (++index < length) {
		        var value = array[index];
		        if (depth > 0 && predicate(value)) {
		          if (depth > 1) {
		            // Recursively flatten arrays (susceptible to call stack limits).
		            baseFlatten(value, depth - 1, predicate, isStrict, result);
		          } else {
		            arrayPush(result, value);
		          }
		        } else if (!isStrict) {
		          result[result.length] = value;
		        }
		      }
		      return result;
		    }

		    /**
		     * The base implementation of `baseForOwn` which iterates over `object`
		     * properties returned by `keysFunc` and invokes `iteratee` for each property.
		     * Iteratee functions may exit iteration early by explicitly returning `false`.
		     *
		     * @private
		     * @param {Object} object The object to iterate over.
		     * @param {Function} iteratee The function invoked per iteration.
		     * @param {Function} keysFunc The function to get the keys of `object`.
		     * @returns {Object} Returns `object`.
		     */
		    var baseFor = createBaseFor();

		    /**
		     * This function is like `baseFor` except that it iterates over properties
		     * in the opposite order.
		     *
		     * @private
		     * @param {Object} object The object to iterate over.
		     * @param {Function} iteratee The function invoked per iteration.
		     * @param {Function} keysFunc The function to get the keys of `object`.
		     * @returns {Object} Returns `object`.
		     */
		    var baseForRight = createBaseFor(true);

		    /**
		     * The base implementation of `_.forOwn` without support for iteratee shorthands.
		     *
		     * @private
		     * @param {Object} object The object to iterate over.
		     * @param {Function} iteratee The function invoked per iteration.
		     * @returns {Object} Returns `object`.
		     */
		    function baseForOwn(object, iteratee) {
		      return object && baseFor(object, iteratee, keys);
		    }

		    /**
		     * The base implementation of `_.forOwnRight` without support for iteratee shorthands.
		     *
		     * @private
		     * @param {Object} object The object to iterate over.
		     * @param {Function} iteratee The function invoked per iteration.
		     * @returns {Object} Returns `object`.
		     */
		    function baseForOwnRight(object, iteratee) {
		      return object && baseForRight(object, iteratee, keys);
		    }

		    /**
		     * The base implementation of `_.functions` which creates an array of
		     * `object` function property names filtered from `props`.
		     *
		     * @private
		     * @param {Object} object The object to inspect.
		     * @param {Array} props The property names to filter.
		     * @returns {Array} Returns the function names.
		     */
		    function baseFunctions(object, props) {
		      return arrayFilter(props, function(key) {
		        return isFunction(object[key]);
		      });
		    }

		    /**
		     * The base implementation of `_.get` without support for default values.
		     *
		     * @private
		     * @param {Object} object The object to query.
		     * @param {Array|string} path The path of the property to get.
		     * @returns {*} Returns the resolved value.
		     */
		    function baseGet(object, path) {
		      path = castPath(path, object);

		      var index = 0,
		          length = path.length;

		      while (object != null && index < length) {
		        object = object[toKey(path[index++])];
		      }
		      return (index && index == length) ? object : undefined$1;
		    }

		    /**
		     * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
		     * `keysFunc` and `symbolsFunc` to get the enumerable property names and
		     * symbols of `object`.
		     *
		     * @private
		     * @param {Object} object The object to query.
		     * @param {Function} keysFunc The function to get the keys of `object`.
		     * @param {Function} symbolsFunc The function to get the symbols of `object`.
		     * @returns {Array} Returns the array of property names and symbols.
		     */
		    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
		      var result = keysFunc(object);
		      return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
		    }

		    /**
		     * The base implementation of `getTag` without fallbacks for buggy environments.
		     *
		     * @private
		     * @param {*} value The value to query.
		     * @returns {string} Returns the `toStringTag`.
		     */
		    function baseGetTag(value) {
		      if (value == null) {
		        return value === undefined$1 ? undefinedTag : nullTag;
		      }
		      return (symToStringTag && symToStringTag in Object(value))
		        ? getRawTag(value)
		        : objectToString(value);
		    }

		    /**
		     * The base implementation of `_.gt` which doesn't coerce arguments.
		     *
		     * @private
		     * @param {*} value The value to compare.
		     * @param {*} other The other value to compare.
		     * @returns {boolean} Returns `true` if `value` is greater than `other`,
		     *  else `false`.
		     */
		    function baseGt(value, other) {
		      return value > other;
		    }

		    /**
		     * The base implementation of `_.has` without support for deep paths.
		     *
		     * @private
		     * @param {Object} [object] The object to query.
		     * @param {Array|string} key The key to check.
		     * @returns {boolean} Returns `true` if `key` exists, else `false`.
		     */
		    function baseHas(object, key) {
		      return object != null && hasOwnProperty.call(object, key);
		    }

		    /**
		     * The base implementation of `_.hasIn` without support for deep paths.
		     *
		     * @private
		     * @param {Object} [object] The object to query.
		     * @param {Array|string} key The key to check.
		     * @returns {boolean} Returns `true` if `key` exists, else `false`.
		     */
		    function baseHasIn(object, key) {
		      return object != null && key in Object(object);
		    }

		    /**
		     * The base implementation of `_.inRange` which doesn't coerce arguments.
		     *
		     * @private
		     * @param {number} number The number to check.
		     * @param {number} start The start of the range.
		     * @param {number} end The end of the range.
		     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
		     */
		    function baseInRange(number, start, end) {
		      return number >= nativeMin(start, end) && number < nativeMax(start, end);
		    }

		    /**
		     * The base implementation of methods like `_.intersection`, without support
		     * for iteratee shorthands, that accepts an array of arrays to inspect.
		     *
		     * @private
		     * @param {Array} arrays The arrays to inspect.
		     * @param {Function} [iteratee] The iteratee invoked per element.
		     * @param {Function} [comparator] The comparator invoked per element.
		     * @returns {Array} Returns the new array of shared values.
		     */
		    function baseIntersection(arrays, iteratee, comparator) {
		      var includes = comparator ? arrayIncludesWith : arrayIncludes,
		          length = arrays[0].length,
		          othLength = arrays.length,
		          othIndex = othLength,
		          caches = Array(othLength),
		          maxLength = Infinity,
		          result = [];

		      while (othIndex--) {
		        var array = arrays[othIndex];
		        if (othIndex && iteratee) {
		          array = arrayMap(array, baseUnary(iteratee));
		        }
		        maxLength = nativeMin(array.length, maxLength);
		        caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))
		          ? new SetCache(othIndex && array)
		          : undefined$1;
		      }
		      array = arrays[0];

		      var index = -1,
		          seen = caches[0];

		      outer:
		      while (++index < length && result.length < maxLength) {
		        var value = array[index],
		            computed = iteratee ? iteratee(value) : value;

		        value = (comparator || value !== 0) ? value : 0;
		        if (!(seen
		              ? cacheHas(seen, computed)
		              : includes(result, computed, comparator)
		            )) {
		          othIndex = othLength;
		          while (--othIndex) {
		            var cache = caches[othIndex];
		            if (!(cache
		                  ? cacheHas(cache, computed)
		                  : includes(arrays[othIndex], computed, comparator))
		                ) {
		              continue outer;
		            }
		          }
		          if (seen) {
		            seen.push(computed);
		          }
		          result.push(value);
		        }
		      }
		      return result;
		    }

		    /**
		     * The base implementation of `_.invert` and `_.invertBy` which inverts
		     * `object` with values transformed by `iteratee` and set by `setter`.
		     *
		     * @private
		     * @param {Object} object The object to iterate over.
		     * @param {Function} setter The function to set `accumulator` values.
		     * @param {Function} iteratee The iteratee to transform values.
		     * @param {Object} accumulator The initial inverted object.
		     * @returns {Function} Returns `accumulator`.
		     */
		    function baseInverter(object, setter, iteratee, accumulator) {
		      baseForOwn(object, function(value, key, object) {
		        setter(accumulator, iteratee(value), key, object);
		      });
		      return accumulator;
		    }

		    /**
		     * The base implementation of `_.invoke` without support for individual
		     * method arguments.
		     *
		     * @private
		     * @param {Object} object The object to query.
		     * @param {Array|string} path The path of the method to invoke.
		     * @param {Array} args The arguments to invoke the method with.
		     * @returns {*} Returns the result of the invoked method.
		     */
		    function baseInvoke(object, path, args) {
		      path = castPath(path, object);
		      object = parent(object, path);
		      var func = object == null ? object : object[toKey(last(path))];
		      return func == null ? undefined$1 : apply(func, object, args);
		    }

		    /**
		     * The base implementation of `_.isArguments`.
		     *
		     * @private
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
		     */
		    function baseIsArguments(value) {
		      return isObjectLike(value) && baseGetTag(value) == argsTag;
		    }

		    /**
		     * The base implementation of `_.isArrayBuffer` without Node.js optimizations.
		     *
		     * @private
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
		     */
		    function baseIsArrayBuffer(value) {
		      return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
		    }

		    /**
		     * The base implementation of `_.isDate` without Node.js optimizations.
		     *
		     * @private
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
		     */
		    function baseIsDate(value) {
		      return isObjectLike(value) && baseGetTag(value) == dateTag;
		    }

		    /**
		     * The base implementation of `_.isEqual` which supports partial comparisons
		     * and tracks traversed objects.
		     *
		     * @private
		     * @param {*} value The value to compare.
		     * @param {*} other The other value to compare.
		     * @param {boolean} bitmask The bitmask flags.
		     *  1 - Unordered comparison
		     *  2 - Partial comparison
		     * @param {Function} [customizer] The function to customize comparisons.
		     * @param {Object} [stack] Tracks traversed `value` and `other` objects.
		     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
		     */
		    function baseIsEqual(value, other, bitmask, customizer, stack) {
		      if (value === other) {
		        return true;
		      }
		      if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {
		        return value !== value && other !== other;
		      }
		      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
		    }

		    /**
		     * A specialized version of `baseIsEqual` for arrays and objects which performs
		     * deep comparisons and tracks traversed objects enabling objects with circular
		     * references to be compared.
		     *
		     * @private
		     * @param {Object} object The object to compare.
		     * @param {Object} other The other object to compare.
		     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
		     * @param {Function} customizer The function to customize comparisons.
		     * @param {Function} equalFunc The function to determine equivalents of values.
		     * @param {Object} [stack] Tracks traversed `object` and `other` objects.
		     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
		     */
		    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
		      var objIsArr = isArray(object),
		          othIsArr = isArray(other),
		          objTag = objIsArr ? arrayTag : getTag(object),
		          othTag = othIsArr ? arrayTag : getTag(other);

		      objTag = objTag == argsTag ? objectTag : objTag;
		      othTag = othTag == argsTag ? objectTag : othTag;

		      var objIsObj = objTag == objectTag,
		          othIsObj = othTag == objectTag,
		          isSameTag = objTag == othTag;

		      if (isSameTag && isBuffer(object)) {
		        if (!isBuffer(other)) {
		          return false;
		        }
		        objIsArr = true;
		        objIsObj = false;
		      }
		      if (isSameTag && !objIsObj) {
		        stack || (stack = new Stack);
		        return (objIsArr || isTypedArray(object))
		          ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
		          : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
		      }
		      if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
		        var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
		            othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');

		        if (objIsWrapped || othIsWrapped) {
		          var objUnwrapped = objIsWrapped ? object.value() : object,
		              othUnwrapped = othIsWrapped ? other.value() : other;

		          stack || (stack = new Stack);
		          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
		        }
		      }
		      if (!isSameTag) {
		        return false;
		      }
		      stack || (stack = new Stack);
		      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
		    }

		    /**
		     * The base implementation of `_.isMap` without Node.js optimizations.
		     *
		     * @private
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a map, else `false`.
		     */
		    function baseIsMap(value) {
		      return isObjectLike(value) && getTag(value) == mapTag;
		    }

		    /**
		     * The base implementation of `_.isMatch` without support for iteratee shorthands.
		     *
		     * @private
		     * @param {Object} object The object to inspect.
		     * @param {Object} source The object of property values to match.
		     * @param {Array} matchData The property names, values, and compare flags to match.
		     * @param {Function} [customizer] The function to customize comparisons.
		     * @returns {boolean} Returns `true` if `object` is a match, else `false`.
		     */
		    function baseIsMatch(object, source, matchData, customizer) {
		      var index = matchData.length,
		          length = index,
		          noCustomizer = !customizer;

		      if (object == null) {
		        return !length;
		      }
		      object = Object(object);
		      while (index--) {
		        var data = matchData[index];
		        if ((noCustomizer && data[2])
		              ? data[1] !== object[data[0]]
		              : !(data[0] in object)
		            ) {
		          return false;
		        }
		      }
		      while (++index < length) {
		        data = matchData[index];
		        var key = data[0],
		            objValue = object[key],
		            srcValue = data[1];

		        if (noCustomizer && data[2]) {
		          if (objValue === undefined$1 && !(key in object)) {
		            return false;
		          }
		        } else {
		          var stack = new Stack;
		          if (customizer) {
		            var result = customizer(objValue, srcValue, key, object, source, stack);
		          }
		          if (!(result === undefined$1
		                ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)
		                : result
		              )) {
		            return false;
		          }
		        }
		      }
		      return true;
		    }

		    /**
		     * The base implementation of `_.isNative` without bad shim checks.
		     *
		     * @private
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a native function,
		     *  else `false`.
		     */
		    function baseIsNative(value) {
		      if (!isObject(value) || isMasked(value)) {
		        return false;
		      }
		      var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
		      return pattern.test(toSource(value));
		    }

		    /**
		     * The base implementation of `_.isRegExp` without Node.js optimizations.
		     *
		     * @private
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
		     */
		    function baseIsRegExp(value) {
		      return isObjectLike(value) && baseGetTag(value) == regexpTag;
		    }

		    /**
		     * The base implementation of `_.isSet` without Node.js optimizations.
		     *
		     * @private
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a set, else `false`.
		     */
		    function baseIsSet(value) {
		      return isObjectLike(value) && getTag(value) == setTag;
		    }

		    /**
		     * The base implementation of `_.isTypedArray` without Node.js optimizations.
		     *
		     * @private
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
		     */
		    function baseIsTypedArray(value) {
		      return isObjectLike(value) &&
		        isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
		    }

		    /**
		     * The base implementation of `_.iteratee`.
		     *
		     * @private
		     * @param {*} [value=_.identity] The value to convert to an iteratee.
		     * @returns {Function} Returns the iteratee.
		     */
		    function baseIteratee(value) {
		      // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
		      // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
		      if (typeof value == 'function') {
		        return value;
		      }
		      if (value == null) {
		        return identity;
		      }
		      if (typeof value == 'object') {
		        return isArray(value)
		          ? baseMatchesProperty(value[0], value[1])
		          : baseMatches(value);
		      }
		      return property(value);
		    }

		    /**
		     * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
		     *
		     * @private
		     * @param {Object} object The object to query.
		     * @returns {Array} Returns the array of property names.
		     */
		    function baseKeys(object) {
		      if (!isPrototype(object)) {
		        return nativeKeys(object);
		      }
		      var result = [];
		      for (var key in Object(object)) {
		        if (hasOwnProperty.call(object, key) && key != 'constructor') {
		          result.push(key);
		        }
		      }
		      return result;
		    }

		    /**
		     * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
		     *
		     * @private
		     * @param {Object} object The object to query.
		     * @returns {Array} Returns the array of property names.
		     */
		    function baseKeysIn(object) {
		      if (!isObject(object)) {
		        return nativeKeysIn(object);
		      }
		      var isProto = isPrototype(object),
		          result = [];

		      for (var key in object) {
		        if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
		          result.push(key);
		        }
		      }
		      return result;
		    }

		    /**
		     * The base implementation of `_.lt` which doesn't coerce arguments.
		     *
		     * @private
		     * @param {*} value The value to compare.
		     * @param {*} other The other value to compare.
		     * @returns {boolean} Returns `true` if `value` is less than `other`,
		     *  else `false`.
		     */
		    function baseLt(value, other) {
		      return value < other;
		    }

		    /**
		     * The base implementation of `_.map` without support for iteratee shorthands.
		     *
		     * @private
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} iteratee The function invoked per iteration.
		     * @returns {Array} Returns the new mapped array.
		     */
		    function baseMap(collection, iteratee) {
		      var index = -1,
		          result = isArrayLike(collection) ? Array(collection.length) : [];

		      baseEach(collection, function(value, key, collection) {
		        result[++index] = iteratee(value, key, collection);
		      });
		      return result;
		    }

		    /**
		     * The base implementation of `_.matches` which doesn't clone `source`.
		     *
		     * @private
		     * @param {Object} source The object of property values to match.
		     * @returns {Function} Returns the new spec function.
		     */
		    function baseMatches(source) {
		      var matchData = getMatchData(source);
		      if (matchData.length == 1 && matchData[0][2]) {
		        return matchesStrictComparable(matchData[0][0], matchData[0][1]);
		      }
		      return function(object) {
		        return object === source || baseIsMatch(object, source, matchData);
		      };
		    }

		    /**
		     * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
		     *
		     * @private
		     * @param {string} path The path of the property to get.
		     * @param {*} srcValue The value to match.
		     * @returns {Function} Returns the new spec function.
		     */
		    function baseMatchesProperty(path, srcValue) {
		      if (isKey(path) && isStrictComparable(srcValue)) {
		        return matchesStrictComparable(toKey(path), srcValue);
		      }
		      return function(object) {
		        var objValue = get(object, path);
		        return (objValue === undefined$1 && objValue === srcValue)
		          ? hasIn(object, path)
		          : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
		      };
		    }

		    /**
		     * The base implementation of `_.merge` without support for multiple sources.
		     *
		     * @private
		     * @param {Object} object The destination object.
		     * @param {Object} source The source object.
		     * @param {number} srcIndex The index of `source`.
		     * @param {Function} [customizer] The function to customize merged values.
		     * @param {Object} [stack] Tracks traversed source values and their merged
		     *  counterparts.
		     */
		    function baseMerge(object, source, srcIndex, customizer, stack) {
		      if (object === source) {
		        return;
		      }
		      baseFor(source, function(srcValue, key) {
		        stack || (stack = new Stack);
		        if (isObject(srcValue)) {
		          baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
		        }
		        else {
		          var newValue = customizer
		            ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)
		            : undefined$1;

		          if (newValue === undefined$1) {
		            newValue = srcValue;
		          }
		          assignMergeValue(object, key, newValue);
		        }
		      }, keysIn);
		    }

		    /**
		     * A specialized version of `baseMerge` for arrays and objects which performs
		     * deep merges and tracks traversed objects enabling objects with circular
		     * references to be merged.
		     *
		     * @private
		     * @param {Object} object The destination object.
		     * @param {Object} source The source object.
		     * @param {string} key The key of the value to merge.
		     * @param {number} srcIndex The index of `source`.
		     * @param {Function} mergeFunc The function to merge values.
		     * @param {Function} [customizer] The function to customize assigned values.
		     * @param {Object} [stack] Tracks traversed source values and their merged
		     *  counterparts.
		     */
		    function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
		      var objValue = safeGet(object, key),
		          srcValue = safeGet(source, key),
		          stacked = stack.get(srcValue);

		      if (stacked) {
		        assignMergeValue(object, key, stacked);
		        return;
		      }
		      var newValue = customizer
		        ? customizer(objValue, srcValue, (key + ''), object, source, stack)
		        : undefined$1;

		      var isCommon = newValue === undefined$1;

		      if (isCommon) {
		        var isArr = isArray(srcValue),
		            isBuff = !isArr && isBuffer(srcValue),
		            isTyped = !isArr && !isBuff && isTypedArray(srcValue);

		        newValue = srcValue;
		        if (isArr || isBuff || isTyped) {
		          if (isArray(objValue)) {
		            newValue = objValue;
		          }
		          else if (isArrayLikeObject(objValue)) {
		            newValue = copyArray(objValue);
		          }
		          else if (isBuff) {
		            isCommon = false;
		            newValue = cloneBuffer(srcValue, true);
		          }
		          else if (isTyped) {
		            isCommon = false;
		            newValue = cloneTypedArray(srcValue, true);
		          }
		          else {
		            newValue = [];
		          }
		        }
		        else if (isPlainObject(srcValue) || isArguments(srcValue)) {
		          newValue = objValue;
		          if (isArguments(objValue)) {
		            newValue = toPlainObject(objValue);
		          }
		          else if (!isObject(objValue) || isFunction(objValue)) {
		            newValue = initCloneObject(srcValue);
		          }
		        }
		        else {
		          isCommon = false;
		        }
		      }
		      if (isCommon) {
		        // Recursively merge objects and arrays (susceptible to call stack limits).
		        stack.set(srcValue, newValue);
		        mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
		        stack['delete'](srcValue);
		      }
		      assignMergeValue(object, key, newValue);
		    }

		    /**
		     * The base implementation of `_.nth` which doesn't coerce arguments.
		     *
		     * @private
		     * @param {Array} array The array to query.
		     * @param {number} n The index of the element to return.
		     * @returns {*} Returns the nth element of `array`.
		     */
		    function baseNth(array, n) {
		      var length = array.length;
		      if (!length) {
		        return;
		      }
		      n += n < 0 ? length : 0;
		      return isIndex(n, length) ? array[n] : undefined$1;
		    }

		    /**
		     * The base implementation of `_.orderBy` without param guards.
		     *
		     * @private
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
		     * @param {string[]} orders The sort orders of `iteratees`.
		     * @returns {Array} Returns the new sorted array.
		     */
		    function baseOrderBy(collection, iteratees, orders) {
		      if (iteratees.length) {
		        iteratees = arrayMap(iteratees, function(iteratee) {
		          if (isArray(iteratee)) {
		            return function(value) {
		              return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
		            }
		          }
		          return iteratee;
		        });
		      } else {
		        iteratees = [identity];
		      }

		      var index = -1;
		      iteratees = arrayMap(iteratees, baseUnary(getIteratee()));

		      var result = baseMap(collection, function(value, key, collection) {
		        var criteria = arrayMap(iteratees, function(iteratee) {
		          return iteratee(value);
		        });
		        return { 'criteria': criteria, 'index': ++index, 'value': value };
		      });

		      return baseSortBy(result, function(object, other) {
		        return compareMultiple(object, other, orders);
		      });
		    }

		    /**
		     * The base implementation of `_.pick` without support for individual
		     * property identifiers.
		     *
		     * @private
		     * @param {Object} object The source object.
		     * @param {string[]} paths The property paths to pick.
		     * @returns {Object} Returns the new object.
		     */
		    function basePick(object, paths) {
		      return basePickBy(object, paths, function(value, path) {
		        return hasIn(object, path);
		      });
		    }

		    /**
		     * The base implementation of  `_.pickBy` without support for iteratee shorthands.
		     *
		     * @private
		     * @param {Object} object The source object.
		     * @param {string[]} paths The property paths to pick.
		     * @param {Function} predicate The function invoked per property.
		     * @returns {Object} Returns the new object.
		     */
		    function basePickBy(object, paths, predicate) {
		      var index = -1,
		          length = paths.length,
		          result = {};

		      while (++index < length) {
		        var path = paths[index],
		            value = baseGet(object, path);

		        if (predicate(value, path)) {
		          baseSet(result, castPath(path, object), value);
		        }
		      }
		      return result;
		    }

		    /**
		     * A specialized version of `baseProperty` which supports deep paths.
		     *
		     * @private
		     * @param {Array|string} path The path of the property to get.
		     * @returns {Function} Returns the new accessor function.
		     */
		    function basePropertyDeep(path) {
		      return function(object) {
		        return baseGet(object, path);
		      };
		    }

		    /**
		     * The base implementation of `_.pullAllBy` without support for iteratee
		     * shorthands.
		     *
		     * @private
		     * @param {Array} array The array to modify.
		     * @param {Array} values The values to remove.
		     * @param {Function} [iteratee] The iteratee invoked per element.
		     * @param {Function} [comparator] The comparator invoked per element.
		     * @returns {Array} Returns `array`.
		     */
		    function basePullAll(array, values, iteratee, comparator) {
		      var indexOf = comparator ? baseIndexOfWith : baseIndexOf,
		          index = -1,
		          length = values.length,
		          seen = array;

		      if (array === values) {
		        values = copyArray(values);
		      }
		      if (iteratee) {
		        seen = arrayMap(array, baseUnary(iteratee));
		      }
		      while (++index < length) {
		        var fromIndex = 0,
		            value = values[index],
		            computed = iteratee ? iteratee(value) : value;

		        while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
		          if (seen !== array) {
		            splice.call(seen, fromIndex, 1);
		          }
		          splice.call(array, fromIndex, 1);
		        }
		      }
		      return array;
		    }

		    /**
		     * The base implementation of `_.pullAt` without support for individual
		     * indexes or capturing the removed elements.
		     *
		     * @private
		     * @param {Array} array The array to modify.
		     * @param {number[]} indexes The indexes of elements to remove.
		     * @returns {Array} Returns `array`.
		     */
		    function basePullAt(array, indexes) {
		      var length = array ? indexes.length : 0,
		          lastIndex = length - 1;

		      while (length--) {
		        var index = indexes[length];
		        if (length == lastIndex || index !== previous) {
		          var previous = index;
		          if (isIndex(index)) {
		            splice.call(array, index, 1);
		          } else {
		            baseUnset(array, index);
		          }
		        }
		      }
		      return array;
		    }

		    /**
		     * The base implementation of `_.random` without support for returning
		     * floating-point numbers.
		     *
		     * @private
		     * @param {number} lower The lower bound.
		     * @param {number} upper The upper bound.
		     * @returns {number} Returns the random number.
		     */
		    function baseRandom(lower, upper) {
		      return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
		    }

		    /**
		     * The base implementation of `_.range` and `_.rangeRight` which doesn't
		     * coerce arguments.
		     *
		     * @private
		     * @param {number} start The start of the range.
		     * @param {number} end The end of the range.
		     * @param {number} step The value to increment or decrement by.
		     * @param {boolean} [fromRight] Specify iterating from right to left.
		     * @returns {Array} Returns the range of numbers.
		     */
		    function baseRange(start, end, step, fromRight) {
		      var index = -1,
		          length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),
		          result = Array(length);

		      while (length--) {
		        result[fromRight ? length : ++index] = start;
		        start += step;
		      }
		      return result;
		    }

		    /**
		     * The base implementation of `_.repeat` which doesn't coerce arguments.
		     *
		     * @private
		     * @param {string} string The string to repeat.
		     * @param {number} n The number of times to repeat the string.
		     * @returns {string} Returns the repeated string.
		     */
		    function baseRepeat(string, n) {
		      var result = '';
		      if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
		        return result;
		      }
		      // Leverage the exponentiation by squaring algorithm for a faster repeat.
		      // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
		      do {
		        if (n % 2) {
		          result += string;
		        }
		        n = nativeFloor(n / 2);
		        if (n) {
		          string += string;
		        }
		      } while (n);

		      return result;
		    }

		    /**
		     * The base implementation of `_.rest` which doesn't validate or coerce arguments.
		     *
		     * @private
		     * @param {Function} func The function to apply a rest parameter to.
		     * @param {number} [start=func.length-1] The start position of the rest parameter.
		     * @returns {Function} Returns the new function.
		     */
		    function baseRest(func, start) {
		      return setToString(overRest(func, start, identity), func + '');
		    }

		    /**
		     * The base implementation of `_.sample`.
		     *
		     * @private
		     * @param {Array|Object} collection The collection to sample.
		     * @returns {*} Returns the random element.
		     */
		    function baseSample(collection) {
		      return arraySample(values(collection));
		    }

		    /**
		     * The base implementation of `_.sampleSize` without param guards.
		     *
		     * @private
		     * @param {Array|Object} collection The collection to sample.
		     * @param {number} n The number of elements to sample.
		     * @returns {Array} Returns the random elements.
		     */
		    function baseSampleSize(collection, n) {
		      var array = values(collection);
		      return shuffleSelf(array, baseClamp(n, 0, array.length));
		    }

		    /**
		     * The base implementation of `_.set`.
		     *
		     * @private
		     * @param {Object} object The object to modify.
		     * @param {Array|string} path The path of the property to set.
		     * @param {*} value The value to set.
		     * @param {Function} [customizer] The function to customize path creation.
		     * @returns {Object} Returns `object`.
		     */
		    function baseSet(object, path, value, customizer) {
		      if (!isObject(object)) {
		        return object;
		      }
		      path = castPath(path, object);

		      var index = -1,
		          length = path.length,
		          lastIndex = length - 1,
		          nested = object;

		      while (nested != null && ++index < length) {
		        var key = toKey(path[index]),
		            newValue = value;

		        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
		          return object;
		        }

		        if (index != lastIndex) {
		          var objValue = nested[key];
		          newValue = customizer ? customizer(objValue, key, nested) : undefined$1;
		          if (newValue === undefined$1) {
		            newValue = isObject(objValue)
		              ? objValue
		              : (isIndex(path[index + 1]) ? [] : {});
		          }
		        }
		        assignValue(nested, key, newValue);
		        nested = nested[key];
		      }
		      return object;
		    }

		    /**
		     * The base implementation of `setData` without support for hot loop shorting.
		     *
		     * @private
		     * @param {Function} func The function to associate metadata with.
		     * @param {*} data The metadata.
		     * @returns {Function} Returns `func`.
		     */
		    var baseSetData = !metaMap ? identity : function(func, data) {
		      metaMap.set(func, data);
		      return func;
		    };

		    /**
		     * The base implementation of `setToString` without support for hot loop shorting.
		     *
		     * @private
		     * @param {Function} func The function to modify.
		     * @param {Function} string The `toString` result.
		     * @returns {Function} Returns `func`.
		     */
		    var baseSetToString = !defineProperty ? identity : function(func, string) {
		      return defineProperty(func, 'toString', {
		        'configurable': true,
		        'enumerable': false,
		        'value': constant(string),
		        'writable': true
		      });
		    };

		    /**
		     * The base implementation of `_.shuffle`.
		     *
		     * @private
		     * @param {Array|Object} collection The collection to shuffle.
		     * @returns {Array} Returns the new shuffled array.
		     */
		    function baseShuffle(collection) {
		      return shuffleSelf(values(collection));
		    }

		    /**
		     * The base implementation of `_.slice` without an iteratee call guard.
		     *
		     * @private
		     * @param {Array} array The array to slice.
		     * @param {number} [start=0] The start position.
		     * @param {number} [end=array.length] The end position.
		     * @returns {Array} Returns the slice of `array`.
		     */
		    function baseSlice(array, start, end) {
		      var index = -1,
		          length = array.length;

		      if (start < 0) {
		        start = -start > length ? 0 : (length + start);
		      }
		      end = end > length ? length : end;
		      if (end < 0) {
		        end += length;
		      }
		      length = start > end ? 0 : ((end - start) >>> 0);
		      start >>>= 0;

		      var result = Array(length);
		      while (++index < length) {
		        result[index] = array[index + start];
		      }
		      return result;
		    }

		    /**
		     * The base implementation of `_.some` without support for iteratee shorthands.
		     *
		     * @private
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} predicate The function invoked per iteration.
		     * @returns {boolean} Returns `true` if any element passes the predicate check,
		     *  else `false`.
		     */
		    function baseSome(collection, predicate) {
		      var result;

		      baseEach(collection, function(value, index, collection) {
		        result = predicate(value, index, collection);
		        return !result;
		      });
		      return !!result;
		    }

		    /**
		     * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which
		     * performs a binary search of `array` to determine the index at which `value`
		     * should be inserted into `array` in order to maintain its sort order.
		     *
		     * @private
		     * @param {Array} array The sorted array to inspect.
		     * @param {*} value The value to evaluate.
		     * @param {boolean} [retHighest] Specify returning the highest qualified index.
		     * @returns {number} Returns the index at which `value` should be inserted
		     *  into `array`.
		     */
		    function baseSortedIndex(array, value, retHighest) {
		      var low = 0,
		          high = array == null ? low : array.length;

		      if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
		        while (low < high) {
		          var mid = (low + high) >>> 1,
		              computed = array[mid];

		          if (computed !== null && !isSymbol(computed) &&
		              (retHighest ? (computed <= value) : (computed < value))) {
		            low = mid + 1;
		          } else {
		            high = mid;
		          }
		        }
		        return high;
		      }
		      return baseSortedIndexBy(array, value, identity, retHighest);
		    }

		    /**
		     * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`
		     * which invokes `iteratee` for `value` and each element of `array` to compute
		     * their sort ranking. The iteratee is invoked with one argument; (value).
		     *
		     * @private
		     * @param {Array} array The sorted array to inspect.
		     * @param {*} value The value to evaluate.
		     * @param {Function} iteratee The iteratee invoked per element.
		     * @param {boolean} [retHighest] Specify returning the highest qualified index.
		     * @returns {number} Returns the index at which `value` should be inserted
		     *  into `array`.
		     */
		    function baseSortedIndexBy(array, value, iteratee, retHighest) {
		      var low = 0,
		          high = array == null ? 0 : array.length;
		      if (high === 0) {
		        return 0;
		      }

		      value = iteratee(value);
		      var valIsNaN = value !== value,
		          valIsNull = value === null,
		          valIsSymbol = isSymbol(value),
		          valIsUndefined = value === undefined$1;

		      while (low < high) {
		        var mid = nativeFloor((low + high) / 2),
		            computed = iteratee(array[mid]),
		            othIsDefined = computed !== undefined$1,
		            othIsNull = computed === null,
		            othIsReflexive = computed === computed,
		            othIsSymbol = isSymbol(computed);

		        if (valIsNaN) {
		          var setLow = retHighest || othIsReflexive;
		        } else if (valIsUndefined) {
		          setLow = othIsReflexive && (retHighest || othIsDefined);
		        } else if (valIsNull) {
		          setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
		        } else if (valIsSymbol) {
		          setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
		        } else if (othIsNull || othIsSymbol) {
		          setLow = false;
		        } else {
		          setLow = retHighest ? (computed <= value) : (computed < value);
		        }
		        if (setLow) {
		          low = mid + 1;
		        } else {
		          high = mid;
		        }
		      }
		      return nativeMin(high, MAX_ARRAY_INDEX);
		    }

		    /**
		     * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without
		     * support for iteratee shorthands.
		     *
		     * @private
		     * @param {Array} array The array to inspect.
		     * @param {Function} [iteratee] The iteratee invoked per element.
		     * @returns {Array} Returns the new duplicate free array.
		     */
		    function baseSortedUniq(array, iteratee) {
		      var index = -1,
		          length = array.length,
		          resIndex = 0,
		          result = [];

		      while (++index < length) {
		        var value = array[index],
		            computed = iteratee ? iteratee(value) : value;

		        if (!index || !eq(computed, seen)) {
		          var seen = computed;
		          result[resIndex++] = value === 0 ? 0 : value;
		        }
		      }
		      return result;
		    }

		    /**
		     * The base implementation of `_.toNumber` which doesn't ensure correct
		     * conversions of binary, hexadecimal, or octal string values.
		     *
		     * @private
		     * @param {*} value The value to process.
		     * @returns {number} Returns the number.
		     */
		    function baseToNumber(value) {
		      if (typeof value == 'number') {
		        return value;
		      }
		      if (isSymbol(value)) {
		        return NAN;
		      }
		      return +value;
		    }

		    /**
		     * The base implementation of `_.toString` which doesn't convert nullish
		     * values to empty strings.
		     *
		     * @private
		     * @param {*} value The value to process.
		     * @returns {string} Returns the string.
		     */
		    function baseToString(value) {
		      // Exit early for strings to avoid a performance hit in some environments.
		      if (typeof value == 'string') {
		        return value;
		      }
		      if (isArray(value)) {
		        // Recursively convert values (susceptible to call stack limits).
		        return arrayMap(value, baseToString) + '';
		      }
		      if (isSymbol(value)) {
		        return symbolToString ? symbolToString.call(value) : '';
		      }
		      var result = (value + '');
		      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
		    }

		    /**
		     * The base implementation of `_.uniqBy` without support for iteratee shorthands.
		     *
		     * @private
		     * @param {Array} array The array to inspect.
		     * @param {Function} [iteratee] The iteratee invoked per element.
		     * @param {Function} [comparator] The comparator invoked per element.
		     * @returns {Array} Returns the new duplicate free array.
		     */
		    function baseUniq(array, iteratee, comparator) {
		      var index = -1,
		          includes = arrayIncludes,
		          length = array.length,
		          isCommon = true,
		          result = [],
		          seen = result;

		      if (comparator) {
		        isCommon = false;
		        includes = arrayIncludesWith;
		      }
		      else if (length >= LARGE_ARRAY_SIZE) {
		        var set = iteratee ? null : createSet(array);
		        if (set) {
		          return setToArray(set);
		        }
		        isCommon = false;
		        includes = cacheHas;
		        seen = new SetCache;
		      }
		      else {
		        seen = iteratee ? [] : result;
		      }
		      outer:
		      while (++index < length) {
		        var value = array[index],
		            computed = iteratee ? iteratee(value) : value;

		        value = (comparator || value !== 0) ? value : 0;
		        if (isCommon && computed === computed) {
		          var seenIndex = seen.length;
		          while (seenIndex--) {
		            if (seen[seenIndex] === computed) {
		              continue outer;
		            }
		          }
		          if (iteratee) {
		            seen.push(computed);
		          }
		          result.push(value);
		        }
		        else if (!includes(seen, computed, comparator)) {
		          if (seen !== result) {
		            seen.push(computed);
		          }
		          result.push(value);
		        }
		      }
		      return result;
		    }

		    /**
		     * The base implementation of `_.unset`.
		     *
		     * @private
		     * @param {Object} object The object to modify.
		     * @param {Array|string} path The property path to unset.
		     * @returns {boolean} Returns `true` if the property is deleted, else `false`.
		     */
		    function baseUnset(object, path) {
		      path = castPath(path, object);
		      object = parent(object, path);
		      return object == null || delete object[toKey(last(path))];
		    }

		    /**
		     * The base implementation of `_.update`.
		     *
		     * @private
		     * @param {Object} object The object to modify.
		     * @param {Array|string} path The path of the property to update.
		     * @param {Function} updater The function to produce the updated value.
		     * @param {Function} [customizer] The function to customize path creation.
		     * @returns {Object} Returns `object`.
		     */
		    function baseUpdate(object, path, updater, customizer) {
		      return baseSet(object, path, updater(baseGet(object, path)), customizer);
		    }

		    /**
		     * The base implementation of methods like `_.dropWhile` and `_.takeWhile`
		     * without support for iteratee shorthands.
		     *
		     * @private
		     * @param {Array} array The array to query.
		     * @param {Function} predicate The function invoked per iteration.
		     * @param {boolean} [isDrop] Specify dropping elements instead of taking them.
		     * @param {boolean} [fromRight] Specify iterating from right to left.
		     * @returns {Array} Returns the slice of `array`.
		     */
		    function baseWhile(array, predicate, isDrop, fromRight) {
		      var length = array.length,
		          index = fromRight ? length : -1;

		      while ((fromRight ? index-- : ++index < length) &&
		        predicate(array[index], index, array)) {}

		      return isDrop
		        ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))
		        : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));
		    }

		    /**
		     * The base implementation of `wrapperValue` which returns the result of
		     * performing a sequence of actions on the unwrapped `value`, where each
		     * successive action is supplied the return value of the previous.
		     *
		     * @private
		     * @param {*} value The unwrapped value.
		     * @param {Array} actions Actions to perform to resolve the unwrapped value.
		     * @returns {*} Returns the resolved value.
		     */
		    function baseWrapperValue(value, actions) {
		      var result = value;
		      if (result instanceof LazyWrapper) {
		        result = result.value();
		      }
		      return arrayReduce(actions, function(result, action) {
		        return action.func.apply(action.thisArg, arrayPush([result], action.args));
		      }, result);
		    }

		    /**
		     * The base implementation of methods like `_.xor`, without support for
		     * iteratee shorthands, that accepts an array of arrays to inspect.
		     *
		     * @private
		     * @param {Array} arrays The arrays to inspect.
		     * @param {Function} [iteratee] The iteratee invoked per element.
		     * @param {Function} [comparator] The comparator invoked per element.
		     * @returns {Array} Returns the new array of values.
		     */
		    function baseXor(arrays, iteratee, comparator) {
		      var length = arrays.length;
		      if (length < 2) {
		        return length ? baseUniq(arrays[0]) : [];
		      }
		      var index = -1,
		          result = Array(length);

		      while (++index < length) {
		        var array = arrays[index],
		            othIndex = -1;

		        while (++othIndex < length) {
		          if (othIndex != index) {
		            result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
		          }
		        }
		      }
		      return baseUniq(baseFlatten(result, 1), iteratee, comparator);
		    }

		    /**
		     * This base implementation of `_.zipObject` which assigns values using `assignFunc`.
		     *
		     * @private
		     * @param {Array} props The property identifiers.
		     * @param {Array} values The property values.
		     * @param {Function} assignFunc The function to assign values.
		     * @returns {Object} Returns the new object.
		     */
		    function baseZipObject(props, values, assignFunc) {
		      var index = -1,
		          length = props.length,
		          valsLength = values.length,
		          result = {};

		      while (++index < length) {
		        var value = index < valsLength ? values[index] : undefined$1;
		        assignFunc(result, props[index], value);
		      }
		      return result;
		    }

		    /**
		     * Casts `value` to an empty array if it's not an array like object.
		     *
		     * @private
		     * @param {*} value The value to inspect.
		     * @returns {Array|Object} Returns the cast array-like object.
		     */
		    function castArrayLikeObject(value) {
		      return isArrayLikeObject(value) ? value : [];
		    }

		    /**
		     * Casts `value` to `identity` if it's not a function.
		     *
		     * @private
		     * @param {*} value The value to inspect.
		     * @returns {Function} Returns cast function.
		     */
		    function castFunction(value) {
		      return typeof value == 'function' ? value : identity;
		    }

		    /**
		     * Casts `value` to a path array if it's not one.
		     *
		     * @private
		     * @param {*} value The value to inspect.
		     * @param {Object} [object] The object to query keys on.
		     * @returns {Array} Returns the cast property path array.
		     */
		    function castPath(value, object) {
		      if (isArray(value)) {
		        return value;
		      }
		      return isKey(value, object) ? [value] : stringToPath(toString(value));
		    }

		    /**
		     * A `baseRest` alias which can be replaced with `identity` by module
		     * replacement plugins.
		     *
		     * @private
		     * @type {Function}
		     * @param {Function} func The function to apply a rest parameter to.
		     * @returns {Function} Returns the new function.
		     */
		    var castRest = baseRest;

		    /**
		     * Casts `array` to a slice if it's needed.
		     *
		     * @private
		     * @param {Array} array The array to inspect.
		     * @param {number} start The start position.
		     * @param {number} [end=array.length] The end position.
		     * @returns {Array} Returns the cast slice.
		     */
		    function castSlice(array, start, end) {
		      var length = array.length;
		      end = end === undefined$1 ? length : end;
		      return (!start && end >= length) ? array : baseSlice(array, start, end);
		    }

		    /**
		     * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).
		     *
		     * @private
		     * @param {number|Object} id The timer id or timeout object of the timer to clear.
		     */
		    var clearTimeout = ctxClearTimeout || function(id) {
		      return root.clearTimeout(id);
		    };

		    /**
		     * Creates a clone of  `buffer`.
		     *
		     * @private
		     * @param {Buffer} buffer The buffer to clone.
		     * @param {boolean} [isDeep] Specify a deep clone.
		     * @returns {Buffer} Returns the cloned buffer.
		     */
		    function cloneBuffer(buffer, isDeep) {
		      if (isDeep) {
		        return buffer.slice();
		      }
		      var length = buffer.length,
		          result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);

		      buffer.copy(result);
		      return result;
		    }

		    /**
		     * Creates a clone of `arrayBuffer`.
		     *
		     * @private
		     * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
		     * @returns {ArrayBuffer} Returns the cloned array buffer.
		     */
		    function cloneArrayBuffer(arrayBuffer) {
		      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
		      new Uint8Array(result).set(new Uint8Array(arrayBuffer));
		      return result;
		    }

		    /**
		     * Creates a clone of `dataView`.
		     *
		     * @private
		     * @param {Object} dataView The data view to clone.
		     * @param {boolean} [isDeep] Specify a deep clone.
		     * @returns {Object} Returns the cloned data view.
		     */
		    function cloneDataView(dataView, isDeep) {
		      var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
		      return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
		    }

		    /**
		     * Creates a clone of `regexp`.
		     *
		     * @private
		     * @param {Object} regexp The regexp to clone.
		     * @returns {Object} Returns the cloned regexp.
		     */
		    function cloneRegExp(regexp) {
		      var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
		      result.lastIndex = regexp.lastIndex;
		      return result;
		    }

		    /**
		     * Creates a clone of the `symbol` object.
		     *
		     * @private
		     * @param {Object} symbol The symbol object to clone.
		     * @returns {Object} Returns the cloned symbol object.
		     */
		    function cloneSymbol(symbol) {
		      return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
		    }

		    /**
		     * Creates a clone of `typedArray`.
		     *
		     * @private
		     * @param {Object} typedArray The typed array to clone.
		     * @param {boolean} [isDeep] Specify a deep clone.
		     * @returns {Object} Returns the cloned typed array.
		     */
		    function cloneTypedArray(typedArray, isDeep) {
		      var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
		      return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
		    }

		    /**
		     * Compares values to sort them in ascending order.
		     *
		     * @private
		     * @param {*} value The value to compare.
		     * @param {*} other The other value to compare.
		     * @returns {number} Returns the sort order indicator for `value`.
		     */
		    function compareAscending(value, other) {
		      if (value !== other) {
		        var valIsDefined = value !== undefined$1,
		            valIsNull = value === null,
		            valIsReflexive = value === value,
		            valIsSymbol = isSymbol(value);

		        var othIsDefined = other !== undefined$1,
		            othIsNull = other === null,
		            othIsReflexive = other === other,
		            othIsSymbol = isSymbol(other);

		        if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
		            (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
		            (valIsNull && othIsDefined && othIsReflexive) ||
		            (!valIsDefined && othIsReflexive) ||
		            !valIsReflexive) {
		          return 1;
		        }
		        if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
		            (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
		            (othIsNull && valIsDefined && valIsReflexive) ||
		            (!othIsDefined && valIsReflexive) ||
		            !othIsReflexive) {
		          return -1;
		        }
		      }
		      return 0;
		    }

		    /**
		     * Used by `_.orderBy` to compare multiple properties of a value to another
		     * and stable sort them.
		     *
		     * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,
		     * specify an order of "desc" for descending or "asc" for ascending sort order
		     * of corresponding values.
		     *
		     * @private
		     * @param {Object} object The object to compare.
		     * @param {Object} other The other object to compare.
		     * @param {boolean[]|string[]} orders The order to sort by for each property.
		     * @returns {number} Returns the sort order indicator for `object`.
		     */
		    function compareMultiple(object, other, orders) {
		      var index = -1,
		          objCriteria = object.criteria,
		          othCriteria = other.criteria,
		          length = objCriteria.length,
		          ordersLength = orders.length;

		      while (++index < length) {
		        var result = compareAscending(objCriteria[index], othCriteria[index]);
		        if (result) {
		          if (index >= ordersLength) {
		            return result;
		          }
		          var order = orders[index];
		          return result * (order == 'desc' ? -1 : 1);
		        }
		      }
		      // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
		      // that causes it, under certain circumstances, to provide the same value for
		      // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247
		      // for more details.
		      //
		      // This also ensures a stable sort in V8 and other engines.
		      // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
		      return object.index - other.index;
		    }

		    /**
		     * Creates an array that is the composition of partially applied arguments,
		     * placeholders, and provided arguments into a single array of arguments.
		     *
		     * @private
		     * @param {Array} args The provided arguments.
		     * @param {Array} partials The arguments to prepend to those provided.
		     * @param {Array} holders The `partials` placeholder indexes.
		     * @params {boolean} [isCurried] Specify composing for a curried function.
		     * @returns {Array} Returns the new array of composed arguments.
		     */
		    function composeArgs(args, partials, holders, isCurried) {
		      var argsIndex = -1,
		          argsLength = args.length,
		          holdersLength = holders.length,
		          leftIndex = -1,
		          leftLength = partials.length,
		          rangeLength = nativeMax(argsLength - holdersLength, 0),
		          result = Array(leftLength + rangeLength),
		          isUncurried = !isCurried;

		      while (++leftIndex < leftLength) {
		        result[leftIndex] = partials[leftIndex];
		      }
		      while (++argsIndex < holdersLength) {
		        if (isUncurried || argsIndex < argsLength) {
		          result[holders[argsIndex]] = args[argsIndex];
		        }
		      }
		      while (rangeLength--) {
		        result[leftIndex++] = args[argsIndex++];
		      }
		      return result;
		    }

		    /**
		     * This function is like `composeArgs` except that the arguments composition
		     * is tailored for `_.partialRight`.
		     *
		     * @private
		     * @param {Array} args The provided arguments.
		     * @param {Array} partials The arguments to append to those provided.
		     * @param {Array} holders The `partials` placeholder indexes.
		     * @params {boolean} [isCurried] Specify composing for a curried function.
		     * @returns {Array} Returns the new array of composed arguments.
		     */
		    function composeArgsRight(args, partials, holders, isCurried) {
		      var argsIndex = -1,
		          argsLength = args.length,
		          holdersIndex = -1,
		          holdersLength = holders.length,
		          rightIndex = -1,
		          rightLength = partials.length,
		          rangeLength = nativeMax(argsLength - holdersLength, 0),
		          result = Array(rangeLength + rightLength),
		          isUncurried = !isCurried;

		      while (++argsIndex < rangeLength) {
		        result[argsIndex] = args[argsIndex];
		      }
		      var offset = argsIndex;
		      while (++rightIndex < rightLength) {
		        result[offset + rightIndex] = partials[rightIndex];
		      }
		      while (++holdersIndex < holdersLength) {
		        if (isUncurried || argsIndex < argsLength) {
		          result[offset + holders[holdersIndex]] = args[argsIndex++];
		        }
		      }
		      return result;
		    }

		    /**
		     * Copies the values of `source` to `array`.
		     *
		     * @private
		     * @param {Array} source The array to copy values from.
		     * @param {Array} [array=[]] The array to copy values to.
		     * @returns {Array} Returns `array`.
		     */
		    function copyArray(source, array) {
		      var index = -1,
		          length = source.length;

		      array || (array = Array(length));
		      while (++index < length) {
		        array[index] = source[index];
		      }
		      return array;
		    }

		    /**
		     * Copies properties of `source` to `object`.
		     *
		     * @private
		     * @param {Object} source The object to copy properties from.
		     * @param {Array} props The property identifiers to copy.
		     * @param {Object} [object={}] The object to copy properties to.
		     * @param {Function} [customizer] The function to customize copied values.
		     * @returns {Object} Returns `object`.
		     */
		    function copyObject(source, props, object, customizer) {
		      var isNew = !object;
		      object || (object = {});

		      var index = -1,
		          length = props.length;

		      while (++index < length) {
		        var key = props[index];

		        var newValue = customizer
		          ? customizer(object[key], source[key], key, object, source)
		          : undefined$1;

		        if (newValue === undefined$1) {
		          newValue = source[key];
		        }
		        if (isNew) {
		          baseAssignValue(object, key, newValue);
		        } else {
		          assignValue(object, key, newValue);
		        }
		      }
		      return object;
		    }

		    /**
		     * Copies own symbols of `source` to `object`.
		     *
		     * @private
		     * @param {Object} source The object to copy symbols from.
		     * @param {Object} [object={}] The object to copy symbols to.
		     * @returns {Object} Returns `object`.
		     */
		    function copySymbols(source, object) {
		      return copyObject(source, getSymbols(source), object);
		    }

		    /**
		     * Copies own and inherited symbols of `source` to `object`.
		     *
		     * @private
		     * @param {Object} source The object to copy symbols from.
		     * @param {Object} [object={}] The object to copy symbols to.
		     * @returns {Object} Returns `object`.
		     */
		    function copySymbolsIn(source, object) {
		      return copyObject(source, getSymbolsIn(source), object);
		    }

		    /**
		     * Creates a function like `_.groupBy`.
		     *
		     * @private
		     * @param {Function} setter The function to set accumulator values.
		     * @param {Function} [initializer] The accumulator object initializer.
		     * @returns {Function} Returns the new aggregator function.
		     */
		    function createAggregator(setter, initializer) {
		      return function(collection, iteratee) {
		        var func = isArray(collection) ? arrayAggregator : baseAggregator,
		            accumulator = initializer ? initializer() : {};

		        return func(collection, setter, getIteratee(iteratee, 2), accumulator);
		      };
		    }

		    /**
		     * Creates a function like `_.assign`.
		     *
		     * @private
		     * @param {Function} assigner The function to assign values.
		     * @returns {Function} Returns the new assigner function.
		     */
		    function createAssigner(assigner) {
		      return baseRest(function(object, sources) {
		        var index = -1,
		            length = sources.length,
		            customizer = length > 1 ? sources[length - 1] : undefined$1,
		            guard = length > 2 ? sources[2] : undefined$1;

		        customizer = (assigner.length > 3 && typeof customizer == 'function')
		          ? (length--, customizer)
		          : undefined$1;

		        if (guard && isIterateeCall(sources[0], sources[1], guard)) {
		          customizer = length < 3 ? undefined$1 : customizer;
		          length = 1;
		        }
		        object = Object(object);
		        while (++index < length) {
		          var source = sources[index];
		          if (source) {
		            assigner(object, source, index, customizer);
		          }
		        }
		        return object;
		      });
		    }

		    /**
		     * Creates a `baseEach` or `baseEachRight` function.
		     *
		     * @private
		     * @param {Function} eachFunc The function to iterate over a collection.
		     * @param {boolean} [fromRight] Specify iterating from right to left.
		     * @returns {Function} Returns the new base function.
		     */
		    function createBaseEach(eachFunc, fromRight) {
		      return function(collection, iteratee) {
		        if (collection == null) {
		          return collection;
		        }
		        if (!isArrayLike(collection)) {
		          return eachFunc(collection, iteratee);
		        }
		        var length = collection.length,
		            index = fromRight ? length : -1,
		            iterable = Object(collection);

		        while ((fromRight ? index-- : ++index < length)) {
		          if (iteratee(iterable[index], index, iterable) === false) {
		            break;
		          }
		        }
		        return collection;
		      };
		    }

		    /**
		     * Creates a base function for methods like `_.forIn` and `_.forOwn`.
		     *
		     * @private
		     * @param {boolean} [fromRight] Specify iterating from right to left.
		     * @returns {Function} Returns the new base function.
		     */
		    function createBaseFor(fromRight) {
		      return function(object, iteratee, keysFunc) {
		        var index = -1,
		            iterable = Object(object),
		            props = keysFunc(object),
		            length = props.length;

		        while (length--) {
		          var key = props[fromRight ? length : ++index];
		          if (iteratee(iterable[key], key, iterable) === false) {
		            break;
		          }
		        }
		        return object;
		      };
		    }

		    /**
		     * Creates a function that wraps `func` to invoke it with the optional `this`
		     * binding of `thisArg`.
		     *
		     * @private
		     * @param {Function} func The function to wrap.
		     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
		     * @param {*} [thisArg] The `this` binding of `func`.
		     * @returns {Function} Returns the new wrapped function.
		     */
		    function createBind(func, bitmask, thisArg) {
		      var isBind = bitmask & WRAP_BIND_FLAG,
		          Ctor = createCtor(func);

		      function wrapper() {
		        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
		        return fn.apply(isBind ? thisArg : this, arguments);
		      }
		      return wrapper;
		    }

		    /**
		     * Creates a function like `_.lowerFirst`.
		     *
		     * @private
		     * @param {string} methodName The name of the `String` case method to use.
		     * @returns {Function} Returns the new case function.
		     */
		    function createCaseFirst(methodName) {
		      return function(string) {
		        string = toString(string);

		        var strSymbols = hasUnicode(string)
		          ? stringToArray(string)
		          : undefined$1;

		        var chr = strSymbols
		          ? strSymbols[0]
		          : string.charAt(0);

		        var trailing = strSymbols
		          ? castSlice(strSymbols, 1).join('')
		          : string.slice(1);

		        return chr[methodName]() + trailing;
		      };
		    }

		    /**
		     * Creates a function like `_.camelCase`.
		     *
		     * @private
		     * @param {Function} callback The function to combine each word.
		     * @returns {Function} Returns the new compounder function.
		     */
		    function createCompounder(callback) {
		      return function(string) {
		        return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');
		      };
		    }

		    /**
		     * Creates a function that produces an instance of `Ctor` regardless of
		     * whether it was invoked as part of a `new` expression or by `call` or `apply`.
		     *
		     * @private
		     * @param {Function} Ctor The constructor to wrap.
		     * @returns {Function} Returns the new wrapped function.
		     */
		    function createCtor(Ctor) {
		      return function() {
		        // Use a `switch` statement to work with class constructors. See
		        // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist
		        // for more details.
		        var args = arguments;
		        switch (args.length) {
		          case 0: return new Ctor;
		          case 1: return new Ctor(args[0]);
		          case 2: return new Ctor(args[0], args[1]);
		          case 3: return new Ctor(args[0], args[1], args[2]);
		          case 4: return new Ctor(args[0], args[1], args[2], args[3]);
		          case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);
		          case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
		          case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
		        }
		        var thisBinding = baseCreate(Ctor.prototype),
		            result = Ctor.apply(thisBinding, args);

		        // Mimic the constructor's `return` behavior.
		        // See https://es5.github.io/#x13.2.2 for more details.
		        return isObject(result) ? result : thisBinding;
		      };
		    }

		    /**
		     * Creates a function that wraps `func` to enable currying.
		     *
		     * @private
		     * @param {Function} func The function to wrap.
		     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
		     * @param {number} arity The arity of `func`.
		     * @returns {Function} Returns the new wrapped function.
		     */
		    function createCurry(func, bitmask, arity) {
		      var Ctor = createCtor(func);

		      function wrapper() {
		        var length = arguments.length,
		            args = Array(length),
		            index = length,
		            placeholder = getHolder(wrapper);

		        while (index--) {
		          args[index] = arguments[index];
		        }
		        var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)
		          ? []
		          : replaceHolders(args, placeholder);

		        length -= holders.length;
		        if (length < arity) {
		          return createRecurry(
		            func, bitmask, createHybrid, wrapper.placeholder, undefined$1,
		            args, holders, undefined$1, undefined$1, arity - length);
		        }
		        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;
		        return apply(fn, this, args);
		      }
		      return wrapper;
		    }

		    /**
		     * Creates a `_.find` or `_.findLast` function.
		     *
		     * @private
		     * @param {Function} findIndexFunc The function to find the collection index.
		     * @returns {Function} Returns the new find function.
		     */
		    function createFind(findIndexFunc) {
		      return function(collection, predicate, fromIndex) {
		        var iterable = Object(collection);
		        if (!isArrayLike(collection)) {
		          var iteratee = getIteratee(predicate, 3);
		          collection = keys(collection);
		          predicate = function(key) { return iteratee(iterable[key], key, iterable); };
		        }
		        var index = findIndexFunc(collection, predicate, fromIndex);
		        return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined$1;
		      };
		    }

		    /**
		     * Creates a `_.flow` or `_.flowRight` function.
		     *
		     * @private
		     * @param {boolean} [fromRight] Specify iterating from right to left.
		     * @returns {Function} Returns the new flow function.
		     */
		    function createFlow(fromRight) {
		      return flatRest(function(funcs) {
		        var length = funcs.length,
		            index = length,
		            prereq = LodashWrapper.prototype.thru;

		        if (fromRight) {
		          funcs.reverse();
		        }
		        while (index--) {
		          var func = funcs[index];
		          if (typeof func != 'function') {
		            throw new TypeError(FUNC_ERROR_TEXT);
		          }
		          if (prereq && !wrapper && getFuncName(func) == 'wrapper') {
		            var wrapper = new LodashWrapper([], true);
		          }
		        }
		        index = wrapper ? index : length;
		        while (++index < length) {
		          func = funcs[index];

		          var funcName = getFuncName(func),
		              data = funcName == 'wrapper' ? getData(func) : undefined$1;

		          if (data && isLaziable(data[0]) &&
		                data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&
		                !data[4].length && data[9] == 1
		              ) {
		            wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
		          } else {
		            wrapper = (func.length == 1 && isLaziable(func))
		              ? wrapper[funcName]()
		              : wrapper.thru(func);
		          }
		        }
		        return function() {
		          var args = arguments,
		              value = args[0];

		          if (wrapper && args.length == 1 && isArray(value)) {
		            return wrapper.plant(value).value();
		          }
		          var index = 0,
		              result = length ? funcs[index].apply(this, args) : value;

		          while (++index < length) {
		            result = funcs[index].call(this, result);
		          }
		          return result;
		        };
		      });
		    }

		    /**
		     * Creates a function that wraps `func` to invoke it with optional `this`
		     * binding of `thisArg`, partial application, and currying.
		     *
		     * @private
		     * @param {Function|string} func The function or method name to wrap.
		     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
		     * @param {*} [thisArg] The `this` binding of `func`.
		     * @param {Array} [partials] The arguments to prepend to those provided to
		     *  the new function.
		     * @param {Array} [holders] The `partials` placeholder indexes.
		     * @param {Array} [partialsRight] The arguments to append to those provided
		     *  to the new function.
		     * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.
		     * @param {Array} [argPos] The argument positions of the new function.
		     * @param {number} [ary] The arity cap of `func`.
		     * @param {number} [arity] The arity of `func`.
		     * @returns {Function} Returns the new wrapped function.
		     */
		    function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
		      var isAry = bitmask & WRAP_ARY_FLAG,
		          isBind = bitmask & WRAP_BIND_FLAG,
		          isBindKey = bitmask & WRAP_BIND_KEY_FLAG,
		          isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),
		          isFlip = bitmask & WRAP_FLIP_FLAG,
		          Ctor = isBindKey ? undefined$1 : createCtor(func);

		      function wrapper() {
		        var length = arguments.length,
		            args = Array(length),
		            index = length;

		        while (index--) {
		          args[index] = arguments[index];
		        }
		        if (isCurried) {
		          var placeholder = getHolder(wrapper),
		              holdersCount = countHolders(args, placeholder);
		        }
		        if (partials) {
		          args = composeArgs(args, partials, holders, isCurried);
		        }
		        if (partialsRight) {
		          args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
		        }
		        length -= holdersCount;
		        if (isCurried && length < arity) {
		          var newHolders = replaceHolders(args, placeholder);
		          return createRecurry(
		            func, bitmask, createHybrid, wrapper.placeholder, thisArg,
		            args, newHolders, argPos, ary, arity - length
		          );
		        }
		        var thisBinding = isBind ? thisArg : this,
		            fn = isBindKey ? thisBinding[func] : func;

		        length = args.length;
		        if (argPos) {
		          args = reorder(args, argPos);
		        } else if (isFlip && length > 1) {
		          args.reverse();
		        }
		        if (isAry && ary < length) {
		          args.length = ary;
		        }
		        if (this && this !== root && this instanceof wrapper) {
		          fn = Ctor || createCtor(fn);
		        }
		        return fn.apply(thisBinding, args);
		      }
		      return wrapper;
		    }

		    /**
		     * Creates a function like `_.invertBy`.
		     *
		     * @private
		     * @param {Function} setter The function to set accumulator values.
		     * @param {Function} toIteratee The function to resolve iteratees.
		     * @returns {Function} Returns the new inverter function.
		     */
		    function createInverter(setter, toIteratee) {
		      return function(object, iteratee) {
		        return baseInverter(object, setter, toIteratee(iteratee), {});
		      };
		    }

		    /**
		     * Creates a function that performs a mathematical operation on two values.
		     *
		     * @private
		     * @param {Function} operator The function to perform the operation.
		     * @param {number} [defaultValue] The value used for `undefined` arguments.
		     * @returns {Function} Returns the new mathematical operation function.
		     */
		    function createMathOperation(operator, defaultValue) {
		      return function(value, other) {
		        var result;
		        if (value === undefined$1 && other === undefined$1) {
		          return defaultValue;
		        }
		        if (value !== undefined$1) {
		          result = value;
		        }
		        if (other !== undefined$1) {
		          if (result === undefined$1) {
		            return other;
		          }
		          if (typeof value == 'string' || typeof other == 'string') {
		            value = baseToString(value);
		            other = baseToString(other);
		          } else {
		            value = baseToNumber(value);
		            other = baseToNumber(other);
		          }
		          result = operator(value, other);
		        }
		        return result;
		      };
		    }

		    /**
		     * Creates a function like `_.over`.
		     *
		     * @private
		     * @param {Function} arrayFunc The function to iterate over iteratees.
		     * @returns {Function} Returns the new over function.
		     */
		    function createOver(arrayFunc) {
		      return flatRest(function(iteratees) {
		        iteratees = arrayMap(iteratees, baseUnary(getIteratee()));
		        return baseRest(function(args) {
		          var thisArg = this;
		          return arrayFunc(iteratees, function(iteratee) {
		            return apply(iteratee, thisArg, args);
		          });
		        });
		      });
		    }

		    /**
		     * Creates the padding for `string` based on `length`. The `chars` string
		     * is truncated if the number of characters exceeds `length`.
		     *
		     * @private
		     * @param {number} length The padding length.
		     * @param {string} [chars=' '] The string used as padding.
		     * @returns {string} Returns the padding for `string`.
		     */
		    function createPadding(length, chars) {
		      chars = chars === undefined$1 ? ' ' : baseToString(chars);

		      var charsLength = chars.length;
		      if (charsLength < 2) {
		        return charsLength ? baseRepeat(chars, length) : chars;
		      }
		      var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
		      return hasUnicode(chars)
		        ? castSlice(stringToArray(result), 0, length).join('')
		        : result.slice(0, length);
		    }

		    /**
		     * Creates a function that wraps `func` to invoke it with the `this` binding
		     * of `thisArg` and `partials` prepended to the arguments it receives.
		     *
		     * @private
		     * @param {Function} func The function to wrap.
		     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
		     * @param {*} thisArg The `this` binding of `func`.
		     * @param {Array} partials The arguments to prepend to those provided to
		     *  the new function.
		     * @returns {Function} Returns the new wrapped function.
		     */
		    function createPartial(func, bitmask, thisArg, partials) {
		      var isBind = bitmask & WRAP_BIND_FLAG,
		          Ctor = createCtor(func);

		      function wrapper() {
		        var argsIndex = -1,
		            argsLength = arguments.length,
		            leftIndex = -1,
		            leftLength = partials.length,
		            args = Array(leftLength + argsLength),
		            fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;

		        while (++leftIndex < leftLength) {
		          args[leftIndex] = partials[leftIndex];
		        }
		        while (argsLength--) {
		          args[leftIndex++] = arguments[++argsIndex];
		        }
		        return apply(fn, isBind ? thisArg : this, args);
		      }
		      return wrapper;
		    }

		    /**
		     * Creates a `_.range` or `_.rangeRight` function.
		     *
		     * @private
		     * @param {boolean} [fromRight] Specify iterating from right to left.
		     * @returns {Function} Returns the new range function.
		     */
		    function createRange(fromRight) {
		      return function(start, end, step) {
		        if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {
		          end = step = undefined$1;
		        }
		        // Ensure the sign of `-0` is preserved.
		        start = toFinite(start);
		        if (end === undefined$1) {
		          end = start;
		          start = 0;
		        } else {
		          end = toFinite(end);
		        }
		        step = step === undefined$1 ? (start < end ? 1 : -1) : toFinite(step);
		        return baseRange(start, end, step, fromRight);
		      };
		    }

		    /**
		     * Creates a function that performs a relational operation on two values.
		     *
		     * @private
		     * @param {Function} operator The function to perform the operation.
		     * @returns {Function} Returns the new relational operation function.
		     */
		    function createRelationalOperation(operator) {
		      return function(value, other) {
		        if (!(typeof value == 'string' && typeof other == 'string')) {
		          value = toNumber(value);
		          other = toNumber(other);
		        }
		        return operator(value, other);
		      };
		    }

		    /**
		     * Creates a function that wraps `func` to continue currying.
		     *
		     * @private
		     * @param {Function} func The function to wrap.
		     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
		     * @param {Function} wrapFunc The function to create the `func` wrapper.
		     * @param {*} placeholder The placeholder value.
		     * @param {*} [thisArg] The `this` binding of `func`.
		     * @param {Array} [partials] The arguments to prepend to those provided to
		     *  the new function.
		     * @param {Array} [holders] The `partials` placeholder indexes.
		     * @param {Array} [argPos] The argument positions of the new function.
		     * @param {number} [ary] The arity cap of `func`.
		     * @param {number} [arity] The arity of `func`.
		     * @returns {Function} Returns the new wrapped function.
		     */
		    function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
		      var isCurry = bitmask & WRAP_CURRY_FLAG,
		          newHolders = isCurry ? holders : undefined$1,
		          newHoldersRight = isCurry ? undefined$1 : holders,
		          newPartials = isCurry ? partials : undefined$1,
		          newPartialsRight = isCurry ? undefined$1 : partials;

		      bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);
		      bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);

		      if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {
		        bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);
		      }
		      var newData = [
		        func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,
		        newHoldersRight, argPos, ary, arity
		      ];

		      var result = wrapFunc.apply(undefined$1, newData);
		      if (isLaziable(func)) {
		        setData(result, newData);
		      }
		      result.placeholder = placeholder;
		      return setWrapToString(result, func, bitmask);
		    }

		    /**
		     * Creates a function like `_.round`.
		     *
		     * @private
		     * @param {string} methodName The name of the `Math` method to use when rounding.
		     * @returns {Function} Returns the new round function.
		     */
		    function createRound(methodName) {
		      var func = Math[methodName];
		      return function(number, precision) {
		        number = toNumber(number);
		        precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
		        if (precision && nativeIsFinite(number)) {
		          // Shift with exponential notation to avoid floating-point issues.
		          // See [MDN](https://mdn.io/round#Examples) for more details.
		          var pair = (toString(number) + 'e').split('e'),
		              value = func(pair[0] + 'e' + (+pair[1] + precision));

		          pair = (toString(value) + 'e').split('e');
		          return +(pair[0] + 'e' + (+pair[1] - precision));
		        }
		        return func(number);
		      };
		    }

		    /**
		     * Creates a set object of `values`.
		     *
		     * @private
		     * @param {Array} values The values to add to the set.
		     * @returns {Object} Returns the new set.
		     */
		    var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {
		      return new Set(values);
		    };

		    /**
		     * Creates a `_.toPairs` or `_.toPairsIn` function.
		     *
		     * @private
		     * @param {Function} keysFunc The function to get the keys of a given object.
		     * @returns {Function} Returns the new pairs function.
		     */
		    function createToPairs(keysFunc) {
		      return function(object) {
		        var tag = getTag(object);
		        if (tag == mapTag) {
		          return mapToArray(object);
		        }
		        if (tag == setTag) {
		          return setToPairs(object);
		        }
		        return baseToPairs(object, keysFunc(object));
		      };
		    }

		    /**
		     * Creates a function that either curries or invokes `func` with optional
		     * `this` binding and partially applied arguments.
		     *
		     * @private
		     * @param {Function|string} func The function or method name to wrap.
		     * @param {number} bitmask The bitmask flags.
		     *    1 - `_.bind`
		     *    2 - `_.bindKey`
		     *    4 - `_.curry` or `_.curryRight` of a bound function
		     *    8 - `_.curry`
		     *   16 - `_.curryRight`
		     *   32 - `_.partial`
		     *   64 - `_.partialRight`
		     *  128 - `_.rearg`
		     *  256 - `_.ary`
		     *  512 - `_.flip`
		     * @param {*} [thisArg] The `this` binding of `func`.
		     * @param {Array} [partials] The arguments to be partially applied.
		     * @param {Array} [holders] The `partials` placeholder indexes.
		     * @param {Array} [argPos] The argument positions of the new function.
		     * @param {number} [ary] The arity cap of `func`.
		     * @param {number} [arity] The arity of `func`.
		     * @returns {Function} Returns the new wrapped function.
		     */
		    function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
		      var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;
		      if (!isBindKey && typeof func != 'function') {
		        throw new TypeError(FUNC_ERROR_TEXT);
		      }
		      var length = partials ? partials.length : 0;
		      if (!length) {
		        bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);
		        partials = holders = undefined$1;
		      }
		      ary = ary === undefined$1 ? ary : nativeMax(toInteger(ary), 0);
		      arity = arity === undefined$1 ? arity : toInteger(arity);
		      length -= holders ? holders.length : 0;

		      if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {
		        var partialsRight = partials,
		            holdersRight = holders;

		        partials = holders = undefined$1;
		      }
		      var data = isBindKey ? undefined$1 : getData(func);

		      var newData = [
		        func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,
		        argPos, ary, arity
		      ];

		      if (data) {
		        mergeData(newData, data);
		      }
		      func = newData[0];
		      bitmask = newData[1];
		      thisArg = newData[2];
		      partials = newData[3];
		      holders = newData[4];
		      arity = newData[9] = newData[9] === undefined$1
		        ? (isBindKey ? 0 : func.length)
		        : nativeMax(newData[9] - length, 0);

		      if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {
		        bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);
		      }
		      if (!bitmask || bitmask == WRAP_BIND_FLAG) {
		        var result = createBind(func, bitmask, thisArg);
		      } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {
		        result = createCurry(func, bitmask, arity);
		      } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {
		        result = createPartial(func, bitmask, thisArg, partials);
		      } else {
		        result = createHybrid.apply(undefined$1, newData);
		      }
		      var setter = data ? baseSetData : setData;
		      return setWrapToString(setter(result, newData), func, bitmask);
		    }

		    /**
		     * Used by `_.defaults` to customize its `_.assignIn` use to assign properties
		     * of source objects to the destination object for all destination properties
		     * that resolve to `undefined`.
		     *
		     * @private
		     * @param {*} objValue The destination value.
		     * @param {*} srcValue The source value.
		     * @param {string} key The key of the property to assign.
		     * @param {Object} object The parent object of `objValue`.
		     * @returns {*} Returns the value to assign.
		     */
		    function customDefaultsAssignIn(objValue, srcValue, key, object) {
		      if (objValue === undefined$1 ||
		          (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {
		        return srcValue;
		      }
		      return objValue;
		    }

		    /**
		     * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source
		     * objects into destination objects that are passed thru.
		     *
		     * @private
		     * @param {*} objValue The destination value.
		     * @param {*} srcValue The source value.
		     * @param {string} key The key of the property to merge.
		     * @param {Object} object The parent object of `objValue`.
		     * @param {Object} source The parent object of `srcValue`.
		     * @param {Object} [stack] Tracks traversed source values and their merged
		     *  counterparts.
		     * @returns {*} Returns the value to assign.
		     */
		    function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
		      if (isObject(objValue) && isObject(srcValue)) {
		        // Recursively merge objects and arrays (susceptible to call stack limits).
		        stack.set(srcValue, objValue);
		        baseMerge(objValue, srcValue, undefined$1, customDefaultsMerge, stack);
		        stack['delete'](srcValue);
		      }
		      return objValue;
		    }

		    /**
		     * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
		     * objects.
		     *
		     * @private
		     * @param {*} value The value to inspect.
		     * @param {string} key The key of the property to inspect.
		     * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
		     */
		    function customOmitClone(value) {
		      return isPlainObject(value) ? undefined$1 : value;
		    }

		    /**
		     * A specialized version of `baseIsEqualDeep` for arrays with support for
		     * partial deep comparisons.
		     *
		     * @private
		     * @param {Array} array The array to compare.
		     * @param {Array} other The other array to compare.
		     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
		     * @param {Function} customizer The function to customize comparisons.
		     * @param {Function} equalFunc The function to determine equivalents of values.
		     * @param {Object} stack Tracks traversed `array` and `other` objects.
		     * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
		     */
		    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
		      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
		          arrLength = array.length,
		          othLength = other.length;

		      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
		        return false;
		      }
		      // Check that cyclic values are equal.
		      var arrStacked = stack.get(array);
		      var othStacked = stack.get(other);
		      if (arrStacked && othStacked) {
		        return arrStacked == other && othStacked == array;
		      }
		      var index = -1,
		          result = true,
		          seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined$1;

		      stack.set(array, other);
		      stack.set(other, array);

		      // Ignore non-index properties.
		      while (++index < arrLength) {
		        var arrValue = array[index],
		            othValue = other[index];

		        if (customizer) {
		          var compared = isPartial
		            ? customizer(othValue, arrValue, index, other, array, stack)
		            : customizer(arrValue, othValue, index, array, other, stack);
		        }
		        if (compared !== undefined$1) {
		          if (compared) {
		            continue;
		          }
		          result = false;
		          break;
		        }
		        // Recursively compare arrays (susceptible to call stack limits).
		        if (seen) {
		          if (!arraySome(other, function(othValue, othIndex) {
		                if (!cacheHas(seen, othIndex) &&
		                    (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
		                  return seen.push(othIndex);
		                }
		              })) {
		            result = false;
		            break;
		          }
		        } else if (!(
		              arrValue === othValue ||
		                equalFunc(arrValue, othValue, bitmask, customizer, stack)
		            )) {
		          result = false;
		          break;
		        }
		      }
		      stack['delete'](array);
		      stack['delete'](other);
		      return result;
		    }

		    /**
		     * A specialized version of `baseIsEqualDeep` for comparing objects of
		     * the same `toStringTag`.
		     *
		     * **Note:** This function only supports comparing values with tags of
		     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
		     *
		     * @private
		     * @param {Object} object The object to compare.
		     * @param {Object} other The other object to compare.
		     * @param {string} tag The `toStringTag` of the objects to compare.
		     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
		     * @param {Function} customizer The function to customize comparisons.
		     * @param {Function} equalFunc The function to determine equivalents of values.
		     * @param {Object} stack Tracks traversed `object` and `other` objects.
		     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
		     */
		    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
		      switch (tag) {
		        case dataViewTag:
		          if ((object.byteLength != other.byteLength) ||
		              (object.byteOffset != other.byteOffset)) {
		            return false;
		          }
		          object = object.buffer;
		          other = other.buffer;

		        case arrayBufferTag:
		          if ((object.byteLength != other.byteLength) ||
		              !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
		            return false;
		          }
		          return true;

		        case boolTag:
		        case dateTag:
		        case numberTag:
		          // Coerce booleans to `1` or `0` and dates to milliseconds.
		          // Invalid dates are coerced to `NaN`.
		          return eq(+object, +other);

		        case errorTag:
		          return object.name == other.name && object.message == other.message;

		        case regexpTag:
		        case stringTag:
		          // Coerce regexes to strings and treat strings, primitives and objects,
		          // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
		          // for more details.
		          return object == (other + '');

		        case mapTag:
		          var convert = mapToArray;

		        case setTag:
		          var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
		          convert || (convert = setToArray);

		          if (object.size != other.size && !isPartial) {
		            return false;
		          }
		          // Assume cyclic values are equal.
		          var stacked = stack.get(object);
		          if (stacked) {
		            return stacked == other;
		          }
		          bitmask |= COMPARE_UNORDERED_FLAG;

		          // Recursively compare objects (susceptible to call stack limits).
		          stack.set(object, other);
		          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
		          stack['delete'](object);
		          return result;

		        case symbolTag:
		          if (symbolValueOf) {
		            return symbolValueOf.call(object) == symbolValueOf.call(other);
		          }
		      }
		      return false;
		    }

		    /**
		     * A specialized version of `baseIsEqualDeep` for objects with support for
		     * partial deep comparisons.
		     *
		     * @private
		     * @param {Object} object The object to compare.
		     * @param {Object} other The other object to compare.
		     * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
		     * @param {Function} customizer The function to customize comparisons.
		     * @param {Function} equalFunc The function to determine equivalents of values.
		     * @param {Object} stack Tracks traversed `object` and `other` objects.
		     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
		     */
		    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
		      var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
		          objProps = getAllKeys(object),
		          objLength = objProps.length,
		          othProps = getAllKeys(other),
		          othLength = othProps.length;

		      if (objLength != othLength && !isPartial) {
		        return false;
		      }
		      var index = objLength;
		      while (index--) {
		        var key = objProps[index];
		        if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
		          return false;
		        }
		      }
		      // Check that cyclic values are equal.
		      var objStacked = stack.get(object);
		      var othStacked = stack.get(other);
		      if (objStacked && othStacked) {
		        return objStacked == other && othStacked == object;
		      }
		      var result = true;
		      stack.set(object, other);
		      stack.set(other, object);

		      var skipCtor = isPartial;
		      while (++index < objLength) {
		        key = objProps[index];
		        var objValue = object[key],
		            othValue = other[key];

		        if (customizer) {
		          var compared = isPartial
		            ? customizer(othValue, objValue, key, other, object, stack)
		            : customizer(objValue, othValue, key, object, other, stack);
		        }
		        // Recursively compare objects (susceptible to call stack limits).
		        if (!(compared === undefined$1
		              ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
		              : compared
		            )) {
		          result = false;
		          break;
		        }
		        skipCtor || (skipCtor = key == 'constructor');
		      }
		      if (result && !skipCtor) {
		        var objCtor = object.constructor,
		            othCtor = other.constructor;

		        // Non `Object` object instances with different constructors are not equal.
		        if (objCtor != othCtor &&
		            ('constructor' in object && 'constructor' in other) &&
		            !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
		              typeof othCtor == 'function' && othCtor instanceof othCtor)) {
		          result = false;
		        }
		      }
		      stack['delete'](object);
		      stack['delete'](other);
		      return result;
		    }

		    /**
		     * A specialized version of `baseRest` which flattens the rest array.
		     *
		     * @private
		     * @param {Function} func The function to apply a rest parameter to.
		     * @returns {Function} Returns the new function.
		     */
		    function flatRest(func) {
		      return setToString(overRest(func, undefined$1, flatten), func + '');
		    }

		    /**
		     * Creates an array of own enumerable property names and symbols of `object`.
		     *
		     * @private
		     * @param {Object} object The object to query.
		     * @returns {Array} Returns the array of property names and symbols.
		     */
		    function getAllKeys(object) {
		      return baseGetAllKeys(object, keys, getSymbols);
		    }

		    /**
		     * Creates an array of own and inherited enumerable property names and
		     * symbols of `object`.
		     *
		     * @private
		     * @param {Object} object The object to query.
		     * @returns {Array} Returns the array of property names and symbols.
		     */
		    function getAllKeysIn(object) {
		      return baseGetAllKeys(object, keysIn, getSymbolsIn);
		    }

		    /**
		     * Gets metadata for `func`.
		     *
		     * @private
		     * @param {Function} func The function to query.
		     * @returns {*} Returns the metadata for `func`.
		     */
		    var getData = !metaMap ? noop : function(func) {
		      return metaMap.get(func);
		    };

		    /**
		     * Gets the name of `func`.
		     *
		     * @private
		     * @param {Function} func The function to query.
		     * @returns {string} Returns the function name.
		     */
		    function getFuncName(func) {
		      var result = (func.name + ''),
		          array = realNames[result],
		          length = hasOwnProperty.call(realNames, result) ? array.length : 0;

		      while (length--) {
		        var data = array[length],
		            otherFunc = data.func;
		        if (otherFunc == null || otherFunc == func) {
		          return data.name;
		        }
		      }
		      return result;
		    }

		    /**
		     * Gets the argument placeholder value for `func`.
		     *
		     * @private
		     * @param {Function} func The function to inspect.
		     * @returns {*} Returns the placeholder value.
		     */
		    function getHolder(func) {
		      var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;
		      return object.placeholder;
		    }

		    /**
		     * Gets the appropriate "iteratee" function. If `_.iteratee` is customized,
		     * this function returns the custom method, otherwise it returns `baseIteratee`.
		     * If arguments are provided, the chosen function is invoked with them and
		     * its result is returned.
		     *
		     * @private
		     * @param {*} [value] The value to convert to an iteratee.
		     * @param {number} [arity] The arity of the created iteratee.
		     * @returns {Function} Returns the chosen function or its result.
		     */
		    function getIteratee() {
		      var result = lodash.iteratee || iteratee;
		      result = result === iteratee ? baseIteratee : result;
		      return arguments.length ? result(arguments[0], arguments[1]) : result;
		    }

		    /**
		     * Gets the data for `map`.
		     *
		     * @private
		     * @param {Object} map The map to query.
		     * @param {string} key The reference key.
		     * @returns {*} Returns the map data.
		     */
		    function getMapData(map, key) {
		      var data = map.__data__;
		      return isKeyable(key)
		        ? data[typeof key == 'string' ? 'string' : 'hash']
		        : data.map;
		    }

		    /**
		     * Gets the property names, values, and compare flags of `object`.
		     *
		     * @private
		     * @param {Object} object The object to query.
		     * @returns {Array} Returns the match data of `object`.
		     */
		    function getMatchData(object) {
		      var result = keys(object),
		          length = result.length;

		      while (length--) {
		        var key = result[length],
		            value = object[key];

		        result[length] = [key, value, isStrictComparable(value)];
		      }
		      return result;
		    }

		    /**
		     * Gets the native function at `key` of `object`.
		     *
		     * @private
		     * @param {Object} object The object to query.
		     * @param {string} key The key of the method to get.
		     * @returns {*} Returns the function if it's native, else `undefined`.
		     */
		    function getNative(object, key) {
		      var value = getValue(object, key);
		      return baseIsNative(value) ? value : undefined$1;
		    }

		    /**
		     * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
		     *
		     * @private
		     * @param {*} value The value to query.
		     * @returns {string} Returns the raw `toStringTag`.
		     */
		    function getRawTag(value) {
		      var isOwn = hasOwnProperty.call(value, symToStringTag),
		          tag = value[symToStringTag];

		      try {
		        value[symToStringTag] = undefined$1;
		        var unmasked = true;
		      } catch (e) {}

		      var result = nativeObjectToString.call(value);
		      if (unmasked) {
		        if (isOwn) {
		          value[symToStringTag] = tag;
		        } else {
		          delete value[symToStringTag];
		        }
		      }
		      return result;
		    }

		    /**
		     * Creates an array of the own enumerable symbols of `object`.
		     *
		     * @private
		     * @param {Object} object The object to query.
		     * @returns {Array} Returns the array of symbols.
		     */
		    var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
		      if (object == null) {
		        return [];
		      }
		      object = Object(object);
		      return arrayFilter(nativeGetSymbols(object), function(symbol) {
		        return propertyIsEnumerable.call(object, symbol);
		      });
		    };

		    /**
		     * Creates an array of the own and inherited enumerable symbols of `object`.
		     *
		     * @private
		     * @param {Object} object The object to query.
		     * @returns {Array} Returns the array of symbols.
		     */
		    var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
		      var result = [];
		      while (object) {
		        arrayPush(result, getSymbols(object));
		        object = getPrototype(object);
		      }
		      return result;
		    };

		    /**
		     * Gets the `toStringTag` of `value`.
		     *
		     * @private
		     * @param {*} value The value to query.
		     * @returns {string} Returns the `toStringTag`.
		     */
		    var getTag = baseGetTag;

		    // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
		    if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||
		        (Map && getTag(new Map) != mapTag) ||
		        (Promise && getTag(Promise.resolve()) != promiseTag) ||
		        (Set && getTag(new Set) != setTag) ||
		        (WeakMap && getTag(new WeakMap) != weakMapTag)) {
		      getTag = function(value) {
		        var result = baseGetTag(value),
		            Ctor = result == objectTag ? value.constructor : undefined$1,
		            ctorString = Ctor ? toSource(Ctor) : '';

		        if (ctorString) {
		          switch (ctorString) {
		            case dataViewCtorString: return dataViewTag;
		            case mapCtorString: return mapTag;
		            case promiseCtorString: return promiseTag;
		            case setCtorString: return setTag;
		            case weakMapCtorString: return weakMapTag;
		          }
		        }
		        return result;
		      };
		    }

		    /**
		     * Gets the view, applying any `transforms` to the `start` and `end` positions.
		     *
		     * @private
		     * @param {number} start The start of the view.
		     * @param {number} end The end of the view.
		     * @param {Array} transforms The transformations to apply to the view.
		     * @returns {Object} Returns an object containing the `start` and `end`
		     *  positions of the view.
		     */
		    function getView(start, end, transforms) {
		      var index = -1,
		          length = transforms.length;

		      while (++index < length) {
		        var data = transforms[index],
		            size = data.size;

		        switch (data.type) {
		          case 'drop':      start += size; break;
		          case 'dropRight': end -= size; break;
		          case 'take':      end = nativeMin(end, start + size); break;
		          case 'takeRight': start = nativeMax(start, end - size); break;
		        }
		      }
		      return { 'start': start, 'end': end };
		    }

		    /**
		     * Extracts wrapper details from the `source` body comment.
		     *
		     * @private
		     * @param {string} source The source to inspect.
		     * @returns {Array} Returns the wrapper details.
		     */
		    function getWrapDetails(source) {
		      var match = source.match(reWrapDetails);
		      return match ? match[1].split(reSplitDetails) : [];
		    }

		    /**
		     * Checks if `path` exists on `object`.
		     *
		     * @private
		     * @param {Object} object The object to query.
		     * @param {Array|string} path The path to check.
		     * @param {Function} hasFunc The function to check properties.
		     * @returns {boolean} Returns `true` if `path` exists, else `false`.
		     */
		    function hasPath(object, path, hasFunc) {
		      path = castPath(path, object);

		      var index = -1,
		          length = path.length,
		          result = false;

		      while (++index < length) {
		        var key = toKey(path[index]);
		        if (!(result = object != null && hasFunc(object, key))) {
		          break;
		        }
		        object = object[key];
		      }
		      if (result || ++index != length) {
		        return result;
		      }
		      length = object == null ? 0 : object.length;
		      return !!length && isLength(length) && isIndex(key, length) &&
		        (isArray(object) || isArguments(object));
		    }

		    /**
		     * Initializes an array clone.
		     *
		     * @private
		     * @param {Array} array The array to clone.
		     * @returns {Array} Returns the initialized clone.
		     */
		    function initCloneArray(array) {
		      var length = array.length,
		          result = new array.constructor(length);

		      // Add properties assigned by `RegExp#exec`.
		      if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
		        result.index = array.index;
		        result.input = array.input;
		      }
		      return result;
		    }

		    /**
		     * Initializes an object clone.
		     *
		     * @private
		     * @param {Object} object The object to clone.
		     * @returns {Object} Returns the initialized clone.
		     */
		    function initCloneObject(object) {
		      return (typeof object.constructor == 'function' && !isPrototype(object))
		        ? baseCreate(getPrototype(object))
		        : {};
		    }

		    /**
		     * Initializes an object clone based on its `toStringTag`.
		     *
		     * **Note:** This function only supports cloning values with tags of
		     * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
		     *
		     * @private
		     * @param {Object} object The object to clone.
		     * @param {string} tag The `toStringTag` of the object to clone.
		     * @param {boolean} [isDeep] Specify a deep clone.
		     * @returns {Object} Returns the initialized clone.
		     */
		    function initCloneByTag(object, tag, isDeep) {
		      var Ctor = object.constructor;
		      switch (tag) {
		        case arrayBufferTag:
		          return cloneArrayBuffer(object);

		        case boolTag:
		        case dateTag:
		          return new Ctor(+object);

		        case dataViewTag:
		          return cloneDataView(object, isDeep);

		        case float32Tag: case float64Tag:
		        case int8Tag: case int16Tag: case int32Tag:
		        case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
		          return cloneTypedArray(object, isDeep);

		        case mapTag:
		          return new Ctor;

		        case numberTag:
		        case stringTag:
		          return new Ctor(object);

		        case regexpTag:
		          return cloneRegExp(object);

		        case setTag:
		          return new Ctor;

		        case symbolTag:
		          return cloneSymbol(object);
		      }
		    }

		    /**
		     * Inserts wrapper `details` in a comment at the top of the `source` body.
		     *
		     * @private
		     * @param {string} source The source to modify.
		     * @returns {Array} details The details to insert.
		     * @returns {string} Returns the modified source.
		     */
		    function insertWrapDetails(source, details) {
		      var length = details.length;
		      if (!length) {
		        return source;
		      }
		      var lastIndex = length - 1;
		      details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];
		      details = details.join(length > 2 ? ', ' : ' ');
		      return source.replace(reWrapComment, '{\n/* [wrapped with ' + details + '] */\n');
		    }

		    /**
		     * Checks if `value` is a flattenable `arguments` object or array.
		     *
		     * @private
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
		     */
		    function isFlattenable(value) {
		      return isArray(value) || isArguments(value) ||
		        !!(spreadableSymbol && value && value[spreadableSymbol]);
		    }

		    /**
		     * Checks if `value` is a valid array-like index.
		     *
		     * @private
		     * @param {*} value The value to check.
		     * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
		     * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
		     */
		    function isIndex(value, length) {
		      var type = typeof value;
		      length = length == null ? MAX_SAFE_INTEGER : length;

		      return !!length &&
		        (type == 'number' ||
		          (type != 'symbol' && reIsUint.test(value))) &&
		            (value > -1 && value % 1 == 0 && value < length);
		    }

		    /**
		     * Checks if the given arguments are from an iteratee call.
		     *
		     * @private
		     * @param {*} value The potential iteratee value argument.
		     * @param {*} index The potential iteratee index or key argument.
		     * @param {*} object The potential iteratee object argument.
		     * @returns {boolean} Returns `true` if the arguments are from an iteratee call,
		     *  else `false`.
		     */
		    function isIterateeCall(value, index, object) {
		      if (!isObject(object)) {
		        return false;
		      }
		      var type = typeof index;
		      if (type == 'number'
		            ? (isArrayLike(object) && isIndex(index, object.length))
		            : (type == 'string' && index in object)
		          ) {
		        return eq(object[index], value);
		      }
		      return false;
		    }

		    /**
		     * Checks if `value` is a property name and not a property path.
		     *
		     * @private
		     * @param {*} value The value to check.
		     * @param {Object} [object] The object to query keys on.
		     * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
		     */
		    function isKey(value, object) {
		      if (isArray(value)) {
		        return false;
		      }
		      var type = typeof value;
		      if (type == 'number' || type == 'symbol' || type == 'boolean' ||
		          value == null || isSymbol(value)) {
		        return true;
		      }
		      return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
		        (object != null && value in Object(object));
		    }

		    /**
		     * Checks if `value` is suitable for use as unique object key.
		     *
		     * @private
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
		     */
		    function isKeyable(value) {
		      var type = typeof value;
		      return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
		        ? (value !== '__proto__')
		        : (value === null);
		    }

		    /**
		     * Checks if `func` has a lazy counterpart.
		     *
		     * @private
		     * @param {Function} func The function to check.
		     * @returns {boolean} Returns `true` if `func` has a lazy counterpart,
		     *  else `false`.
		     */
		    function isLaziable(func) {
		      var funcName = getFuncName(func),
		          other = lodash[funcName];

		      if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {
		        return false;
		      }
		      if (func === other) {
		        return true;
		      }
		      var data = getData(other);
		      return !!data && func === data[0];
		    }

		    /**
		     * Checks if `func` has its source masked.
		     *
		     * @private
		     * @param {Function} func The function to check.
		     * @returns {boolean} Returns `true` if `func` is masked, else `false`.
		     */
		    function isMasked(func) {
		      return !!maskSrcKey && (maskSrcKey in func);
		    }

		    /**
		     * Checks if `func` is capable of being masked.
		     *
		     * @private
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `func` is maskable, else `false`.
		     */
		    var isMaskable = coreJsData ? isFunction : stubFalse;

		    /**
		     * Checks if `value` is likely a prototype object.
		     *
		     * @private
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
		     */
		    function isPrototype(value) {
		      var Ctor = value && value.constructor,
		          proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;

		      return value === proto;
		    }

		    /**
		     * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
		     *
		     * @private
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` if suitable for strict
		     *  equality comparisons, else `false`.
		     */
		    function isStrictComparable(value) {
		      return value === value && !isObject(value);
		    }

		    /**
		     * A specialized version of `matchesProperty` for source values suitable
		     * for strict equality comparisons, i.e. `===`.
		     *
		     * @private
		     * @param {string} key The key of the property to get.
		     * @param {*} srcValue The value to match.
		     * @returns {Function} Returns the new spec function.
		     */
		    function matchesStrictComparable(key, srcValue) {
		      return function(object) {
		        if (object == null) {
		          return false;
		        }
		        return object[key] === srcValue &&
		          (srcValue !== undefined$1 || (key in Object(object)));
		      };
		    }

		    /**
		     * A specialized version of `_.memoize` which clears the memoized function's
		     * cache when it exceeds `MAX_MEMOIZE_SIZE`.
		     *
		     * @private
		     * @param {Function} func The function to have its output memoized.
		     * @returns {Function} Returns the new memoized function.
		     */
		    function memoizeCapped(func) {
		      var result = memoize(func, function(key) {
		        if (cache.size === MAX_MEMOIZE_SIZE) {
		          cache.clear();
		        }
		        return key;
		      });

		      var cache = result.cache;
		      return result;
		    }

		    /**
		     * Merges the function metadata of `source` into `data`.
		     *
		     * Merging metadata reduces the number of wrappers used to invoke a function.
		     * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`
		     * may be applied regardless of execution order. Methods like `_.ary` and
		     * `_.rearg` modify function arguments, making the order in which they are
		     * executed important, preventing the merging of metadata. However, we make
		     * an exception for a safe combined case where curried functions have `_.ary`
		     * and or `_.rearg` applied.
		     *
		     * @private
		     * @param {Array} data The destination metadata.
		     * @param {Array} source The source metadata.
		     * @returns {Array} Returns `data`.
		     */
		    function mergeData(data, source) {
		      var bitmask = data[1],
		          srcBitmask = source[1],
		          newBitmask = bitmask | srcBitmask,
		          isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);

		      var isCombo =
		        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||
		        ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||
		        ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));

		      // Exit early if metadata can't be merged.
		      if (!(isCommon || isCombo)) {
		        return data;
		      }
		      // Use source `thisArg` if available.
		      if (srcBitmask & WRAP_BIND_FLAG) {
		        data[2] = source[2];
		        // Set when currying a bound function.
		        newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;
		      }
		      // Compose partial arguments.
		      var value = source[3];
		      if (value) {
		        var partials = data[3];
		        data[3] = partials ? composeArgs(partials, value, source[4]) : value;
		        data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
		      }
		      // Compose partial right arguments.
		      value = source[5];
		      if (value) {
		        partials = data[5];
		        data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
		        data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
		      }
		      // Use source `argPos` if available.
		      value = source[7];
		      if (value) {
		        data[7] = value;
		      }
		      // Use source `ary` if it's smaller.
		      if (srcBitmask & WRAP_ARY_FLAG) {
		        data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);
		      }
		      // Use source `arity` if one is not provided.
		      if (data[9] == null) {
		        data[9] = source[9];
		      }
		      // Use source `func` and merge bitmasks.
		      data[0] = source[0];
		      data[1] = newBitmask;

		      return data;
		    }

		    /**
		     * This function is like
		     * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
		     * except that it includes inherited enumerable properties.
		     *
		     * @private
		     * @param {Object} object The object to query.
		     * @returns {Array} Returns the array of property names.
		     */
		    function nativeKeysIn(object) {
		      var result = [];
		      if (object != null) {
		        for (var key in Object(object)) {
		          result.push(key);
		        }
		      }
		      return result;
		    }

		    /**
		     * Converts `value` to a string using `Object.prototype.toString`.
		     *
		     * @private
		     * @param {*} value The value to convert.
		     * @returns {string} Returns the converted string.
		     */
		    function objectToString(value) {
		      return nativeObjectToString.call(value);
		    }

		    /**
		     * A specialized version of `baseRest` which transforms the rest array.
		     *
		     * @private
		     * @param {Function} func The function to apply a rest parameter to.
		     * @param {number} [start=func.length-1] The start position of the rest parameter.
		     * @param {Function} transform The rest array transform.
		     * @returns {Function} Returns the new function.
		     */
		    function overRest(func, start, transform) {
		      start = nativeMax(start === undefined$1 ? (func.length - 1) : start, 0);
		      return function() {
		        var args = arguments,
		            index = -1,
		            length = nativeMax(args.length - start, 0),
		            array = Array(length);

		        while (++index < length) {
		          array[index] = args[start + index];
		        }
		        index = -1;
		        var otherArgs = Array(start + 1);
		        while (++index < start) {
		          otherArgs[index] = args[index];
		        }
		        otherArgs[start] = transform(array);
		        return apply(func, this, otherArgs);
		      };
		    }

		    /**
		     * Gets the parent value at `path` of `object`.
		     *
		     * @private
		     * @param {Object} object The object to query.
		     * @param {Array} path The path to get the parent value of.
		     * @returns {*} Returns the parent value.
		     */
		    function parent(object, path) {
		      return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
		    }

		    /**
		     * Reorder `array` according to the specified indexes where the element at
		     * the first index is assigned as the first element, the element at
		     * the second index is assigned as the second element, and so on.
		     *
		     * @private
		     * @param {Array} array The array to reorder.
		     * @param {Array} indexes The arranged array indexes.
		     * @returns {Array} Returns `array`.
		     */
		    function reorder(array, indexes) {
		      var arrLength = array.length,
		          length = nativeMin(indexes.length, arrLength),
		          oldArray = copyArray(array);

		      while (length--) {
		        var index = indexes[length];
		        array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined$1;
		      }
		      return array;
		    }

		    /**
		     * Gets the value at `key`, unless `key` is "__proto__" or "constructor".
		     *
		     * @private
		     * @param {Object} object The object to query.
		     * @param {string} key The key of the property to get.
		     * @returns {*} Returns the property value.
		     */
		    function safeGet(object, key) {
		      if (key === 'constructor' && typeof object[key] === 'function') {
		        return;
		      }

		      if (key == '__proto__') {
		        return;
		      }

		      return object[key];
		    }

		    /**
		     * Sets metadata for `func`.
		     *
		     * **Note:** If this function becomes hot, i.e. is invoked a lot in a short
		     * period of time, it will trip its breaker and transition to an identity
		     * function to avoid garbage collection pauses in V8. See
		     * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)
		     * for more details.
		     *
		     * @private
		     * @param {Function} func The function to associate metadata with.
		     * @param {*} data The metadata.
		     * @returns {Function} Returns `func`.
		     */
		    var setData = shortOut(baseSetData);

		    /**
		     * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).
		     *
		     * @private
		     * @param {Function} func The function to delay.
		     * @param {number} wait The number of milliseconds to delay invocation.
		     * @returns {number|Object} Returns the timer id or timeout object.
		     */
		    var setTimeout = ctxSetTimeout || function(func, wait) {
		      return root.setTimeout(func, wait);
		    };

		    /**
		     * Sets the `toString` method of `func` to return `string`.
		     *
		     * @private
		     * @param {Function} func The function to modify.
		     * @param {Function} string The `toString` result.
		     * @returns {Function} Returns `func`.
		     */
		    var setToString = shortOut(baseSetToString);

		    /**
		     * Sets the `toString` method of `wrapper` to mimic the source of `reference`
		     * with wrapper details in a comment at the top of the source body.
		     *
		     * @private
		     * @param {Function} wrapper The function to modify.
		     * @param {Function} reference The reference function.
		     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
		     * @returns {Function} Returns `wrapper`.
		     */
		    function setWrapToString(wrapper, reference, bitmask) {
		      var source = (reference + '');
		      return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
		    }

		    /**
		     * Creates a function that'll short out and invoke `identity` instead
		     * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
		     * milliseconds.
		     *
		     * @private
		     * @param {Function} func The function to restrict.
		     * @returns {Function} Returns the new shortable function.
		     */
		    function shortOut(func) {
		      var count = 0,
		          lastCalled = 0;

		      return function() {
		        var stamp = nativeNow(),
		            remaining = HOT_SPAN - (stamp - lastCalled);

		        lastCalled = stamp;
		        if (remaining > 0) {
		          if (++count >= HOT_COUNT) {
		            return arguments[0];
		          }
		        } else {
		          count = 0;
		        }
		        return func.apply(undefined$1, arguments);
		      };
		    }

		    /**
		     * A specialized version of `_.shuffle` which mutates and sets the size of `array`.
		     *
		     * @private
		     * @param {Array} array The array to shuffle.
		     * @param {number} [size=array.length] The size of `array`.
		     * @returns {Array} Returns `array`.
		     */
		    function shuffleSelf(array, size) {
		      var index = -1,
		          length = array.length,
		          lastIndex = length - 1;

		      size = size === undefined$1 ? length : size;
		      while (++index < size) {
		        var rand = baseRandom(index, lastIndex),
		            value = array[rand];

		        array[rand] = array[index];
		        array[index] = value;
		      }
		      array.length = size;
		      return array;
		    }

		    /**
		     * Converts `string` to a property path array.
		     *
		     * @private
		     * @param {string} string The string to convert.
		     * @returns {Array} Returns the property path array.
		     */
		    var stringToPath = memoizeCapped(function(string) {
		      var result = [];
		      if (string.charCodeAt(0) === 46 /* . */) {
		        result.push('');
		      }
		      string.replace(rePropName, function(match, number, quote, subString) {
		        result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
		      });
		      return result;
		    });

		    /**
		     * Converts `value` to a string key if it's not a string or symbol.
		     *
		     * @private
		     * @param {*} value The value to inspect.
		     * @returns {string|symbol} Returns the key.
		     */
		    function toKey(value) {
		      if (typeof value == 'string' || isSymbol(value)) {
		        return value;
		      }
		      var result = (value + '');
		      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
		    }

		    /**
		     * Converts `func` to its source code.
		     *
		     * @private
		     * @param {Function} func The function to convert.
		     * @returns {string} Returns the source code.
		     */
		    function toSource(func) {
		      if (func != null) {
		        try {
		          return funcToString.call(func);
		        } catch (e) {}
		        try {
		          return (func + '');
		        } catch (e) {}
		      }
		      return '';
		    }

		    /**
		     * Updates wrapper `details` based on `bitmask` flags.
		     *
		     * @private
		     * @returns {Array} details The details to modify.
		     * @param {number} bitmask The bitmask flags. See `createWrap` for more details.
		     * @returns {Array} Returns `details`.
		     */
		    function updateWrapDetails(details, bitmask) {
		      arrayEach(wrapFlags, function(pair) {
		        var value = '_.' + pair[0];
		        if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {
		          details.push(value);
		        }
		      });
		      return details.sort();
		    }

		    /**
		     * Creates a clone of `wrapper`.
		     *
		     * @private
		     * @param {Object} wrapper The wrapper to clone.
		     * @returns {Object} Returns the cloned wrapper.
		     */
		    function wrapperClone(wrapper) {
		      if (wrapper instanceof LazyWrapper) {
		        return wrapper.clone();
		      }
		      var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
		      result.__actions__ = copyArray(wrapper.__actions__);
		      result.__index__  = wrapper.__index__;
		      result.__values__ = wrapper.__values__;
		      return result;
		    }

		    /*------------------------------------------------------------------------*/

		    /**
		     * Creates an array of elements split into groups the length of `size`.
		     * If `array` can't be split evenly, the final chunk will be the remaining
		     * elements.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Array
		     * @param {Array} array The array to process.
		     * @param {number} [size=1] The length of each chunk
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {Array} Returns the new array of chunks.
		     * @example
		     *
		     * _.chunk(['a', 'b', 'c', 'd'], 2);
		     * // => [['a', 'b'], ['c', 'd']]
		     *
		     * _.chunk(['a', 'b', 'c', 'd'], 3);
		     * // => [['a', 'b', 'c'], ['d']]
		     */
		    function chunk(array, size, guard) {
		      if ((guard ? isIterateeCall(array, size, guard) : size === undefined$1)) {
		        size = 1;
		      } else {
		        size = nativeMax(toInteger(size), 0);
		      }
		      var length = array == null ? 0 : array.length;
		      if (!length || size < 1) {
		        return [];
		      }
		      var index = 0,
		          resIndex = 0,
		          result = Array(nativeCeil(length / size));

		      while (index < length) {
		        result[resIndex++] = baseSlice(array, index, (index += size));
		      }
		      return result;
		    }

		    /**
		     * Creates an array with all falsey values removed. The values `false`, `null`,
		     * `0`, `""`, `undefined`, and `NaN` are falsey.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Array
		     * @param {Array} array The array to compact.
		     * @returns {Array} Returns the new array of filtered values.
		     * @example
		     *
		     * _.compact([0, 1, false, 2, '', 3]);
		     * // => [1, 2, 3]
		     */
		    function compact(array) {
		      var index = -1,
		          length = array == null ? 0 : array.length,
		          resIndex = 0,
		          result = [];

		      while (++index < length) {
		        var value = array[index];
		        if (value) {
		          result[resIndex++] = value;
		        }
		      }
		      return result;
		    }

		    /**
		     * Creates a new array concatenating `array` with any additional arrays
		     * and/or values.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The array to concatenate.
		     * @param {...*} [values] The values to concatenate.
		     * @returns {Array} Returns the new concatenated array.
		     * @example
		     *
		     * var array = [1];
		     * var other = _.concat(array, 2, [3], [[4]]);
		     *
		     * console.log(other);
		     * // => [1, 2, 3, [4]]
		     *
		     * console.log(array);
		     * // => [1]
		     */
		    function concat() {
		      var length = arguments.length;
		      if (!length) {
		        return [];
		      }
		      var args = Array(length - 1),
		          array = arguments[0],
		          index = length;

		      while (index--) {
		        args[index - 1] = arguments[index];
		      }
		      return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));
		    }

		    /**
		     * Creates an array of `array` values not included in the other given arrays
		     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
		     * for equality comparisons. The order and references of result values are
		     * determined by the first array.
		     *
		     * **Note:** Unlike `_.pullAll`, this method returns a new array.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Array
		     * @param {Array} array The array to inspect.
		     * @param {...Array} [values] The values to exclude.
		     * @returns {Array} Returns the new array of filtered values.
		     * @see _.without, _.xor
		     * @example
		     *
		     * _.difference([2, 1], [2, 3]);
		     * // => [1]
		     */
		    var difference = baseRest(function(array, values) {
		      return isArrayLikeObject(array)
		        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))
		        : [];
		    });

		    /**
		     * This method is like `_.difference` except that it accepts `iteratee` which
		     * is invoked for each element of `array` and `values` to generate the criterion
		     * by which they're compared. The order and references of result values are
		     * determined by the first array. The iteratee is invoked with one argument:
		     * (value).
		     *
		     * **Note:** Unlike `_.pullAllBy`, this method returns a new array.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The array to inspect.
		     * @param {...Array} [values] The values to exclude.
		     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
		     * @returns {Array} Returns the new array of filtered values.
		     * @example
		     *
		     * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
		     * // => [1.2]
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
		     * // => [{ 'x': 2 }]
		     */
		    var differenceBy = baseRest(function(array, values) {
		      var iteratee = last(values);
		      if (isArrayLikeObject(iteratee)) {
		        iteratee = undefined$1;
		      }
		      return isArrayLikeObject(array)
		        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))
		        : [];
		    });

		    /**
		     * This method is like `_.difference` except that it accepts `comparator`
		     * which is invoked to compare elements of `array` to `values`. The order and
		     * references of result values are determined by the first array. The comparator
		     * is invoked with two arguments: (arrVal, othVal).
		     *
		     * **Note:** Unlike `_.pullAllWith`, this method returns a new array.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The array to inspect.
		     * @param {...Array} [values] The values to exclude.
		     * @param {Function} [comparator] The comparator invoked per element.
		     * @returns {Array} Returns the new array of filtered values.
		     * @example
		     *
		     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
		     *
		     * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);
		     * // => [{ 'x': 2, 'y': 1 }]
		     */
		    var differenceWith = baseRest(function(array, values) {
		      var comparator = last(values);
		      if (isArrayLikeObject(comparator)) {
		        comparator = undefined$1;
		      }
		      return isArrayLikeObject(array)
		        ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined$1, comparator)
		        : [];
		    });

		    /**
		     * Creates a slice of `array` with `n` elements dropped from the beginning.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.5.0
		     * @category Array
		     * @param {Array} array The array to query.
		     * @param {number} [n=1] The number of elements to drop.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {Array} Returns the slice of `array`.
		     * @example
		     *
		     * _.drop([1, 2, 3]);
		     * // => [2, 3]
		     *
		     * _.drop([1, 2, 3], 2);
		     * // => [3]
		     *
		     * _.drop([1, 2, 3], 5);
		     * // => []
		     *
		     * _.drop([1, 2, 3], 0);
		     * // => [1, 2, 3]
		     */
		    function drop(array, n, guard) {
		      var length = array == null ? 0 : array.length;
		      if (!length) {
		        return [];
		      }
		      n = (guard || n === undefined$1) ? 1 : toInteger(n);
		      return baseSlice(array, n < 0 ? 0 : n, length);
		    }

		    /**
		     * Creates a slice of `array` with `n` elements dropped from the end.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Array
		     * @param {Array} array The array to query.
		     * @param {number} [n=1] The number of elements to drop.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {Array} Returns the slice of `array`.
		     * @example
		     *
		     * _.dropRight([1, 2, 3]);
		     * // => [1, 2]
		     *
		     * _.dropRight([1, 2, 3], 2);
		     * // => [1]
		     *
		     * _.dropRight([1, 2, 3], 5);
		     * // => []
		     *
		     * _.dropRight([1, 2, 3], 0);
		     * // => [1, 2, 3]
		     */
		    function dropRight(array, n, guard) {
		      var length = array == null ? 0 : array.length;
		      if (!length) {
		        return [];
		      }
		      n = (guard || n === undefined$1) ? 1 : toInteger(n);
		      n = length - n;
		      return baseSlice(array, 0, n < 0 ? 0 : n);
		    }

		    /**
		     * Creates a slice of `array` excluding elements dropped from the end.
		     * Elements are dropped until `predicate` returns falsey. The predicate is
		     * invoked with three arguments: (value, index, array).
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Array
		     * @param {Array} array The array to query.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @returns {Array} Returns the slice of `array`.
		     * @example
		     *
		     * var users = [
		     *   { 'user': 'barney',  'active': true },
		     *   { 'user': 'fred',    'active': false },
		     *   { 'user': 'pebbles', 'active': false }
		     * ];
		     *
		     * _.dropRightWhile(users, function(o) { return !o.active; });
		     * // => objects for ['barney']
		     *
		     * // The `_.matches` iteratee shorthand.
		     * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });
		     * // => objects for ['barney', 'fred']
		     *
		     * // The `_.matchesProperty` iteratee shorthand.
		     * _.dropRightWhile(users, ['active', false]);
		     * // => objects for ['barney']
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.dropRightWhile(users, 'active');
		     * // => objects for ['barney', 'fred', 'pebbles']
		     */
		    function dropRightWhile(array, predicate) {
		      return (array && array.length)
		        ? baseWhile(array, getIteratee(predicate, 3), true, true)
		        : [];
		    }

		    /**
		     * Creates a slice of `array` excluding elements dropped from the beginning.
		     * Elements are dropped until `predicate` returns falsey. The predicate is
		     * invoked with three arguments: (value, index, array).
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Array
		     * @param {Array} array The array to query.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @returns {Array} Returns the slice of `array`.
		     * @example
		     *
		     * var users = [
		     *   { 'user': 'barney',  'active': false },
		     *   { 'user': 'fred',    'active': false },
		     *   { 'user': 'pebbles', 'active': true }
		     * ];
		     *
		     * _.dropWhile(users, function(o) { return !o.active; });
		     * // => objects for ['pebbles']
		     *
		     * // The `_.matches` iteratee shorthand.
		     * _.dropWhile(users, { 'user': 'barney', 'active': false });
		     * // => objects for ['fred', 'pebbles']
		     *
		     * // The `_.matchesProperty` iteratee shorthand.
		     * _.dropWhile(users, ['active', false]);
		     * // => objects for ['pebbles']
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.dropWhile(users, 'active');
		     * // => objects for ['barney', 'fred', 'pebbles']
		     */
		    function dropWhile(array, predicate) {
		      return (array && array.length)
		        ? baseWhile(array, getIteratee(predicate, 3), true)
		        : [];
		    }

		    /**
		     * Fills elements of `array` with `value` from `start` up to, but not
		     * including, `end`.
		     *
		     * **Note:** This method mutates `array`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.2.0
		     * @category Array
		     * @param {Array} array The array to fill.
		     * @param {*} value The value to fill `array` with.
		     * @param {number} [start=0] The start position.
		     * @param {number} [end=array.length] The end position.
		     * @returns {Array} Returns `array`.
		     * @example
		     *
		     * var array = [1, 2, 3];
		     *
		     * _.fill(array, 'a');
		     * console.log(array);
		     * // => ['a', 'a', 'a']
		     *
		     * _.fill(Array(3), 2);
		     * // => [2, 2, 2]
		     *
		     * _.fill([4, 6, 8, 10], '*', 1, 3);
		     * // => [4, '*', '*', 10]
		     */
		    function fill(array, value, start, end) {
		      var length = array == null ? 0 : array.length;
		      if (!length) {
		        return [];
		      }
		      if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {
		        start = 0;
		        end = length;
		      }
		      return baseFill(array, value, start, end);
		    }

		    /**
		     * This method is like `_.find` except that it returns the index of the first
		     * element `predicate` returns truthy for instead of the element itself.
		     *
		     * @static
		     * @memberOf _
		     * @since 1.1.0
		     * @category Array
		     * @param {Array} array The array to inspect.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @param {number} [fromIndex=0] The index to search from.
		     * @returns {number} Returns the index of the found element, else `-1`.
		     * @example
		     *
		     * var users = [
		     *   { 'user': 'barney',  'active': false },
		     *   { 'user': 'fred',    'active': false },
		     *   { 'user': 'pebbles', 'active': true }
		     * ];
		     *
		     * _.findIndex(users, function(o) { return o.user == 'barney'; });
		     * // => 0
		     *
		     * // The `_.matches` iteratee shorthand.
		     * _.findIndex(users, { 'user': 'fred', 'active': false });
		     * // => 1
		     *
		     * // The `_.matchesProperty` iteratee shorthand.
		     * _.findIndex(users, ['active', false]);
		     * // => 0
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.findIndex(users, 'active');
		     * // => 2
		     */
		    function findIndex(array, predicate, fromIndex) {
		      var length = array == null ? 0 : array.length;
		      if (!length) {
		        return -1;
		      }
		      var index = fromIndex == null ? 0 : toInteger(fromIndex);
		      if (index < 0) {
		        index = nativeMax(length + index, 0);
		      }
		      return baseFindIndex(array, getIteratee(predicate, 3), index);
		    }

		    /**
		     * This method is like `_.findIndex` except that it iterates over elements
		     * of `collection` from right to left.
		     *
		     * @static
		     * @memberOf _
		     * @since 2.0.0
		     * @category Array
		     * @param {Array} array The array to inspect.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @param {number} [fromIndex=array.length-1] The index to search from.
		     * @returns {number} Returns the index of the found element, else `-1`.
		     * @example
		     *
		     * var users = [
		     *   { 'user': 'barney',  'active': true },
		     *   { 'user': 'fred',    'active': false },
		     *   { 'user': 'pebbles', 'active': false }
		     * ];
		     *
		     * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
		     * // => 2
		     *
		     * // The `_.matches` iteratee shorthand.
		     * _.findLastIndex(users, { 'user': 'barney', 'active': true });
		     * // => 0
		     *
		     * // The `_.matchesProperty` iteratee shorthand.
		     * _.findLastIndex(users, ['active', false]);
		     * // => 2
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.findLastIndex(users, 'active');
		     * // => 0
		     */
		    function findLastIndex(array, predicate, fromIndex) {
		      var length = array == null ? 0 : array.length;
		      if (!length) {
		        return -1;
		      }
		      var index = length - 1;
		      if (fromIndex !== undefined$1) {
		        index = toInteger(fromIndex);
		        index = fromIndex < 0
		          ? nativeMax(length + index, 0)
		          : nativeMin(index, length - 1);
		      }
		      return baseFindIndex(array, getIteratee(predicate, 3), index, true);
		    }

		    /**
		     * Flattens `array` a single level deep.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Array
		     * @param {Array} array The array to flatten.
		     * @returns {Array} Returns the new flattened array.
		     * @example
		     *
		     * _.flatten([1, [2, [3, [4]], 5]]);
		     * // => [1, 2, [3, [4]], 5]
		     */
		    function flatten(array) {
		      var length = array == null ? 0 : array.length;
		      return length ? baseFlatten(array, 1) : [];
		    }

		    /**
		     * Recursively flattens `array`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Array
		     * @param {Array} array The array to flatten.
		     * @returns {Array} Returns the new flattened array.
		     * @example
		     *
		     * _.flattenDeep([1, [2, [3, [4]], 5]]);
		     * // => [1, 2, 3, 4, 5]
		     */
		    function flattenDeep(array) {
		      var length = array == null ? 0 : array.length;
		      return length ? baseFlatten(array, INFINITY) : [];
		    }

		    /**
		     * Recursively flatten `array` up to `depth` times.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.4.0
		     * @category Array
		     * @param {Array} array The array to flatten.
		     * @param {number} [depth=1] The maximum recursion depth.
		     * @returns {Array} Returns the new flattened array.
		     * @example
		     *
		     * var array = [1, [2, [3, [4]], 5]];
		     *
		     * _.flattenDepth(array, 1);
		     * // => [1, 2, [3, [4]], 5]
		     *
		     * _.flattenDepth(array, 2);
		     * // => [1, 2, 3, [4], 5]
		     */
		    function flattenDepth(array, depth) {
		      var length = array == null ? 0 : array.length;
		      if (!length) {
		        return [];
		      }
		      depth = depth === undefined$1 ? 1 : toInteger(depth);
		      return baseFlatten(array, depth);
		    }

		    /**
		     * The inverse of `_.toPairs`; this method returns an object composed
		     * from key-value `pairs`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} pairs The key-value pairs.
		     * @returns {Object} Returns the new object.
		     * @example
		     *
		     * _.fromPairs([['a', 1], ['b', 2]]);
		     * // => { 'a': 1, 'b': 2 }
		     */
		    function fromPairs(pairs) {
		      var index = -1,
		          length = pairs == null ? 0 : pairs.length,
		          result = {};

		      while (++index < length) {
		        var pair = pairs[index];
		        result[pair[0]] = pair[1];
		      }
		      return result;
		    }

		    /**
		     * Gets the first element of `array`.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @alias first
		     * @category Array
		     * @param {Array} array The array to query.
		     * @returns {*} Returns the first element of `array`.
		     * @example
		     *
		     * _.head([1, 2, 3]);
		     * // => 1
		     *
		     * _.head([]);
		     * // => undefined
		     */
		    function head(array) {
		      return (array && array.length) ? array[0] : undefined$1;
		    }

		    /**
		     * Gets the index at which the first occurrence of `value` is found in `array`
		     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
		     * for equality comparisons. If `fromIndex` is negative, it's used as the
		     * offset from the end of `array`.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Array
		     * @param {Array} array The array to inspect.
		     * @param {*} value The value to search for.
		     * @param {number} [fromIndex=0] The index to search from.
		     * @returns {number} Returns the index of the matched value, else `-1`.
		     * @example
		     *
		     * _.indexOf([1, 2, 1, 2], 2);
		     * // => 1
		     *
		     * // Search from the `fromIndex`.
		     * _.indexOf([1, 2, 1, 2], 2, 2);
		     * // => 3
		     */
		    function indexOf(array, value, fromIndex) {
		      var length = array == null ? 0 : array.length;
		      if (!length) {
		        return -1;
		      }
		      var index = fromIndex == null ? 0 : toInteger(fromIndex);
		      if (index < 0) {
		        index = nativeMax(length + index, 0);
		      }
		      return baseIndexOf(array, value, index);
		    }

		    /**
		     * Gets all but the last element of `array`.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Array
		     * @param {Array} array The array to query.
		     * @returns {Array} Returns the slice of `array`.
		     * @example
		     *
		     * _.initial([1, 2, 3]);
		     * // => [1, 2]
		     */
		    function initial(array) {
		      var length = array == null ? 0 : array.length;
		      return length ? baseSlice(array, 0, -1) : [];
		    }

		    /**
		     * Creates an array of unique values that are included in all given arrays
		     * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
		     * for equality comparisons. The order and references of result values are
		     * determined by the first array.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Array
		     * @param {...Array} [arrays] The arrays to inspect.
		     * @returns {Array} Returns the new array of intersecting values.
		     * @example
		     *
		     * _.intersection([2, 1], [2, 3]);
		     * // => [2]
		     */
		    var intersection = baseRest(function(arrays) {
		      var mapped = arrayMap(arrays, castArrayLikeObject);
		      return (mapped.length && mapped[0] === arrays[0])
		        ? baseIntersection(mapped)
		        : [];
		    });

		    /**
		     * This method is like `_.intersection` except that it accepts `iteratee`
		     * which is invoked for each element of each `arrays` to generate the criterion
		     * by which they're compared. The order and references of result values are
		     * determined by the first array. The iteratee is invoked with one argument:
		     * (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {...Array} [arrays] The arrays to inspect.
		     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
		     * @returns {Array} Returns the new array of intersecting values.
		     * @example
		     *
		     * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
		     * // => [2.1]
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
		     * // => [{ 'x': 1 }]
		     */
		    var intersectionBy = baseRest(function(arrays) {
		      var iteratee = last(arrays),
		          mapped = arrayMap(arrays, castArrayLikeObject);

		      if (iteratee === last(mapped)) {
		        iteratee = undefined$1;
		      } else {
		        mapped.pop();
		      }
		      return (mapped.length && mapped[0] === arrays[0])
		        ? baseIntersection(mapped, getIteratee(iteratee, 2))
		        : [];
		    });

		    /**
		     * This method is like `_.intersection` except that it accepts `comparator`
		     * which is invoked to compare elements of `arrays`. The order and references
		     * of result values are determined by the first array. The comparator is
		     * invoked with two arguments: (arrVal, othVal).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {...Array} [arrays] The arrays to inspect.
		     * @param {Function} [comparator] The comparator invoked per element.
		     * @returns {Array} Returns the new array of intersecting values.
		     * @example
		     *
		     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
		     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
		     *
		     * _.intersectionWith(objects, others, _.isEqual);
		     * // => [{ 'x': 1, 'y': 2 }]
		     */
		    var intersectionWith = baseRest(function(arrays) {
		      var comparator = last(arrays),
		          mapped = arrayMap(arrays, castArrayLikeObject);

		      comparator = typeof comparator == 'function' ? comparator : undefined$1;
		      if (comparator) {
		        mapped.pop();
		      }
		      return (mapped.length && mapped[0] === arrays[0])
		        ? baseIntersection(mapped, undefined$1, comparator)
		        : [];
		    });

		    /**
		     * Converts all elements in `array` into a string separated by `separator`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The array to convert.
		     * @param {string} [separator=','] The element separator.
		     * @returns {string} Returns the joined string.
		     * @example
		     *
		     * _.join(['a', 'b', 'c'], '~');
		     * // => 'a~b~c'
		     */
		    function join(array, separator) {
		      return array == null ? '' : nativeJoin.call(array, separator);
		    }

		    /**
		     * Gets the last element of `array`.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Array
		     * @param {Array} array The array to query.
		     * @returns {*} Returns the last element of `array`.
		     * @example
		     *
		     * _.last([1, 2, 3]);
		     * // => 3
		     */
		    function last(array) {
		      var length = array == null ? 0 : array.length;
		      return length ? array[length - 1] : undefined$1;
		    }

		    /**
		     * This method is like `_.indexOf` except that it iterates over elements of
		     * `array` from right to left.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Array
		     * @param {Array} array The array to inspect.
		     * @param {*} value The value to search for.
		     * @param {number} [fromIndex=array.length-1] The index to search from.
		     * @returns {number} Returns the index of the matched value, else `-1`.
		     * @example
		     *
		     * _.lastIndexOf([1, 2, 1, 2], 2);
		     * // => 3
		     *
		     * // Search from the `fromIndex`.
		     * _.lastIndexOf([1, 2, 1, 2], 2, 2);
		     * // => 1
		     */
		    function lastIndexOf(array, value, fromIndex) {
		      var length = array == null ? 0 : array.length;
		      if (!length) {
		        return -1;
		      }
		      var index = length;
		      if (fromIndex !== undefined$1) {
		        index = toInteger(fromIndex);
		        index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);
		      }
		      return value === value
		        ? strictLastIndexOf(array, value, index)
		        : baseFindIndex(array, baseIsNaN, index, true);
		    }

		    /**
		     * Gets the element at index `n` of `array`. If `n` is negative, the nth
		     * element from the end is returned.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.11.0
		     * @category Array
		     * @param {Array} array The array to query.
		     * @param {number} [n=0] The index of the element to return.
		     * @returns {*} Returns the nth element of `array`.
		     * @example
		     *
		     * var array = ['a', 'b', 'c', 'd'];
		     *
		     * _.nth(array, 1);
		     * // => 'b'
		     *
		     * _.nth(array, -2);
		     * // => 'c';
		     */
		    function nth(array, n) {
		      return (array && array.length) ? baseNth(array, toInteger(n)) : undefined$1;
		    }

		    /**
		     * Removes all given values from `array` using
		     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
		     * for equality comparisons.
		     *
		     * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`
		     * to remove elements from an array by predicate.
		     *
		     * @static
		     * @memberOf _
		     * @since 2.0.0
		     * @category Array
		     * @param {Array} array The array to modify.
		     * @param {...*} [values] The values to remove.
		     * @returns {Array} Returns `array`.
		     * @example
		     *
		     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
		     *
		     * _.pull(array, 'a', 'c');
		     * console.log(array);
		     * // => ['b', 'b']
		     */
		    var pull = baseRest(pullAll);

		    /**
		     * This method is like `_.pull` except that it accepts an array of values to remove.
		     *
		     * **Note:** Unlike `_.difference`, this method mutates `array`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The array to modify.
		     * @param {Array} values The values to remove.
		     * @returns {Array} Returns `array`.
		     * @example
		     *
		     * var array = ['a', 'b', 'c', 'a', 'b', 'c'];
		     *
		     * _.pullAll(array, ['a', 'c']);
		     * console.log(array);
		     * // => ['b', 'b']
		     */
		    function pullAll(array, values) {
		      return (array && array.length && values && values.length)
		        ? basePullAll(array, values)
		        : array;
		    }

		    /**
		     * This method is like `_.pullAll` except that it accepts `iteratee` which is
		     * invoked for each element of `array` and `values` to generate the criterion
		     * by which they're compared. The iteratee is invoked with one argument: (value).
		     *
		     * **Note:** Unlike `_.differenceBy`, this method mutates `array`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The array to modify.
		     * @param {Array} values The values to remove.
		     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
		     * @returns {Array} Returns `array`.
		     * @example
		     *
		     * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];
		     *
		     * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
		     * console.log(array);
		     * // => [{ 'x': 2 }]
		     */
		    function pullAllBy(array, values, iteratee) {
		      return (array && array.length && values && values.length)
		        ? basePullAll(array, values, getIteratee(iteratee, 2))
		        : array;
		    }

		    /**
		     * This method is like `_.pullAll` except that it accepts `comparator` which
		     * is invoked to compare elements of `array` to `values`. The comparator is
		     * invoked with two arguments: (arrVal, othVal).
		     *
		     * **Note:** Unlike `_.differenceWith`, this method mutates `array`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.6.0
		     * @category Array
		     * @param {Array} array The array to modify.
		     * @param {Array} values The values to remove.
		     * @param {Function} [comparator] The comparator invoked per element.
		     * @returns {Array} Returns `array`.
		     * @example
		     *
		     * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];
		     *
		     * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
		     * console.log(array);
		     * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]
		     */
		    function pullAllWith(array, values, comparator) {
		      return (array && array.length && values && values.length)
		        ? basePullAll(array, values, undefined$1, comparator)
		        : array;
		    }

		    /**
		     * Removes elements from `array` corresponding to `indexes` and returns an
		     * array of removed elements.
		     *
		     * **Note:** Unlike `_.at`, this method mutates `array`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Array
		     * @param {Array} array The array to modify.
		     * @param {...(number|number[])} [indexes] The indexes of elements to remove.
		     * @returns {Array} Returns the new array of removed elements.
		     * @example
		     *
		     * var array = ['a', 'b', 'c', 'd'];
		     * var pulled = _.pullAt(array, [1, 3]);
		     *
		     * console.log(array);
		     * // => ['a', 'c']
		     *
		     * console.log(pulled);
		     * // => ['b', 'd']
		     */
		    var pullAt = flatRest(function(array, indexes) {
		      var length = array == null ? 0 : array.length,
		          result = baseAt(array, indexes);

		      basePullAt(array, arrayMap(indexes, function(index) {
		        return isIndex(index, length) ? +index : index;
		      }).sort(compareAscending));

		      return result;
		    });

		    /**
		     * Removes all elements from `array` that `predicate` returns truthy for
		     * and returns an array of the removed elements. The predicate is invoked
		     * with three arguments: (value, index, array).
		     *
		     * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`
		     * to pull elements from an array by value.
		     *
		     * @static
		     * @memberOf _
		     * @since 2.0.0
		     * @category Array
		     * @param {Array} array The array to modify.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @returns {Array} Returns the new array of removed elements.
		     * @example
		     *
		     * var array = [1, 2, 3, 4];
		     * var evens = _.remove(array, function(n) {
		     *   return n % 2 == 0;
		     * });
		     *
		     * console.log(array);
		     * // => [1, 3]
		     *
		     * console.log(evens);
		     * // => [2, 4]
		     */
		    function remove(array, predicate) {
		      var result = [];
		      if (!(array && array.length)) {
		        return result;
		      }
		      var index = -1,
		          indexes = [],
		          length = array.length;

		      predicate = getIteratee(predicate, 3);
		      while (++index < length) {
		        var value = array[index];
		        if (predicate(value, index, array)) {
		          result.push(value);
		          indexes.push(index);
		        }
		      }
		      basePullAt(array, indexes);
		      return result;
		    }

		    /**
		     * Reverses `array` so that the first element becomes the last, the second
		     * element becomes the second to last, and so on.
		     *
		     * **Note:** This method mutates `array` and is based on
		     * [`Array#reverse`](https://mdn.io/Array/reverse).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The array to modify.
		     * @returns {Array} Returns `array`.
		     * @example
		     *
		     * var array = [1, 2, 3];
		     *
		     * _.reverse(array);
		     * // => [3, 2, 1]
		     *
		     * console.log(array);
		     * // => [3, 2, 1]
		     */
		    function reverse(array) {
		      return array == null ? array : nativeReverse.call(array);
		    }

		    /**
		     * Creates a slice of `array` from `start` up to, but not including, `end`.
		     *
		     * **Note:** This method is used instead of
		     * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are
		     * returned.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Array
		     * @param {Array} array The array to slice.
		     * @param {number} [start=0] The start position.
		     * @param {number} [end=array.length] The end position.
		     * @returns {Array} Returns the slice of `array`.
		     */
		    function slice(array, start, end) {
		      var length = array == null ? 0 : array.length;
		      if (!length) {
		        return [];
		      }
		      if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {
		        start = 0;
		        end = length;
		      }
		      else {
		        start = start == null ? 0 : toInteger(start);
		        end = end === undefined$1 ? length : toInteger(end);
		      }
		      return baseSlice(array, start, end);
		    }

		    /**
		     * Uses a binary search to determine the lowest index at which `value`
		     * should be inserted into `array` in order to maintain its sort order.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Array
		     * @param {Array} array The sorted array to inspect.
		     * @param {*} value The value to evaluate.
		     * @returns {number} Returns the index at which `value` should be inserted
		     *  into `array`.
		     * @example
		     *
		     * _.sortedIndex([30, 50], 40);
		     * // => 1
		     */
		    function sortedIndex(array, value) {
		      return baseSortedIndex(array, value);
		    }

		    /**
		     * This method is like `_.sortedIndex` except that it accepts `iteratee`
		     * which is invoked for `value` and each element of `array` to compute their
		     * sort ranking. The iteratee is invoked with one argument: (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The sorted array to inspect.
		     * @param {*} value The value to evaluate.
		     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
		     * @returns {number} Returns the index at which `value` should be inserted
		     *  into `array`.
		     * @example
		     *
		     * var objects = [{ 'x': 4 }, { 'x': 5 }];
		     *
		     * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
		     * // => 0
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.sortedIndexBy(objects, { 'x': 4 }, 'x');
		     * // => 0
		     */
		    function sortedIndexBy(array, value, iteratee) {
		      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));
		    }

		    /**
		     * This method is like `_.indexOf` except that it performs a binary
		     * search on a sorted `array`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The array to inspect.
		     * @param {*} value The value to search for.
		     * @returns {number} Returns the index of the matched value, else `-1`.
		     * @example
		     *
		     * _.sortedIndexOf([4, 5, 5, 5, 6], 5);
		     * // => 1
		     */
		    function sortedIndexOf(array, value) {
		      var length = array == null ? 0 : array.length;
		      if (length) {
		        var index = baseSortedIndex(array, value);
		        if (index < length && eq(array[index], value)) {
		          return index;
		        }
		      }
		      return -1;
		    }

		    /**
		     * This method is like `_.sortedIndex` except that it returns the highest
		     * index at which `value` should be inserted into `array` in order to
		     * maintain its sort order.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Array
		     * @param {Array} array The sorted array to inspect.
		     * @param {*} value The value to evaluate.
		     * @returns {number} Returns the index at which `value` should be inserted
		     *  into `array`.
		     * @example
		     *
		     * _.sortedLastIndex([4, 5, 5, 5, 6], 5);
		     * // => 4
		     */
		    function sortedLastIndex(array, value) {
		      return baseSortedIndex(array, value, true);
		    }

		    /**
		     * This method is like `_.sortedLastIndex` except that it accepts `iteratee`
		     * which is invoked for `value` and each element of `array` to compute their
		     * sort ranking. The iteratee is invoked with one argument: (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The sorted array to inspect.
		     * @param {*} value The value to evaluate.
		     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
		     * @returns {number} Returns the index at which `value` should be inserted
		     *  into `array`.
		     * @example
		     *
		     * var objects = [{ 'x': 4 }, { 'x': 5 }];
		     *
		     * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
		     * // => 1
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
		     * // => 1
		     */
		    function sortedLastIndexBy(array, value, iteratee) {
		      return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);
		    }

		    /**
		     * This method is like `_.lastIndexOf` except that it performs a binary
		     * search on a sorted `array`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The array to inspect.
		     * @param {*} value The value to search for.
		     * @returns {number} Returns the index of the matched value, else `-1`.
		     * @example
		     *
		     * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
		     * // => 3
		     */
		    function sortedLastIndexOf(array, value) {
		      var length = array == null ? 0 : array.length;
		      if (length) {
		        var index = baseSortedIndex(array, value, true) - 1;
		        if (eq(array[index], value)) {
		          return index;
		        }
		      }
		      return -1;
		    }

		    /**
		     * This method is like `_.uniq` except that it's designed and optimized
		     * for sorted arrays.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The array to inspect.
		     * @returns {Array} Returns the new duplicate free array.
		     * @example
		     *
		     * _.sortedUniq([1, 1, 2]);
		     * // => [1, 2]
		     */
		    function sortedUniq(array) {
		      return (array && array.length)
		        ? baseSortedUniq(array)
		        : [];
		    }

		    /**
		     * This method is like `_.uniqBy` except that it's designed and optimized
		     * for sorted arrays.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The array to inspect.
		     * @param {Function} [iteratee] The iteratee invoked per element.
		     * @returns {Array} Returns the new duplicate free array.
		     * @example
		     *
		     * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
		     * // => [1.1, 2.3]
		     */
		    function sortedUniqBy(array, iteratee) {
		      return (array && array.length)
		        ? baseSortedUniq(array, getIteratee(iteratee, 2))
		        : [];
		    }

		    /**
		     * Gets all but the first element of `array`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The array to query.
		     * @returns {Array} Returns the slice of `array`.
		     * @example
		     *
		     * _.tail([1, 2, 3]);
		     * // => [2, 3]
		     */
		    function tail(array) {
		      var length = array == null ? 0 : array.length;
		      return length ? baseSlice(array, 1, length) : [];
		    }

		    /**
		     * Creates a slice of `array` with `n` elements taken from the beginning.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Array
		     * @param {Array} array The array to query.
		     * @param {number} [n=1] The number of elements to take.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {Array} Returns the slice of `array`.
		     * @example
		     *
		     * _.take([1, 2, 3]);
		     * // => [1]
		     *
		     * _.take([1, 2, 3], 2);
		     * // => [1, 2]
		     *
		     * _.take([1, 2, 3], 5);
		     * // => [1, 2, 3]
		     *
		     * _.take([1, 2, 3], 0);
		     * // => []
		     */
		    function take(array, n, guard) {
		      if (!(array && array.length)) {
		        return [];
		      }
		      n = (guard || n === undefined$1) ? 1 : toInteger(n);
		      return baseSlice(array, 0, n < 0 ? 0 : n);
		    }

		    /**
		     * Creates a slice of `array` with `n` elements taken from the end.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Array
		     * @param {Array} array The array to query.
		     * @param {number} [n=1] The number of elements to take.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {Array} Returns the slice of `array`.
		     * @example
		     *
		     * _.takeRight([1, 2, 3]);
		     * // => [3]
		     *
		     * _.takeRight([1, 2, 3], 2);
		     * // => [2, 3]
		     *
		     * _.takeRight([1, 2, 3], 5);
		     * // => [1, 2, 3]
		     *
		     * _.takeRight([1, 2, 3], 0);
		     * // => []
		     */
		    function takeRight(array, n, guard) {
		      var length = array == null ? 0 : array.length;
		      if (!length) {
		        return [];
		      }
		      n = (guard || n === undefined$1) ? 1 : toInteger(n);
		      n = length - n;
		      return baseSlice(array, n < 0 ? 0 : n, length);
		    }

		    /**
		     * Creates a slice of `array` with elements taken from the end. Elements are
		     * taken until `predicate` returns falsey. The predicate is invoked with
		     * three arguments: (value, index, array).
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Array
		     * @param {Array} array The array to query.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @returns {Array} Returns the slice of `array`.
		     * @example
		     *
		     * var users = [
		     *   { 'user': 'barney',  'active': true },
		     *   { 'user': 'fred',    'active': false },
		     *   { 'user': 'pebbles', 'active': false }
		     * ];
		     *
		     * _.takeRightWhile(users, function(o) { return !o.active; });
		     * // => objects for ['fred', 'pebbles']
		     *
		     * // The `_.matches` iteratee shorthand.
		     * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
		     * // => objects for ['pebbles']
		     *
		     * // The `_.matchesProperty` iteratee shorthand.
		     * _.takeRightWhile(users, ['active', false]);
		     * // => objects for ['fred', 'pebbles']
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.takeRightWhile(users, 'active');
		     * // => []
		     */
		    function takeRightWhile(array, predicate) {
		      return (array && array.length)
		        ? baseWhile(array, getIteratee(predicate, 3), false, true)
		        : [];
		    }

		    /**
		     * Creates a slice of `array` with elements taken from the beginning. Elements
		     * are taken until `predicate` returns falsey. The predicate is invoked with
		     * three arguments: (value, index, array).
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Array
		     * @param {Array} array The array to query.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @returns {Array} Returns the slice of `array`.
		     * @example
		     *
		     * var users = [
		     *   { 'user': 'barney',  'active': false },
		     *   { 'user': 'fred',    'active': false },
		     *   { 'user': 'pebbles', 'active': true }
		     * ];
		     *
		     * _.takeWhile(users, function(o) { return !o.active; });
		     * // => objects for ['barney', 'fred']
		     *
		     * // The `_.matches` iteratee shorthand.
		     * _.takeWhile(users, { 'user': 'barney', 'active': false });
		     * // => objects for ['barney']
		     *
		     * // The `_.matchesProperty` iteratee shorthand.
		     * _.takeWhile(users, ['active', false]);
		     * // => objects for ['barney', 'fred']
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.takeWhile(users, 'active');
		     * // => []
		     */
		    function takeWhile(array, predicate) {
		      return (array && array.length)
		        ? baseWhile(array, getIteratee(predicate, 3))
		        : [];
		    }

		    /**
		     * Creates an array of unique values, in order, from all given arrays using
		     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
		     * for equality comparisons.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Array
		     * @param {...Array} [arrays] The arrays to inspect.
		     * @returns {Array} Returns the new array of combined values.
		     * @example
		     *
		     * _.union([2], [1, 2]);
		     * // => [2, 1]
		     */
		    var union = baseRest(function(arrays) {
		      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
		    });

		    /**
		     * This method is like `_.union` except that it accepts `iteratee` which is
		     * invoked for each element of each `arrays` to generate the criterion by
		     * which uniqueness is computed. Result values are chosen from the first
		     * array in which the value occurs. The iteratee is invoked with one argument:
		     * (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {...Array} [arrays] The arrays to inspect.
		     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
		     * @returns {Array} Returns the new array of combined values.
		     * @example
		     *
		     * _.unionBy([2.1], [1.2, 2.3], Math.floor);
		     * // => [2.1, 1.2]
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
		     * // => [{ 'x': 1 }, { 'x': 2 }]
		     */
		    var unionBy = baseRest(function(arrays) {
		      var iteratee = last(arrays);
		      if (isArrayLikeObject(iteratee)) {
		        iteratee = undefined$1;
		      }
		      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));
		    });

		    /**
		     * This method is like `_.union` except that it accepts `comparator` which
		     * is invoked to compare elements of `arrays`. Result values are chosen from
		     * the first array in which the value occurs. The comparator is invoked
		     * with two arguments: (arrVal, othVal).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {...Array} [arrays] The arrays to inspect.
		     * @param {Function} [comparator] The comparator invoked per element.
		     * @returns {Array} Returns the new array of combined values.
		     * @example
		     *
		     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
		     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
		     *
		     * _.unionWith(objects, others, _.isEqual);
		     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
		     */
		    var unionWith = baseRest(function(arrays) {
		      var comparator = last(arrays);
		      comparator = typeof comparator == 'function' ? comparator : undefined$1;
		      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined$1, comparator);
		    });

		    /**
		     * Creates a duplicate-free version of an array, using
		     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
		     * for equality comparisons, in which only the first occurrence of each element
		     * is kept. The order of result values is determined by the order they occur
		     * in the array.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Array
		     * @param {Array} array The array to inspect.
		     * @returns {Array} Returns the new duplicate free array.
		     * @example
		     *
		     * _.uniq([2, 1, 2]);
		     * // => [2, 1]
		     */
		    function uniq(array) {
		      return (array && array.length) ? baseUniq(array) : [];
		    }

		    /**
		     * This method is like `_.uniq` except that it accepts `iteratee` which is
		     * invoked for each element in `array` to generate the criterion by which
		     * uniqueness is computed. The order of result values is determined by the
		     * order they occur in the array. The iteratee is invoked with one argument:
		     * (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The array to inspect.
		     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
		     * @returns {Array} Returns the new duplicate free array.
		     * @example
		     *
		     * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
		     * // => [2.1, 1.2]
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
		     * // => [{ 'x': 1 }, { 'x': 2 }]
		     */
		    function uniqBy(array, iteratee) {
		      return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];
		    }

		    /**
		     * This method is like `_.uniq` except that it accepts `comparator` which
		     * is invoked to compare elements of `array`. The order of result values is
		     * determined by the order they occur in the array.The comparator is invoked
		     * with two arguments: (arrVal, othVal).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {Array} array The array to inspect.
		     * @param {Function} [comparator] The comparator invoked per element.
		     * @returns {Array} Returns the new duplicate free array.
		     * @example
		     *
		     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];
		     *
		     * _.uniqWith(objects, _.isEqual);
		     * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]
		     */
		    function uniqWith(array, comparator) {
		      comparator = typeof comparator == 'function' ? comparator : undefined$1;
		      return (array && array.length) ? baseUniq(array, undefined$1, comparator) : [];
		    }

		    /**
		     * This method is like `_.zip` except that it accepts an array of grouped
		     * elements and creates an array regrouping the elements to their pre-zip
		     * configuration.
		     *
		     * @static
		     * @memberOf _
		     * @since 1.2.0
		     * @category Array
		     * @param {Array} array The array of grouped elements to process.
		     * @returns {Array} Returns the new array of regrouped elements.
		     * @example
		     *
		     * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);
		     * // => [['a', 1, true], ['b', 2, false]]
		     *
		     * _.unzip(zipped);
		     * // => [['a', 'b'], [1, 2], [true, false]]
		     */
		    function unzip(array) {
		      if (!(array && array.length)) {
		        return [];
		      }
		      var length = 0;
		      array = arrayFilter(array, function(group) {
		        if (isArrayLikeObject(group)) {
		          length = nativeMax(group.length, length);
		          return true;
		        }
		      });
		      return baseTimes(length, function(index) {
		        return arrayMap(array, baseProperty(index));
		      });
		    }

		    /**
		     * This method is like `_.unzip` except that it accepts `iteratee` to specify
		     * how regrouped values should be combined. The iteratee is invoked with the
		     * elements of each group: (...group).
		     *
		     * @static
		     * @memberOf _
		     * @since 3.8.0
		     * @category Array
		     * @param {Array} array The array of grouped elements to process.
		     * @param {Function} [iteratee=_.identity] The function to combine
		     *  regrouped values.
		     * @returns {Array} Returns the new array of regrouped elements.
		     * @example
		     *
		     * var zipped = _.zip([1, 2], [10, 20], [100, 200]);
		     * // => [[1, 10, 100], [2, 20, 200]]
		     *
		     * _.unzipWith(zipped, _.add);
		     * // => [3, 30, 300]
		     */
		    function unzipWith(array, iteratee) {
		      if (!(array && array.length)) {
		        return [];
		      }
		      var result = unzip(array);
		      if (iteratee == null) {
		        return result;
		      }
		      return arrayMap(result, function(group) {
		        return apply(iteratee, undefined$1, group);
		      });
		    }

		    /**
		     * Creates an array excluding all given values using
		     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
		     * for equality comparisons.
		     *
		     * **Note:** Unlike `_.pull`, this method returns a new array.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Array
		     * @param {Array} array The array to inspect.
		     * @param {...*} [values] The values to exclude.
		     * @returns {Array} Returns the new array of filtered values.
		     * @see _.difference, _.xor
		     * @example
		     *
		     * _.without([2, 1, 2, 3], 1, 2);
		     * // => [3]
		     */
		    var without = baseRest(function(array, values) {
		      return isArrayLikeObject(array)
		        ? baseDifference(array, values)
		        : [];
		    });

		    /**
		     * Creates an array of unique values that is the
		     * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)
		     * of the given arrays. The order of result values is determined by the order
		     * they occur in the arrays.
		     *
		     * @static
		     * @memberOf _
		     * @since 2.4.0
		     * @category Array
		     * @param {...Array} [arrays] The arrays to inspect.
		     * @returns {Array} Returns the new array of filtered values.
		     * @see _.difference, _.without
		     * @example
		     *
		     * _.xor([2, 1], [2, 3]);
		     * // => [1, 3]
		     */
		    var xor = baseRest(function(arrays) {
		      return baseXor(arrayFilter(arrays, isArrayLikeObject));
		    });

		    /**
		     * This method is like `_.xor` except that it accepts `iteratee` which is
		     * invoked for each element of each `arrays` to generate the criterion by
		     * which by which they're compared. The order of result values is determined
		     * by the order they occur in the arrays. The iteratee is invoked with one
		     * argument: (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {...Array} [arrays] The arrays to inspect.
		     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
		     * @returns {Array} Returns the new array of filtered values.
		     * @example
		     *
		     * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
		     * // => [1.2, 3.4]
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
		     * // => [{ 'x': 2 }]
		     */
		    var xorBy = baseRest(function(arrays) {
		      var iteratee = last(arrays);
		      if (isArrayLikeObject(iteratee)) {
		        iteratee = undefined$1;
		      }
		      return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));
		    });

		    /**
		     * This method is like `_.xor` except that it accepts `comparator` which is
		     * invoked to compare elements of `arrays`. The order of result values is
		     * determined by the order they occur in the arrays. The comparator is invoked
		     * with two arguments: (arrVal, othVal).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Array
		     * @param {...Array} [arrays] The arrays to inspect.
		     * @param {Function} [comparator] The comparator invoked per element.
		     * @returns {Array} Returns the new array of filtered values.
		     * @example
		     *
		     * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
		     * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
		     *
		     * _.xorWith(objects, others, _.isEqual);
		     * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]
		     */
		    var xorWith = baseRest(function(arrays) {
		      var comparator = last(arrays);
		      comparator = typeof comparator == 'function' ? comparator : undefined$1;
		      return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined$1, comparator);
		    });

		    /**
		     * Creates an array of grouped elements, the first of which contains the
		     * first elements of the given arrays, the second of which contains the
		     * second elements of the given arrays, and so on.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Array
		     * @param {...Array} [arrays] The arrays to process.
		     * @returns {Array} Returns the new array of grouped elements.
		     * @example
		     *
		     * _.zip(['a', 'b'], [1, 2], [true, false]);
		     * // => [['a', 1, true], ['b', 2, false]]
		     */
		    var zip = baseRest(unzip);

		    /**
		     * This method is like `_.fromPairs` except that it accepts two arrays,
		     * one of property identifiers and one of corresponding values.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.4.0
		     * @category Array
		     * @param {Array} [props=[]] The property identifiers.
		     * @param {Array} [values=[]] The property values.
		     * @returns {Object} Returns the new object.
		     * @example
		     *
		     * _.zipObject(['a', 'b'], [1, 2]);
		     * // => { 'a': 1, 'b': 2 }
		     */
		    function zipObject(props, values) {
		      return baseZipObject(props || [], values || [], assignValue);
		    }

		    /**
		     * This method is like `_.zipObject` except that it supports property paths.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.1.0
		     * @category Array
		     * @param {Array} [props=[]] The property identifiers.
		     * @param {Array} [values=[]] The property values.
		     * @returns {Object} Returns the new object.
		     * @example
		     *
		     * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
		     * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
		     */
		    function zipObjectDeep(props, values) {
		      return baseZipObject(props || [], values || [], baseSet);
		    }

		    /**
		     * This method is like `_.zip` except that it accepts `iteratee` to specify
		     * how grouped values should be combined. The iteratee is invoked with the
		     * elements of each group: (...group).
		     *
		     * @static
		     * @memberOf _
		     * @since 3.8.0
		     * @category Array
		     * @param {...Array} [arrays] The arrays to process.
		     * @param {Function} [iteratee=_.identity] The function to combine
		     *  grouped values.
		     * @returns {Array} Returns the new array of grouped elements.
		     * @example
		     *
		     * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
		     *   return a + b + c;
		     * });
		     * // => [111, 222]
		     */
		    var zipWith = baseRest(function(arrays) {
		      var length = arrays.length,
		          iteratee = length > 1 ? arrays[length - 1] : undefined$1;

		      iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined$1;
		      return unzipWith(arrays, iteratee);
		    });

		    /*------------------------------------------------------------------------*/

		    /**
		     * Creates a `lodash` wrapper instance that wraps `value` with explicit method
		     * chain sequences enabled. The result of such sequences must be unwrapped
		     * with `_#value`.
		     *
		     * @static
		     * @memberOf _
		     * @since 1.3.0
		     * @category Seq
		     * @param {*} value The value to wrap.
		     * @returns {Object} Returns the new `lodash` wrapper instance.
		     * @example
		     *
		     * var users = [
		     *   { 'user': 'barney',  'age': 36 },
		     *   { 'user': 'fred',    'age': 40 },
		     *   { 'user': 'pebbles', 'age': 1 }
		     * ];
		     *
		     * var youngest = _
		     *   .chain(users)
		     *   .sortBy('age')
		     *   .map(function(o) {
		     *     return o.user + ' is ' + o.age;
		     *   })
		     *   .head()
		     *   .value();
		     * // => 'pebbles is 1'
		     */
		    function chain(value) {
		      var result = lodash(value);
		      result.__chain__ = true;
		      return result;
		    }

		    /**
		     * This method invokes `interceptor` and returns `value`. The interceptor
		     * is invoked with one argument; (value). The purpose of this method is to
		     * "tap into" a method chain sequence in order to modify intermediate results.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Seq
		     * @param {*} value The value to provide to `interceptor`.
		     * @param {Function} interceptor The function to invoke.
		     * @returns {*} Returns `value`.
		     * @example
		     *
		     * _([1, 2, 3])
		     *  .tap(function(array) {
		     *    // Mutate input array.
		     *    array.pop();
		     *  })
		     *  .reverse()
		     *  .value();
		     * // => [2, 1]
		     */
		    function tap(value, interceptor) {
		      interceptor(value);
		      return value;
		    }

		    /**
		     * This method is like `_.tap` except that it returns the result of `interceptor`.
		     * The purpose of this method is to "pass thru" values replacing intermediate
		     * results in a method chain sequence.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Seq
		     * @param {*} value The value to provide to `interceptor`.
		     * @param {Function} interceptor The function to invoke.
		     * @returns {*} Returns the result of `interceptor`.
		     * @example
		     *
		     * _('  abc  ')
		     *  .chain()
		     *  .trim()
		     *  .thru(function(value) {
		     *    return [value];
		     *  })
		     *  .value();
		     * // => ['abc']
		     */
		    function thru(value, interceptor) {
		      return interceptor(value);
		    }

		    /**
		     * This method is the wrapper version of `_.at`.
		     *
		     * @name at
		     * @memberOf _
		     * @since 1.0.0
		     * @category Seq
		     * @param {...(string|string[])} [paths] The property paths to pick.
		     * @returns {Object} Returns the new `lodash` wrapper instance.
		     * @example
		     *
		     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
		     *
		     * _(object).at(['a[0].b.c', 'a[1]']).value();
		     * // => [3, 4]
		     */
		    var wrapperAt = flatRest(function(paths) {
		      var length = paths.length,
		          start = length ? paths[0] : 0,
		          value = this.__wrapped__,
		          interceptor = function(object) { return baseAt(object, paths); };

		      if (length > 1 || this.__actions__.length ||
		          !(value instanceof LazyWrapper) || !isIndex(start)) {
		        return this.thru(interceptor);
		      }
		      value = value.slice(start, +start + (length ? 1 : 0));
		      value.__actions__.push({
		        'func': thru,
		        'args': [interceptor],
		        'thisArg': undefined$1
		      });
		      return new LodashWrapper(value, this.__chain__).thru(function(array) {
		        if (length && !array.length) {
		          array.push(undefined$1);
		        }
		        return array;
		      });
		    });

		    /**
		     * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.
		     *
		     * @name chain
		     * @memberOf _
		     * @since 0.1.0
		     * @category Seq
		     * @returns {Object} Returns the new `lodash` wrapper instance.
		     * @example
		     *
		     * var users = [
		     *   { 'user': 'barney', 'age': 36 },
		     *   { 'user': 'fred',   'age': 40 }
		     * ];
		     *
		     * // A sequence without explicit chaining.
		     * _(users).head();
		     * // => { 'user': 'barney', 'age': 36 }
		     *
		     * // A sequence with explicit chaining.
		     * _(users)
		     *   .chain()
		     *   .head()
		     *   .pick('user')
		     *   .value();
		     * // => { 'user': 'barney' }
		     */
		    function wrapperChain() {
		      return chain(this);
		    }

		    /**
		     * Executes the chain sequence and returns the wrapped result.
		     *
		     * @name commit
		     * @memberOf _
		     * @since 3.2.0
		     * @category Seq
		     * @returns {Object} Returns the new `lodash` wrapper instance.
		     * @example
		     *
		     * var array = [1, 2];
		     * var wrapped = _(array).push(3);
		     *
		     * console.log(array);
		     * // => [1, 2]
		     *
		     * wrapped = wrapped.commit();
		     * console.log(array);
		     * // => [1, 2, 3]
		     *
		     * wrapped.last();
		     * // => 3
		     *
		     * console.log(array);
		     * // => [1, 2, 3]
		     */
		    function wrapperCommit() {
		      return new LodashWrapper(this.value(), this.__chain__);
		    }

		    /**
		     * Gets the next value on a wrapped object following the
		     * [iterator protocol](https://mdn.io/iteration_protocols#iterator).
		     *
		     * @name next
		     * @memberOf _
		     * @since 4.0.0
		     * @category Seq
		     * @returns {Object} Returns the next iterator value.
		     * @example
		     *
		     * var wrapped = _([1, 2]);
		     *
		     * wrapped.next();
		     * // => { 'done': false, 'value': 1 }
		     *
		     * wrapped.next();
		     * // => { 'done': false, 'value': 2 }
		     *
		     * wrapped.next();
		     * // => { 'done': true, 'value': undefined }
		     */
		    function wrapperNext() {
		      if (this.__values__ === undefined$1) {
		        this.__values__ = toArray(this.value());
		      }
		      var done = this.__index__ >= this.__values__.length,
		          value = done ? undefined$1 : this.__values__[this.__index__++];

		      return { 'done': done, 'value': value };
		    }

		    /**
		     * Enables the wrapper to be iterable.
		     *
		     * @name Symbol.iterator
		     * @memberOf _
		     * @since 4.0.0
		     * @category Seq
		     * @returns {Object} Returns the wrapper object.
		     * @example
		     *
		     * var wrapped = _([1, 2]);
		     *
		     * wrapped[Symbol.iterator]() === wrapped;
		     * // => true
		     *
		     * Array.from(wrapped);
		     * // => [1, 2]
		     */
		    function wrapperToIterator() {
		      return this;
		    }

		    /**
		     * Creates a clone of the chain sequence planting `value` as the wrapped value.
		     *
		     * @name plant
		     * @memberOf _
		     * @since 3.2.0
		     * @category Seq
		     * @param {*} value The value to plant.
		     * @returns {Object} Returns the new `lodash` wrapper instance.
		     * @example
		     *
		     * function square(n) {
		     *   return n * n;
		     * }
		     *
		     * var wrapped = _([1, 2]).map(square);
		     * var other = wrapped.plant([3, 4]);
		     *
		     * other.value();
		     * // => [9, 16]
		     *
		     * wrapped.value();
		     * // => [1, 4]
		     */
		    function wrapperPlant(value) {
		      var result,
		          parent = this;

		      while (parent instanceof baseLodash) {
		        var clone = wrapperClone(parent);
		        clone.__index__ = 0;
		        clone.__values__ = undefined$1;
		        if (result) {
		          previous.__wrapped__ = clone;
		        } else {
		          result = clone;
		        }
		        var previous = clone;
		        parent = parent.__wrapped__;
		      }
		      previous.__wrapped__ = value;
		      return result;
		    }

		    /**
		     * This method is the wrapper version of `_.reverse`.
		     *
		     * **Note:** This method mutates the wrapped array.
		     *
		     * @name reverse
		     * @memberOf _
		     * @since 0.1.0
		     * @category Seq
		     * @returns {Object} Returns the new `lodash` wrapper instance.
		     * @example
		     *
		     * var array = [1, 2, 3];
		     *
		     * _(array).reverse().value()
		     * // => [3, 2, 1]
		     *
		     * console.log(array);
		     * // => [3, 2, 1]
		     */
		    function wrapperReverse() {
		      var value = this.__wrapped__;
		      if (value instanceof LazyWrapper) {
		        var wrapped = value;
		        if (this.__actions__.length) {
		          wrapped = new LazyWrapper(this);
		        }
		        wrapped = wrapped.reverse();
		        wrapped.__actions__.push({
		          'func': thru,
		          'args': [reverse],
		          'thisArg': undefined$1
		        });
		        return new LodashWrapper(wrapped, this.__chain__);
		      }
		      return this.thru(reverse);
		    }

		    /**
		     * Executes the chain sequence to resolve the unwrapped value.
		     *
		     * @name value
		     * @memberOf _
		     * @since 0.1.0
		     * @alias toJSON, valueOf
		     * @category Seq
		     * @returns {*} Returns the resolved unwrapped value.
		     * @example
		     *
		     * _([1, 2, 3]).value();
		     * // => [1, 2, 3]
		     */
		    function wrapperValue() {
		      return baseWrapperValue(this.__wrapped__, this.__actions__);
		    }

		    /*------------------------------------------------------------------------*/

		    /**
		     * Creates an object composed of keys generated from the results of running
		     * each element of `collection` thru `iteratee`. The corresponding value of
		     * each key is the number of times the key was returned by `iteratee`. The
		     * iteratee is invoked with one argument: (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 0.5.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
		     * @returns {Object} Returns the composed aggregate object.
		     * @example
		     *
		     * _.countBy([6.1, 4.2, 6.3], Math.floor);
		     * // => { '4': 1, '6': 2 }
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.countBy(['one', 'two', 'three'], 'length');
		     * // => { '3': 2, '5': 1 }
		     */
		    var countBy = createAggregator(function(result, value, key) {
		      if (hasOwnProperty.call(result, key)) {
		        ++result[key];
		      } else {
		        baseAssignValue(result, key, 1);
		      }
		    });

		    /**
		     * Checks if `predicate` returns truthy for **all** elements of `collection`.
		     * Iteration is stopped once `predicate` returns falsey. The predicate is
		     * invoked with three arguments: (value, index|key, collection).
		     *
		     * **Note:** This method returns `true` for
		     * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because
		     * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of
		     * elements of empty collections.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {boolean} Returns `true` if all elements pass the predicate check,
		     *  else `false`.
		     * @example
		     *
		     * _.every([true, 1, null, 'yes'], Boolean);
		     * // => false
		     *
		     * var users = [
		     *   { 'user': 'barney', 'age': 36, 'active': false },
		     *   { 'user': 'fred',   'age': 40, 'active': false }
		     * ];
		     *
		     * // The `_.matches` iteratee shorthand.
		     * _.every(users, { 'user': 'barney', 'active': false });
		     * // => false
		     *
		     * // The `_.matchesProperty` iteratee shorthand.
		     * _.every(users, ['active', false]);
		     * // => true
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.every(users, 'active');
		     * // => false
		     */
		    function every(collection, predicate, guard) {
		      var func = isArray(collection) ? arrayEvery : baseEvery;
		      if (guard && isIterateeCall(collection, predicate, guard)) {
		        predicate = undefined$1;
		      }
		      return func(collection, getIteratee(predicate, 3));
		    }

		    /**
		     * Iterates over elements of `collection`, returning an array of all elements
		     * `predicate` returns truthy for. The predicate is invoked with three
		     * arguments: (value, index|key, collection).
		     *
		     * **Note:** Unlike `_.remove`, this method returns a new array.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @returns {Array} Returns the new filtered array.
		     * @see _.reject
		     * @example
		     *
		     * var users = [
		     *   { 'user': 'barney', 'age': 36, 'active': true },
		     *   { 'user': 'fred',   'age': 40, 'active': false }
		     * ];
		     *
		     * _.filter(users, function(o) { return !o.active; });
		     * // => objects for ['fred']
		     *
		     * // The `_.matches` iteratee shorthand.
		     * _.filter(users, { 'age': 36, 'active': true });
		     * // => objects for ['barney']
		     *
		     * // The `_.matchesProperty` iteratee shorthand.
		     * _.filter(users, ['active', false]);
		     * // => objects for ['fred']
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.filter(users, 'active');
		     * // => objects for ['barney']
		     *
		     * // Combining several predicates using `_.overEvery` or `_.overSome`.
		     * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]]));
		     * // => objects for ['fred', 'barney']
		     */
		    function filter(collection, predicate) {
		      var func = isArray(collection) ? arrayFilter : baseFilter;
		      return func(collection, getIteratee(predicate, 3));
		    }

		    /**
		     * Iterates over elements of `collection`, returning the first element
		     * `predicate` returns truthy for. The predicate is invoked with three
		     * arguments: (value, index|key, collection).
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to inspect.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @param {number} [fromIndex=0] The index to search from.
		     * @returns {*} Returns the matched element, else `undefined`.
		     * @example
		     *
		     * var users = [
		     *   { 'user': 'barney',  'age': 36, 'active': true },
		     *   { 'user': 'fred',    'age': 40, 'active': false },
		     *   { 'user': 'pebbles', 'age': 1,  'active': true }
		     * ];
		     *
		     * _.find(users, function(o) { return o.age < 40; });
		     * // => object for 'barney'
		     *
		     * // The `_.matches` iteratee shorthand.
		     * _.find(users, { 'age': 1, 'active': true });
		     * // => object for 'pebbles'
		     *
		     * // The `_.matchesProperty` iteratee shorthand.
		     * _.find(users, ['active', false]);
		     * // => object for 'fred'
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.find(users, 'active');
		     * // => object for 'barney'
		     */
		    var find = createFind(findIndex);

		    /**
		     * This method is like `_.find` except that it iterates over elements of
		     * `collection` from right to left.
		     *
		     * @static
		     * @memberOf _
		     * @since 2.0.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to inspect.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @param {number} [fromIndex=collection.length-1] The index to search from.
		     * @returns {*} Returns the matched element, else `undefined`.
		     * @example
		     *
		     * _.findLast([1, 2, 3, 4], function(n) {
		     *   return n % 2 == 1;
		     * });
		     * // => 3
		     */
		    var findLast = createFind(findLastIndex);

		    /**
		     * Creates a flattened array of values by running each element in `collection`
		     * thru `iteratee` and flattening the mapped results. The iteratee is invoked
		     * with three arguments: (value, index|key, collection).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @returns {Array} Returns the new flattened array.
		     * @example
		     *
		     * function duplicate(n) {
		     *   return [n, n];
		     * }
		     *
		     * _.flatMap([1, 2], duplicate);
		     * // => [1, 1, 2, 2]
		     */
		    function flatMap(collection, iteratee) {
		      return baseFlatten(map(collection, iteratee), 1);
		    }

		    /**
		     * This method is like `_.flatMap` except that it recursively flattens the
		     * mapped results.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.7.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @returns {Array} Returns the new flattened array.
		     * @example
		     *
		     * function duplicate(n) {
		     *   return [[[n, n]]];
		     * }
		     *
		     * _.flatMapDeep([1, 2], duplicate);
		     * // => [1, 1, 2, 2]
		     */
		    function flatMapDeep(collection, iteratee) {
		      return baseFlatten(map(collection, iteratee), INFINITY);
		    }

		    /**
		     * This method is like `_.flatMap` except that it recursively flattens the
		     * mapped results up to `depth` times.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.7.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @param {number} [depth=1] The maximum recursion depth.
		     * @returns {Array} Returns the new flattened array.
		     * @example
		     *
		     * function duplicate(n) {
		     *   return [[[n, n]]];
		     * }
		     *
		     * _.flatMapDepth([1, 2], duplicate, 2);
		     * // => [[1, 1], [2, 2]]
		     */
		    function flatMapDepth(collection, iteratee, depth) {
		      depth = depth === undefined$1 ? 1 : toInteger(depth);
		      return baseFlatten(map(collection, iteratee), depth);
		    }

		    /**
		     * Iterates over elements of `collection` and invokes `iteratee` for each element.
		     * The iteratee is invoked with three arguments: (value, index|key, collection).
		     * Iteratee functions may exit iteration early by explicitly returning `false`.
		     *
		     * **Note:** As with other "Collections" methods, objects with a "length"
		     * property are iterated like arrays. To avoid this behavior use `_.forIn`
		     * or `_.forOwn` for object iteration.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @alias each
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @returns {Array|Object} Returns `collection`.
		     * @see _.forEachRight
		     * @example
		     *
		     * _.forEach([1, 2], function(value) {
		     *   console.log(value);
		     * });
		     * // => Logs `1` then `2`.
		     *
		     * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
		     *   console.log(key);
		     * });
		     * // => Logs 'a' then 'b' (iteration order is not guaranteed).
		     */
		    function forEach(collection, iteratee) {
		      var func = isArray(collection) ? arrayEach : baseEach;
		      return func(collection, getIteratee(iteratee, 3));
		    }

		    /**
		     * This method is like `_.forEach` except that it iterates over elements of
		     * `collection` from right to left.
		     *
		     * @static
		     * @memberOf _
		     * @since 2.0.0
		     * @alias eachRight
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @returns {Array|Object} Returns `collection`.
		     * @see _.forEach
		     * @example
		     *
		     * _.forEachRight([1, 2], function(value) {
		     *   console.log(value);
		     * });
		     * // => Logs `2` then `1`.
		     */
		    function forEachRight(collection, iteratee) {
		      var func = isArray(collection) ? arrayEachRight : baseEachRight;
		      return func(collection, getIteratee(iteratee, 3));
		    }

		    /**
		     * Creates an object composed of keys generated from the results of running
		     * each element of `collection` thru `iteratee`. The order of grouped values
		     * is determined by the order they occur in `collection`. The corresponding
		     * value of each key is an array of elements responsible for generating the
		     * key. The iteratee is invoked with one argument: (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
		     * @returns {Object} Returns the composed aggregate object.
		     * @example
		     *
		     * _.groupBy([6.1, 4.2, 6.3], Math.floor);
		     * // => { '4': [4.2], '6': [6.1, 6.3] }
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.groupBy(['one', 'two', 'three'], 'length');
		     * // => { '3': ['one', 'two'], '5': ['three'] }
		     */
		    var groupBy = createAggregator(function(result, value, key) {
		      if (hasOwnProperty.call(result, key)) {
		        result[key].push(value);
		      } else {
		        baseAssignValue(result, key, [value]);
		      }
		    });

		    /**
		     * Checks if `value` is in `collection`. If `collection` is a string, it's
		     * checked for a substring of `value`, otherwise
		     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
		     * is used for equality comparisons. If `fromIndex` is negative, it's used as
		     * the offset from the end of `collection`.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Collection
		     * @param {Array|Object|string} collection The collection to inspect.
		     * @param {*} value The value to search for.
		     * @param {number} [fromIndex=0] The index to search from.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
		     * @returns {boolean} Returns `true` if `value` is found, else `false`.
		     * @example
		     *
		     * _.includes([1, 2, 3], 1);
		     * // => true
		     *
		     * _.includes([1, 2, 3], 1, 2);
		     * // => false
		     *
		     * _.includes({ 'a': 1, 'b': 2 }, 1);
		     * // => true
		     *
		     * _.includes('abcd', 'bc');
		     * // => true
		     */
		    function includes(collection, value, fromIndex, guard) {
		      collection = isArrayLike(collection) ? collection : values(collection);
		      fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;

		      var length = collection.length;
		      if (fromIndex < 0) {
		        fromIndex = nativeMax(length + fromIndex, 0);
		      }
		      return isString(collection)
		        ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)
		        : (!!length && baseIndexOf(collection, value, fromIndex) > -1);
		    }

		    /**
		     * Invokes the method at `path` of each element in `collection`, returning
		     * an array of the results of each invoked method. Any additional arguments
		     * are provided to each invoked method. If `path` is a function, it's invoked
		     * for, and `this` bound to, each element in `collection`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Array|Function|string} path The path of the method to invoke or
		     *  the function invoked per iteration.
		     * @param {...*} [args] The arguments to invoke each method with.
		     * @returns {Array} Returns the array of results.
		     * @example
		     *
		     * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
		     * // => [[1, 5, 7], [1, 2, 3]]
		     *
		     * _.invokeMap([123, 456], String.prototype.split, '');
		     * // => [['1', '2', '3'], ['4', '5', '6']]
		     */
		    var invokeMap = baseRest(function(collection, path, args) {
		      var index = -1,
		          isFunc = typeof path == 'function',
		          result = isArrayLike(collection) ? Array(collection.length) : [];

		      baseEach(collection, function(value) {
		        result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
		      });
		      return result;
		    });

		    /**
		     * Creates an object composed of keys generated from the results of running
		     * each element of `collection` thru `iteratee`. The corresponding value of
		     * each key is the last element responsible for generating the key. The
		     * iteratee is invoked with one argument: (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [iteratee=_.identity] The iteratee to transform keys.
		     * @returns {Object} Returns the composed aggregate object.
		     * @example
		     *
		     * var array = [
		     *   { 'dir': 'left', 'code': 97 },
		     *   { 'dir': 'right', 'code': 100 }
		     * ];
		     *
		     * _.keyBy(array, function(o) {
		     *   return String.fromCharCode(o.code);
		     * });
		     * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }
		     *
		     * _.keyBy(array, 'dir');
		     * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }
		     */
		    var keyBy = createAggregator(function(result, value, key) {
		      baseAssignValue(result, key, value);
		    });

		    /**
		     * Creates an array of values by running each element in `collection` thru
		     * `iteratee`. The iteratee is invoked with three arguments:
		     * (value, index|key, collection).
		     *
		     * Many lodash methods are guarded to work as iteratees for methods like
		     * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
		     *
		     * The guarded methods are:
		     * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
		     * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
		     * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
		     * `template`, `trim`, `trimEnd`, `trimStart`, and `words`
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @returns {Array} Returns the new mapped array.
		     * @example
		     *
		     * function square(n) {
		     *   return n * n;
		     * }
		     *
		     * _.map([4, 8], square);
		     * // => [16, 64]
		     *
		     * _.map({ 'a': 4, 'b': 8 }, square);
		     * // => [16, 64] (iteration order is not guaranteed)
		     *
		     * var users = [
		     *   { 'user': 'barney' },
		     *   { 'user': 'fred' }
		     * ];
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.map(users, 'user');
		     * // => ['barney', 'fred']
		     */
		    function map(collection, iteratee) {
		      var func = isArray(collection) ? arrayMap : baseMap;
		      return func(collection, getIteratee(iteratee, 3));
		    }

		    /**
		     * This method is like `_.sortBy` except that it allows specifying the sort
		     * orders of the iteratees to sort by. If `orders` is unspecified, all values
		     * are sorted in ascending order. Otherwise, specify an order of "desc" for
		     * descending or "asc" for ascending sort order of corresponding values.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]
		     *  The iteratees to sort by.
		     * @param {string[]} [orders] The sort orders of `iteratees`.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.
		     * @returns {Array} Returns the new sorted array.
		     * @example
		     *
		     * var users = [
		     *   { 'user': 'fred',   'age': 48 },
		     *   { 'user': 'barney', 'age': 34 },
		     *   { 'user': 'fred',   'age': 40 },
		     *   { 'user': 'barney', 'age': 36 }
		     * ];
		     *
		     * // Sort by `user` in ascending order and by `age` in descending order.
		     * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
		     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
		     */
		    function orderBy(collection, iteratees, orders, guard) {
		      if (collection == null) {
		        return [];
		      }
		      if (!isArray(iteratees)) {
		        iteratees = iteratees == null ? [] : [iteratees];
		      }
		      orders = guard ? undefined$1 : orders;
		      if (!isArray(orders)) {
		        orders = orders == null ? [] : [orders];
		      }
		      return baseOrderBy(collection, iteratees, orders);
		    }

		    /**
		     * Creates an array of elements split into two groups, the first of which
		     * contains elements `predicate` returns truthy for, the second of which
		     * contains elements `predicate` returns falsey for. The predicate is
		     * invoked with one argument: (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @returns {Array} Returns the array of grouped elements.
		     * @example
		     *
		     * var users = [
		     *   { 'user': 'barney',  'age': 36, 'active': false },
		     *   { 'user': 'fred',    'age': 40, 'active': true },
		     *   { 'user': 'pebbles', 'age': 1,  'active': false }
		     * ];
		     *
		     * _.partition(users, function(o) { return o.active; });
		     * // => objects for [['fred'], ['barney', 'pebbles']]
		     *
		     * // The `_.matches` iteratee shorthand.
		     * _.partition(users, { 'age': 1, 'active': false });
		     * // => objects for [['pebbles'], ['barney', 'fred']]
		     *
		     * // The `_.matchesProperty` iteratee shorthand.
		     * _.partition(users, ['active', false]);
		     * // => objects for [['barney', 'pebbles'], ['fred']]
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.partition(users, 'active');
		     * // => objects for [['fred'], ['barney', 'pebbles']]
		     */
		    var partition = createAggregator(function(result, value, key) {
		      result[key ? 0 : 1].push(value);
		    }, function() { return [[], []]; });

		    /**
		     * Reduces `collection` to a value which is the accumulated result of running
		     * each element in `collection` thru `iteratee`, where each successive
		     * invocation is supplied the return value of the previous. If `accumulator`
		     * is not given, the first element of `collection` is used as the initial
		     * value. The iteratee is invoked with four arguments:
		     * (accumulator, value, index|key, collection).
		     *
		     * Many lodash methods are guarded to work as iteratees for methods like
		     * `_.reduce`, `_.reduceRight`, and `_.transform`.
		     *
		     * The guarded methods are:
		     * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,
		     * and `sortBy`
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @param {*} [accumulator] The initial value.
		     * @returns {*} Returns the accumulated value.
		     * @see _.reduceRight
		     * @example
		     *
		     * _.reduce([1, 2], function(sum, n) {
		     *   return sum + n;
		     * }, 0);
		     * // => 3
		     *
		     * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
		     *   (result[value] || (result[value] = [])).push(key);
		     *   return result;
		     * }, {});
		     * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)
		     */
		    function reduce(collection, iteratee, accumulator) {
		      var func = isArray(collection) ? arrayReduce : baseReduce,
		          initAccum = arguments.length < 3;

		      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);
		    }

		    /**
		     * This method is like `_.reduce` except that it iterates over elements of
		     * `collection` from right to left.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @param {*} [accumulator] The initial value.
		     * @returns {*} Returns the accumulated value.
		     * @see _.reduce
		     * @example
		     *
		     * var array = [[0, 1], [2, 3], [4, 5]];
		     *
		     * _.reduceRight(array, function(flattened, other) {
		     *   return flattened.concat(other);
		     * }, []);
		     * // => [4, 5, 2, 3, 0, 1]
		     */
		    function reduceRight(collection, iteratee, accumulator) {
		      var func = isArray(collection) ? arrayReduceRight : baseReduce,
		          initAccum = arguments.length < 3;

		      return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);
		    }

		    /**
		     * The opposite of `_.filter`; this method returns the elements of `collection`
		     * that `predicate` does **not** return truthy for.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @returns {Array} Returns the new filtered array.
		     * @see _.filter
		     * @example
		     *
		     * var users = [
		     *   { 'user': 'barney', 'age': 36, 'active': false },
		     *   { 'user': 'fred',   'age': 40, 'active': true }
		     * ];
		     *
		     * _.reject(users, function(o) { return !o.active; });
		     * // => objects for ['fred']
		     *
		     * // The `_.matches` iteratee shorthand.
		     * _.reject(users, { 'age': 40, 'active': true });
		     * // => objects for ['barney']
		     *
		     * // The `_.matchesProperty` iteratee shorthand.
		     * _.reject(users, ['active', false]);
		     * // => objects for ['fred']
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.reject(users, 'active');
		     * // => objects for ['barney']
		     */
		    function reject(collection, predicate) {
		      var func = isArray(collection) ? arrayFilter : baseFilter;
		      return func(collection, negate(getIteratee(predicate, 3)));
		    }

		    /**
		     * Gets a random element from `collection`.
		     *
		     * @static
		     * @memberOf _
		     * @since 2.0.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to sample.
		     * @returns {*} Returns the random element.
		     * @example
		     *
		     * _.sample([1, 2, 3, 4]);
		     * // => 2
		     */
		    function sample(collection) {
		      var func = isArray(collection) ? arraySample : baseSample;
		      return func(collection);
		    }

		    /**
		     * Gets `n` random elements at unique keys from `collection` up to the
		     * size of `collection`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to sample.
		     * @param {number} [n=1] The number of elements to sample.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {Array} Returns the random elements.
		     * @example
		     *
		     * _.sampleSize([1, 2, 3], 2);
		     * // => [3, 1]
		     *
		     * _.sampleSize([1, 2, 3], 4);
		     * // => [2, 3, 1]
		     */
		    function sampleSize(collection, n, guard) {
		      if ((guard ? isIterateeCall(collection, n, guard) : n === undefined$1)) {
		        n = 1;
		      } else {
		        n = toInteger(n);
		      }
		      var func = isArray(collection) ? arraySampleSize : baseSampleSize;
		      return func(collection, n);
		    }

		    /**
		     * Creates an array of shuffled values, using a version of the
		     * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to shuffle.
		     * @returns {Array} Returns the new shuffled array.
		     * @example
		     *
		     * _.shuffle([1, 2, 3, 4]);
		     * // => [4, 1, 3, 2]
		     */
		    function shuffle(collection) {
		      var func = isArray(collection) ? arrayShuffle : baseShuffle;
		      return func(collection);
		    }

		    /**
		     * Gets the size of `collection` by returning its length for array-like
		     * values or the number of own enumerable string keyed properties for objects.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Collection
		     * @param {Array|Object|string} collection The collection to inspect.
		     * @returns {number} Returns the collection size.
		     * @example
		     *
		     * _.size([1, 2, 3]);
		     * // => 3
		     *
		     * _.size({ 'a': 1, 'b': 2 });
		     * // => 2
		     *
		     * _.size('pebbles');
		     * // => 7
		     */
		    function size(collection) {
		      if (collection == null) {
		        return 0;
		      }
		      if (isArrayLike(collection)) {
		        return isString(collection) ? stringSize(collection) : collection.length;
		      }
		      var tag = getTag(collection);
		      if (tag == mapTag || tag == setTag) {
		        return collection.size;
		      }
		      return baseKeys(collection).length;
		    }

		    /**
		     * Checks if `predicate` returns truthy for **any** element of `collection`.
		     * Iteration is stopped once `predicate` returns truthy. The predicate is
		     * invoked with three arguments: (value, index|key, collection).
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {boolean} Returns `true` if any element passes the predicate check,
		     *  else `false`.
		     * @example
		     *
		     * _.some([null, 0, 'yes', false], Boolean);
		     * // => true
		     *
		     * var users = [
		     *   { 'user': 'barney', 'active': true },
		     *   { 'user': 'fred',   'active': false }
		     * ];
		     *
		     * // The `_.matches` iteratee shorthand.
		     * _.some(users, { 'user': 'barney', 'active': false });
		     * // => false
		     *
		     * // The `_.matchesProperty` iteratee shorthand.
		     * _.some(users, ['active', false]);
		     * // => true
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.some(users, 'active');
		     * // => true
		     */
		    function some(collection, predicate, guard) {
		      var func = isArray(collection) ? arraySome : baseSome;
		      if (guard && isIterateeCall(collection, predicate, guard)) {
		        predicate = undefined$1;
		      }
		      return func(collection, getIteratee(predicate, 3));
		    }

		    /**
		     * Creates an array of elements, sorted in ascending order by the results of
		     * running each element in a collection thru each iteratee. This method
		     * performs a stable sort, that is, it preserves the original sort order of
		     * equal elements. The iteratees are invoked with one argument: (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Collection
		     * @param {Array|Object} collection The collection to iterate over.
		     * @param {...(Function|Function[])} [iteratees=[_.identity]]
		     *  The iteratees to sort by.
		     * @returns {Array} Returns the new sorted array.
		     * @example
		     *
		     * var users = [
		     *   { 'user': 'fred',   'age': 48 },
		     *   { 'user': 'barney', 'age': 36 },
		     *   { 'user': 'fred',   'age': 30 },
		     *   { 'user': 'barney', 'age': 34 }
		     * ];
		     *
		     * _.sortBy(users, [function(o) { return o.user; }]);
		     * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]]
		     *
		     * _.sortBy(users, ['user', 'age']);
		     * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]]
		     */
		    var sortBy = baseRest(function(collection, iteratees) {
		      if (collection == null) {
		        return [];
		      }
		      var length = iteratees.length;
		      if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
		        iteratees = [];
		      } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
		        iteratees = [iteratees[0]];
		      }
		      return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
		    });

		    /*------------------------------------------------------------------------*/

		    /**
		     * Gets the timestamp of the number of milliseconds that have elapsed since
		     * the Unix epoch (1 January 1970 00:00:00 UTC).
		     *
		     * @static
		     * @memberOf _
		     * @since 2.4.0
		     * @category Date
		     * @returns {number} Returns the timestamp.
		     * @example
		     *
		     * _.defer(function(stamp) {
		     *   console.log(_.now() - stamp);
		     * }, _.now());
		     * // => Logs the number of milliseconds it took for the deferred invocation.
		     */
		    var now = ctxNow || function() {
		      return root.Date.now();
		    };

		    /*------------------------------------------------------------------------*/

		    /**
		     * The opposite of `_.before`; this method creates a function that invokes
		     * `func` once it's called `n` or more times.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Function
		     * @param {number} n The number of calls before `func` is invoked.
		     * @param {Function} func The function to restrict.
		     * @returns {Function} Returns the new restricted function.
		     * @example
		     *
		     * var saves = ['profile', 'settings'];
		     *
		     * var done = _.after(saves.length, function() {
		     *   console.log('done saving!');
		     * });
		     *
		     * _.forEach(saves, function(type) {
		     *   asyncSave({ 'type': type, 'complete': done });
		     * });
		     * // => Logs 'done saving!' after the two async saves have completed.
		     */
		    function after(n, func) {
		      if (typeof func != 'function') {
		        throw new TypeError(FUNC_ERROR_TEXT);
		      }
		      n = toInteger(n);
		      return function() {
		        if (--n < 1) {
		          return func.apply(this, arguments);
		        }
		      };
		    }

		    /**
		     * Creates a function that invokes `func`, with up to `n` arguments,
		     * ignoring any additional arguments.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Function
		     * @param {Function} func The function to cap arguments for.
		     * @param {number} [n=func.length] The arity cap.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {Function} Returns the new capped function.
		     * @example
		     *
		     * _.map(['6', '8', '10'], _.ary(parseInt, 1));
		     * // => [6, 8, 10]
		     */
		    function ary(func, n, guard) {
		      n = guard ? undefined$1 : n;
		      n = (func && n == null) ? func.length : n;
		      return createWrap(func, WRAP_ARY_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, n);
		    }

		    /**
		     * Creates a function that invokes `func`, with the `this` binding and arguments
		     * of the created function, while it's called less than `n` times. Subsequent
		     * calls to the created function return the result of the last `func` invocation.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Function
		     * @param {number} n The number of calls at which `func` is no longer invoked.
		     * @param {Function} func The function to restrict.
		     * @returns {Function} Returns the new restricted function.
		     * @example
		     *
		     * jQuery(element).on('click', _.before(5, addContactToList));
		     * // => Allows adding up to 4 contacts to the list.
		     */
		    function before(n, func) {
		      var result;
		      if (typeof func != 'function') {
		        throw new TypeError(FUNC_ERROR_TEXT);
		      }
		      n = toInteger(n);
		      return function() {
		        if (--n > 0) {
		          result = func.apply(this, arguments);
		        }
		        if (n <= 1) {
		          func = undefined$1;
		        }
		        return result;
		      };
		    }

		    /**
		     * Creates a function that invokes `func` with the `this` binding of `thisArg`
		     * and `partials` prepended to the arguments it receives.
		     *
		     * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,
		     * may be used as a placeholder for partially applied arguments.
		     *
		     * **Note:** Unlike native `Function#bind`, this method doesn't set the "length"
		     * property of bound functions.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Function
		     * @param {Function} func The function to bind.
		     * @param {*} thisArg The `this` binding of `func`.
		     * @param {...*} [partials] The arguments to be partially applied.
		     * @returns {Function} Returns the new bound function.
		     * @example
		     *
		     * function greet(greeting, punctuation) {
		     *   return greeting + ' ' + this.user + punctuation;
		     * }
		     *
		     * var object = { 'user': 'fred' };
		     *
		     * var bound = _.bind(greet, object, 'hi');
		     * bound('!');
		     * // => 'hi fred!'
		     *
		     * // Bound with placeholders.
		     * var bound = _.bind(greet, object, _, '!');
		     * bound('hi');
		     * // => 'hi fred!'
		     */
		    var bind = baseRest(function(func, thisArg, partials) {
		      var bitmask = WRAP_BIND_FLAG;
		      if (partials.length) {
		        var holders = replaceHolders(partials, getHolder(bind));
		        bitmask |= WRAP_PARTIAL_FLAG;
		      }
		      return createWrap(func, bitmask, thisArg, partials, holders);
		    });

		    /**
		     * Creates a function that invokes the method at `object[key]` with `partials`
		     * prepended to the arguments it receives.
		     *
		     * This method differs from `_.bind` by allowing bound functions to reference
		     * methods that may be redefined or don't yet exist. See
		     * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)
		     * for more details.
		     *
		     * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic
		     * builds, may be used as a placeholder for partially applied arguments.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.10.0
		     * @category Function
		     * @param {Object} object The object to invoke the method on.
		     * @param {string} key The key of the method.
		     * @param {...*} [partials] The arguments to be partially applied.
		     * @returns {Function} Returns the new bound function.
		     * @example
		     *
		     * var object = {
		     *   'user': 'fred',
		     *   'greet': function(greeting, punctuation) {
		     *     return greeting + ' ' + this.user + punctuation;
		     *   }
		     * };
		     *
		     * var bound = _.bindKey(object, 'greet', 'hi');
		     * bound('!');
		     * // => 'hi fred!'
		     *
		     * object.greet = function(greeting, punctuation) {
		     *   return greeting + 'ya ' + this.user + punctuation;
		     * };
		     *
		     * bound('!');
		     * // => 'hiya fred!'
		     *
		     * // Bound with placeholders.
		     * var bound = _.bindKey(object, 'greet', _, '!');
		     * bound('hi');
		     * // => 'hiya fred!'
		     */
		    var bindKey = baseRest(function(object, key, partials) {
		      var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;
		      if (partials.length) {
		        var holders = replaceHolders(partials, getHolder(bindKey));
		        bitmask |= WRAP_PARTIAL_FLAG;
		      }
		      return createWrap(key, bitmask, object, partials, holders);
		    });

		    /**
		     * Creates a function that accepts arguments of `func` and either invokes
		     * `func` returning its result, if at least `arity` number of arguments have
		     * been provided, or returns a function that accepts the remaining `func`
		     * arguments, and so on. The arity of `func` may be specified if `func.length`
		     * is not sufficient.
		     *
		     * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,
		     * may be used as a placeholder for provided arguments.
		     *
		     * **Note:** This method doesn't set the "length" property of curried functions.
		     *
		     * @static
		     * @memberOf _
		     * @since 2.0.0
		     * @category Function
		     * @param {Function} func The function to curry.
		     * @param {number} [arity=func.length] The arity of `func`.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {Function} Returns the new curried function.
		     * @example
		     *
		     * var abc = function(a, b, c) {
		     *   return [a, b, c];
		     * };
		     *
		     * var curried = _.curry(abc);
		     *
		     * curried(1)(2)(3);
		     * // => [1, 2, 3]
		     *
		     * curried(1, 2)(3);
		     * // => [1, 2, 3]
		     *
		     * curried(1, 2, 3);
		     * // => [1, 2, 3]
		     *
		     * // Curried with placeholders.
		     * curried(1)(_, 3)(2);
		     * // => [1, 2, 3]
		     */
		    function curry(func, arity, guard) {
		      arity = guard ? undefined$1 : arity;
		      var result = createWrap(func, WRAP_CURRY_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, undefined$1, arity);
		      result.placeholder = curry.placeholder;
		      return result;
		    }

		    /**
		     * This method is like `_.curry` except that arguments are applied to `func`
		     * in the manner of `_.partialRight` instead of `_.partial`.
		     *
		     * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic
		     * builds, may be used as a placeholder for provided arguments.
		     *
		     * **Note:** This method doesn't set the "length" property of curried functions.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Function
		     * @param {Function} func The function to curry.
		     * @param {number} [arity=func.length] The arity of `func`.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {Function} Returns the new curried function.
		     * @example
		     *
		     * var abc = function(a, b, c) {
		     *   return [a, b, c];
		     * };
		     *
		     * var curried = _.curryRight(abc);
		     *
		     * curried(3)(2)(1);
		     * // => [1, 2, 3]
		     *
		     * curried(2, 3)(1);
		     * // => [1, 2, 3]
		     *
		     * curried(1, 2, 3);
		     * // => [1, 2, 3]
		     *
		     * // Curried with placeholders.
		     * curried(3)(1, _)(2);
		     * // => [1, 2, 3]
		     */
		    function curryRight(func, arity, guard) {
		      arity = guard ? undefined$1 : arity;
		      var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined$1, undefined$1, undefined$1, undefined$1, undefined$1, arity);
		      result.placeholder = curryRight.placeholder;
		      return result;
		    }

		    /**
		     * Creates a debounced function that delays invoking `func` until after `wait`
		     * milliseconds have elapsed since the last time the debounced function was
		     * invoked. The debounced function comes with a `cancel` method to cancel
		     * delayed `func` invocations and a `flush` method to immediately invoke them.
		     * Provide `options` to indicate whether `func` should be invoked on the
		     * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
		     * with the last arguments provided to the debounced function. Subsequent
		     * calls to the debounced function return the result of the last `func`
		     * invocation.
		     *
		     * **Note:** If `leading` and `trailing` options are `true`, `func` is
		     * invoked on the trailing edge of the timeout only if the debounced function
		     * is invoked more than once during the `wait` timeout.
		     *
		     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
		     * until to the next tick, similar to `setTimeout` with a timeout of `0`.
		     *
		     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
		     * for details over the differences between `_.debounce` and `_.throttle`.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Function
		     * @param {Function} func The function to debounce.
		     * @param {number} [wait=0] The number of milliseconds to delay.
		     * @param {Object} [options={}] The options object.
		     * @param {boolean} [options.leading=false]
		     *  Specify invoking on the leading edge of the timeout.
		     * @param {number} [options.maxWait]
		     *  The maximum time `func` is allowed to be delayed before it's invoked.
		     * @param {boolean} [options.trailing=true]
		     *  Specify invoking on the trailing edge of the timeout.
		     * @returns {Function} Returns the new debounced function.
		     * @example
		     *
		     * // Avoid costly calculations while the window size is in flux.
		     * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
		     *
		     * // Invoke `sendMail` when clicked, debouncing subsequent calls.
		     * jQuery(element).on('click', _.debounce(sendMail, 300, {
		     *   'leading': true,
		     *   'trailing': false
		     * }));
		     *
		     * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
		     * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
		     * var source = new EventSource('/stream');
		     * jQuery(source).on('message', debounced);
		     *
		     * // Cancel the trailing debounced invocation.
		     * jQuery(window).on('popstate', debounced.cancel);
		     */
		    function debounce(func, wait, options) {
		      var lastArgs,
		          lastThis,
		          maxWait,
		          result,
		          timerId,
		          lastCallTime,
		          lastInvokeTime = 0,
		          leading = false,
		          maxing = false,
		          trailing = true;

		      if (typeof func != 'function') {
		        throw new TypeError(FUNC_ERROR_TEXT);
		      }
		      wait = toNumber(wait) || 0;
		      if (isObject(options)) {
		        leading = !!options.leading;
		        maxing = 'maxWait' in options;
		        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
		        trailing = 'trailing' in options ? !!options.trailing : trailing;
		      }

		      function invokeFunc(time) {
		        var args = lastArgs,
		            thisArg = lastThis;

		        lastArgs = lastThis = undefined$1;
		        lastInvokeTime = time;
		        result = func.apply(thisArg, args);
		        return result;
		      }

		      function leadingEdge(time) {
		        // Reset any `maxWait` timer.
		        lastInvokeTime = time;
		        // Start the timer for the trailing edge.
		        timerId = setTimeout(timerExpired, wait);
		        // Invoke the leading edge.
		        return leading ? invokeFunc(time) : result;
		      }

		      function remainingWait(time) {
		        var timeSinceLastCall = time - lastCallTime,
		            timeSinceLastInvoke = time - lastInvokeTime,
		            timeWaiting = wait - timeSinceLastCall;

		        return maxing
		          ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)
		          : timeWaiting;
		      }

		      function shouldInvoke(time) {
		        var timeSinceLastCall = time - lastCallTime,
		            timeSinceLastInvoke = time - lastInvokeTime;

		        // Either this is the first call, activity has stopped and we're at the
		        // trailing edge, the system time has gone backwards and we're treating
		        // it as the trailing edge, or we've hit the `maxWait` limit.
		        return (lastCallTime === undefined$1 || (timeSinceLastCall >= wait) ||
		          (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
		      }

		      function timerExpired() {
		        var time = now();
		        if (shouldInvoke(time)) {
		          return trailingEdge(time);
		        }
		        // Restart the timer.
		        timerId = setTimeout(timerExpired, remainingWait(time));
		      }

		      function trailingEdge(time) {
		        timerId = undefined$1;

		        // Only invoke if we have `lastArgs` which means `func` has been
		        // debounced at least once.
		        if (trailing && lastArgs) {
		          return invokeFunc(time);
		        }
		        lastArgs = lastThis = undefined$1;
		        return result;
		      }

		      function cancel() {
		        if (timerId !== undefined$1) {
		          clearTimeout(timerId);
		        }
		        lastInvokeTime = 0;
		        lastArgs = lastCallTime = lastThis = timerId = undefined$1;
		      }

		      function flush() {
		        return timerId === undefined$1 ? result : trailingEdge(now());
		      }

		      function debounced() {
		        var time = now(),
		            isInvoking = shouldInvoke(time);

		        lastArgs = arguments;
		        lastThis = this;
		        lastCallTime = time;

		        if (isInvoking) {
		          if (timerId === undefined$1) {
		            return leadingEdge(lastCallTime);
		          }
		          if (maxing) {
		            // Handle invocations in a tight loop.
		            clearTimeout(timerId);
		            timerId = setTimeout(timerExpired, wait);
		            return invokeFunc(lastCallTime);
		          }
		        }
		        if (timerId === undefined$1) {
		          timerId = setTimeout(timerExpired, wait);
		        }
		        return result;
		      }
		      debounced.cancel = cancel;
		      debounced.flush = flush;
		      return debounced;
		    }

		    /**
		     * Defers invoking the `func` until the current call stack has cleared. Any
		     * additional arguments are provided to `func` when it's invoked.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Function
		     * @param {Function} func The function to defer.
		     * @param {...*} [args] The arguments to invoke `func` with.
		     * @returns {number} Returns the timer id.
		     * @example
		     *
		     * _.defer(function(text) {
		     *   console.log(text);
		     * }, 'deferred');
		     * // => Logs 'deferred' after one millisecond.
		     */
		    var defer = baseRest(function(func, args) {
		      return baseDelay(func, 1, args);
		    });

		    /**
		     * Invokes `func` after `wait` milliseconds. Any additional arguments are
		     * provided to `func` when it's invoked.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Function
		     * @param {Function} func The function to delay.
		     * @param {number} wait The number of milliseconds to delay invocation.
		     * @param {...*} [args] The arguments to invoke `func` with.
		     * @returns {number} Returns the timer id.
		     * @example
		     *
		     * _.delay(function(text) {
		     *   console.log(text);
		     * }, 1000, 'later');
		     * // => Logs 'later' after one second.
		     */
		    var delay = baseRest(function(func, wait, args) {
		      return baseDelay(func, toNumber(wait) || 0, args);
		    });

		    /**
		     * Creates a function that invokes `func` with arguments reversed.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Function
		     * @param {Function} func The function to flip arguments for.
		     * @returns {Function} Returns the new flipped function.
		     * @example
		     *
		     * var flipped = _.flip(function() {
		     *   return _.toArray(arguments);
		     * });
		     *
		     * flipped('a', 'b', 'c', 'd');
		     * // => ['d', 'c', 'b', 'a']
		     */
		    function flip(func) {
		      return createWrap(func, WRAP_FLIP_FLAG);
		    }

		    /**
		     * Creates a function that memoizes the result of `func`. If `resolver` is
		     * provided, it determines the cache key for storing the result based on the
		     * arguments provided to the memoized function. By default, the first argument
		     * provided to the memoized function is used as the map cache key. The `func`
		     * is invoked with the `this` binding of the memoized function.
		     *
		     * **Note:** The cache is exposed as the `cache` property on the memoized
		     * function. Its creation may be customized by replacing the `_.memoize.Cache`
		     * constructor with one whose instances implement the
		     * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
		     * method interface of `clear`, `delete`, `get`, `has`, and `set`.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Function
		     * @param {Function} func The function to have its output memoized.
		     * @param {Function} [resolver] The function to resolve the cache key.
		     * @returns {Function} Returns the new memoized function.
		     * @example
		     *
		     * var object = { 'a': 1, 'b': 2 };
		     * var other = { 'c': 3, 'd': 4 };
		     *
		     * var values = _.memoize(_.values);
		     * values(object);
		     * // => [1, 2]
		     *
		     * values(other);
		     * // => [3, 4]
		     *
		     * object.a = 2;
		     * values(object);
		     * // => [1, 2]
		     *
		     * // Modify the result cache.
		     * values.cache.set(object, ['a', 'b']);
		     * values(object);
		     * // => ['a', 'b']
		     *
		     * // Replace `_.memoize.Cache`.
		     * _.memoize.Cache = WeakMap;
		     */
		    function memoize(func, resolver) {
		      if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
		        throw new TypeError(FUNC_ERROR_TEXT);
		      }
		      var memoized = function() {
		        var args = arguments,
		            key = resolver ? resolver.apply(this, args) : args[0],
		            cache = memoized.cache;

		        if (cache.has(key)) {
		          return cache.get(key);
		        }
		        var result = func.apply(this, args);
		        memoized.cache = cache.set(key, result) || cache;
		        return result;
		      };
		      memoized.cache = new (memoize.Cache || MapCache);
		      return memoized;
		    }

		    // Expose `MapCache`.
		    memoize.Cache = MapCache;

		    /**
		     * Creates a function that negates the result of the predicate `func`. The
		     * `func` predicate is invoked with the `this` binding and arguments of the
		     * created function.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Function
		     * @param {Function} predicate The predicate to negate.
		     * @returns {Function} Returns the new negated function.
		     * @example
		     *
		     * function isEven(n) {
		     *   return n % 2 == 0;
		     * }
		     *
		     * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
		     * // => [1, 3, 5]
		     */
		    function negate(predicate) {
		      if (typeof predicate != 'function') {
		        throw new TypeError(FUNC_ERROR_TEXT);
		      }
		      return function() {
		        var args = arguments;
		        switch (args.length) {
		          case 0: return !predicate.call(this);
		          case 1: return !predicate.call(this, args[0]);
		          case 2: return !predicate.call(this, args[0], args[1]);
		          case 3: return !predicate.call(this, args[0], args[1], args[2]);
		        }
		        return !predicate.apply(this, args);
		      };
		    }

		    /**
		     * Creates a function that is restricted to invoking `func` once. Repeat calls
		     * to the function return the value of the first invocation. The `func` is
		     * invoked with the `this` binding and arguments of the created function.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Function
		     * @param {Function} func The function to restrict.
		     * @returns {Function} Returns the new restricted function.
		     * @example
		     *
		     * var initialize = _.once(createApplication);
		     * initialize();
		     * initialize();
		     * // => `createApplication` is invoked once
		     */
		    function once(func) {
		      return before(2, func);
		    }

		    /**
		     * Creates a function that invokes `func` with its arguments transformed.
		     *
		     * @static
		     * @since 4.0.0
		     * @memberOf _
		     * @category Function
		     * @param {Function} func The function to wrap.
		     * @param {...(Function|Function[])} [transforms=[_.identity]]
		     *  The argument transforms.
		     * @returns {Function} Returns the new function.
		     * @example
		     *
		     * function doubled(n) {
		     *   return n * 2;
		     * }
		     *
		     * function square(n) {
		     *   return n * n;
		     * }
		     *
		     * var func = _.overArgs(function(x, y) {
		     *   return [x, y];
		     * }, [square, doubled]);
		     *
		     * func(9, 3);
		     * // => [81, 6]
		     *
		     * func(10, 5);
		     * // => [100, 10]
		     */
		    var overArgs = castRest(function(func, transforms) {
		      transforms = (transforms.length == 1 && isArray(transforms[0]))
		        ? arrayMap(transforms[0], baseUnary(getIteratee()))
		        : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));

		      var funcsLength = transforms.length;
		      return baseRest(function(args) {
		        var index = -1,
		            length = nativeMin(args.length, funcsLength);

		        while (++index < length) {
		          args[index] = transforms[index].call(this, args[index]);
		        }
		        return apply(func, this, args);
		      });
		    });

		    /**
		     * Creates a function that invokes `func` with `partials` prepended to the
		     * arguments it receives. This method is like `_.bind` except it does **not**
		     * alter the `this` binding.
		     *
		     * The `_.partial.placeholder` value, which defaults to `_` in monolithic
		     * builds, may be used as a placeholder for partially applied arguments.
		     *
		     * **Note:** This method doesn't set the "length" property of partially
		     * applied functions.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.2.0
		     * @category Function
		     * @param {Function} func The function to partially apply arguments to.
		     * @param {...*} [partials] The arguments to be partially applied.
		     * @returns {Function} Returns the new partially applied function.
		     * @example
		     *
		     * function greet(greeting, name) {
		     *   return greeting + ' ' + name;
		     * }
		     *
		     * var sayHelloTo = _.partial(greet, 'hello');
		     * sayHelloTo('fred');
		     * // => 'hello fred'
		     *
		     * // Partially applied with placeholders.
		     * var greetFred = _.partial(greet, _, 'fred');
		     * greetFred('hi');
		     * // => 'hi fred'
		     */
		    var partial = baseRest(function(func, partials) {
		      var holders = replaceHolders(partials, getHolder(partial));
		      return createWrap(func, WRAP_PARTIAL_FLAG, undefined$1, partials, holders);
		    });

		    /**
		     * This method is like `_.partial` except that partially applied arguments
		     * are appended to the arguments it receives.
		     *
		     * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic
		     * builds, may be used as a placeholder for partially applied arguments.
		     *
		     * **Note:** This method doesn't set the "length" property of partially
		     * applied functions.
		     *
		     * @static
		     * @memberOf _
		     * @since 1.0.0
		     * @category Function
		     * @param {Function} func The function to partially apply arguments to.
		     * @param {...*} [partials] The arguments to be partially applied.
		     * @returns {Function} Returns the new partially applied function.
		     * @example
		     *
		     * function greet(greeting, name) {
		     *   return greeting + ' ' + name;
		     * }
		     *
		     * var greetFred = _.partialRight(greet, 'fred');
		     * greetFred('hi');
		     * // => 'hi fred'
		     *
		     * // Partially applied with placeholders.
		     * var sayHelloTo = _.partialRight(greet, 'hello', _);
		     * sayHelloTo('fred');
		     * // => 'hello fred'
		     */
		    var partialRight = baseRest(function(func, partials) {
		      var holders = replaceHolders(partials, getHolder(partialRight));
		      return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined$1, partials, holders);
		    });

		    /**
		     * Creates a function that invokes `func` with arguments arranged according
		     * to the specified `indexes` where the argument value at the first index is
		     * provided as the first argument, the argument value at the second index is
		     * provided as the second argument, and so on.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Function
		     * @param {Function} func The function to rearrange arguments for.
		     * @param {...(number|number[])} indexes The arranged argument indexes.
		     * @returns {Function} Returns the new function.
		     * @example
		     *
		     * var rearged = _.rearg(function(a, b, c) {
		     *   return [a, b, c];
		     * }, [2, 0, 1]);
		     *
		     * rearged('b', 'c', 'a')
		     * // => ['a', 'b', 'c']
		     */
		    var rearg = flatRest(function(func, indexes) {
		      return createWrap(func, WRAP_REARG_FLAG, undefined$1, undefined$1, undefined$1, indexes);
		    });

		    /**
		     * Creates a function that invokes `func` with the `this` binding of the
		     * created function and arguments from `start` and beyond provided as
		     * an array.
		     *
		     * **Note:** This method is based on the
		     * [rest parameter](https://mdn.io/rest_parameters).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Function
		     * @param {Function} func The function to apply a rest parameter to.
		     * @param {number} [start=func.length-1] The start position of the rest parameter.
		     * @returns {Function} Returns the new function.
		     * @example
		     *
		     * var say = _.rest(function(what, names) {
		     *   return what + ' ' + _.initial(names).join(', ') +
		     *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);
		     * });
		     *
		     * say('hello', 'fred', 'barney', 'pebbles');
		     * // => 'hello fred, barney, & pebbles'
		     */
		    function rest(func, start) {
		      if (typeof func != 'function') {
		        throw new TypeError(FUNC_ERROR_TEXT);
		      }
		      start = start === undefined$1 ? start : toInteger(start);
		      return baseRest(func, start);
		    }

		    /**
		     * Creates a function that invokes `func` with the `this` binding of the
		     * create function and an array of arguments much like
		     * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).
		     *
		     * **Note:** This method is based on the
		     * [spread operator](https://mdn.io/spread_operator).
		     *
		     * @static
		     * @memberOf _
		     * @since 3.2.0
		     * @category Function
		     * @param {Function} func The function to spread arguments over.
		     * @param {number} [start=0] The start position of the spread.
		     * @returns {Function} Returns the new function.
		     * @example
		     *
		     * var say = _.spread(function(who, what) {
		     *   return who + ' says ' + what;
		     * });
		     *
		     * say(['fred', 'hello']);
		     * // => 'fred says hello'
		     *
		     * var numbers = Promise.all([
		     *   Promise.resolve(40),
		     *   Promise.resolve(36)
		     * ]);
		     *
		     * numbers.then(_.spread(function(x, y) {
		     *   return x + y;
		     * }));
		     * // => a Promise of 76
		     */
		    function spread(func, start) {
		      if (typeof func != 'function') {
		        throw new TypeError(FUNC_ERROR_TEXT);
		      }
		      start = start == null ? 0 : nativeMax(toInteger(start), 0);
		      return baseRest(function(args) {
		        var array = args[start],
		            otherArgs = castSlice(args, 0, start);

		        if (array) {
		          arrayPush(otherArgs, array);
		        }
		        return apply(func, this, otherArgs);
		      });
		    }

		    /**
		     * Creates a throttled function that only invokes `func` at most once per
		     * every `wait` milliseconds. The throttled function comes with a `cancel`
		     * method to cancel delayed `func` invocations and a `flush` method to
		     * immediately invoke them. Provide `options` to indicate whether `func`
		     * should be invoked on the leading and/or trailing edge of the `wait`
		     * timeout. The `func` is invoked with the last arguments provided to the
		     * throttled function. Subsequent calls to the throttled function return the
		     * result of the last `func` invocation.
		     *
		     * **Note:** If `leading` and `trailing` options are `true`, `func` is
		     * invoked on the trailing edge of the timeout only if the throttled function
		     * is invoked more than once during the `wait` timeout.
		     *
		     * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
		     * until to the next tick, similar to `setTimeout` with a timeout of `0`.
		     *
		     * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
		     * for details over the differences between `_.throttle` and `_.debounce`.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Function
		     * @param {Function} func The function to throttle.
		     * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
		     * @param {Object} [options={}] The options object.
		     * @param {boolean} [options.leading=true]
		     *  Specify invoking on the leading edge of the timeout.
		     * @param {boolean} [options.trailing=true]
		     *  Specify invoking on the trailing edge of the timeout.
		     * @returns {Function} Returns the new throttled function.
		     * @example
		     *
		     * // Avoid excessively updating the position while scrolling.
		     * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
		     *
		     * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
		     * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
		     * jQuery(element).on('click', throttled);
		     *
		     * // Cancel the trailing throttled invocation.
		     * jQuery(window).on('popstate', throttled.cancel);
		     */
		    function throttle(func, wait, options) {
		      var leading = true,
		          trailing = true;

		      if (typeof func != 'function') {
		        throw new TypeError(FUNC_ERROR_TEXT);
		      }
		      if (isObject(options)) {
		        leading = 'leading' in options ? !!options.leading : leading;
		        trailing = 'trailing' in options ? !!options.trailing : trailing;
		      }
		      return debounce(func, wait, {
		        'leading': leading,
		        'maxWait': wait,
		        'trailing': trailing
		      });
		    }

		    /**
		     * Creates a function that accepts up to one argument, ignoring any
		     * additional arguments.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Function
		     * @param {Function} func The function to cap arguments for.
		     * @returns {Function} Returns the new capped function.
		     * @example
		     *
		     * _.map(['6', '8', '10'], _.unary(parseInt));
		     * // => [6, 8, 10]
		     */
		    function unary(func) {
		      return ary(func, 1);
		    }

		    /**
		     * Creates a function that provides `value` to `wrapper` as its first
		     * argument. Any additional arguments provided to the function are appended
		     * to those provided to the `wrapper`. The wrapper is invoked with the `this`
		     * binding of the created function.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Function
		     * @param {*} value The value to wrap.
		     * @param {Function} [wrapper=identity] The wrapper function.
		     * @returns {Function} Returns the new function.
		     * @example
		     *
		     * var p = _.wrap(_.escape, function(func, text) {
		     *   return '<p>' + func(text) + '</p>';
		     * });
		     *
		     * p('fred, barney, & pebbles');
		     * // => '<p>fred, barney, &amp; pebbles</p>'
		     */
		    function wrap(value, wrapper) {
		      return partial(castFunction(wrapper), value);
		    }

		    /*------------------------------------------------------------------------*/

		    /**
		     * Casts `value` as an array if it's not one.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.4.0
		     * @category Lang
		     * @param {*} value The value to inspect.
		     * @returns {Array} Returns the cast array.
		     * @example
		     *
		     * _.castArray(1);
		     * // => [1]
		     *
		     * _.castArray({ 'a': 1 });
		     * // => [{ 'a': 1 }]
		     *
		     * _.castArray('abc');
		     * // => ['abc']
		     *
		     * _.castArray(null);
		     * // => [null]
		     *
		     * _.castArray(undefined);
		     * // => [undefined]
		     *
		     * _.castArray();
		     * // => []
		     *
		     * var array = [1, 2, 3];
		     * console.log(_.castArray(array) === array);
		     * // => true
		     */
		    function castArray() {
		      if (!arguments.length) {
		        return [];
		      }
		      var value = arguments[0];
		      return isArray(value) ? value : [value];
		    }

		    /**
		     * Creates a shallow clone of `value`.
		     *
		     * **Note:** This method is loosely based on the
		     * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)
		     * and supports cloning arrays, array buffers, booleans, date objects, maps,
		     * numbers, `Object` objects, regexes, sets, strings, symbols, and typed
		     * arrays. The own enumerable properties of `arguments` objects are cloned
		     * as plain objects. An empty object is returned for uncloneable values such
		     * as error objects, functions, DOM nodes, and WeakMaps.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Lang
		     * @param {*} value The value to clone.
		     * @returns {*} Returns the cloned value.
		     * @see _.cloneDeep
		     * @example
		     *
		     * var objects = [{ 'a': 1 }, { 'b': 2 }];
		     *
		     * var shallow = _.clone(objects);
		     * console.log(shallow[0] === objects[0]);
		     * // => true
		     */
		    function clone(value) {
		      return baseClone(value, CLONE_SYMBOLS_FLAG);
		    }

		    /**
		     * This method is like `_.clone` except that it accepts `customizer` which
		     * is invoked to produce the cloned value. If `customizer` returns `undefined`,
		     * cloning is handled by the method instead. The `customizer` is invoked with
		     * up to four arguments; (value [, index|key, object, stack]).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to clone.
		     * @param {Function} [customizer] The function to customize cloning.
		     * @returns {*} Returns the cloned value.
		     * @see _.cloneDeepWith
		     * @example
		     *
		     * function customizer(value) {
		     *   if (_.isElement(value)) {
		     *     return value.cloneNode(false);
		     *   }
		     * }
		     *
		     * var el = _.cloneWith(document.body, customizer);
		     *
		     * console.log(el === document.body);
		     * // => false
		     * console.log(el.nodeName);
		     * // => 'BODY'
		     * console.log(el.childNodes.length);
		     * // => 0
		     */
		    function cloneWith(value, customizer) {
		      customizer = typeof customizer == 'function' ? customizer : undefined$1;
		      return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);
		    }

		    /**
		     * This method is like `_.clone` except that it recursively clones `value`.
		     *
		     * @static
		     * @memberOf _
		     * @since 1.0.0
		     * @category Lang
		     * @param {*} value The value to recursively clone.
		     * @returns {*} Returns the deep cloned value.
		     * @see _.clone
		     * @example
		     *
		     * var objects = [{ 'a': 1 }, { 'b': 2 }];
		     *
		     * var deep = _.cloneDeep(objects);
		     * console.log(deep[0] === objects[0]);
		     * // => false
		     */
		    function cloneDeep(value) {
		      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
		    }

		    /**
		     * This method is like `_.cloneWith` except that it recursively clones `value`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to recursively clone.
		     * @param {Function} [customizer] The function to customize cloning.
		     * @returns {*} Returns the deep cloned value.
		     * @see _.cloneWith
		     * @example
		     *
		     * function customizer(value) {
		     *   if (_.isElement(value)) {
		     *     return value.cloneNode(true);
		     *   }
		     * }
		     *
		     * var el = _.cloneDeepWith(document.body, customizer);
		     *
		     * console.log(el === document.body);
		     * // => false
		     * console.log(el.nodeName);
		     * // => 'BODY'
		     * console.log(el.childNodes.length);
		     * // => 20
		     */
		    function cloneDeepWith(value, customizer) {
		      customizer = typeof customizer == 'function' ? customizer : undefined$1;
		      return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
		    }

		    /**
		     * Checks if `object` conforms to `source` by invoking the predicate
		     * properties of `source` with the corresponding property values of `object`.
		     *
		     * **Note:** This method is equivalent to `_.conforms` when `source` is
		     * partially applied.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.14.0
		     * @category Lang
		     * @param {Object} object The object to inspect.
		     * @param {Object} source The object of property predicates to conform to.
		     * @returns {boolean} Returns `true` if `object` conforms, else `false`.
		     * @example
		     *
		     * var object = { 'a': 1, 'b': 2 };
		     *
		     * _.conformsTo(object, { 'b': function(n) { return n > 1; } });
		     * // => true
		     *
		     * _.conformsTo(object, { 'b': function(n) { return n > 2; } });
		     * // => false
		     */
		    function conformsTo(object, source) {
		      return source == null || baseConformsTo(object, source, keys(source));
		    }

		    /**
		     * Performs a
		     * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
		     * comparison between two values to determine if they are equivalent.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to compare.
		     * @param {*} other The other value to compare.
		     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
		     * @example
		     *
		     * var object = { 'a': 1 };
		     * var other = { 'a': 1 };
		     *
		     * _.eq(object, object);
		     * // => true
		     *
		     * _.eq(object, other);
		     * // => false
		     *
		     * _.eq('a', 'a');
		     * // => true
		     *
		     * _.eq('a', Object('a'));
		     * // => false
		     *
		     * _.eq(NaN, NaN);
		     * // => true
		     */
		    function eq(value, other) {
		      return value === other || (value !== value && other !== other);
		    }

		    /**
		     * Checks if `value` is greater than `other`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.9.0
		     * @category Lang
		     * @param {*} value The value to compare.
		     * @param {*} other The other value to compare.
		     * @returns {boolean} Returns `true` if `value` is greater than `other`,
		     *  else `false`.
		     * @see _.lt
		     * @example
		     *
		     * _.gt(3, 1);
		     * // => true
		     *
		     * _.gt(3, 3);
		     * // => false
		     *
		     * _.gt(1, 3);
		     * // => false
		     */
		    var gt = createRelationalOperation(baseGt);

		    /**
		     * Checks if `value` is greater than or equal to `other`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.9.0
		     * @category Lang
		     * @param {*} value The value to compare.
		     * @param {*} other The other value to compare.
		     * @returns {boolean} Returns `true` if `value` is greater than or equal to
		     *  `other`, else `false`.
		     * @see _.lte
		     * @example
		     *
		     * _.gte(3, 1);
		     * // => true
		     *
		     * _.gte(3, 3);
		     * // => true
		     *
		     * _.gte(1, 3);
		     * // => false
		     */
		    var gte = createRelationalOperation(function(value, other) {
		      return value >= other;
		    });

		    /**
		     * Checks if `value` is likely an `arguments` object.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is an `arguments` object,
		     *  else `false`.
		     * @example
		     *
		     * _.isArguments(function() { return arguments; }());
		     * // => true
		     *
		     * _.isArguments([1, 2, 3]);
		     * // => false
		     */
		    var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
		      return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&
		        !propertyIsEnumerable.call(value, 'callee');
		    };

		    /**
		     * Checks if `value` is classified as an `Array` object.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is an array, else `false`.
		     * @example
		     *
		     * _.isArray([1, 2, 3]);
		     * // => true
		     *
		     * _.isArray(document.body.children);
		     * // => false
		     *
		     * _.isArray('abc');
		     * // => false
		     *
		     * _.isArray(_.noop);
		     * // => false
		     */
		    var isArray = Array.isArray;

		    /**
		     * Checks if `value` is classified as an `ArrayBuffer` object.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.3.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
		     * @example
		     *
		     * _.isArrayBuffer(new ArrayBuffer(2));
		     * // => true
		     *
		     * _.isArrayBuffer(new Array(2));
		     * // => false
		     */
		    var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;

		    /**
		     * Checks if `value` is array-like. A value is considered array-like if it's
		     * not a function and has a `value.length` that's an integer greater than or
		     * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
		     * @example
		     *
		     * _.isArrayLike([1, 2, 3]);
		     * // => true
		     *
		     * _.isArrayLike(document.body.children);
		     * // => true
		     *
		     * _.isArrayLike('abc');
		     * // => true
		     *
		     * _.isArrayLike(_.noop);
		     * // => false
		     */
		    function isArrayLike(value) {
		      return value != null && isLength(value.length) && !isFunction(value);
		    }

		    /**
		     * This method is like `_.isArrayLike` except that it also checks if `value`
		     * is an object.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is an array-like object,
		     *  else `false`.
		     * @example
		     *
		     * _.isArrayLikeObject([1, 2, 3]);
		     * // => true
		     *
		     * _.isArrayLikeObject(document.body.children);
		     * // => true
		     *
		     * _.isArrayLikeObject('abc');
		     * // => false
		     *
		     * _.isArrayLikeObject(_.noop);
		     * // => false
		     */
		    function isArrayLikeObject(value) {
		      return isObjectLike(value) && isArrayLike(value);
		    }

		    /**
		     * Checks if `value` is classified as a boolean primitive or object.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.
		     * @example
		     *
		     * _.isBoolean(false);
		     * // => true
		     *
		     * _.isBoolean(null);
		     * // => false
		     */
		    function isBoolean(value) {
		      return value === true || value === false ||
		        (isObjectLike(value) && baseGetTag(value) == boolTag);
		    }

		    /**
		     * Checks if `value` is a buffer.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.3.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
		     * @example
		     *
		     * _.isBuffer(new Buffer(2));
		     * // => true
		     *
		     * _.isBuffer(new Uint8Array(2));
		     * // => false
		     */
		    var isBuffer = nativeIsBuffer || stubFalse;

		    /**
		     * Checks if `value` is classified as a `Date` object.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
		     * @example
		     *
		     * _.isDate(new Date);
		     * // => true
		     *
		     * _.isDate('Mon April 23 2012');
		     * // => false
		     */
		    var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;

		    /**
		     * Checks if `value` is likely a DOM element.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.
		     * @example
		     *
		     * _.isElement(document.body);
		     * // => true
		     *
		     * _.isElement('<body>');
		     * // => false
		     */
		    function isElement(value) {
		      return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
		    }

		    /**
		     * Checks if `value` is an empty object, collection, map, or set.
		     *
		     * Objects are considered empty if they have no own enumerable string keyed
		     * properties.
		     *
		     * Array-like values such as `arguments` objects, arrays, buffers, strings, or
		     * jQuery-like collections are considered empty if they have a `length` of `0`.
		     * Similarly, maps and sets are considered empty if they have a `size` of `0`.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is empty, else `false`.
		     * @example
		     *
		     * _.isEmpty(null);
		     * // => true
		     *
		     * _.isEmpty(true);
		     * // => true
		     *
		     * _.isEmpty(1);
		     * // => true
		     *
		     * _.isEmpty([1, 2, 3]);
		     * // => false
		     *
		     * _.isEmpty({ 'a': 1 });
		     * // => false
		     */
		    function isEmpty(value) {
		      if (value == null) {
		        return true;
		      }
		      if (isArrayLike(value) &&
		          (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||
		            isBuffer(value) || isTypedArray(value) || isArguments(value))) {
		        return !value.length;
		      }
		      var tag = getTag(value);
		      if (tag == mapTag || tag == setTag) {
		        return !value.size;
		      }
		      if (isPrototype(value)) {
		        return !baseKeys(value).length;
		      }
		      for (var key in value) {
		        if (hasOwnProperty.call(value, key)) {
		          return false;
		        }
		      }
		      return true;
		    }

		    /**
		     * Performs a deep comparison between two values to determine if they are
		     * equivalent.
		     *
		     * **Note:** This method supports comparing arrays, array buffers, booleans,
		     * date objects, error objects, maps, numbers, `Object` objects, regexes,
		     * sets, strings, symbols, and typed arrays. `Object` objects are compared
		     * by their own, not inherited, enumerable properties. Functions and DOM
		     * nodes are compared by strict equality, i.e. `===`.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Lang
		     * @param {*} value The value to compare.
		     * @param {*} other The other value to compare.
		     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
		     * @example
		     *
		     * var object = { 'a': 1 };
		     * var other = { 'a': 1 };
		     *
		     * _.isEqual(object, other);
		     * // => true
		     *
		     * object === other;
		     * // => false
		     */
		    function isEqual(value, other) {
		      return baseIsEqual(value, other);
		    }

		    /**
		     * This method is like `_.isEqual` except that it accepts `customizer` which
		     * is invoked to compare values. If `customizer` returns `undefined`, comparisons
		     * are handled by the method instead. The `customizer` is invoked with up to
		     * six arguments: (objValue, othValue [, index|key, object, other, stack]).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to compare.
		     * @param {*} other The other value to compare.
		     * @param {Function} [customizer] The function to customize comparisons.
		     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
		     * @example
		     *
		     * function isGreeting(value) {
		     *   return /^h(?:i|ello)$/.test(value);
		     * }
		     *
		     * function customizer(objValue, othValue) {
		     *   if (isGreeting(objValue) && isGreeting(othValue)) {
		     *     return true;
		     *   }
		     * }
		     *
		     * var array = ['hello', 'goodbye'];
		     * var other = ['hi', 'goodbye'];
		     *
		     * _.isEqualWith(array, other, customizer);
		     * // => true
		     */
		    function isEqualWith(value, other, customizer) {
		      customizer = typeof customizer == 'function' ? customizer : undefined$1;
		      var result = customizer ? customizer(value, other) : undefined$1;
		      return result === undefined$1 ? baseIsEqual(value, other, undefined$1, customizer) : !!result;
		    }

		    /**
		     * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,
		     * `SyntaxError`, `TypeError`, or `URIError` object.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is an error object, else `false`.
		     * @example
		     *
		     * _.isError(new Error);
		     * // => true
		     *
		     * _.isError(Error);
		     * // => false
		     */
		    function isError(value) {
		      if (!isObjectLike(value)) {
		        return false;
		      }
		      var tag = baseGetTag(value);
		      return tag == errorTag || tag == domExcTag ||
		        (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));
		    }

		    /**
		     * Checks if `value` is a finite primitive number.
		     *
		     * **Note:** This method is based on
		     * [`Number.isFinite`](https://mdn.io/Number/isFinite).
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.
		     * @example
		     *
		     * _.isFinite(3);
		     * // => true
		     *
		     * _.isFinite(Number.MIN_VALUE);
		     * // => true
		     *
		     * _.isFinite(Infinity);
		     * // => false
		     *
		     * _.isFinite('3');
		     * // => false
		     */
		    function isFinite(value) {
		      return typeof value == 'number' && nativeIsFinite(value);
		    }

		    /**
		     * Checks if `value` is classified as a `Function` object.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a function, else `false`.
		     * @example
		     *
		     * _.isFunction(_);
		     * // => true
		     *
		     * _.isFunction(/abc/);
		     * // => false
		     */
		    function isFunction(value) {
		      if (!isObject(value)) {
		        return false;
		      }
		      // The use of `Object#toString` avoids issues with the `typeof` operator
		      // in Safari 9 which returns 'object' for typed arrays and other constructors.
		      var tag = baseGetTag(value);
		      return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
		    }

		    /**
		     * Checks if `value` is an integer.
		     *
		     * **Note:** This method is based on
		     * [`Number.isInteger`](https://mdn.io/Number/isInteger).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is an integer, else `false`.
		     * @example
		     *
		     * _.isInteger(3);
		     * // => true
		     *
		     * _.isInteger(Number.MIN_VALUE);
		     * // => false
		     *
		     * _.isInteger(Infinity);
		     * // => false
		     *
		     * _.isInteger('3');
		     * // => false
		     */
		    function isInteger(value) {
		      return typeof value == 'number' && value == toInteger(value);
		    }

		    /**
		     * Checks if `value` is a valid array-like length.
		     *
		     * **Note:** This method is loosely based on
		     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
		     * @example
		     *
		     * _.isLength(3);
		     * // => true
		     *
		     * _.isLength(Number.MIN_VALUE);
		     * // => false
		     *
		     * _.isLength(Infinity);
		     * // => false
		     *
		     * _.isLength('3');
		     * // => false
		     */
		    function isLength(value) {
		      return typeof value == 'number' &&
		        value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
		    }

		    /**
		     * Checks if `value` is the
		     * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
		     * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is an object, else `false`.
		     * @example
		     *
		     * _.isObject({});
		     * // => true
		     *
		     * _.isObject([1, 2, 3]);
		     * // => true
		     *
		     * _.isObject(_.noop);
		     * // => true
		     *
		     * _.isObject(null);
		     * // => false
		     */
		    function isObject(value) {
		      var type = typeof value;
		      return value != null && (type == 'object' || type == 'function');
		    }

		    /**
		     * Checks if `value` is object-like. A value is object-like if it's not `null`
		     * and has a `typeof` result of "object".
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
		     * @example
		     *
		     * _.isObjectLike({});
		     * // => true
		     *
		     * _.isObjectLike([1, 2, 3]);
		     * // => true
		     *
		     * _.isObjectLike(_.noop);
		     * // => false
		     *
		     * _.isObjectLike(null);
		     * // => false
		     */
		    function isObjectLike(value) {
		      return value != null && typeof value == 'object';
		    }

		    /**
		     * Checks if `value` is classified as a `Map` object.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.3.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a map, else `false`.
		     * @example
		     *
		     * _.isMap(new Map);
		     * // => true
		     *
		     * _.isMap(new WeakMap);
		     * // => false
		     */
		    var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;

		    /**
		     * Performs a partial deep comparison between `object` and `source` to
		     * determine if `object` contains equivalent property values.
		     *
		     * **Note:** This method is equivalent to `_.matches` when `source` is
		     * partially applied.
		     *
		     * Partial comparisons will match empty array and empty object `source`
		     * values against any array or object value, respectively. See `_.isEqual`
		     * for a list of supported value comparisons.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Lang
		     * @param {Object} object The object to inspect.
		     * @param {Object} source The object of property values to match.
		     * @returns {boolean} Returns `true` if `object` is a match, else `false`.
		     * @example
		     *
		     * var object = { 'a': 1, 'b': 2 };
		     *
		     * _.isMatch(object, { 'b': 2 });
		     * // => true
		     *
		     * _.isMatch(object, { 'b': 1 });
		     * // => false
		     */
		    function isMatch(object, source) {
		      return object === source || baseIsMatch(object, source, getMatchData(source));
		    }

		    /**
		     * This method is like `_.isMatch` except that it accepts `customizer` which
		     * is invoked to compare values. If `customizer` returns `undefined`, comparisons
		     * are handled by the method instead. The `customizer` is invoked with five
		     * arguments: (objValue, srcValue, index|key, object, source).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {Object} object The object to inspect.
		     * @param {Object} source The object of property values to match.
		     * @param {Function} [customizer] The function to customize comparisons.
		     * @returns {boolean} Returns `true` if `object` is a match, else `false`.
		     * @example
		     *
		     * function isGreeting(value) {
		     *   return /^h(?:i|ello)$/.test(value);
		     * }
		     *
		     * function customizer(objValue, srcValue) {
		     *   if (isGreeting(objValue) && isGreeting(srcValue)) {
		     *     return true;
		     *   }
		     * }
		     *
		     * var object = { 'greeting': 'hello' };
		     * var source = { 'greeting': 'hi' };
		     *
		     * _.isMatchWith(object, source, customizer);
		     * // => true
		     */
		    function isMatchWith(object, source, customizer) {
		      customizer = typeof customizer == 'function' ? customizer : undefined$1;
		      return baseIsMatch(object, source, getMatchData(source), customizer);
		    }

		    /**
		     * Checks if `value` is `NaN`.
		     *
		     * **Note:** This method is based on
		     * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as
		     * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for
		     * `undefined` and other non-number values.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
		     * @example
		     *
		     * _.isNaN(NaN);
		     * // => true
		     *
		     * _.isNaN(new Number(NaN));
		     * // => true
		     *
		     * isNaN(undefined);
		     * // => true
		     *
		     * _.isNaN(undefined);
		     * // => false
		     */
		    function isNaN(value) {
		      // An `NaN` primitive is the only value that is not equal to itself.
		      // Perform the `toStringTag` check first to avoid errors with some
		      // ActiveX objects in IE.
		      return isNumber(value) && value != +value;
		    }

		    /**
		     * Checks if `value` is a pristine native function.
		     *
		     * **Note:** This method can't reliably detect native functions in the presence
		     * of the core-js package because core-js circumvents this kind of detection.
		     * Despite multiple requests, the core-js maintainer has made it clear: any
		     * attempt to fix the detection will be obstructed. As a result, we're left
		     * with little choice but to throw an error. Unfortunately, this also affects
		     * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),
		     * which rely on core-js.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a native function,
		     *  else `false`.
		     * @example
		     *
		     * _.isNative(Array.prototype.push);
		     * // => true
		     *
		     * _.isNative(_);
		     * // => false
		     */
		    function isNative(value) {
		      if (isMaskable(value)) {
		        throw new Error(CORE_ERROR_TEXT);
		      }
		      return baseIsNative(value);
		    }

		    /**
		     * Checks if `value` is `null`.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is `null`, else `false`.
		     * @example
		     *
		     * _.isNull(null);
		     * // => true
		     *
		     * _.isNull(void 0);
		     * // => false
		     */
		    function isNull(value) {
		      return value === null;
		    }

		    /**
		     * Checks if `value` is `null` or `undefined`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is nullish, else `false`.
		     * @example
		     *
		     * _.isNil(null);
		     * // => true
		     *
		     * _.isNil(void 0);
		     * // => true
		     *
		     * _.isNil(NaN);
		     * // => false
		     */
		    function isNil(value) {
		      return value == null;
		    }

		    /**
		     * Checks if `value` is classified as a `Number` primitive or object.
		     *
		     * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are
		     * classified as numbers, use the `_.isFinite` method.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a number, else `false`.
		     * @example
		     *
		     * _.isNumber(3);
		     * // => true
		     *
		     * _.isNumber(Number.MIN_VALUE);
		     * // => true
		     *
		     * _.isNumber(Infinity);
		     * // => true
		     *
		     * _.isNumber('3');
		     * // => false
		     */
		    function isNumber(value) {
		      return typeof value == 'number' ||
		        (isObjectLike(value) && baseGetTag(value) == numberTag);
		    }

		    /**
		     * Checks if `value` is a plain object, that is, an object created by the
		     * `Object` constructor or one with a `[[Prototype]]` of `null`.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.8.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
		     * @example
		     *
		     * function Foo() {
		     *   this.a = 1;
		     * }
		     *
		     * _.isPlainObject(new Foo);
		     * // => false
		     *
		     * _.isPlainObject([1, 2, 3]);
		     * // => false
		     *
		     * _.isPlainObject({ 'x': 0, 'y': 0 });
		     * // => true
		     *
		     * _.isPlainObject(Object.create(null));
		     * // => true
		     */
		    function isPlainObject(value) {
		      if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
		        return false;
		      }
		      var proto = getPrototype(value);
		      if (proto === null) {
		        return true;
		      }
		      var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
		      return typeof Ctor == 'function' && Ctor instanceof Ctor &&
		        funcToString.call(Ctor) == objectCtorString;
		    }

		    /**
		     * Checks if `value` is classified as a `RegExp` object.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.1.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.
		     * @example
		     *
		     * _.isRegExp(/abc/);
		     * // => true
		     *
		     * _.isRegExp('/abc/');
		     * // => false
		     */
		    var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;

		    /**
		     * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754
		     * double precision number which isn't the result of a rounded unsafe integer.
		     *
		     * **Note:** This method is based on
		     * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.
		     * @example
		     *
		     * _.isSafeInteger(3);
		     * // => true
		     *
		     * _.isSafeInteger(Number.MIN_VALUE);
		     * // => false
		     *
		     * _.isSafeInteger(Infinity);
		     * // => false
		     *
		     * _.isSafeInteger('3');
		     * // => false
		     */
		    function isSafeInteger(value) {
		      return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
		    }

		    /**
		     * Checks if `value` is classified as a `Set` object.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.3.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a set, else `false`.
		     * @example
		     *
		     * _.isSet(new Set);
		     * // => true
		     *
		     * _.isSet(new WeakSet);
		     * // => false
		     */
		    var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;

		    /**
		     * Checks if `value` is classified as a `String` primitive or object.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a string, else `false`.
		     * @example
		     *
		     * _.isString('abc');
		     * // => true
		     *
		     * _.isString(1);
		     * // => false
		     */
		    function isString(value) {
		      return typeof value == 'string' ||
		        (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);
		    }

		    /**
		     * Checks if `value` is classified as a `Symbol` primitive or object.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
		     * @example
		     *
		     * _.isSymbol(Symbol.iterator);
		     * // => true
		     *
		     * _.isSymbol('abc');
		     * // => false
		     */
		    function isSymbol(value) {
		      return typeof value == 'symbol' ||
		        (isObjectLike(value) && baseGetTag(value) == symbolTag);
		    }

		    /**
		     * Checks if `value` is classified as a typed array.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
		     * @example
		     *
		     * _.isTypedArray(new Uint8Array);
		     * // => true
		     *
		     * _.isTypedArray([]);
		     * // => false
		     */
		    var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;

		    /**
		     * Checks if `value` is `undefined`.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
		     * @example
		     *
		     * _.isUndefined(void 0);
		     * // => true
		     *
		     * _.isUndefined(null);
		     * // => false
		     */
		    function isUndefined(value) {
		      return value === undefined$1;
		    }

		    /**
		     * Checks if `value` is classified as a `WeakMap` object.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.3.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.
		     * @example
		     *
		     * _.isWeakMap(new WeakMap);
		     * // => true
		     *
		     * _.isWeakMap(new Map);
		     * // => false
		     */
		    function isWeakMap(value) {
		      return isObjectLike(value) && getTag(value) == weakMapTag;
		    }

		    /**
		     * Checks if `value` is classified as a `WeakSet` object.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.3.0
		     * @category Lang
		     * @param {*} value The value to check.
		     * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.
		     * @example
		     *
		     * _.isWeakSet(new WeakSet);
		     * // => true
		     *
		     * _.isWeakSet(new Set);
		     * // => false
		     */
		    function isWeakSet(value) {
		      return isObjectLike(value) && baseGetTag(value) == weakSetTag;
		    }

		    /**
		     * Checks if `value` is less than `other`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.9.0
		     * @category Lang
		     * @param {*} value The value to compare.
		     * @param {*} other The other value to compare.
		     * @returns {boolean} Returns `true` if `value` is less than `other`,
		     *  else `false`.
		     * @see _.gt
		     * @example
		     *
		     * _.lt(1, 3);
		     * // => true
		     *
		     * _.lt(3, 3);
		     * // => false
		     *
		     * _.lt(3, 1);
		     * // => false
		     */
		    var lt = createRelationalOperation(baseLt);

		    /**
		     * Checks if `value` is less than or equal to `other`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.9.0
		     * @category Lang
		     * @param {*} value The value to compare.
		     * @param {*} other The other value to compare.
		     * @returns {boolean} Returns `true` if `value` is less than or equal to
		     *  `other`, else `false`.
		     * @see _.gte
		     * @example
		     *
		     * _.lte(1, 3);
		     * // => true
		     *
		     * _.lte(3, 3);
		     * // => true
		     *
		     * _.lte(3, 1);
		     * // => false
		     */
		    var lte = createRelationalOperation(function(value, other) {
		      return value <= other;
		    });

		    /**
		     * Converts `value` to an array.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Lang
		     * @param {*} value The value to convert.
		     * @returns {Array} Returns the converted array.
		     * @example
		     *
		     * _.toArray({ 'a': 1, 'b': 2 });
		     * // => [1, 2]
		     *
		     * _.toArray('abc');
		     * // => ['a', 'b', 'c']
		     *
		     * _.toArray(1);
		     * // => []
		     *
		     * _.toArray(null);
		     * // => []
		     */
		    function toArray(value) {
		      if (!value) {
		        return [];
		      }
		      if (isArrayLike(value)) {
		        return isString(value) ? stringToArray(value) : copyArray(value);
		      }
		      if (symIterator && value[symIterator]) {
		        return iteratorToArray(value[symIterator]());
		      }
		      var tag = getTag(value),
		          func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);

		      return func(value);
		    }

		    /**
		     * Converts `value` to a finite number.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.12.0
		     * @category Lang
		     * @param {*} value The value to convert.
		     * @returns {number} Returns the converted number.
		     * @example
		     *
		     * _.toFinite(3.2);
		     * // => 3.2
		     *
		     * _.toFinite(Number.MIN_VALUE);
		     * // => 5e-324
		     *
		     * _.toFinite(Infinity);
		     * // => 1.7976931348623157e+308
		     *
		     * _.toFinite('3.2');
		     * // => 3.2
		     */
		    function toFinite(value) {
		      if (!value) {
		        return value === 0 ? value : 0;
		      }
		      value = toNumber(value);
		      if (value === INFINITY || value === -INFINITY) {
		        var sign = (value < 0 ? -1 : 1);
		        return sign * MAX_INTEGER;
		      }
		      return value === value ? value : 0;
		    }

		    /**
		     * Converts `value` to an integer.
		     *
		     * **Note:** This method is loosely based on
		     * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to convert.
		     * @returns {number} Returns the converted integer.
		     * @example
		     *
		     * _.toInteger(3.2);
		     * // => 3
		     *
		     * _.toInteger(Number.MIN_VALUE);
		     * // => 0
		     *
		     * _.toInteger(Infinity);
		     * // => 1.7976931348623157e+308
		     *
		     * _.toInteger('3.2');
		     * // => 3
		     */
		    function toInteger(value) {
		      var result = toFinite(value),
		          remainder = result % 1;

		      return result === result ? (remainder ? result - remainder : result) : 0;
		    }

		    /**
		     * Converts `value` to an integer suitable for use as the length of an
		     * array-like object.
		     *
		     * **Note:** This method is based on
		     * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to convert.
		     * @returns {number} Returns the converted integer.
		     * @example
		     *
		     * _.toLength(3.2);
		     * // => 3
		     *
		     * _.toLength(Number.MIN_VALUE);
		     * // => 0
		     *
		     * _.toLength(Infinity);
		     * // => 4294967295
		     *
		     * _.toLength('3.2');
		     * // => 3
		     */
		    function toLength(value) {
		      return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;
		    }

		    /**
		     * Converts `value` to a number.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to process.
		     * @returns {number} Returns the number.
		     * @example
		     *
		     * _.toNumber(3.2);
		     * // => 3.2
		     *
		     * _.toNumber(Number.MIN_VALUE);
		     * // => 5e-324
		     *
		     * _.toNumber(Infinity);
		     * // => Infinity
		     *
		     * _.toNumber('3.2');
		     * // => 3.2
		     */
		    function toNumber(value) {
		      if (typeof value == 'number') {
		        return value;
		      }
		      if (isSymbol(value)) {
		        return NAN;
		      }
		      if (isObject(value)) {
		        var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
		        value = isObject(other) ? (other + '') : other;
		      }
		      if (typeof value != 'string') {
		        return value === 0 ? value : +value;
		      }
		      value = baseTrim(value);
		      var isBinary = reIsBinary.test(value);
		      return (isBinary || reIsOctal.test(value))
		        ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
		        : (reIsBadHex.test(value) ? NAN : +value);
		    }

		    /**
		     * Converts `value` to a plain object flattening inherited enumerable string
		     * keyed properties of `value` to own properties of the plain object.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Lang
		     * @param {*} value The value to convert.
		     * @returns {Object} Returns the converted plain object.
		     * @example
		     *
		     * function Foo() {
		     *   this.b = 2;
		     * }
		     *
		     * Foo.prototype.c = 3;
		     *
		     * _.assign({ 'a': 1 }, new Foo);
		     * // => { 'a': 1, 'b': 2 }
		     *
		     * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
		     * // => { 'a': 1, 'b': 2, 'c': 3 }
		     */
		    function toPlainObject(value) {
		      return copyObject(value, keysIn(value));
		    }

		    /**
		     * Converts `value` to a safe integer. A safe integer can be compared and
		     * represented correctly.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to convert.
		     * @returns {number} Returns the converted integer.
		     * @example
		     *
		     * _.toSafeInteger(3.2);
		     * // => 3
		     *
		     * _.toSafeInteger(Number.MIN_VALUE);
		     * // => 0
		     *
		     * _.toSafeInteger(Infinity);
		     * // => 9007199254740991
		     *
		     * _.toSafeInteger('3.2');
		     * // => 3
		     */
		    function toSafeInteger(value) {
		      return value
		        ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)
		        : (value === 0 ? value : 0);
		    }

		    /**
		     * Converts `value` to a string. An empty string is returned for `null`
		     * and `undefined` values. The sign of `-0` is preserved.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Lang
		     * @param {*} value The value to convert.
		     * @returns {string} Returns the converted string.
		     * @example
		     *
		     * _.toString(null);
		     * // => ''
		     *
		     * _.toString(-0);
		     * // => '-0'
		     *
		     * _.toString([1, 2, 3]);
		     * // => '1,2,3'
		     */
		    function toString(value) {
		      return value == null ? '' : baseToString(value);
		    }

		    /*------------------------------------------------------------------------*/

		    /**
		     * Assigns own enumerable string keyed properties of source objects to the
		     * destination object. Source objects are applied from left to right.
		     * Subsequent sources overwrite property assignments of previous sources.
		     *
		     * **Note:** This method mutates `object` and is loosely based on
		     * [`Object.assign`](https://mdn.io/Object/assign).
		     *
		     * @static
		     * @memberOf _
		     * @since 0.10.0
		     * @category Object
		     * @param {Object} object The destination object.
		     * @param {...Object} [sources] The source objects.
		     * @returns {Object} Returns `object`.
		     * @see _.assignIn
		     * @example
		     *
		     * function Foo() {
		     *   this.a = 1;
		     * }
		     *
		     * function Bar() {
		     *   this.c = 3;
		     * }
		     *
		     * Foo.prototype.b = 2;
		     * Bar.prototype.d = 4;
		     *
		     * _.assign({ 'a': 0 }, new Foo, new Bar);
		     * // => { 'a': 1, 'c': 3 }
		     */
		    var assign = createAssigner(function(object, source) {
		      if (isPrototype(source) || isArrayLike(source)) {
		        copyObject(source, keys(source), object);
		        return;
		      }
		      for (var key in source) {
		        if (hasOwnProperty.call(source, key)) {
		          assignValue(object, key, source[key]);
		        }
		      }
		    });

		    /**
		     * This method is like `_.assign` except that it iterates over own and
		     * inherited source properties.
		     *
		     * **Note:** This method mutates `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @alias extend
		     * @category Object
		     * @param {Object} object The destination object.
		     * @param {...Object} [sources] The source objects.
		     * @returns {Object} Returns `object`.
		     * @see _.assign
		     * @example
		     *
		     * function Foo() {
		     *   this.a = 1;
		     * }
		     *
		     * function Bar() {
		     *   this.c = 3;
		     * }
		     *
		     * Foo.prototype.b = 2;
		     * Bar.prototype.d = 4;
		     *
		     * _.assignIn({ 'a': 0 }, new Foo, new Bar);
		     * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }
		     */
		    var assignIn = createAssigner(function(object, source) {
		      copyObject(source, keysIn(source), object);
		    });

		    /**
		     * This method is like `_.assignIn` except that it accepts `customizer`
		     * which is invoked to produce the assigned values. If `customizer` returns
		     * `undefined`, assignment is handled by the method instead. The `customizer`
		     * is invoked with five arguments: (objValue, srcValue, key, object, source).
		     *
		     * **Note:** This method mutates `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @alias extendWith
		     * @category Object
		     * @param {Object} object The destination object.
		     * @param {...Object} sources The source objects.
		     * @param {Function} [customizer] The function to customize assigned values.
		     * @returns {Object} Returns `object`.
		     * @see _.assignWith
		     * @example
		     *
		     * function customizer(objValue, srcValue) {
		     *   return _.isUndefined(objValue) ? srcValue : objValue;
		     * }
		     *
		     * var defaults = _.partialRight(_.assignInWith, customizer);
		     *
		     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
		     * // => { 'a': 1, 'b': 2 }
		     */
		    var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
		      copyObject(source, keysIn(source), object, customizer);
		    });

		    /**
		     * This method is like `_.assign` except that it accepts `customizer`
		     * which is invoked to produce the assigned values. If `customizer` returns
		     * `undefined`, assignment is handled by the method instead. The `customizer`
		     * is invoked with five arguments: (objValue, srcValue, key, object, source).
		     *
		     * **Note:** This method mutates `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Object
		     * @param {Object} object The destination object.
		     * @param {...Object} sources The source objects.
		     * @param {Function} [customizer] The function to customize assigned values.
		     * @returns {Object} Returns `object`.
		     * @see _.assignInWith
		     * @example
		     *
		     * function customizer(objValue, srcValue) {
		     *   return _.isUndefined(objValue) ? srcValue : objValue;
		     * }
		     *
		     * var defaults = _.partialRight(_.assignWith, customizer);
		     *
		     * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
		     * // => { 'a': 1, 'b': 2 }
		     */
		    var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
		      copyObject(source, keys(source), object, customizer);
		    });

		    /**
		     * Creates an array of values corresponding to `paths` of `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 1.0.0
		     * @category Object
		     * @param {Object} object The object to iterate over.
		     * @param {...(string|string[])} [paths] The property paths to pick.
		     * @returns {Array} Returns the picked values.
		     * @example
		     *
		     * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };
		     *
		     * _.at(object, ['a[0].b.c', 'a[1]']);
		     * // => [3, 4]
		     */
		    var at = flatRest(baseAt);

		    /**
		     * Creates an object that inherits from the `prototype` object. If a
		     * `properties` object is given, its own enumerable string keyed properties
		     * are assigned to the created object.
		     *
		     * @static
		     * @memberOf _
		     * @since 2.3.0
		     * @category Object
		     * @param {Object} prototype The object to inherit from.
		     * @param {Object} [properties] The properties to assign to the object.
		     * @returns {Object} Returns the new object.
		     * @example
		     *
		     * function Shape() {
		     *   this.x = 0;
		     *   this.y = 0;
		     * }
		     *
		     * function Circle() {
		     *   Shape.call(this);
		     * }
		     *
		     * Circle.prototype = _.create(Shape.prototype, {
		     *   'constructor': Circle
		     * });
		     *
		     * var circle = new Circle;
		     * circle instanceof Circle;
		     * // => true
		     *
		     * circle instanceof Shape;
		     * // => true
		     */
		    function create(prototype, properties) {
		      var result = baseCreate(prototype);
		      return properties == null ? result : baseAssign(result, properties);
		    }

		    /**
		     * Assigns own and inherited enumerable string keyed properties of source
		     * objects to the destination object for all destination properties that
		     * resolve to `undefined`. Source objects are applied from left to right.
		     * Once a property is set, additional values of the same property are ignored.
		     *
		     * **Note:** This method mutates `object`.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Object
		     * @param {Object} object The destination object.
		     * @param {...Object} [sources] The source objects.
		     * @returns {Object} Returns `object`.
		     * @see _.defaultsDeep
		     * @example
		     *
		     * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
		     * // => { 'a': 1, 'b': 2 }
		     */
		    var defaults = baseRest(function(object, sources) {
		      object = Object(object);

		      var index = -1;
		      var length = sources.length;
		      var guard = length > 2 ? sources[2] : undefined$1;

		      if (guard && isIterateeCall(sources[0], sources[1], guard)) {
		        length = 1;
		      }

		      while (++index < length) {
		        var source = sources[index];
		        var props = keysIn(source);
		        var propsIndex = -1;
		        var propsLength = props.length;

		        while (++propsIndex < propsLength) {
		          var key = props[propsIndex];
		          var value = object[key];

		          if (value === undefined$1 ||
		              (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {
		            object[key] = source[key];
		          }
		        }
		      }

		      return object;
		    });

		    /**
		     * This method is like `_.defaults` except that it recursively assigns
		     * default properties.
		     *
		     * **Note:** This method mutates `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.10.0
		     * @category Object
		     * @param {Object} object The destination object.
		     * @param {...Object} [sources] The source objects.
		     * @returns {Object} Returns `object`.
		     * @see _.defaults
		     * @example
		     *
		     * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });
		     * // => { 'a': { 'b': 2, 'c': 3 } }
		     */
		    var defaultsDeep = baseRest(function(args) {
		      args.push(undefined$1, customDefaultsMerge);
		      return apply(mergeWith, undefined$1, args);
		    });

		    /**
		     * This method is like `_.find` except that it returns the key of the first
		     * element `predicate` returns truthy for instead of the element itself.
		     *
		     * @static
		     * @memberOf _
		     * @since 1.1.0
		     * @category Object
		     * @param {Object} object The object to inspect.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @returns {string|undefined} Returns the key of the matched element,
		     *  else `undefined`.
		     * @example
		     *
		     * var users = {
		     *   'barney':  { 'age': 36, 'active': true },
		     *   'fred':    { 'age': 40, 'active': false },
		     *   'pebbles': { 'age': 1,  'active': true }
		     * };
		     *
		     * _.findKey(users, function(o) { return o.age < 40; });
		     * // => 'barney' (iteration order is not guaranteed)
		     *
		     * // The `_.matches` iteratee shorthand.
		     * _.findKey(users, { 'age': 1, 'active': true });
		     * // => 'pebbles'
		     *
		     * // The `_.matchesProperty` iteratee shorthand.
		     * _.findKey(users, ['active', false]);
		     * // => 'fred'
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.findKey(users, 'active');
		     * // => 'barney'
		     */
		    function findKey(object, predicate) {
		      return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);
		    }

		    /**
		     * This method is like `_.findKey` except that it iterates over elements of
		     * a collection in the opposite order.
		     *
		     * @static
		     * @memberOf _
		     * @since 2.0.0
		     * @category Object
		     * @param {Object} object The object to inspect.
		     * @param {Function} [predicate=_.identity] The function invoked per iteration.
		     * @returns {string|undefined} Returns the key of the matched element,
		     *  else `undefined`.
		     * @example
		     *
		     * var users = {
		     *   'barney':  { 'age': 36, 'active': true },
		     *   'fred':    { 'age': 40, 'active': false },
		     *   'pebbles': { 'age': 1,  'active': true }
		     * };
		     *
		     * _.findLastKey(users, function(o) { return o.age < 40; });
		     * // => returns 'pebbles' assuming `_.findKey` returns 'barney'
		     *
		     * // The `_.matches` iteratee shorthand.
		     * _.findLastKey(users, { 'age': 36, 'active': true });
		     * // => 'barney'
		     *
		     * // The `_.matchesProperty` iteratee shorthand.
		     * _.findLastKey(users, ['active', false]);
		     * // => 'fred'
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.findLastKey(users, 'active');
		     * // => 'pebbles'
		     */
		    function findLastKey(object, predicate) {
		      return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);
		    }

		    /**
		     * Iterates over own and inherited enumerable string keyed properties of an
		     * object and invokes `iteratee` for each property. The iteratee is invoked
		     * with three arguments: (value, key, object). Iteratee functions may exit
		     * iteration early by explicitly returning `false`.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.3.0
		     * @category Object
		     * @param {Object} object The object to iterate over.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @returns {Object} Returns `object`.
		     * @see _.forInRight
		     * @example
		     *
		     * function Foo() {
		     *   this.a = 1;
		     *   this.b = 2;
		     * }
		     *
		     * Foo.prototype.c = 3;
		     *
		     * _.forIn(new Foo, function(value, key) {
		     *   console.log(key);
		     * });
		     * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).
		     */
		    function forIn(object, iteratee) {
		      return object == null
		        ? object
		        : baseFor(object, getIteratee(iteratee, 3), keysIn);
		    }

		    /**
		     * This method is like `_.forIn` except that it iterates over properties of
		     * `object` in the opposite order.
		     *
		     * @static
		     * @memberOf _
		     * @since 2.0.0
		     * @category Object
		     * @param {Object} object The object to iterate over.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @returns {Object} Returns `object`.
		     * @see _.forIn
		     * @example
		     *
		     * function Foo() {
		     *   this.a = 1;
		     *   this.b = 2;
		     * }
		     *
		     * Foo.prototype.c = 3;
		     *
		     * _.forInRight(new Foo, function(value, key) {
		     *   console.log(key);
		     * });
		     * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.
		     */
		    function forInRight(object, iteratee) {
		      return object == null
		        ? object
		        : baseForRight(object, getIteratee(iteratee, 3), keysIn);
		    }

		    /**
		     * Iterates over own enumerable string keyed properties of an object and
		     * invokes `iteratee` for each property. The iteratee is invoked with three
		     * arguments: (value, key, object). Iteratee functions may exit iteration
		     * early by explicitly returning `false`.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.3.0
		     * @category Object
		     * @param {Object} object The object to iterate over.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @returns {Object} Returns `object`.
		     * @see _.forOwnRight
		     * @example
		     *
		     * function Foo() {
		     *   this.a = 1;
		     *   this.b = 2;
		     * }
		     *
		     * Foo.prototype.c = 3;
		     *
		     * _.forOwn(new Foo, function(value, key) {
		     *   console.log(key);
		     * });
		     * // => Logs 'a' then 'b' (iteration order is not guaranteed).
		     */
		    function forOwn(object, iteratee) {
		      return object && baseForOwn(object, getIteratee(iteratee, 3));
		    }

		    /**
		     * This method is like `_.forOwn` except that it iterates over properties of
		     * `object` in the opposite order.
		     *
		     * @static
		     * @memberOf _
		     * @since 2.0.0
		     * @category Object
		     * @param {Object} object The object to iterate over.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @returns {Object} Returns `object`.
		     * @see _.forOwn
		     * @example
		     *
		     * function Foo() {
		     *   this.a = 1;
		     *   this.b = 2;
		     * }
		     *
		     * Foo.prototype.c = 3;
		     *
		     * _.forOwnRight(new Foo, function(value, key) {
		     *   console.log(key);
		     * });
		     * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.
		     */
		    function forOwnRight(object, iteratee) {
		      return object && baseForOwnRight(object, getIteratee(iteratee, 3));
		    }

		    /**
		     * Creates an array of function property names from own enumerable properties
		     * of `object`.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Object
		     * @param {Object} object The object to inspect.
		     * @returns {Array} Returns the function names.
		     * @see _.functionsIn
		     * @example
		     *
		     * function Foo() {
		     *   this.a = _.constant('a');
		     *   this.b = _.constant('b');
		     * }
		     *
		     * Foo.prototype.c = _.constant('c');
		     *
		     * _.functions(new Foo);
		     * // => ['a', 'b']
		     */
		    function functions(object) {
		      return object == null ? [] : baseFunctions(object, keys(object));
		    }

		    /**
		     * Creates an array of function property names from own and inherited
		     * enumerable properties of `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Object
		     * @param {Object} object The object to inspect.
		     * @returns {Array} Returns the function names.
		     * @see _.functions
		     * @example
		     *
		     * function Foo() {
		     *   this.a = _.constant('a');
		     *   this.b = _.constant('b');
		     * }
		     *
		     * Foo.prototype.c = _.constant('c');
		     *
		     * _.functionsIn(new Foo);
		     * // => ['a', 'b', 'c']
		     */
		    function functionsIn(object) {
		      return object == null ? [] : baseFunctions(object, keysIn(object));
		    }

		    /**
		     * Gets the value at `path` of `object`. If the resolved value is
		     * `undefined`, the `defaultValue` is returned in its place.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.7.0
		     * @category Object
		     * @param {Object} object The object to query.
		     * @param {Array|string} path The path of the property to get.
		     * @param {*} [defaultValue] The value returned for `undefined` resolved values.
		     * @returns {*} Returns the resolved value.
		     * @example
		     *
		     * var object = { 'a': [{ 'b': { 'c': 3 } }] };
		     *
		     * _.get(object, 'a[0].b.c');
		     * // => 3
		     *
		     * _.get(object, ['a', '0', 'b', 'c']);
		     * // => 3
		     *
		     * _.get(object, 'a.b.c', 'default');
		     * // => 'default'
		     */
		    function get(object, path, defaultValue) {
		      var result = object == null ? undefined$1 : baseGet(object, path);
		      return result === undefined$1 ? defaultValue : result;
		    }

		    /**
		     * Checks if `path` is a direct property of `object`.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Object
		     * @param {Object} object The object to query.
		     * @param {Array|string} path The path to check.
		     * @returns {boolean} Returns `true` if `path` exists, else `false`.
		     * @example
		     *
		     * var object = { 'a': { 'b': 2 } };
		     * var other = _.create({ 'a': _.create({ 'b': 2 }) });
		     *
		     * _.has(object, 'a');
		     * // => true
		     *
		     * _.has(object, 'a.b');
		     * // => true
		     *
		     * _.has(object, ['a', 'b']);
		     * // => true
		     *
		     * _.has(other, 'a');
		     * // => false
		     */
		    function has(object, path) {
		      return object != null && hasPath(object, path, baseHas);
		    }

		    /**
		     * Checks if `path` is a direct or inherited property of `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Object
		     * @param {Object} object The object to query.
		     * @param {Array|string} path The path to check.
		     * @returns {boolean} Returns `true` if `path` exists, else `false`.
		     * @example
		     *
		     * var object = _.create({ 'a': _.create({ 'b': 2 }) });
		     *
		     * _.hasIn(object, 'a');
		     * // => true
		     *
		     * _.hasIn(object, 'a.b');
		     * // => true
		     *
		     * _.hasIn(object, ['a', 'b']);
		     * // => true
		     *
		     * _.hasIn(object, 'b');
		     * // => false
		     */
		    function hasIn(object, path) {
		      return object != null && hasPath(object, path, baseHasIn);
		    }

		    /**
		     * Creates an object composed of the inverted keys and values of `object`.
		     * If `object` contains duplicate values, subsequent values overwrite
		     * property assignments of previous values.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.7.0
		     * @category Object
		     * @param {Object} object The object to invert.
		     * @returns {Object} Returns the new inverted object.
		     * @example
		     *
		     * var object = { 'a': 1, 'b': 2, 'c': 1 };
		     *
		     * _.invert(object);
		     * // => { '1': 'c', '2': 'b' }
		     */
		    var invert = createInverter(function(result, value, key) {
		      if (value != null &&
		          typeof value.toString != 'function') {
		        value = nativeObjectToString.call(value);
		      }

		      result[value] = key;
		    }, constant(identity));

		    /**
		     * This method is like `_.invert` except that the inverted object is generated
		     * from the results of running each element of `object` thru `iteratee`. The
		     * corresponding inverted value of each inverted key is an array of keys
		     * responsible for generating the inverted value. The iteratee is invoked
		     * with one argument: (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.1.0
		     * @category Object
		     * @param {Object} object The object to invert.
		     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
		     * @returns {Object} Returns the new inverted object.
		     * @example
		     *
		     * var object = { 'a': 1, 'b': 2, 'c': 1 };
		     *
		     * _.invertBy(object);
		     * // => { '1': ['a', 'c'], '2': ['b'] }
		     *
		     * _.invertBy(object, function(value) {
		     *   return 'group' + value;
		     * });
		     * // => { 'group1': ['a', 'c'], 'group2': ['b'] }
		     */
		    var invertBy = createInverter(function(result, value, key) {
		      if (value != null &&
		          typeof value.toString != 'function') {
		        value = nativeObjectToString.call(value);
		      }

		      if (hasOwnProperty.call(result, value)) {
		        result[value].push(key);
		      } else {
		        result[value] = [key];
		      }
		    }, getIteratee);

		    /**
		     * Invokes the method at `path` of `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Object
		     * @param {Object} object The object to query.
		     * @param {Array|string} path The path of the method to invoke.
		     * @param {...*} [args] The arguments to invoke the method with.
		     * @returns {*} Returns the result of the invoked method.
		     * @example
		     *
		     * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };
		     *
		     * _.invoke(object, 'a[0].b.c.slice', 1, 3);
		     * // => [2, 3]
		     */
		    var invoke = baseRest(baseInvoke);

		    /**
		     * Creates an array of the own enumerable property names of `object`.
		     *
		     * **Note:** Non-object values are coerced to objects. See the
		     * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
		     * for more details.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Object
		     * @param {Object} object The object to query.
		     * @returns {Array} Returns the array of property names.
		     * @example
		     *
		     * function Foo() {
		     *   this.a = 1;
		     *   this.b = 2;
		     * }
		     *
		     * Foo.prototype.c = 3;
		     *
		     * _.keys(new Foo);
		     * // => ['a', 'b'] (iteration order is not guaranteed)
		     *
		     * _.keys('hi');
		     * // => ['0', '1']
		     */
		    function keys(object) {
		      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
		    }

		    /**
		     * Creates an array of the own and inherited enumerable property names of `object`.
		     *
		     * **Note:** Non-object values are coerced to objects.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Object
		     * @param {Object} object The object to query.
		     * @returns {Array} Returns the array of property names.
		     * @example
		     *
		     * function Foo() {
		     *   this.a = 1;
		     *   this.b = 2;
		     * }
		     *
		     * Foo.prototype.c = 3;
		     *
		     * _.keysIn(new Foo);
		     * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
		     */
		    function keysIn(object) {
		      return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
		    }

		    /**
		     * The opposite of `_.mapValues`; this method creates an object with the
		     * same values as `object` and keys generated by running each own enumerable
		     * string keyed property of `object` thru `iteratee`. The iteratee is invoked
		     * with three arguments: (value, key, object).
		     *
		     * @static
		     * @memberOf _
		     * @since 3.8.0
		     * @category Object
		     * @param {Object} object The object to iterate over.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @returns {Object} Returns the new mapped object.
		     * @see _.mapValues
		     * @example
		     *
		     * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {
		     *   return key + value;
		     * });
		     * // => { 'a1': 1, 'b2': 2 }
		     */
		    function mapKeys(object, iteratee) {
		      var result = {};
		      iteratee = getIteratee(iteratee, 3);

		      baseForOwn(object, function(value, key, object) {
		        baseAssignValue(result, iteratee(value, key, object), value);
		      });
		      return result;
		    }

		    /**
		     * Creates an object with the same keys as `object` and values generated
		     * by running each own enumerable string keyed property of `object` thru
		     * `iteratee`. The iteratee is invoked with three arguments:
		     * (value, key, object).
		     *
		     * @static
		     * @memberOf _
		     * @since 2.4.0
		     * @category Object
		     * @param {Object} object The object to iterate over.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @returns {Object} Returns the new mapped object.
		     * @see _.mapKeys
		     * @example
		     *
		     * var users = {
		     *   'fred':    { 'user': 'fred',    'age': 40 },
		     *   'pebbles': { 'user': 'pebbles', 'age': 1 }
		     * };
		     *
		     * _.mapValues(users, function(o) { return o.age; });
		     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.mapValues(users, 'age');
		     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
		     */
		    function mapValues(object, iteratee) {
		      var result = {};
		      iteratee = getIteratee(iteratee, 3);

		      baseForOwn(object, function(value, key, object) {
		        baseAssignValue(result, key, iteratee(value, key, object));
		      });
		      return result;
		    }

		    /**
		     * This method is like `_.assign` except that it recursively merges own and
		     * inherited enumerable string keyed properties of source objects into the
		     * destination object. Source properties that resolve to `undefined` are
		     * skipped if a destination value exists. Array and plain object properties
		     * are merged recursively. Other objects and value types are overridden by
		     * assignment. Source objects are applied from left to right. Subsequent
		     * sources overwrite property assignments of previous sources.
		     *
		     * **Note:** This method mutates `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.5.0
		     * @category Object
		     * @param {Object} object The destination object.
		     * @param {...Object} [sources] The source objects.
		     * @returns {Object} Returns `object`.
		     * @example
		     *
		     * var object = {
		     *   'a': [{ 'b': 2 }, { 'd': 4 }]
		     * };
		     *
		     * var other = {
		     *   'a': [{ 'c': 3 }, { 'e': 5 }]
		     * };
		     *
		     * _.merge(object, other);
		     * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
		     */
		    var merge = createAssigner(function(object, source, srcIndex) {
		      baseMerge(object, source, srcIndex);
		    });

		    /**
		     * This method is like `_.merge` except that it accepts `customizer` which
		     * is invoked to produce the merged values of the destination and source
		     * properties. If `customizer` returns `undefined`, merging is handled by the
		     * method instead. The `customizer` is invoked with six arguments:
		     * (objValue, srcValue, key, object, source, stack).
		     *
		     * **Note:** This method mutates `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Object
		     * @param {Object} object The destination object.
		     * @param {...Object} sources The source objects.
		     * @param {Function} customizer The function to customize assigned values.
		     * @returns {Object} Returns `object`.
		     * @example
		     *
		     * function customizer(objValue, srcValue) {
		     *   if (_.isArray(objValue)) {
		     *     return objValue.concat(srcValue);
		     *   }
		     * }
		     *
		     * var object = { 'a': [1], 'b': [2] };
		     * var other = { 'a': [3], 'b': [4] };
		     *
		     * _.mergeWith(object, other, customizer);
		     * // => { 'a': [1, 3], 'b': [2, 4] }
		     */
		    var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
		      baseMerge(object, source, srcIndex, customizer);
		    });

		    /**
		     * The opposite of `_.pick`; this method creates an object composed of the
		     * own and inherited enumerable property paths of `object` that are not omitted.
		     *
		     * **Note:** This method is considerably slower than `_.pick`.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Object
		     * @param {Object} object The source object.
		     * @param {...(string|string[])} [paths] The property paths to omit.
		     * @returns {Object} Returns the new object.
		     * @example
		     *
		     * var object = { 'a': 1, 'b': '2', 'c': 3 };
		     *
		     * _.omit(object, ['a', 'c']);
		     * // => { 'b': '2' }
		     */
		    var omit = flatRest(function(object, paths) {
		      var result = {};
		      if (object == null) {
		        return result;
		      }
		      var isDeep = false;
		      paths = arrayMap(paths, function(path) {
		        path = castPath(path, object);
		        isDeep || (isDeep = path.length > 1);
		        return path;
		      });
		      copyObject(object, getAllKeysIn(object), result);
		      if (isDeep) {
		        result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
		      }
		      var length = paths.length;
		      while (length--) {
		        baseUnset(result, paths[length]);
		      }
		      return result;
		    });

		    /**
		     * The opposite of `_.pickBy`; this method creates an object composed of
		     * the own and inherited enumerable string keyed properties of `object` that
		     * `predicate` doesn't return truthy for. The predicate is invoked with two
		     * arguments: (value, key).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Object
		     * @param {Object} object The source object.
		     * @param {Function} [predicate=_.identity] The function invoked per property.
		     * @returns {Object} Returns the new object.
		     * @example
		     *
		     * var object = { 'a': 1, 'b': '2', 'c': 3 };
		     *
		     * _.omitBy(object, _.isNumber);
		     * // => { 'b': '2' }
		     */
		    function omitBy(object, predicate) {
		      return pickBy(object, negate(getIteratee(predicate)));
		    }

		    /**
		     * Creates an object composed of the picked `object` properties.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Object
		     * @param {Object} object The source object.
		     * @param {...(string|string[])} [paths] The property paths to pick.
		     * @returns {Object} Returns the new object.
		     * @example
		     *
		     * var object = { 'a': 1, 'b': '2', 'c': 3 };
		     *
		     * _.pick(object, ['a', 'c']);
		     * // => { 'a': 1, 'c': 3 }
		     */
		    var pick = flatRest(function(object, paths) {
		      return object == null ? {} : basePick(object, paths);
		    });

		    /**
		     * Creates an object composed of the `object` properties `predicate` returns
		     * truthy for. The predicate is invoked with two arguments: (value, key).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Object
		     * @param {Object} object The source object.
		     * @param {Function} [predicate=_.identity] The function invoked per property.
		     * @returns {Object} Returns the new object.
		     * @example
		     *
		     * var object = { 'a': 1, 'b': '2', 'c': 3 };
		     *
		     * _.pickBy(object, _.isNumber);
		     * // => { 'a': 1, 'c': 3 }
		     */
		    function pickBy(object, predicate) {
		      if (object == null) {
		        return {};
		      }
		      var props = arrayMap(getAllKeysIn(object), function(prop) {
		        return [prop];
		      });
		      predicate = getIteratee(predicate);
		      return basePickBy(object, props, function(value, path) {
		        return predicate(value, path[0]);
		      });
		    }

		    /**
		     * This method is like `_.get` except that if the resolved value is a
		     * function it's invoked with the `this` binding of its parent object and
		     * its result is returned.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Object
		     * @param {Object} object The object to query.
		     * @param {Array|string} path The path of the property to resolve.
		     * @param {*} [defaultValue] The value returned for `undefined` resolved values.
		     * @returns {*} Returns the resolved value.
		     * @example
		     *
		     * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };
		     *
		     * _.result(object, 'a[0].b.c1');
		     * // => 3
		     *
		     * _.result(object, 'a[0].b.c2');
		     * // => 4
		     *
		     * _.result(object, 'a[0].b.c3', 'default');
		     * // => 'default'
		     *
		     * _.result(object, 'a[0].b.c3', _.constant('default'));
		     * // => 'default'
		     */
		    function result(object, path, defaultValue) {
		      path = castPath(path, object);

		      var index = -1,
		          length = path.length;

		      // Ensure the loop is entered when path is empty.
		      if (!length) {
		        length = 1;
		        object = undefined$1;
		      }
		      while (++index < length) {
		        var value = object == null ? undefined$1 : object[toKey(path[index])];
		        if (value === undefined$1) {
		          index = length;
		          value = defaultValue;
		        }
		        object = isFunction(value) ? value.call(object) : value;
		      }
		      return object;
		    }

		    /**
		     * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
		     * it's created. Arrays are created for missing index properties while objects
		     * are created for all other missing properties. Use `_.setWith` to customize
		     * `path` creation.
		     *
		     * **Note:** This method mutates `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.7.0
		     * @category Object
		     * @param {Object} object The object to modify.
		     * @param {Array|string} path The path of the property to set.
		     * @param {*} value The value to set.
		     * @returns {Object} Returns `object`.
		     * @example
		     *
		     * var object = { 'a': [{ 'b': { 'c': 3 } }] };
		     *
		     * _.set(object, 'a[0].b.c', 4);
		     * console.log(object.a[0].b.c);
		     * // => 4
		     *
		     * _.set(object, ['x', '0', 'y', 'z'], 5);
		     * console.log(object.x[0].y.z);
		     * // => 5
		     */
		    function set(object, path, value) {
		      return object == null ? object : baseSet(object, path, value);
		    }

		    /**
		     * This method is like `_.set` except that it accepts `customizer` which is
		     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`
		     * path creation is handled by the method instead. The `customizer` is invoked
		     * with three arguments: (nsValue, key, nsObject).
		     *
		     * **Note:** This method mutates `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Object
		     * @param {Object} object The object to modify.
		     * @param {Array|string} path The path of the property to set.
		     * @param {*} value The value to set.
		     * @param {Function} [customizer] The function to customize assigned values.
		     * @returns {Object} Returns `object`.
		     * @example
		     *
		     * var object = {};
		     *
		     * _.setWith(object, '[0][1]', 'a', Object);
		     * // => { '0': { '1': 'a' } }
		     */
		    function setWith(object, path, value, customizer) {
		      customizer = typeof customizer == 'function' ? customizer : undefined$1;
		      return object == null ? object : baseSet(object, path, value, customizer);
		    }

		    /**
		     * Creates an array of own enumerable string keyed-value pairs for `object`
		     * which can be consumed by `_.fromPairs`. If `object` is a map or set, its
		     * entries are returned.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @alias entries
		     * @category Object
		     * @param {Object} object The object to query.
		     * @returns {Array} Returns the key-value pairs.
		     * @example
		     *
		     * function Foo() {
		     *   this.a = 1;
		     *   this.b = 2;
		     * }
		     *
		     * Foo.prototype.c = 3;
		     *
		     * _.toPairs(new Foo);
		     * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)
		     */
		    var toPairs = createToPairs(keys);

		    /**
		     * Creates an array of own and inherited enumerable string keyed-value pairs
		     * for `object` which can be consumed by `_.fromPairs`. If `object` is a map
		     * or set, its entries are returned.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @alias entriesIn
		     * @category Object
		     * @param {Object} object The object to query.
		     * @returns {Array} Returns the key-value pairs.
		     * @example
		     *
		     * function Foo() {
		     *   this.a = 1;
		     *   this.b = 2;
		     * }
		     *
		     * Foo.prototype.c = 3;
		     *
		     * _.toPairsIn(new Foo);
		     * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)
		     */
		    var toPairsIn = createToPairs(keysIn);

		    /**
		     * An alternative to `_.reduce`; this method transforms `object` to a new
		     * `accumulator` object which is the result of running each of its own
		     * enumerable string keyed properties thru `iteratee`, with each invocation
		     * potentially mutating the `accumulator` object. If `accumulator` is not
		     * provided, a new object with the same `[[Prototype]]` will be used. The
		     * iteratee is invoked with four arguments: (accumulator, value, key, object).
		     * Iteratee functions may exit iteration early by explicitly returning `false`.
		     *
		     * @static
		     * @memberOf _
		     * @since 1.3.0
		     * @category Object
		     * @param {Object} object The object to iterate over.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @param {*} [accumulator] The custom accumulator value.
		     * @returns {*} Returns the accumulated value.
		     * @example
		     *
		     * _.transform([2, 3, 4], function(result, n) {
		     *   result.push(n *= n);
		     *   return n % 2 == 0;
		     * }, []);
		     * // => [4, 9]
		     *
		     * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
		     *   (result[value] || (result[value] = [])).push(key);
		     * }, {});
		     * // => { '1': ['a', 'c'], '2': ['b'] }
		     */
		    function transform(object, iteratee, accumulator) {
		      var isArr = isArray(object),
		          isArrLike = isArr || isBuffer(object) || isTypedArray(object);

		      iteratee = getIteratee(iteratee, 4);
		      if (accumulator == null) {
		        var Ctor = object && object.constructor;
		        if (isArrLike) {
		          accumulator = isArr ? new Ctor : [];
		        }
		        else if (isObject(object)) {
		          accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};
		        }
		        else {
		          accumulator = {};
		        }
		      }
		      (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {
		        return iteratee(accumulator, value, index, object);
		      });
		      return accumulator;
		    }

		    /**
		     * Removes the property at `path` of `object`.
		     *
		     * **Note:** This method mutates `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Object
		     * @param {Object} object The object to modify.
		     * @param {Array|string} path The path of the property to unset.
		     * @returns {boolean} Returns `true` if the property is deleted, else `false`.
		     * @example
		     *
		     * var object = { 'a': [{ 'b': { 'c': 7 } }] };
		     * _.unset(object, 'a[0].b.c');
		     * // => true
		     *
		     * console.log(object);
		     * // => { 'a': [{ 'b': {} }] };
		     *
		     * _.unset(object, ['a', '0', 'b', 'c']);
		     * // => true
		     *
		     * console.log(object);
		     * // => { 'a': [{ 'b': {} }] };
		     */
		    function unset(object, path) {
		      return object == null ? true : baseUnset(object, path);
		    }

		    /**
		     * This method is like `_.set` except that accepts `updater` to produce the
		     * value to set. Use `_.updateWith` to customize `path` creation. The `updater`
		     * is invoked with one argument: (value).
		     *
		     * **Note:** This method mutates `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.6.0
		     * @category Object
		     * @param {Object} object The object to modify.
		     * @param {Array|string} path The path of the property to set.
		     * @param {Function} updater The function to produce the updated value.
		     * @returns {Object} Returns `object`.
		     * @example
		     *
		     * var object = { 'a': [{ 'b': { 'c': 3 } }] };
		     *
		     * _.update(object, 'a[0].b.c', function(n) { return n * n; });
		     * console.log(object.a[0].b.c);
		     * // => 9
		     *
		     * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });
		     * console.log(object.x[0].y.z);
		     * // => 0
		     */
		    function update(object, path, updater) {
		      return object == null ? object : baseUpdate(object, path, castFunction(updater));
		    }

		    /**
		     * This method is like `_.update` except that it accepts `customizer` which is
		     * invoked to produce the objects of `path`.  If `customizer` returns `undefined`
		     * path creation is handled by the method instead. The `customizer` is invoked
		     * with three arguments: (nsValue, key, nsObject).
		     *
		     * **Note:** This method mutates `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.6.0
		     * @category Object
		     * @param {Object} object The object to modify.
		     * @param {Array|string} path The path of the property to set.
		     * @param {Function} updater The function to produce the updated value.
		     * @param {Function} [customizer] The function to customize assigned values.
		     * @returns {Object} Returns `object`.
		     * @example
		     *
		     * var object = {};
		     *
		     * _.updateWith(object, '[0][1]', _.constant('a'), Object);
		     * // => { '0': { '1': 'a' } }
		     */
		    function updateWith(object, path, updater, customizer) {
		      customizer = typeof customizer == 'function' ? customizer : undefined$1;
		      return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
		    }

		    /**
		     * Creates an array of the own enumerable string keyed property values of `object`.
		     *
		     * **Note:** Non-object values are coerced to objects.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Object
		     * @param {Object} object The object to query.
		     * @returns {Array} Returns the array of property values.
		     * @example
		     *
		     * function Foo() {
		     *   this.a = 1;
		     *   this.b = 2;
		     * }
		     *
		     * Foo.prototype.c = 3;
		     *
		     * _.values(new Foo);
		     * // => [1, 2] (iteration order is not guaranteed)
		     *
		     * _.values('hi');
		     * // => ['h', 'i']
		     */
		    function values(object) {
		      return object == null ? [] : baseValues(object, keys(object));
		    }

		    /**
		     * Creates an array of the own and inherited enumerable string keyed property
		     * values of `object`.
		     *
		     * **Note:** Non-object values are coerced to objects.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Object
		     * @param {Object} object The object to query.
		     * @returns {Array} Returns the array of property values.
		     * @example
		     *
		     * function Foo() {
		     *   this.a = 1;
		     *   this.b = 2;
		     * }
		     *
		     * Foo.prototype.c = 3;
		     *
		     * _.valuesIn(new Foo);
		     * // => [1, 2, 3] (iteration order is not guaranteed)
		     */
		    function valuesIn(object) {
		      return object == null ? [] : baseValues(object, keysIn(object));
		    }

		    /*------------------------------------------------------------------------*/

		    /**
		     * Clamps `number` within the inclusive `lower` and `upper` bounds.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Number
		     * @param {number} number The number to clamp.
		     * @param {number} [lower] The lower bound.
		     * @param {number} upper The upper bound.
		     * @returns {number} Returns the clamped number.
		     * @example
		     *
		     * _.clamp(-10, -5, 5);
		     * // => -5
		     *
		     * _.clamp(10, -5, 5);
		     * // => 5
		     */
		    function clamp(number, lower, upper) {
		      if (upper === undefined$1) {
		        upper = lower;
		        lower = undefined$1;
		      }
		      if (upper !== undefined$1) {
		        upper = toNumber(upper);
		        upper = upper === upper ? upper : 0;
		      }
		      if (lower !== undefined$1) {
		        lower = toNumber(lower);
		        lower = lower === lower ? lower : 0;
		      }
		      return baseClamp(toNumber(number), lower, upper);
		    }

		    /**
		     * Checks if `n` is between `start` and up to, but not including, `end`. If
		     * `end` is not specified, it's set to `start` with `start` then set to `0`.
		     * If `start` is greater than `end` the params are swapped to support
		     * negative ranges.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.3.0
		     * @category Number
		     * @param {number} number The number to check.
		     * @param {number} [start=0] The start of the range.
		     * @param {number} end The end of the range.
		     * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
		     * @see _.range, _.rangeRight
		     * @example
		     *
		     * _.inRange(3, 2, 4);
		     * // => true
		     *
		     * _.inRange(4, 8);
		     * // => true
		     *
		     * _.inRange(4, 2);
		     * // => false
		     *
		     * _.inRange(2, 2);
		     * // => false
		     *
		     * _.inRange(1.2, 2);
		     * // => true
		     *
		     * _.inRange(5.2, 4);
		     * // => false
		     *
		     * _.inRange(-3, -2, -6);
		     * // => true
		     */
		    function inRange(number, start, end) {
		      start = toFinite(start);
		      if (end === undefined$1) {
		        end = start;
		        start = 0;
		      } else {
		        end = toFinite(end);
		      }
		      number = toNumber(number);
		      return baseInRange(number, start, end);
		    }

		    /**
		     * Produces a random number between the inclusive `lower` and `upper` bounds.
		     * If only one argument is provided a number between `0` and the given number
		     * is returned. If `floating` is `true`, or either `lower` or `upper` are
		     * floats, a floating-point number is returned instead of an integer.
		     *
		     * **Note:** JavaScript follows the IEEE-754 standard for resolving
		     * floating-point values which can produce unexpected results.
		     *
		     * @static
		     * @memberOf _
		     * @since 0.7.0
		     * @category Number
		     * @param {number} [lower=0] The lower bound.
		     * @param {number} [upper=1] The upper bound.
		     * @param {boolean} [floating] Specify returning a floating-point number.
		     * @returns {number} Returns the random number.
		     * @example
		     *
		     * _.random(0, 5);
		     * // => an integer between 0 and 5
		     *
		     * _.random(5);
		     * // => also an integer between 0 and 5
		     *
		     * _.random(5, true);
		     * // => a floating-point number between 0 and 5
		     *
		     * _.random(1.2, 5.2);
		     * // => a floating-point number between 1.2 and 5.2
		     */
		    function random(lower, upper, floating) {
		      if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {
		        upper = floating = undefined$1;
		      }
		      if (floating === undefined$1) {
		        if (typeof upper == 'boolean') {
		          floating = upper;
		          upper = undefined$1;
		        }
		        else if (typeof lower == 'boolean') {
		          floating = lower;
		          lower = undefined$1;
		        }
		      }
		      if (lower === undefined$1 && upper === undefined$1) {
		        lower = 0;
		        upper = 1;
		      }
		      else {
		        lower = toFinite(lower);
		        if (upper === undefined$1) {
		          upper = lower;
		          lower = 0;
		        } else {
		          upper = toFinite(upper);
		        }
		      }
		      if (lower > upper) {
		        var temp = lower;
		        lower = upper;
		        upper = temp;
		      }
		      if (floating || lower % 1 || upper % 1) {
		        var rand = nativeRandom();
		        return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);
		      }
		      return baseRandom(lower, upper);
		    }

		    /*------------------------------------------------------------------------*/

		    /**
		     * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category String
		     * @param {string} [string=''] The string to convert.
		     * @returns {string} Returns the camel cased string.
		     * @example
		     *
		     * _.camelCase('Foo Bar');
		     * // => 'fooBar'
		     *
		     * _.camelCase('--foo-bar--');
		     * // => 'fooBar'
		     *
		     * _.camelCase('__FOO_BAR__');
		     * // => 'fooBar'
		     */
		    var camelCase = createCompounder(function(result, word, index) {
		      word = word.toLowerCase();
		      return result + (index ? capitalize(word) : word);
		    });

		    /**
		     * Converts the first character of `string` to upper case and the remaining
		     * to lower case.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category String
		     * @param {string} [string=''] The string to capitalize.
		     * @returns {string} Returns the capitalized string.
		     * @example
		     *
		     * _.capitalize('FRED');
		     * // => 'Fred'
		     */
		    function capitalize(string) {
		      return upperFirst(toString(string).toLowerCase());
		    }

		    /**
		     * Deburrs `string` by converting
		     * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
		     * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
		     * letters to basic Latin letters and removing
		     * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category String
		     * @param {string} [string=''] The string to deburr.
		     * @returns {string} Returns the deburred string.
		     * @example
		     *
		     * _.deburr('déjà vu');
		     * // => 'deja vu'
		     */
		    function deburr(string) {
		      string = toString(string);
		      return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');
		    }

		    /**
		     * Checks if `string` ends with the given target string.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category String
		     * @param {string} [string=''] The string to inspect.
		     * @param {string} [target] The string to search for.
		     * @param {number} [position=string.length] The position to search up to.
		     * @returns {boolean} Returns `true` if `string` ends with `target`,
		     *  else `false`.
		     * @example
		     *
		     * _.endsWith('abc', 'c');
		     * // => true
		     *
		     * _.endsWith('abc', 'b');
		     * // => false
		     *
		     * _.endsWith('abc', 'b', 2);
		     * // => true
		     */
		    function endsWith(string, target, position) {
		      string = toString(string);
		      target = baseToString(target);

		      var length = string.length;
		      position = position === undefined$1
		        ? length
		        : baseClamp(toInteger(position), 0, length);

		      var end = position;
		      position -= target.length;
		      return position >= 0 && string.slice(position, end) == target;
		    }

		    /**
		     * Converts the characters "&", "<", ">", '"', and "'" in `string` to their
		     * corresponding HTML entities.
		     *
		     * **Note:** No other characters are escaped. To escape additional
		     * characters use a third-party library like [_he_](https://mths.be/he).
		     *
		     * Though the ">" character is escaped for symmetry, characters like
		     * ">" and "/" don't need escaping in HTML and have no special meaning
		     * unless they're part of a tag or unquoted attribute value. See
		     * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)
		     * (under "semi-related fun fact") for more details.
		     *
		     * When working with HTML you should always
		     * [quote attribute values](http://wonko.com/post/html-escaping) to reduce
		     * XSS vectors.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category String
		     * @param {string} [string=''] The string to escape.
		     * @returns {string} Returns the escaped string.
		     * @example
		     *
		     * _.escape('fred, barney, & pebbles');
		     * // => 'fred, barney, &amp; pebbles'
		     */
		    function escape(string) {
		      string = toString(string);
		      return (string && reHasUnescapedHtml.test(string))
		        ? string.replace(reUnescapedHtml, escapeHtmlChar)
		        : string;
		    }

		    /**
		     * Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+",
		     * "?", "(", ")", "[", "]", "{", "}", and "|" in `string`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category String
		     * @param {string} [string=''] The string to escape.
		     * @returns {string} Returns the escaped string.
		     * @example
		     *
		     * _.escapeRegExp('[lodash](https://lodash.com/)');
		     * // => '\[lodash\]\(https://lodash\.com/\)'
		     */
		    function escapeRegExp(string) {
		      string = toString(string);
		      return (string && reHasRegExpChar.test(string))
		        ? string.replace(reRegExpChar, '\\$&')
		        : string;
		    }

		    /**
		     * Converts `string` to
		     * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category String
		     * @param {string} [string=''] The string to convert.
		     * @returns {string} Returns the kebab cased string.
		     * @example
		     *
		     * _.kebabCase('Foo Bar');
		     * // => 'foo-bar'
		     *
		     * _.kebabCase('fooBar');
		     * // => 'foo-bar'
		     *
		     * _.kebabCase('__FOO_BAR__');
		     * // => 'foo-bar'
		     */
		    var kebabCase = createCompounder(function(result, word, index) {
		      return result + (index ? '-' : '') + word.toLowerCase();
		    });

		    /**
		     * Converts `string`, as space separated words, to lower case.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category String
		     * @param {string} [string=''] The string to convert.
		     * @returns {string} Returns the lower cased string.
		     * @example
		     *
		     * _.lowerCase('--Foo-Bar--');
		     * // => 'foo bar'
		     *
		     * _.lowerCase('fooBar');
		     * // => 'foo bar'
		     *
		     * _.lowerCase('__FOO_BAR__');
		     * // => 'foo bar'
		     */
		    var lowerCase = createCompounder(function(result, word, index) {
		      return result + (index ? ' ' : '') + word.toLowerCase();
		    });

		    /**
		     * Converts the first character of `string` to lower case.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category String
		     * @param {string} [string=''] The string to convert.
		     * @returns {string} Returns the converted string.
		     * @example
		     *
		     * _.lowerFirst('Fred');
		     * // => 'fred'
		     *
		     * _.lowerFirst('FRED');
		     * // => 'fRED'
		     */
		    var lowerFirst = createCaseFirst('toLowerCase');

		    /**
		     * Pads `string` on the left and right sides if it's shorter than `length`.
		     * Padding characters are truncated if they can't be evenly divided by `length`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category String
		     * @param {string} [string=''] The string to pad.
		     * @param {number} [length=0] The padding length.
		     * @param {string} [chars=' '] The string used as padding.
		     * @returns {string} Returns the padded string.
		     * @example
		     *
		     * _.pad('abc', 8);
		     * // => '  abc   '
		     *
		     * _.pad('abc', 8, '_-');
		     * // => '_-abc_-_'
		     *
		     * _.pad('abc', 3);
		     * // => 'abc'
		     */
		    function pad(string, length, chars) {
		      string = toString(string);
		      length = toInteger(length);

		      var strLength = length ? stringSize(string) : 0;
		      if (!length || strLength >= length) {
		        return string;
		      }
		      var mid = (length - strLength) / 2;
		      return (
		        createPadding(nativeFloor(mid), chars) +
		        string +
		        createPadding(nativeCeil(mid), chars)
		      );
		    }

		    /**
		     * Pads `string` on the right side if it's shorter than `length`. Padding
		     * characters are truncated if they exceed `length`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category String
		     * @param {string} [string=''] The string to pad.
		     * @param {number} [length=0] The padding length.
		     * @param {string} [chars=' '] The string used as padding.
		     * @returns {string} Returns the padded string.
		     * @example
		     *
		     * _.padEnd('abc', 6);
		     * // => 'abc   '
		     *
		     * _.padEnd('abc', 6, '_-');
		     * // => 'abc_-_'
		     *
		     * _.padEnd('abc', 3);
		     * // => 'abc'
		     */
		    function padEnd(string, length, chars) {
		      string = toString(string);
		      length = toInteger(length);

		      var strLength = length ? stringSize(string) : 0;
		      return (length && strLength < length)
		        ? (string + createPadding(length - strLength, chars))
		        : string;
		    }

		    /**
		     * Pads `string` on the left side if it's shorter than `length`. Padding
		     * characters are truncated if they exceed `length`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category String
		     * @param {string} [string=''] The string to pad.
		     * @param {number} [length=0] The padding length.
		     * @param {string} [chars=' '] The string used as padding.
		     * @returns {string} Returns the padded string.
		     * @example
		     *
		     * _.padStart('abc', 6);
		     * // => '   abc'
		     *
		     * _.padStart('abc', 6, '_-');
		     * // => '_-_abc'
		     *
		     * _.padStart('abc', 3);
		     * // => 'abc'
		     */
		    function padStart(string, length, chars) {
		      string = toString(string);
		      length = toInteger(length);

		      var strLength = length ? stringSize(string) : 0;
		      return (length && strLength < length)
		        ? (createPadding(length - strLength, chars) + string)
		        : string;
		    }

		    /**
		     * Converts `string` to an integer of the specified radix. If `radix` is
		     * `undefined` or `0`, a `radix` of `10` is used unless `value` is a
		     * hexadecimal, in which case a `radix` of `16` is used.
		     *
		     * **Note:** This method aligns with the
		     * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.
		     *
		     * @static
		     * @memberOf _
		     * @since 1.1.0
		     * @category String
		     * @param {string} string The string to convert.
		     * @param {number} [radix=10] The radix to interpret `value` by.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {number} Returns the converted integer.
		     * @example
		     *
		     * _.parseInt('08');
		     * // => 8
		     *
		     * _.map(['6', '08', '10'], _.parseInt);
		     * // => [6, 8, 10]
		     */
		    function parseInt(string, radix, guard) {
		      if (guard || radix == null) {
		        radix = 0;
		      } else if (radix) {
		        radix = +radix;
		      }
		      return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);
		    }

		    /**
		     * Repeats the given string `n` times.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category String
		     * @param {string} [string=''] The string to repeat.
		     * @param {number} [n=1] The number of times to repeat the string.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {string} Returns the repeated string.
		     * @example
		     *
		     * _.repeat('*', 3);
		     * // => '***'
		     *
		     * _.repeat('abc', 2);
		     * // => 'abcabc'
		     *
		     * _.repeat('abc', 0);
		     * // => ''
		     */
		    function repeat(string, n, guard) {
		      if ((guard ? isIterateeCall(string, n, guard) : n === undefined$1)) {
		        n = 1;
		      } else {
		        n = toInteger(n);
		      }
		      return baseRepeat(toString(string), n);
		    }

		    /**
		     * Replaces matches for `pattern` in `string` with `replacement`.
		     *
		     * **Note:** This method is based on
		     * [`String#replace`](https://mdn.io/String/replace).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category String
		     * @param {string} [string=''] The string to modify.
		     * @param {RegExp|string} pattern The pattern to replace.
		     * @param {Function|string} replacement The match replacement.
		     * @returns {string} Returns the modified string.
		     * @example
		     *
		     * _.replace('Hi Fred', 'Fred', 'Barney');
		     * // => 'Hi Barney'
		     */
		    function replace() {
		      var args = arguments,
		          string = toString(args[0]);

		      return args.length < 3 ? string : string.replace(args[1], args[2]);
		    }

		    /**
		     * Converts `string` to
		     * [snake case](https://en.wikipedia.org/wiki/Snake_case).
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category String
		     * @param {string} [string=''] The string to convert.
		     * @returns {string} Returns the snake cased string.
		     * @example
		     *
		     * _.snakeCase('Foo Bar');
		     * // => 'foo_bar'
		     *
		     * _.snakeCase('fooBar');
		     * // => 'foo_bar'
		     *
		     * _.snakeCase('--FOO-BAR--');
		     * // => 'foo_bar'
		     */
		    var snakeCase = createCompounder(function(result, word, index) {
		      return result + (index ? '_' : '') + word.toLowerCase();
		    });

		    /**
		     * Splits `string` by `separator`.
		     *
		     * **Note:** This method is based on
		     * [`String#split`](https://mdn.io/String/split).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category String
		     * @param {string} [string=''] The string to split.
		     * @param {RegExp|string} separator The separator pattern to split by.
		     * @param {number} [limit] The length to truncate results to.
		     * @returns {Array} Returns the string segments.
		     * @example
		     *
		     * _.split('a-b-c', '-', 2);
		     * // => ['a', 'b']
		     */
		    function split(string, separator, limit) {
		      if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {
		        separator = limit = undefined$1;
		      }
		      limit = limit === undefined$1 ? MAX_ARRAY_LENGTH : limit >>> 0;
		      if (!limit) {
		        return [];
		      }
		      string = toString(string);
		      if (string && (
		            typeof separator == 'string' ||
		            (separator != null && !isRegExp(separator))
		          )) {
		        separator = baseToString(separator);
		        if (!separator && hasUnicode(string)) {
		          return castSlice(stringToArray(string), 0, limit);
		        }
		      }
		      return string.split(separator, limit);
		    }

		    /**
		     * Converts `string` to
		     * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).
		     *
		     * @static
		     * @memberOf _
		     * @since 3.1.0
		     * @category String
		     * @param {string} [string=''] The string to convert.
		     * @returns {string} Returns the start cased string.
		     * @example
		     *
		     * _.startCase('--foo-bar--');
		     * // => 'Foo Bar'
		     *
		     * _.startCase('fooBar');
		     * // => 'Foo Bar'
		     *
		     * _.startCase('__FOO_BAR__');
		     * // => 'FOO BAR'
		     */
		    var startCase = createCompounder(function(result, word, index) {
		      return result + (index ? ' ' : '') + upperFirst(word);
		    });

		    /**
		     * Checks if `string` starts with the given target string.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category String
		     * @param {string} [string=''] The string to inspect.
		     * @param {string} [target] The string to search for.
		     * @param {number} [position=0] The position to search from.
		     * @returns {boolean} Returns `true` if `string` starts with `target`,
		     *  else `false`.
		     * @example
		     *
		     * _.startsWith('abc', 'a');
		     * // => true
		     *
		     * _.startsWith('abc', 'b');
		     * // => false
		     *
		     * _.startsWith('abc', 'b', 1);
		     * // => true
		     */
		    function startsWith(string, target, position) {
		      string = toString(string);
		      position = position == null
		        ? 0
		        : baseClamp(toInteger(position), 0, string.length);

		      target = baseToString(target);
		      return string.slice(position, position + target.length) == target;
		    }

		    /**
		     * Creates a compiled template function that can interpolate data properties
		     * in "interpolate" delimiters, HTML-escape interpolated data properties in
		     * "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data
		     * properties may be accessed as free variables in the template. If a setting
		     * object is given, it takes precedence over `_.templateSettings` values.
		     *
		     * **Note:** In the development build `_.template` utilizes
		     * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)
		     * for easier debugging.
		     *
		     * For more information on precompiling templates see
		     * [lodash's custom builds documentation](https://lodash.com/custom-builds).
		     *
		     * For more information on Chrome extension sandboxes see
		     * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category String
		     * @param {string} [string=''] The template string.
		     * @param {Object} [options={}] The options object.
		     * @param {RegExp} [options.escape=_.templateSettings.escape]
		     *  The HTML "escape" delimiter.
		     * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]
		     *  The "evaluate" delimiter.
		     * @param {Object} [options.imports=_.templateSettings.imports]
		     *  An object to import into the template as free variables.
		     * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]
		     *  The "interpolate" delimiter.
		     * @param {string} [options.sourceURL='lodash.templateSources[n]']
		     *  The sourceURL of the compiled template.
		     * @param {string} [options.variable='obj']
		     *  The data object variable name.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {Function} Returns the compiled template function.
		     * @example
		     *
		     * // Use the "interpolate" delimiter to create a compiled template.
		     * var compiled = _.template('hello <%= user %>!');
		     * compiled({ 'user': 'fred' });
		     * // => 'hello fred!'
		     *
		     * // Use the HTML "escape" delimiter to escape data property values.
		     * var compiled = _.template('<b><%- value %></b>');
		     * compiled({ 'value': '<script>' });
		     * // => '<b>&lt;script&gt;</b>'
		     *
		     * // Use the "evaluate" delimiter to execute JavaScript and generate HTML.
		     * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');
		     * compiled({ 'users': ['fred', 'barney'] });
		     * // => '<li>fred</li><li>barney</li>'
		     *
		     * // Use the internal `print` function in "evaluate" delimiters.
		     * var compiled = _.template('<% print("hello " + user); %>!');
		     * compiled({ 'user': 'barney' });
		     * // => 'hello barney!'
		     *
		     * // Use the ES template literal delimiter as an "interpolate" delimiter.
		     * // Disable support by replacing the "interpolate" delimiter.
		     * var compiled = _.template('hello ${ user }!');
		     * compiled({ 'user': 'pebbles' });
		     * // => 'hello pebbles!'
		     *
		     * // Use backslashes to treat delimiters as plain text.
		     * var compiled = _.template('<%= "\\<%- value %\\>" %>');
		     * compiled({ 'value': 'ignored' });
		     * // => '<%- value %>'
		     *
		     * // Use the `imports` option to import `jQuery` as `jq`.
		     * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';
		     * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });
		     * compiled({ 'users': ['fred', 'barney'] });
		     * // => '<li>fred</li><li>barney</li>'
		     *
		     * // Use the `sourceURL` option to specify a custom sourceURL for the template.
		     * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });
		     * compiled(data);
		     * // => Find the source of "greeting.jst" under the Sources tab or Resources panel of the web inspector.
		     *
		     * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.
		     * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });
		     * compiled.source;
		     * // => function(data) {
		     * //   var __t, __p = '';
		     * //   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';
		     * //   return __p;
		     * // }
		     *
		     * // Use custom template delimiters.
		     * _.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
		     * var compiled = _.template('hello {{ user }}!');
		     * compiled({ 'user': 'mustache' });
		     * // => 'hello mustache!'
		     *
		     * // Use the `source` property to inline compiled templates for meaningful
		     * // line numbers in error messages and stack traces.
		     * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\
		     *   var JST = {\
		     *     "main": ' + _.template(mainText).source + '\
		     *   };\
		     * ');
		     */
		    function template(string, options, guard) {
		      // Based on John Resig's `tmpl` implementation
		      // (http://ejohn.org/blog/javascript-micro-templating/)
		      // and Laura Doktorova's doT.js (https://github.com/olado/doT).
		      var settings = lodash.templateSettings;

		      if (guard && isIterateeCall(string, options, guard)) {
		        options = undefined$1;
		      }
		      string = toString(string);
		      options = assignInWith({}, options, settings, customDefaultsAssignIn);

		      var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),
		          importsKeys = keys(imports),
		          importsValues = baseValues(imports, importsKeys);

		      var isEscaping,
		          isEvaluating,
		          index = 0,
		          interpolate = options.interpolate || reNoMatch,
		          source = "__p += '";

		      // Compile the regexp to match each delimiter.
		      var reDelimiters = RegExp(
		        (options.escape || reNoMatch).source + '|' +
		        interpolate.source + '|' +
		        (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +
		        (options.evaluate || reNoMatch).source + '|$'
		      , 'g');

		      // Use a sourceURL for easier debugging.
		      // The sourceURL gets injected into the source that's eval-ed, so be careful
		      // to normalize all kinds of whitespace, so e.g. newlines (and unicode versions of it) can't sneak in
		      // and escape the comment, thus injecting code that gets evaled.
		      var sourceURL = '//# sourceURL=' +
		        (hasOwnProperty.call(options, 'sourceURL')
		          ? (options.sourceURL + '').replace(/\s/g, ' ')
		          : ('lodash.templateSources[' + (++templateCounter) + ']')
		        ) + '\n';

		      string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
		        interpolateValue || (interpolateValue = esTemplateValue);

		        // Escape characters that can't be included in string literals.
		        source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);

		        // Replace delimiters with snippets.
		        if (escapeValue) {
		          isEscaping = true;
		          source += "' +\n__e(" + escapeValue + ") +\n'";
		        }
		        if (evaluateValue) {
		          isEvaluating = true;
		          source += "';\n" + evaluateValue + ";\n__p += '";
		        }
		        if (interpolateValue) {
		          source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
		        }
		        index = offset + match.length;

		        // The JS engine embedded in Adobe products needs `match` returned in
		        // order to produce the correct `offset` value.
		        return match;
		      });

		      source += "';\n";

		      // If `variable` is not specified wrap a with-statement around the generated
		      // code to add the data object to the top of the scope chain.
		      var variable = hasOwnProperty.call(options, 'variable') && options.variable;
		      if (!variable) {
		        source = 'with (obj) {\n' + source + '\n}\n';
		      }
		      // Throw an error if a forbidden character was found in `variable`, to prevent
		      // potential command injection attacks.
		      else if (reForbiddenIdentifierChars.test(variable)) {
		        throw new Error(INVALID_TEMPL_VAR_ERROR_TEXT);
		      }

		      // Cleanup code by stripping empty strings.
		      source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)
		        .replace(reEmptyStringMiddle, '$1')
		        .replace(reEmptyStringTrailing, '$1;');

		      // Frame code as the function body.
		      source = 'function(' + (variable || 'obj') + ') {\n' +
		        (variable
		          ? ''
		          : 'obj || (obj = {});\n'
		        ) +
		        "var __t, __p = ''" +
		        (isEscaping
		           ? ', __e = _.escape'
		           : ''
		        ) +
		        (isEvaluating
		          ? ', __j = Array.prototype.join;\n' +
		            "function print() { __p += __j.call(arguments, '') }\n"
		          : ';\n'
		        ) +
		        source +
		        'return __p\n}';

		      var result = attempt(function() {
		        return Function(importsKeys, sourceURL + 'return ' + source)
		          .apply(undefined$1, importsValues);
		      });

		      // Provide the compiled function's source by its `toString` method or
		      // the `source` property as a convenience for inlining compiled templates.
		      result.source = source;
		      if (isError(result)) {
		        throw result;
		      }
		      return result;
		    }

		    /**
		     * Converts `string`, as a whole, to lower case just like
		     * [String#toLowerCase](https://mdn.io/toLowerCase).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category String
		     * @param {string} [string=''] The string to convert.
		     * @returns {string} Returns the lower cased string.
		     * @example
		     *
		     * _.toLower('--Foo-Bar--');
		     * // => '--foo-bar--'
		     *
		     * _.toLower('fooBar');
		     * // => 'foobar'
		     *
		     * _.toLower('__FOO_BAR__');
		     * // => '__foo_bar__'
		     */
		    function toLower(value) {
		      return toString(value).toLowerCase();
		    }

		    /**
		     * Converts `string`, as a whole, to upper case just like
		     * [String#toUpperCase](https://mdn.io/toUpperCase).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category String
		     * @param {string} [string=''] The string to convert.
		     * @returns {string} Returns the upper cased string.
		     * @example
		     *
		     * _.toUpper('--foo-bar--');
		     * // => '--FOO-BAR--'
		     *
		     * _.toUpper('fooBar');
		     * // => 'FOOBAR'
		     *
		     * _.toUpper('__foo_bar__');
		     * // => '__FOO_BAR__'
		     */
		    function toUpper(value) {
		      return toString(value).toUpperCase();
		    }

		    /**
		     * Removes leading and trailing whitespace or specified characters from `string`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category String
		     * @param {string} [string=''] The string to trim.
		     * @param {string} [chars=whitespace] The characters to trim.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {string} Returns the trimmed string.
		     * @example
		     *
		     * _.trim('  abc  ');
		     * // => 'abc'
		     *
		     * _.trim('-_-abc-_-', '_-');
		     * // => 'abc'
		     *
		     * _.map(['  foo  ', '  bar  '], _.trim);
		     * // => ['foo', 'bar']
		     */
		    function trim(string, chars, guard) {
		      string = toString(string);
		      if (string && (guard || chars === undefined$1)) {
		        return baseTrim(string);
		      }
		      if (!string || !(chars = baseToString(chars))) {
		        return string;
		      }
		      var strSymbols = stringToArray(string),
		          chrSymbols = stringToArray(chars),
		          start = charsStartIndex(strSymbols, chrSymbols),
		          end = charsEndIndex(strSymbols, chrSymbols) + 1;

		      return castSlice(strSymbols, start, end).join('');
		    }

		    /**
		     * Removes trailing whitespace or specified characters from `string`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category String
		     * @param {string} [string=''] The string to trim.
		     * @param {string} [chars=whitespace] The characters to trim.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {string} Returns the trimmed string.
		     * @example
		     *
		     * _.trimEnd('  abc  ');
		     * // => '  abc'
		     *
		     * _.trimEnd('-_-abc-_-', '_-');
		     * // => '-_-abc'
		     */
		    function trimEnd(string, chars, guard) {
		      string = toString(string);
		      if (string && (guard || chars === undefined$1)) {
		        return string.slice(0, trimmedEndIndex(string) + 1);
		      }
		      if (!string || !(chars = baseToString(chars))) {
		        return string;
		      }
		      var strSymbols = stringToArray(string),
		          end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;

		      return castSlice(strSymbols, 0, end).join('');
		    }

		    /**
		     * Removes leading whitespace or specified characters from `string`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category String
		     * @param {string} [string=''] The string to trim.
		     * @param {string} [chars=whitespace] The characters to trim.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {string} Returns the trimmed string.
		     * @example
		     *
		     * _.trimStart('  abc  ');
		     * // => 'abc  '
		     *
		     * _.trimStart('-_-abc-_-', '_-');
		     * // => 'abc-_-'
		     */
		    function trimStart(string, chars, guard) {
		      string = toString(string);
		      if (string && (guard || chars === undefined$1)) {
		        return string.replace(reTrimStart, '');
		      }
		      if (!string || !(chars = baseToString(chars))) {
		        return string;
		      }
		      var strSymbols = stringToArray(string),
		          start = charsStartIndex(strSymbols, stringToArray(chars));

		      return castSlice(strSymbols, start).join('');
		    }

		    /**
		     * Truncates `string` if it's longer than the given maximum string length.
		     * The last characters of the truncated string are replaced with the omission
		     * string which defaults to "...".
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category String
		     * @param {string} [string=''] The string to truncate.
		     * @param {Object} [options={}] The options object.
		     * @param {number} [options.length=30] The maximum string length.
		     * @param {string} [options.omission='...'] The string to indicate text is omitted.
		     * @param {RegExp|string} [options.separator] The separator pattern to truncate to.
		     * @returns {string} Returns the truncated string.
		     * @example
		     *
		     * _.truncate('hi-diddly-ho there, neighborino');
		     * // => 'hi-diddly-ho there, neighbo...'
		     *
		     * _.truncate('hi-diddly-ho there, neighborino', {
		     *   'length': 24,
		     *   'separator': ' '
		     * });
		     * // => 'hi-diddly-ho there,...'
		     *
		     * _.truncate('hi-diddly-ho there, neighborino', {
		     *   'length': 24,
		     *   'separator': /,? +/
		     * });
		     * // => 'hi-diddly-ho there...'
		     *
		     * _.truncate('hi-diddly-ho there, neighborino', {
		     *   'omission': ' [...]'
		     * });
		     * // => 'hi-diddly-ho there, neig [...]'
		     */
		    function truncate(string, options) {
		      var length = DEFAULT_TRUNC_LENGTH,
		          omission = DEFAULT_TRUNC_OMISSION;

		      if (isObject(options)) {
		        var separator = 'separator' in options ? options.separator : separator;
		        length = 'length' in options ? toInteger(options.length) : length;
		        omission = 'omission' in options ? baseToString(options.omission) : omission;
		      }
		      string = toString(string);

		      var strLength = string.length;
		      if (hasUnicode(string)) {
		        var strSymbols = stringToArray(string);
		        strLength = strSymbols.length;
		      }
		      if (length >= strLength) {
		        return string;
		      }
		      var end = length - stringSize(omission);
		      if (end < 1) {
		        return omission;
		      }
		      var result = strSymbols
		        ? castSlice(strSymbols, 0, end).join('')
		        : string.slice(0, end);

		      if (separator === undefined$1) {
		        return result + omission;
		      }
		      if (strSymbols) {
		        end += (result.length - end);
		      }
		      if (isRegExp(separator)) {
		        if (string.slice(end).search(separator)) {
		          var match,
		              substring = result;

		          if (!separator.global) {
		            separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');
		          }
		          separator.lastIndex = 0;
		          while ((match = separator.exec(substring))) {
		            var newEnd = match.index;
		          }
		          result = result.slice(0, newEnd === undefined$1 ? end : newEnd);
		        }
		      } else if (string.indexOf(baseToString(separator), end) != end) {
		        var index = result.lastIndexOf(separator);
		        if (index > -1) {
		          result = result.slice(0, index);
		        }
		      }
		      return result + omission;
		    }

		    /**
		     * The inverse of `_.escape`; this method converts the HTML entities
		     * `&amp;`, `&lt;`, `&gt;`, `&quot;`, and `&#39;` in `string` to
		     * their corresponding characters.
		     *
		     * **Note:** No other HTML entities are unescaped. To unescape additional
		     * HTML entities use a third-party library like [_he_](https://mths.be/he).
		     *
		     * @static
		     * @memberOf _
		     * @since 0.6.0
		     * @category String
		     * @param {string} [string=''] The string to unescape.
		     * @returns {string} Returns the unescaped string.
		     * @example
		     *
		     * _.unescape('fred, barney, &amp; pebbles');
		     * // => 'fred, barney, & pebbles'
		     */
		    function unescape(string) {
		      string = toString(string);
		      return (string && reHasEscapedHtml.test(string))
		        ? string.replace(reEscapedHtml, unescapeHtmlChar)
		        : string;
		    }

		    /**
		     * Converts `string`, as space separated words, to upper case.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category String
		     * @param {string} [string=''] The string to convert.
		     * @returns {string} Returns the upper cased string.
		     * @example
		     *
		     * _.upperCase('--foo-bar');
		     * // => 'FOO BAR'
		     *
		     * _.upperCase('fooBar');
		     * // => 'FOO BAR'
		     *
		     * _.upperCase('__foo_bar__');
		     * // => 'FOO BAR'
		     */
		    var upperCase = createCompounder(function(result, word, index) {
		      return result + (index ? ' ' : '') + word.toUpperCase();
		    });

		    /**
		     * Converts the first character of `string` to upper case.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category String
		     * @param {string} [string=''] The string to convert.
		     * @returns {string} Returns the converted string.
		     * @example
		     *
		     * _.upperFirst('fred');
		     * // => 'Fred'
		     *
		     * _.upperFirst('FRED');
		     * // => 'FRED'
		     */
		    var upperFirst = createCaseFirst('toUpperCase');

		    /**
		     * Splits `string` into an array of its words.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category String
		     * @param {string} [string=''] The string to inspect.
		     * @param {RegExp|string} [pattern] The pattern to match words.
		     * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
		     * @returns {Array} Returns the words of `string`.
		     * @example
		     *
		     * _.words('fred, barney, & pebbles');
		     * // => ['fred', 'barney', 'pebbles']
		     *
		     * _.words('fred, barney, & pebbles', /[^, ]+/g);
		     * // => ['fred', 'barney', '&', 'pebbles']
		     */
		    function words(string, pattern, guard) {
		      string = toString(string);
		      pattern = guard ? undefined$1 : pattern;

		      if (pattern === undefined$1) {
		        return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
		      }
		      return string.match(pattern) || [];
		    }

		    /*------------------------------------------------------------------------*/

		    /**
		     * Attempts to invoke `func`, returning either the result or the caught error
		     * object. Any additional arguments are provided to `func` when it's invoked.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Util
		     * @param {Function} func The function to attempt.
		     * @param {...*} [args] The arguments to invoke `func` with.
		     * @returns {*} Returns the `func` result or error object.
		     * @example
		     *
		     * // Avoid throwing errors for invalid selectors.
		     * var elements = _.attempt(function(selector) {
		     *   return document.querySelectorAll(selector);
		     * }, '>_>');
		     *
		     * if (_.isError(elements)) {
		     *   elements = [];
		     * }
		     */
		    var attempt = baseRest(function(func, args) {
		      try {
		        return apply(func, undefined$1, args);
		      } catch (e) {
		        return isError(e) ? e : new Error(e);
		      }
		    });

		    /**
		     * Binds methods of an object to the object itself, overwriting the existing
		     * method.
		     *
		     * **Note:** This method doesn't set the "length" property of bound functions.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Util
		     * @param {Object} object The object to bind and assign the bound methods to.
		     * @param {...(string|string[])} methodNames The object method names to bind.
		     * @returns {Object} Returns `object`.
		     * @example
		     *
		     * var view = {
		     *   'label': 'docs',
		     *   'click': function() {
		     *     console.log('clicked ' + this.label);
		     *   }
		     * };
		     *
		     * _.bindAll(view, ['click']);
		     * jQuery(element).on('click', view.click);
		     * // => Logs 'clicked docs' when clicked.
		     */
		    var bindAll = flatRest(function(object, methodNames) {
		      arrayEach(methodNames, function(key) {
		        key = toKey(key);
		        baseAssignValue(object, key, bind(object[key], object));
		      });
		      return object;
		    });

		    /**
		     * Creates a function that iterates over `pairs` and invokes the corresponding
		     * function of the first predicate to return truthy. The predicate-function
		     * pairs are invoked with the `this` binding and arguments of the created
		     * function.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Util
		     * @param {Array} pairs The predicate-function pairs.
		     * @returns {Function} Returns the new composite function.
		     * @example
		     *
		     * var func = _.cond([
		     *   [_.matches({ 'a': 1 }),           _.constant('matches A')],
		     *   [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],
		     *   [_.stubTrue,                      _.constant('no match')]
		     * ]);
		     *
		     * func({ 'a': 1, 'b': 2 });
		     * // => 'matches A'
		     *
		     * func({ 'a': 0, 'b': 1 });
		     * // => 'matches B'
		     *
		     * func({ 'a': '1', 'b': '2' });
		     * // => 'no match'
		     */
		    function cond(pairs) {
		      var length = pairs == null ? 0 : pairs.length,
		          toIteratee = getIteratee();

		      pairs = !length ? [] : arrayMap(pairs, function(pair) {
		        if (typeof pair[1] != 'function') {
		          throw new TypeError(FUNC_ERROR_TEXT);
		        }
		        return [toIteratee(pair[0]), pair[1]];
		      });

		      return baseRest(function(args) {
		        var index = -1;
		        while (++index < length) {
		          var pair = pairs[index];
		          if (apply(pair[0], this, args)) {
		            return apply(pair[1], this, args);
		          }
		        }
		      });
		    }

		    /**
		     * Creates a function that invokes the predicate properties of `source` with
		     * the corresponding property values of a given object, returning `true` if
		     * all predicates return truthy, else `false`.
		     *
		     * **Note:** The created function is equivalent to `_.conformsTo` with
		     * `source` partially applied.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Util
		     * @param {Object} source The object of property predicates to conform to.
		     * @returns {Function} Returns the new spec function.
		     * @example
		     *
		     * var objects = [
		     *   { 'a': 2, 'b': 1 },
		     *   { 'a': 1, 'b': 2 }
		     * ];
		     *
		     * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));
		     * // => [{ 'a': 1, 'b': 2 }]
		     */
		    function conforms(source) {
		      return baseConforms(baseClone(source, CLONE_DEEP_FLAG));
		    }

		    /**
		     * Creates a function that returns `value`.
		     *
		     * @static
		     * @memberOf _
		     * @since 2.4.0
		     * @category Util
		     * @param {*} value The value to return from the new function.
		     * @returns {Function} Returns the new constant function.
		     * @example
		     *
		     * var objects = _.times(2, _.constant({ 'a': 1 }));
		     *
		     * console.log(objects);
		     * // => [{ 'a': 1 }, { 'a': 1 }]
		     *
		     * console.log(objects[0] === objects[1]);
		     * // => true
		     */
		    function constant(value) {
		      return function() {
		        return value;
		      };
		    }

		    /**
		     * Checks `value` to determine whether a default value should be returned in
		     * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,
		     * or `undefined`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.14.0
		     * @category Util
		     * @param {*} value The value to check.
		     * @param {*} defaultValue The default value.
		     * @returns {*} Returns the resolved value.
		     * @example
		     *
		     * _.defaultTo(1, 10);
		     * // => 1
		     *
		     * _.defaultTo(undefined, 10);
		     * // => 10
		     */
		    function defaultTo(value, defaultValue) {
		      return (value == null || value !== value) ? defaultValue : value;
		    }

		    /**
		     * Creates a function that returns the result of invoking the given functions
		     * with the `this` binding of the created function, where each successive
		     * invocation is supplied the return value of the previous.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Util
		     * @param {...(Function|Function[])} [funcs] The functions to invoke.
		     * @returns {Function} Returns the new composite function.
		     * @see _.flowRight
		     * @example
		     *
		     * function square(n) {
		     *   return n * n;
		     * }
		     *
		     * var addSquare = _.flow([_.add, square]);
		     * addSquare(1, 2);
		     * // => 9
		     */
		    var flow = createFlow();

		    /**
		     * This method is like `_.flow` except that it creates a function that
		     * invokes the given functions from right to left.
		     *
		     * @static
		     * @since 3.0.0
		     * @memberOf _
		     * @category Util
		     * @param {...(Function|Function[])} [funcs] The functions to invoke.
		     * @returns {Function} Returns the new composite function.
		     * @see _.flow
		     * @example
		     *
		     * function square(n) {
		     *   return n * n;
		     * }
		     *
		     * var addSquare = _.flowRight([square, _.add]);
		     * addSquare(1, 2);
		     * // => 9
		     */
		    var flowRight = createFlow(true);

		    /**
		     * This method returns the first argument it receives.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Util
		     * @param {*} value Any value.
		     * @returns {*} Returns `value`.
		     * @example
		     *
		     * var object = { 'a': 1 };
		     *
		     * console.log(_.identity(object) === object);
		     * // => true
		     */
		    function identity(value) {
		      return value;
		    }

		    /**
		     * Creates a function that invokes `func` with the arguments of the created
		     * function. If `func` is a property name, the created function returns the
		     * property value for a given element. If `func` is an array or object, the
		     * created function returns `true` for elements that contain the equivalent
		     * source properties, otherwise it returns `false`.
		     *
		     * @static
		     * @since 4.0.0
		     * @memberOf _
		     * @category Util
		     * @param {*} [func=_.identity] The value to convert to a callback.
		     * @returns {Function} Returns the callback.
		     * @example
		     *
		     * var users = [
		     *   { 'user': 'barney', 'age': 36, 'active': true },
		     *   { 'user': 'fred',   'age': 40, 'active': false }
		     * ];
		     *
		     * // The `_.matches` iteratee shorthand.
		     * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));
		     * // => [{ 'user': 'barney', 'age': 36, 'active': true }]
		     *
		     * // The `_.matchesProperty` iteratee shorthand.
		     * _.filter(users, _.iteratee(['user', 'fred']));
		     * // => [{ 'user': 'fred', 'age': 40 }]
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.map(users, _.iteratee('user'));
		     * // => ['barney', 'fred']
		     *
		     * // Create custom iteratee shorthands.
		     * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {
		     *   return !_.isRegExp(func) ? iteratee(func) : function(string) {
		     *     return func.test(string);
		     *   };
		     * });
		     *
		     * _.filter(['abc', 'def'], /ef/);
		     * // => ['def']
		     */
		    function iteratee(func) {
		      return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));
		    }

		    /**
		     * Creates a function that performs a partial deep comparison between a given
		     * object and `source`, returning `true` if the given object has equivalent
		     * property values, else `false`.
		     *
		     * **Note:** The created function is equivalent to `_.isMatch` with `source`
		     * partially applied.
		     *
		     * Partial comparisons will match empty array and empty object `source`
		     * values against any array or object value, respectively. See `_.isEqual`
		     * for a list of supported value comparisons.
		     *
		     * **Note:** Multiple values can be checked by combining several matchers
		     * using `_.overSome`
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Util
		     * @param {Object} source The object of property values to match.
		     * @returns {Function} Returns the new spec function.
		     * @example
		     *
		     * var objects = [
		     *   { 'a': 1, 'b': 2, 'c': 3 },
		     *   { 'a': 4, 'b': 5, 'c': 6 }
		     * ];
		     *
		     * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));
		     * // => [{ 'a': 4, 'b': 5, 'c': 6 }]
		     *
		     * // Checking for several possible values
		     * _.filter(objects, _.overSome([_.matches({ 'a': 1 }), _.matches({ 'a': 4 })]));
		     * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]
		     */
		    function matches(source) {
		      return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
		    }

		    /**
		     * Creates a function that performs a partial deep comparison between the
		     * value at `path` of a given object to `srcValue`, returning `true` if the
		     * object value is equivalent, else `false`.
		     *
		     * **Note:** Partial comparisons will match empty array and empty object
		     * `srcValue` values against any array or object value, respectively. See
		     * `_.isEqual` for a list of supported value comparisons.
		     *
		     * **Note:** Multiple values can be checked by combining several matchers
		     * using `_.overSome`
		     *
		     * @static
		     * @memberOf _
		     * @since 3.2.0
		     * @category Util
		     * @param {Array|string} path The path of the property to get.
		     * @param {*} srcValue The value to match.
		     * @returns {Function} Returns the new spec function.
		     * @example
		     *
		     * var objects = [
		     *   { 'a': 1, 'b': 2, 'c': 3 },
		     *   { 'a': 4, 'b': 5, 'c': 6 }
		     * ];
		     *
		     * _.find(objects, _.matchesProperty('a', 4));
		     * // => { 'a': 4, 'b': 5, 'c': 6 }
		     *
		     * // Checking for several possible values
		     * _.filter(objects, _.overSome([_.matchesProperty('a', 1), _.matchesProperty('a', 4)]));
		     * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]
		     */
		    function matchesProperty(path, srcValue) {
		      return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));
		    }

		    /**
		     * Creates a function that invokes the method at `path` of a given object.
		     * Any additional arguments are provided to the invoked method.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.7.0
		     * @category Util
		     * @param {Array|string} path The path of the method to invoke.
		     * @param {...*} [args] The arguments to invoke the method with.
		     * @returns {Function} Returns the new invoker function.
		     * @example
		     *
		     * var objects = [
		     *   { 'a': { 'b': _.constant(2) } },
		     *   { 'a': { 'b': _.constant(1) } }
		     * ];
		     *
		     * _.map(objects, _.method('a.b'));
		     * // => [2, 1]
		     *
		     * _.map(objects, _.method(['a', 'b']));
		     * // => [2, 1]
		     */
		    var method = baseRest(function(path, args) {
		      return function(object) {
		        return baseInvoke(object, path, args);
		      };
		    });

		    /**
		     * The opposite of `_.method`; this method creates a function that invokes
		     * the method at a given path of `object`. Any additional arguments are
		     * provided to the invoked method.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.7.0
		     * @category Util
		     * @param {Object} object The object to query.
		     * @param {...*} [args] The arguments to invoke the method with.
		     * @returns {Function} Returns the new invoker function.
		     * @example
		     *
		     * var array = _.times(3, _.constant),
		     *     object = { 'a': array, 'b': array, 'c': array };
		     *
		     * _.map(['a[2]', 'c[0]'], _.methodOf(object));
		     * // => [2, 0]
		     *
		     * _.map([['a', '2'], ['c', '0']], _.methodOf(object));
		     * // => [2, 0]
		     */
		    var methodOf = baseRest(function(object, args) {
		      return function(path) {
		        return baseInvoke(object, path, args);
		      };
		    });

		    /**
		     * Adds all own enumerable string keyed function properties of a source
		     * object to the destination object. If `object` is a function, then methods
		     * are added to its prototype as well.
		     *
		     * **Note:** Use `_.runInContext` to create a pristine `lodash` function to
		     * avoid conflicts caused by modifying the original.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Util
		     * @param {Function|Object} [object=lodash] The destination object.
		     * @param {Object} source The object of functions to add.
		     * @param {Object} [options={}] The options object.
		     * @param {boolean} [options.chain=true] Specify whether mixins are chainable.
		     * @returns {Function|Object} Returns `object`.
		     * @example
		     *
		     * function vowels(string) {
		     *   return _.filter(string, function(v) {
		     *     return /[aeiou]/i.test(v);
		     *   });
		     * }
		     *
		     * _.mixin({ 'vowels': vowels });
		     * _.vowels('fred');
		     * // => ['e']
		     *
		     * _('fred').vowels().value();
		     * // => ['e']
		     *
		     * _.mixin({ 'vowels': vowels }, { 'chain': false });
		     * _('fred').vowels();
		     * // => ['e']
		     */
		    function mixin(object, source, options) {
		      var props = keys(source),
		          methodNames = baseFunctions(source, props);

		      if (options == null &&
		          !(isObject(source) && (methodNames.length || !props.length))) {
		        options = source;
		        source = object;
		        object = this;
		        methodNames = baseFunctions(source, keys(source));
		      }
		      var chain = !(isObject(options) && 'chain' in options) || !!options.chain,
		          isFunc = isFunction(object);

		      arrayEach(methodNames, function(methodName) {
		        var func = source[methodName];
		        object[methodName] = func;
		        if (isFunc) {
		          object.prototype[methodName] = function() {
		            var chainAll = this.__chain__;
		            if (chain || chainAll) {
		              var result = object(this.__wrapped__),
		                  actions = result.__actions__ = copyArray(this.__actions__);

		              actions.push({ 'func': func, 'args': arguments, 'thisArg': object });
		              result.__chain__ = chainAll;
		              return result;
		            }
		            return func.apply(object, arrayPush([this.value()], arguments));
		          };
		        }
		      });

		      return object;
		    }

		    /**
		     * Reverts the `_` variable to its previous value and returns a reference to
		     * the `lodash` function.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Util
		     * @returns {Function} Returns the `lodash` function.
		     * @example
		     *
		     * var lodash = _.noConflict();
		     */
		    function noConflict() {
		      if (root._ === this) {
		        root._ = oldDash;
		      }
		      return this;
		    }

		    /**
		     * This method returns `undefined`.
		     *
		     * @static
		     * @memberOf _
		     * @since 2.3.0
		     * @category Util
		     * @example
		     *
		     * _.times(2, _.noop);
		     * // => [undefined, undefined]
		     */
		    function noop() {
		      // No operation performed.
		    }

		    /**
		     * Creates a function that gets the argument at index `n`. If `n` is negative,
		     * the nth argument from the end is returned.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Util
		     * @param {number} [n=0] The index of the argument to return.
		     * @returns {Function} Returns the new pass-thru function.
		     * @example
		     *
		     * var func = _.nthArg(1);
		     * func('a', 'b', 'c', 'd');
		     * // => 'b'
		     *
		     * var func = _.nthArg(-2);
		     * func('a', 'b', 'c', 'd');
		     * // => 'c'
		     */
		    function nthArg(n) {
		      n = toInteger(n);
		      return baseRest(function(args) {
		        return baseNth(args, n);
		      });
		    }

		    /**
		     * Creates a function that invokes `iteratees` with the arguments it receives
		     * and returns their results.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Util
		     * @param {...(Function|Function[])} [iteratees=[_.identity]]
		     *  The iteratees to invoke.
		     * @returns {Function} Returns the new function.
		     * @example
		     *
		     * var func = _.over([Math.max, Math.min]);
		     *
		     * func(1, 2, 3, 4);
		     * // => [4, 1]
		     */
		    var over = createOver(arrayMap);

		    /**
		     * Creates a function that checks if **all** of the `predicates` return
		     * truthy when invoked with the arguments it receives.
		     *
		     * Following shorthands are possible for providing predicates.
		     * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.
		     * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Util
		     * @param {...(Function|Function[])} [predicates=[_.identity]]
		     *  The predicates to check.
		     * @returns {Function} Returns the new function.
		     * @example
		     *
		     * var func = _.overEvery([Boolean, isFinite]);
		     *
		     * func('1');
		     * // => true
		     *
		     * func(null);
		     * // => false
		     *
		     * func(NaN);
		     * // => false
		     */
		    var overEvery = createOver(arrayEvery);

		    /**
		     * Creates a function that checks if **any** of the `predicates` return
		     * truthy when invoked with the arguments it receives.
		     *
		     * Following shorthands are possible for providing predicates.
		     * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.
		     * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Util
		     * @param {...(Function|Function[])} [predicates=[_.identity]]
		     *  The predicates to check.
		     * @returns {Function} Returns the new function.
		     * @example
		     *
		     * var func = _.overSome([Boolean, isFinite]);
		     *
		     * func('1');
		     * // => true
		     *
		     * func(null);
		     * // => true
		     *
		     * func(NaN);
		     * // => false
		     *
		     * var matchesFunc = _.overSome([{ 'a': 1 }, { 'a': 2 }])
		     * var matchesPropertyFunc = _.overSome([['a', 1], ['a', 2]])
		     */
		    var overSome = createOver(arraySome);

		    /**
		     * Creates a function that returns the value at `path` of a given object.
		     *
		     * @static
		     * @memberOf _
		     * @since 2.4.0
		     * @category Util
		     * @param {Array|string} path The path of the property to get.
		     * @returns {Function} Returns the new accessor function.
		     * @example
		     *
		     * var objects = [
		     *   { 'a': { 'b': 2 } },
		     *   { 'a': { 'b': 1 } }
		     * ];
		     *
		     * _.map(objects, _.property('a.b'));
		     * // => [2, 1]
		     *
		     * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
		     * // => [1, 2]
		     */
		    function property(path) {
		      return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
		    }

		    /**
		     * The opposite of `_.property`; this method creates a function that returns
		     * the value at a given path of `object`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.0.0
		     * @category Util
		     * @param {Object} object The object to query.
		     * @returns {Function} Returns the new accessor function.
		     * @example
		     *
		     * var array = [0, 1, 2],
		     *     object = { 'a': array, 'b': array, 'c': array };
		     *
		     * _.map(['a[2]', 'c[0]'], _.propertyOf(object));
		     * // => [2, 0]
		     *
		     * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));
		     * // => [2, 0]
		     */
		    function propertyOf(object) {
		      return function(path) {
		        return object == null ? undefined$1 : baseGet(object, path);
		      };
		    }

		    /**
		     * Creates an array of numbers (positive and/or negative) progressing from
		     * `start` up to, but not including, `end`. A step of `-1` is used if a negative
		     * `start` is specified without an `end` or `step`. If `end` is not specified,
		     * it's set to `start` with `start` then set to `0`.
		     *
		     * **Note:** JavaScript follows the IEEE-754 standard for resolving
		     * floating-point values which can produce unexpected results.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Util
		     * @param {number} [start=0] The start of the range.
		     * @param {number} end The end of the range.
		     * @param {number} [step=1] The value to increment or decrement by.
		     * @returns {Array} Returns the range of numbers.
		     * @see _.inRange, _.rangeRight
		     * @example
		     *
		     * _.range(4);
		     * // => [0, 1, 2, 3]
		     *
		     * _.range(-4);
		     * // => [0, -1, -2, -3]
		     *
		     * _.range(1, 5);
		     * // => [1, 2, 3, 4]
		     *
		     * _.range(0, 20, 5);
		     * // => [0, 5, 10, 15]
		     *
		     * _.range(0, -4, -1);
		     * // => [0, -1, -2, -3]
		     *
		     * _.range(1, 4, 0);
		     * // => [1, 1, 1]
		     *
		     * _.range(0);
		     * // => []
		     */
		    var range = createRange();

		    /**
		     * This method is like `_.range` except that it populates values in
		     * descending order.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Util
		     * @param {number} [start=0] The start of the range.
		     * @param {number} end The end of the range.
		     * @param {number} [step=1] The value to increment or decrement by.
		     * @returns {Array} Returns the range of numbers.
		     * @see _.inRange, _.range
		     * @example
		     *
		     * _.rangeRight(4);
		     * // => [3, 2, 1, 0]
		     *
		     * _.rangeRight(-4);
		     * // => [-3, -2, -1, 0]
		     *
		     * _.rangeRight(1, 5);
		     * // => [4, 3, 2, 1]
		     *
		     * _.rangeRight(0, 20, 5);
		     * // => [15, 10, 5, 0]
		     *
		     * _.rangeRight(0, -4, -1);
		     * // => [-3, -2, -1, 0]
		     *
		     * _.rangeRight(1, 4, 0);
		     * // => [1, 1, 1]
		     *
		     * _.rangeRight(0);
		     * // => []
		     */
		    var rangeRight = createRange(true);

		    /**
		     * This method returns a new empty array.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.13.0
		     * @category Util
		     * @returns {Array} Returns the new empty array.
		     * @example
		     *
		     * var arrays = _.times(2, _.stubArray);
		     *
		     * console.log(arrays);
		     * // => [[], []]
		     *
		     * console.log(arrays[0] === arrays[1]);
		     * // => false
		     */
		    function stubArray() {
		      return [];
		    }

		    /**
		     * This method returns `false`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.13.0
		     * @category Util
		     * @returns {boolean} Returns `false`.
		     * @example
		     *
		     * _.times(2, _.stubFalse);
		     * // => [false, false]
		     */
		    function stubFalse() {
		      return false;
		    }

		    /**
		     * This method returns a new empty object.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.13.0
		     * @category Util
		     * @returns {Object} Returns the new empty object.
		     * @example
		     *
		     * var objects = _.times(2, _.stubObject);
		     *
		     * console.log(objects);
		     * // => [{}, {}]
		     *
		     * console.log(objects[0] === objects[1]);
		     * // => false
		     */
		    function stubObject() {
		      return {};
		    }

		    /**
		     * This method returns an empty string.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.13.0
		     * @category Util
		     * @returns {string} Returns the empty string.
		     * @example
		     *
		     * _.times(2, _.stubString);
		     * // => ['', '']
		     */
		    function stubString() {
		      return '';
		    }

		    /**
		     * This method returns `true`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.13.0
		     * @category Util
		     * @returns {boolean} Returns `true`.
		     * @example
		     *
		     * _.times(2, _.stubTrue);
		     * // => [true, true]
		     */
		    function stubTrue() {
		      return true;
		    }

		    /**
		     * Invokes the iteratee `n` times, returning an array of the results of
		     * each invocation. The iteratee is invoked with one argument; (index).
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Util
		     * @param {number} n The number of times to invoke `iteratee`.
		     * @param {Function} [iteratee=_.identity] The function invoked per iteration.
		     * @returns {Array} Returns the array of results.
		     * @example
		     *
		     * _.times(3, String);
		     * // => ['0', '1', '2']
		     *
		     *  _.times(4, _.constant(0));
		     * // => [0, 0, 0, 0]
		     */
		    function times(n, iteratee) {
		      n = toInteger(n);
		      if (n < 1 || n > MAX_SAFE_INTEGER) {
		        return [];
		      }
		      var index = MAX_ARRAY_LENGTH,
		          length = nativeMin(n, MAX_ARRAY_LENGTH);

		      iteratee = getIteratee(iteratee);
		      n -= MAX_ARRAY_LENGTH;

		      var result = baseTimes(length, iteratee);
		      while (++index < n) {
		        iteratee(index);
		      }
		      return result;
		    }

		    /**
		     * Converts `value` to a property path array.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Util
		     * @param {*} value The value to convert.
		     * @returns {Array} Returns the new property path array.
		     * @example
		     *
		     * _.toPath('a.b.c');
		     * // => ['a', 'b', 'c']
		     *
		     * _.toPath('a[0].b.c');
		     * // => ['a', '0', 'b', 'c']
		     */
		    function toPath(value) {
		      if (isArray(value)) {
		        return arrayMap(value, toKey);
		      }
		      return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));
		    }

		    /**
		     * Generates a unique ID. If `prefix` is given, the ID is appended to it.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Util
		     * @param {string} [prefix=''] The value to prefix the ID with.
		     * @returns {string} Returns the unique ID.
		     * @example
		     *
		     * _.uniqueId('contact_');
		     * // => 'contact_104'
		     *
		     * _.uniqueId();
		     * // => '105'
		     */
		    function uniqueId(prefix) {
		      var id = ++idCounter;
		      return toString(prefix) + id;
		    }

		    /*------------------------------------------------------------------------*/

		    /**
		     * Adds two numbers.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.4.0
		     * @category Math
		     * @param {number} augend The first number in an addition.
		     * @param {number} addend The second number in an addition.
		     * @returns {number} Returns the total.
		     * @example
		     *
		     * _.add(6, 4);
		     * // => 10
		     */
		    var add = createMathOperation(function(augend, addend) {
		      return augend + addend;
		    }, 0);

		    /**
		     * Computes `number` rounded up to `precision`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.10.0
		     * @category Math
		     * @param {number} number The number to round up.
		     * @param {number} [precision=0] The precision to round up to.
		     * @returns {number} Returns the rounded up number.
		     * @example
		     *
		     * _.ceil(4.006);
		     * // => 5
		     *
		     * _.ceil(6.004, 2);
		     * // => 6.01
		     *
		     * _.ceil(6040, -2);
		     * // => 6100
		     */
		    var ceil = createRound('ceil');

		    /**
		     * Divide two numbers.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.7.0
		     * @category Math
		     * @param {number} dividend The first number in a division.
		     * @param {number} divisor The second number in a division.
		     * @returns {number} Returns the quotient.
		     * @example
		     *
		     * _.divide(6, 4);
		     * // => 1.5
		     */
		    var divide = createMathOperation(function(dividend, divisor) {
		      return dividend / divisor;
		    }, 1);

		    /**
		     * Computes `number` rounded down to `precision`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.10.0
		     * @category Math
		     * @param {number} number The number to round down.
		     * @param {number} [precision=0] The precision to round down to.
		     * @returns {number} Returns the rounded down number.
		     * @example
		     *
		     * _.floor(4.006);
		     * // => 4
		     *
		     * _.floor(0.046, 2);
		     * // => 0.04
		     *
		     * _.floor(4060, -2);
		     * // => 4000
		     */
		    var floor = createRound('floor');

		    /**
		     * Computes the maximum value of `array`. If `array` is empty or falsey,
		     * `undefined` is returned.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Math
		     * @param {Array} array The array to iterate over.
		     * @returns {*} Returns the maximum value.
		     * @example
		     *
		     * _.max([4, 2, 8, 6]);
		     * // => 8
		     *
		     * _.max([]);
		     * // => undefined
		     */
		    function max(array) {
		      return (array && array.length)
		        ? baseExtremum(array, identity, baseGt)
		        : undefined$1;
		    }

		    /**
		     * This method is like `_.max` except that it accepts `iteratee` which is
		     * invoked for each element in `array` to generate the criterion by which
		     * the value is ranked. The iteratee is invoked with one argument: (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Math
		     * @param {Array} array The array to iterate over.
		     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
		     * @returns {*} Returns the maximum value.
		     * @example
		     *
		     * var objects = [{ 'n': 1 }, { 'n': 2 }];
		     *
		     * _.maxBy(objects, function(o) { return o.n; });
		     * // => { 'n': 2 }
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.maxBy(objects, 'n');
		     * // => { 'n': 2 }
		     */
		    function maxBy(array, iteratee) {
		      return (array && array.length)
		        ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)
		        : undefined$1;
		    }

		    /**
		     * Computes the mean of the values in `array`.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Math
		     * @param {Array} array The array to iterate over.
		     * @returns {number} Returns the mean.
		     * @example
		     *
		     * _.mean([4, 2, 8, 6]);
		     * // => 5
		     */
		    function mean(array) {
		      return baseMean(array, identity);
		    }

		    /**
		     * This method is like `_.mean` except that it accepts `iteratee` which is
		     * invoked for each element in `array` to generate the value to be averaged.
		     * The iteratee is invoked with one argument: (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.7.0
		     * @category Math
		     * @param {Array} array The array to iterate over.
		     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
		     * @returns {number} Returns the mean.
		     * @example
		     *
		     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
		     *
		     * _.meanBy(objects, function(o) { return o.n; });
		     * // => 5
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.meanBy(objects, 'n');
		     * // => 5
		     */
		    function meanBy(array, iteratee) {
		      return baseMean(array, getIteratee(iteratee, 2));
		    }

		    /**
		     * Computes the minimum value of `array`. If `array` is empty or falsey,
		     * `undefined` is returned.
		     *
		     * @static
		     * @since 0.1.0
		     * @memberOf _
		     * @category Math
		     * @param {Array} array The array to iterate over.
		     * @returns {*} Returns the minimum value.
		     * @example
		     *
		     * _.min([4, 2, 8, 6]);
		     * // => 2
		     *
		     * _.min([]);
		     * // => undefined
		     */
		    function min(array) {
		      return (array && array.length)
		        ? baseExtremum(array, identity, baseLt)
		        : undefined$1;
		    }

		    /**
		     * This method is like `_.min` except that it accepts `iteratee` which is
		     * invoked for each element in `array` to generate the criterion by which
		     * the value is ranked. The iteratee is invoked with one argument: (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Math
		     * @param {Array} array The array to iterate over.
		     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
		     * @returns {*} Returns the minimum value.
		     * @example
		     *
		     * var objects = [{ 'n': 1 }, { 'n': 2 }];
		     *
		     * _.minBy(objects, function(o) { return o.n; });
		     * // => { 'n': 1 }
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.minBy(objects, 'n');
		     * // => { 'n': 1 }
		     */
		    function minBy(array, iteratee) {
		      return (array && array.length)
		        ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)
		        : undefined$1;
		    }

		    /**
		     * Multiply two numbers.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.7.0
		     * @category Math
		     * @param {number} multiplier The first number in a multiplication.
		     * @param {number} multiplicand The second number in a multiplication.
		     * @returns {number} Returns the product.
		     * @example
		     *
		     * _.multiply(6, 4);
		     * // => 24
		     */
		    var multiply = createMathOperation(function(multiplier, multiplicand) {
		      return multiplier * multiplicand;
		    }, 1);

		    /**
		     * Computes `number` rounded to `precision`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.10.0
		     * @category Math
		     * @param {number} number The number to round.
		     * @param {number} [precision=0] The precision to round to.
		     * @returns {number} Returns the rounded number.
		     * @example
		     *
		     * _.round(4.006);
		     * // => 4
		     *
		     * _.round(4.006, 2);
		     * // => 4.01
		     *
		     * _.round(4060, -2);
		     * // => 4100
		     */
		    var round = createRound('round');

		    /**
		     * Subtract two numbers.
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Math
		     * @param {number} minuend The first number in a subtraction.
		     * @param {number} subtrahend The second number in a subtraction.
		     * @returns {number} Returns the difference.
		     * @example
		     *
		     * _.subtract(6, 4);
		     * // => 2
		     */
		    var subtract = createMathOperation(function(minuend, subtrahend) {
		      return minuend - subtrahend;
		    }, 0);

		    /**
		     * Computes the sum of the values in `array`.
		     *
		     * @static
		     * @memberOf _
		     * @since 3.4.0
		     * @category Math
		     * @param {Array} array The array to iterate over.
		     * @returns {number} Returns the sum.
		     * @example
		     *
		     * _.sum([4, 2, 8, 6]);
		     * // => 20
		     */
		    function sum(array) {
		      return (array && array.length)
		        ? baseSum(array, identity)
		        : 0;
		    }

		    /**
		     * This method is like `_.sum` except that it accepts `iteratee` which is
		     * invoked for each element in `array` to generate the value to be summed.
		     * The iteratee is invoked with one argument: (value).
		     *
		     * @static
		     * @memberOf _
		     * @since 4.0.0
		     * @category Math
		     * @param {Array} array The array to iterate over.
		     * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
		     * @returns {number} Returns the sum.
		     * @example
		     *
		     * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];
		     *
		     * _.sumBy(objects, function(o) { return o.n; });
		     * // => 20
		     *
		     * // The `_.property` iteratee shorthand.
		     * _.sumBy(objects, 'n');
		     * // => 20
		     */
		    function sumBy(array, iteratee) {
		      return (array && array.length)
		        ? baseSum(array, getIteratee(iteratee, 2))
		        : 0;
		    }

		    /*------------------------------------------------------------------------*/

		    // Add methods that return wrapped values in chain sequences.
		    lodash.after = after;
		    lodash.ary = ary;
		    lodash.assign = assign;
		    lodash.assignIn = assignIn;
		    lodash.assignInWith = assignInWith;
		    lodash.assignWith = assignWith;
		    lodash.at = at;
		    lodash.before = before;
		    lodash.bind = bind;
		    lodash.bindAll = bindAll;
		    lodash.bindKey = bindKey;
		    lodash.castArray = castArray;
		    lodash.chain = chain;
		    lodash.chunk = chunk;
		    lodash.compact = compact;
		    lodash.concat = concat;
		    lodash.cond = cond;
		    lodash.conforms = conforms;
		    lodash.constant = constant;
		    lodash.countBy = countBy;
		    lodash.create = create;
		    lodash.curry = curry;
		    lodash.curryRight = curryRight;
		    lodash.debounce = debounce;
		    lodash.defaults = defaults;
		    lodash.defaultsDeep = defaultsDeep;
		    lodash.defer = defer;
		    lodash.delay = delay;
		    lodash.difference = difference;
		    lodash.differenceBy = differenceBy;
		    lodash.differenceWith = differenceWith;
		    lodash.drop = drop;
		    lodash.dropRight = dropRight;
		    lodash.dropRightWhile = dropRightWhile;
		    lodash.dropWhile = dropWhile;
		    lodash.fill = fill;
		    lodash.filter = filter;
		    lodash.flatMap = flatMap;
		    lodash.flatMapDeep = flatMapDeep;
		    lodash.flatMapDepth = flatMapDepth;
		    lodash.flatten = flatten;
		    lodash.flattenDeep = flattenDeep;
		    lodash.flattenDepth = flattenDepth;
		    lodash.flip = flip;
		    lodash.flow = flow;
		    lodash.flowRight = flowRight;
		    lodash.fromPairs = fromPairs;
		    lodash.functions = functions;
		    lodash.functionsIn = functionsIn;
		    lodash.groupBy = groupBy;
		    lodash.initial = initial;
		    lodash.intersection = intersection;
		    lodash.intersectionBy = intersectionBy;
		    lodash.intersectionWith = intersectionWith;
		    lodash.invert = invert;
		    lodash.invertBy = invertBy;
		    lodash.invokeMap = invokeMap;
		    lodash.iteratee = iteratee;
		    lodash.keyBy = keyBy;
		    lodash.keys = keys;
		    lodash.keysIn = keysIn;
		    lodash.map = map;
		    lodash.mapKeys = mapKeys;
		    lodash.mapValues = mapValues;
		    lodash.matches = matches;
		    lodash.matchesProperty = matchesProperty;
		    lodash.memoize = memoize;
		    lodash.merge = merge;
		    lodash.mergeWith = mergeWith;
		    lodash.method = method;
		    lodash.methodOf = methodOf;
		    lodash.mixin = mixin;
		    lodash.negate = negate;
		    lodash.nthArg = nthArg;
		    lodash.omit = omit;
		    lodash.omitBy = omitBy;
		    lodash.once = once;
		    lodash.orderBy = orderBy;
		    lodash.over = over;
		    lodash.overArgs = overArgs;
		    lodash.overEvery = overEvery;
		    lodash.overSome = overSome;
		    lodash.partial = partial;
		    lodash.partialRight = partialRight;
		    lodash.partition = partition;
		    lodash.pick = pick;
		    lodash.pickBy = pickBy;
		    lodash.property = property;
		    lodash.propertyOf = propertyOf;
		    lodash.pull = pull;
		    lodash.pullAll = pullAll;
		    lodash.pullAllBy = pullAllBy;
		    lodash.pullAllWith = pullAllWith;
		    lodash.pullAt = pullAt;
		    lodash.range = range;
		    lodash.rangeRight = rangeRight;
		    lodash.rearg = rearg;
		    lodash.reject = reject;
		    lodash.remove = remove;
		    lodash.rest = rest;
		    lodash.reverse = reverse;
		    lodash.sampleSize = sampleSize;
		    lodash.set = set;
		    lodash.setWith = setWith;
		    lodash.shuffle = shuffle;
		    lodash.slice = slice;
		    lodash.sortBy = sortBy;
		    lodash.sortedUniq = sortedUniq;
		    lodash.sortedUniqBy = sortedUniqBy;
		    lodash.split = split;
		    lodash.spread = spread;
		    lodash.tail = tail;
		    lodash.take = take;
		    lodash.takeRight = takeRight;
		    lodash.takeRightWhile = takeRightWhile;
		    lodash.takeWhile = takeWhile;
		    lodash.tap = tap;
		    lodash.throttle = throttle;
		    lodash.thru = thru;
		    lodash.toArray = toArray;
		    lodash.toPairs = toPairs;
		    lodash.toPairsIn = toPairsIn;
		    lodash.toPath = toPath;
		    lodash.toPlainObject = toPlainObject;
		    lodash.transform = transform;
		    lodash.unary = unary;
		    lodash.union = union;
		    lodash.unionBy = unionBy;
		    lodash.unionWith = unionWith;
		    lodash.uniq = uniq;
		    lodash.uniqBy = uniqBy;
		    lodash.uniqWith = uniqWith;
		    lodash.unset = unset;
		    lodash.unzip = unzip;
		    lodash.unzipWith = unzipWith;
		    lodash.update = update;
		    lodash.updateWith = updateWith;
		    lodash.values = values;
		    lodash.valuesIn = valuesIn;
		    lodash.without = without;
		    lodash.words = words;
		    lodash.wrap = wrap;
		    lodash.xor = xor;
		    lodash.xorBy = xorBy;
		    lodash.xorWith = xorWith;
		    lodash.zip = zip;
		    lodash.zipObject = zipObject;
		    lodash.zipObjectDeep = zipObjectDeep;
		    lodash.zipWith = zipWith;

		    // Add aliases.
		    lodash.entries = toPairs;
		    lodash.entriesIn = toPairsIn;
		    lodash.extend = assignIn;
		    lodash.extendWith = assignInWith;

		    // Add methods to `lodash.prototype`.
		    mixin(lodash, lodash);

		    /*------------------------------------------------------------------------*/

		    // Add methods that return unwrapped values in chain sequences.
		    lodash.add = add;
		    lodash.attempt = attempt;
		    lodash.camelCase = camelCase;
		    lodash.capitalize = capitalize;
		    lodash.ceil = ceil;
		    lodash.clamp = clamp;
		    lodash.clone = clone;
		    lodash.cloneDeep = cloneDeep;
		    lodash.cloneDeepWith = cloneDeepWith;
		    lodash.cloneWith = cloneWith;
		    lodash.conformsTo = conformsTo;
		    lodash.deburr = deburr;
		    lodash.defaultTo = defaultTo;
		    lodash.divide = divide;
		    lodash.endsWith = endsWith;
		    lodash.eq = eq;
		    lodash.escape = escape;
		    lodash.escapeRegExp = escapeRegExp;
		    lodash.every = every;
		    lodash.find = find;
		    lodash.findIndex = findIndex;
		    lodash.findKey = findKey;
		    lodash.findLast = findLast;
		    lodash.findLastIndex = findLastIndex;
		    lodash.findLastKey = findLastKey;
		    lodash.floor = floor;
		    lodash.forEach = forEach;
		    lodash.forEachRight = forEachRight;
		    lodash.forIn = forIn;
		    lodash.forInRight = forInRight;
		    lodash.forOwn = forOwn;
		    lodash.forOwnRight = forOwnRight;
		    lodash.get = get;
		    lodash.gt = gt;
		    lodash.gte = gte;
		    lodash.has = has;
		    lodash.hasIn = hasIn;
		    lodash.head = head;
		    lodash.identity = identity;
		    lodash.includes = includes;
		    lodash.indexOf = indexOf;
		    lodash.inRange = inRange;
		    lodash.invoke = invoke;
		    lodash.isArguments = isArguments;
		    lodash.isArray = isArray;
		    lodash.isArrayBuffer = isArrayBuffer;
		    lodash.isArrayLike = isArrayLike;
		    lodash.isArrayLikeObject = isArrayLikeObject;
		    lodash.isBoolean = isBoolean;
		    lodash.isBuffer = isBuffer;
		    lodash.isDate = isDate;
		    lodash.isElement = isElement;
		    lodash.isEmpty = isEmpty;
		    lodash.isEqual = isEqual;
		    lodash.isEqualWith = isEqualWith;
		    lodash.isError = isError;
		    lodash.isFinite = isFinite;
		    lodash.isFunction = isFunction;
		    lodash.isInteger = isInteger;
		    lodash.isLength = isLength;
		    lodash.isMap = isMap;
		    lodash.isMatch = isMatch;
		    lodash.isMatchWith = isMatchWith;
		    lodash.isNaN = isNaN;
		    lodash.isNative = isNative;
		    lodash.isNil = isNil;
		    lodash.isNull = isNull;
		    lodash.isNumber = isNumber;
		    lodash.isObject = isObject;
		    lodash.isObjectLike = isObjectLike;
		    lodash.isPlainObject = isPlainObject;
		    lodash.isRegExp = isRegExp;
		    lodash.isSafeInteger = isSafeInteger;
		    lodash.isSet = isSet;
		    lodash.isString = isString;
		    lodash.isSymbol = isSymbol;
		    lodash.isTypedArray = isTypedArray;
		    lodash.isUndefined = isUndefined;
		    lodash.isWeakMap = isWeakMap;
		    lodash.isWeakSet = isWeakSet;
		    lodash.join = join;
		    lodash.kebabCase = kebabCase;
		    lodash.last = last;
		    lodash.lastIndexOf = lastIndexOf;
		    lodash.lowerCase = lowerCase;
		    lodash.lowerFirst = lowerFirst;
		    lodash.lt = lt;
		    lodash.lte = lte;
		    lodash.max = max;
		    lodash.maxBy = maxBy;
		    lodash.mean = mean;
		    lodash.meanBy = meanBy;
		    lodash.min = min;
		    lodash.minBy = minBy;
		    lodash.stubArray = stubArray;
		    lodash.stubFalse = stubFalse;
		    lodash.stubObject = stubObject;
		    lodash.stubString = stubString;
		    lodash.stubTrue = stubTrue;
		    lodash.multiply = multiply;
		    lodash.nth = nth;
		    lodash.noConflict = noConflict;
		    lodash.noop = noop;
		    lodash.now = now;
		    lodash.pad = pad;
		    lodash.padEnd = padEnd;
		    lodash.padStart = padStart;
		    lodash.parseInt = parseInt;
		    lodash.random = random;
		    lodash.reduce = reduce;
		    lodash.reduceRight = reduceRight;
		    lodash.repeat = repeat;
		    lodash.replace = replace;
		    lodash.result = result;
		    lodash.round = round;
		    lodash.runInContext = runInContext;
		    lodash.sample = sample;
		    lodash.size = size;
		    lodash.snakeCase = snakeCase;
		    lodash.some = some;
		    lodash.sortedIndex = sortedIndex;
		    lodash.sortedIndexBy = sortedIndexBy;
		    lodash.sortedIndexOf = sortedIndexOf;
		    lodash.sortedLastIndex = sortedLastIndex;
		    lodash.sortedLastIndexBy = sortedLastIndexBy;
		    lodash.sortedLastIndexOf = sortedLastIndexOf;
		    lodash.startCase = startCase;
		    lodash.startsWith = startsWith;
		    lodash.subtract = subtract;
		    lodash.sum = sum;
		    lodash.sumBy = sumBy;
		    lodash.template = template;
		    lodash.times = times;
		    lodash.toFinite = toFinite;
		    lodash.toInteger = toInteger;
		    lodash.toLength = toLength;
		    lodash.toLower = toLower;
		    lodash.toNumber = toNumber;
		    lodash.toSafeInteger = toSafeInteger;
		    lodash.toString = toString;
		    lodash.toUpper = toUpper;
		    lodash.trim = trim;
		    lodash.trimEnd = trimEnd;
		    lodash.trimStart = trimStart;
		    lodash.truncate = truncate;
		    lodash.unescape = unescape;
		    lodash.uniqueId = uniqueId;
		    lodash.upperCase = upperCase;
		    lodash.upperFirst = upperFirst;

		    // Add aliases.
		    lodash.each = forEach;
		    lodash.eachRight = forEachRight;
		    lodash.first = head;

		    mixin(lodash, (function() {
		      var source = {};
		      baseForOwn(lodash, function(func, methodName) {
		        if (!hasOwnProperty.call(lodash.prototype, methodName)) {
		          source[methodName] = func;
		        }
		      });
		      return source;
		    }()), { 'chain': false });

		    /*------------------------------------------------------------------------*/

		    /**
		     * The semantic version number.
		     *
		     * @static
		     * @memberOf _
		     * @type {string}
		     */
		    lodash.VERSION = VERSION;

		    // Assign default placeholders.
		    arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {
		      lodash[methodName].placeholder = lodash;
		    });

		    // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.
		    arrayEach(['drop', 'take'], function(methodName, index) {
		      LazyWrapper.prototype[methodName] = function(n) {
		        n = n === undefined$1 ? 1 : nativeMax(toInteger(n), 0);

		        var result = (this.__filtered__ && !index)
		          ? new LazyWrapper(this)
		          : this.clone();

		        if (result.__filtered__) {
		          result.__takeCount__ = nativeMin(n, result.__takeCount__);
		        } else {
		          result.__views__.push({
		            'size': nativeMin(n, MAX_ARRAY_LENGTH),
		            'type': methodName + (result.__dir__ < 0 ? 'Right' : '')
		          });
		        }
		        return result;
		      };

		      LazyWrapper.prototype[methodName + 'Right'] = function(n) {
		        return this.reverse()[methodName](n).reverse();
		      };
		    });

		    // Add `LazyWrapper` methods that accept an `iteratee` value.
		    arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {
		      var type = index + 1,
		          isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;

		      LazyWrapper.prototype[methodName] = function(iteratee) {
		        var result = this.clone();
		        result.__iteratees__.push({
		          'iteratee': getIteratee(iteratee, 3),
		          'type': type
		        });
		        result.__filtered__ = result.__filtered__ || isFilter;
		        return result;
		      };
		    });

		    // Add `LazyWrapper` methods for `_.head` and `_.last`.
		    arrayEach(['head', 'last'], function(methodName, index) {
		      var takeName = 'take' + (index ? 'Right' : '');

		      LazyWrapper.prototype[methodName] = function() {
		        return this[takeName](1).value()[0];
		      };
		    });

		    // Add `LazyWrapper` methods for `_.initial` and `_.tail`.
		    arrayEach(['initial', 'tail'], function(methodName, index) {
		      var dropName = 'drop' + (index ? '' : 'Right');

		      LazyWrapper.prototype[methodName] = function() {
		        return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
		      };
		    });

		    LazyWrapper.prototype.compact = function() {
		      return this.filter(identity);
		    };

		    LazyWrapper.prototype.find = function(predicate) {
		      return this.filter(predicate).head();
		    };

		    LazyWrapper.prototype.findLast = function(predicate) {
		      return this.reverse().find(predicate);
		    };

		    LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
		      if (typeof path == 'function') {
		        return new LazyWrapper(this);
		      }
		      return this.map(function(value) {
		        return baseInvoke(value, path, args);
		      });
		    });

		    LazyWrapper.prototype.reject = function(predicate) {
		      return this.filter(negate(getIteratee(predicate)));
		    };

		    LazyWrapper.prototype.slice = function(start, end) {
		      start = toInteger(start);

		      var result = this;
		      if (result.__filtered__ && (start > 0 || end < 0)) {
		        return new LazyWrapper(result);
		      }
		      if (start < 0) {
		        result = result.takeRight(-start);
		      } else if (start) {
		        result = result.drop(start);
		      }
		      if (end !== undefined$1) {
		        end = toInteger(end);
		        result = end < 0 ? result.dropRight(-end) : result.take(end - start);
		      }
		      return result;
		    };

		    LazyWrapper.prototype.takeRightWhile = function(predicate) {
		      return this.reverse().takeWhile(predicate).reverse();
		    };

		    LazyWrapper.prototype.toArray = function() {
		      return this.take(MAX_ARRAY_LENGTH);
		    };

		    // Add `LazyWrapper` methods to `lodash.prototype`.
		    baseForOwn(LazyWrapper.prototype, function(func, methodName) {
		      var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),
		          isTaker = /^(?:head|last)$/.test(methodName),
		          lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],
		          retUnwrapped = isTaker || /^find/.test(methodName);

		      if (!lodashFunc) {
		        return;
		      }
		      lodash.prototype[methodName] = function() {
		        var value = this.__wrapped__,
		            args = isTaker ? [1] : arguments,
		            isLazy = value instanceof LazyWrapper,
		            iteratee = args[0],
		            useLazy = isLazy || isArray(value);

		        var interceptor = function(value) {
		          var result = lodashFunc.apply(lodash, arrayPush([value], args));
		          return (isTaker && chainAll) ? result[0] : result;
		        };

		        if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {
		          // Avoid lazy use if the iteratee has a "length" value other than `1`.
		          isLazy = useLazy = false;
		        }
		        var chainAll = this.__chain__,
		            isHybrid = !!this.__actions__.length,
		            isUnwrapped = retUnwrapped && !chainAll,
		            onlyLazy = isLazy && !isHybrid;

		        if (!retUnwrapped && useLazy) {
		          value = onlyLazy ? value : new LazyWrapper(this);
		          var result = func.apply(value, args);
		          result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined$1 });
		          return new LodashWrapper(result, chainAll);
		        }
		        if (isUnwrapped && onlyLazy) {
		          return func.apply(this, args);
		        }
		        result = this.thru(interceptor);
		        return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;
		      };
		    });

		    // Add `Array` methods to `lodash.prototype`.
		    arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {
		      var func = arrayProto[methodName],
		          chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',
		          retUnwrapped = /^(?:pop|shift)$/.test(methodName);

		      lodash.prototype[methodName] = function() {
		        var args = arguments;
		        if (retUnwrapped && !this.__chain__) {
		          var value = this.value();
		          return func.apply(isArray(value) ? value : [], args);
		        }
		        return this[chainName](function(value) {
		          return func.apply(isArray(value) ? value : [], args);
		        });
		      };
		    });

		    // Map minified method names to their real names.
		    baseForOwn(LazyWrapper.prototype, function(func, methodName) {
		      var lodashFunc = lodash[methodName];
		      if (lodashFunc) {
		        var key = lodashFunc.name + '';
		        if (!hasOwnProperty.call(realNames, key)) {
		          realNames[key] = [];
		        }
		        realNames[key].push({ 'name': methodName, 'func': lodashFunc });
		      }
		    });

		    realNames[createHybrid(undefined$1, WRAP_BIND_KEY_FLAG).name] = [{
		      'name': 'wrapper',
		      'func': undefined$1
		    }];

		    // Add methods to `LazyWrapper`.
		    LazyWrapper.prototype.clone = lazyClone;
		    LazyWrapper.prototype.reverse = lazyReverse;
		    LazyWrapper.prototype.value = lazyValue;

		    // Add chain sequence methods to the `lodash` wrapper.
		    lodash.prototype.at = wrapperAt;
		    lodash.prototype.chain = wrapperChain;
		    lodash.prototype.commit = wrapperCommit;
		    lodash.prototype.next = wrapperNext;
		    lodash.prototype.plant = wrapperPlant;
		    lodash.prototype.reverse = wrapperReverse;
		    lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;

		    // Add lazy aliases.
		    lodash.prototype.first = lodash.prototype.head;

		    if (symIterator) {
		      lodash.prototype[symIterator] = wrapperToIterator;
		    }
		    return lodash;
		  });

		  /*--------------------------------------------------------------------------*/

		  // Export lodash.
		  var _ = runInContext();

		  // Some AMD build optimizers, like r.js, check for condition patterns like:
		  if (freeModule) {
		    // Export for Node.js.
		    (freeModule.exports = _)._ = _;
		    // Export for CommonJS support.
		    freeExports._ = _;
		  }
		  else {
		    // Export to the global object.
		    root._ = _;
		  }
		}.call(commonjsGlobal)); 
	} (lodash, lodash.exports));

	var lodashExports = lodash.exports;
	var _$5 = /*@__PURE__*/getDefaultExportFromCjs(lodashExports);

	Object.defineProperty(prefixNegativeModifiers$2, "__esModule", {
	  value: true
	});
	prefixNegativeModifiers$2.default = prefixNegativeModifiers$1;

	var _lodash$1 = _interopRequireDefault$1(lodashExports);

	function _interopRequireDefault$1(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

	function prefixNegativeModifiers$1(base, modifier) {
	  if (modifier === '-') {
	    return `-${base}`;
	  } else if (_lodash$1.default.startsWith(modifier, '-')) {
	    return `-${base}-${modifier.slice(1)}`;
	  } else {
	    return `${base}-${modifier}`;
	  }
	}

	var flattenColorPalette$2 = {};

	Object.defineProperty(flattenColorPalette$2, "__esModule", {
	  value: true
	});
	flattenColorPalette$2.default = void 0;

	const flattenColorPalette$1 = colors => Object.assign({}, ...Object.entries(colors).flatMap(([color, values]) => typeof values == 'object' ? Object.entries(flattenColorPalette$1(values)).map(([number, hex]) => ({
	  [color + (number === 'DEFAULT' ? '' : `-${number}`)]: hex
	})) : [{
	  [`${color}`]: values
	}]));

	var _default$2 = flattenColorPalette$1;
	flattenColorPalette$2.default = _default$2;

	var withAlphaVariable$2 = {};

	var colorString$1 = {exports: {}};

	var colorName = {
		"aliceblue": [240, 248, 255],
		"antiquewhite": [250, 235, 215],
		"aqua": [0, 255, 255],
		"aquamarine": [127, 255, 212],
		"azure": [240, 255, 255],
		"beige": [245, 245, 220],
		"bisque": [255, 228, 196],
		"black": [0, 0, 0],
		"blanchedalmond": [255, 235, 205],
		"blue": [0, 0, 255],
		"blueviolet": [138, 43, 226],
		"brown": [165, 42, 42],
		"burlywood": [222, 184, 135],
		"cadetblue": [95, 158, 160],
		"chartreuse": [127, 255, 0],
		"chocolate": [210, 105, 30],
		"coral": [255, 127, 80],
		"cornflowerblue": [100, 149, 237],
		"cornsilk": [255, 248, 220],
		"crimson": [220, 20, 60],
		"cyan": [0, 255, 255],
		"darkblue": [0, 0, 139],
		"darkcyan": [0, 139, 139],
		"darkgoldenrod": [184, 134, 11],
		"darkgray": [169, 169, 169],
		"darkgreen": [0, 100, 0],
		"darkgrey": [169, 169, 169],
		"darkkhaki": [189, 183, 107],
		"darkmagenta": [139, 0, 139],
		"darkolivegreen": [85, 107, 47],
		"darkorange": [255, 140, 0],
		"darkorchid": [153, 50, 204],
		"darkred": [139, 0, 0],
		"darksalmon": [233, 150, 122],
		"darkseagreen": [143, 188, 143],
		"darkslateblue": [72, 61, 139],
		"darkslategray": [47, 79, 79],
		"darkslategrey": [47, 79, 79],
		"darkturquoise": [0, 206, 209],
		"darkviolet": [148, 0, 211],
		"deeppink": [255, 20, 147],
		"deepskyblue": [0, 191, 255],
		"dimgray": [105, 105, 105],
		"dimgrey": [105, 105, 105],
		"dodgerblue": [30, 144, 255],
		"firebrick": [178, 34, 34],
		"floralwhite": [255, 250, 240],
		"forestgreen": [34, 139, 34],
		"fuchsia": [255, 0, 255],
		"gainsboro": [220, 220, 220],
		"ghostwhite": [248, 248, 255],
		"gold": [255, 215, 0],
		"goldenrod": [218, 165, 32],
		"gray": [128, 128, 128],
		"green": [0, 128, 0],
		"greenyellow": [173, 255, 47],
		"grey": [128, 128, 128],
		"honeydew": [240, 255, 240],
		"hotpink": [255, 105, 180],
		"indianred": [205, 92, 92],
		"indigo": [75, 0, 130],
		"ivory": [255, 255, 240],
		"khaki": [240, 230, 140],
		"lavender": [230, 230, 250],
		"lavenderblush": [255, 240, 245],
		"lawngreen": [124, 252, 0],
		"lemonchiffon": [255, 250, 205],
		"lightblue": [173, 216, 230],
		"lightcoral": [240, 128, 128],
		"lightcyan": [224, 255, 255],
		"lightgoldenrodyellow": [250, 250, 210],
		"lightgray": [211, 211, 211],
		"lightgreen": [144, 238, 144],
		"lightgrey": [211, 211, 211],
		"lightpink": [255, 182, 193],
		"lightsalmon": [255, 160, 122],
		"lightseagreen": [32, 178, 170],
		"lightskyblue": [135, 206, 250],
		"lightslategray": [119, 136, 153],
		"lightslategrey": [119, 136, 153],
		"lightsteelblue": [176, 196, 222],
		"lightyellow": [255, 255, 224],
		"lime": [0, 255, 0],
		"limegreen": [50, 205, 50],
		"linen": [250, 240, 230],
		"magenta": [255, 0, 255],
		"maroon": [128, 0, 0],
		"mediumaquamarine": [102, 205, 170],
		"mediumblue": [0, 0, 205],
		"mediumorchid": [186, 85, 211],
		"mediumpurple": [147, 112, 219],
		"mediumseagreen": [60, 179, 113],
		"mediumslateblue": [123, 104, 238],
		"mediumspringgreen": [0, 250, 154],
		"mediumturquoise": [72, 209, 204],
		"mediumvioletred": [199, 21, 133],
		"midnightblue": [25, 25, 112],
		"mintcream": [245, 255, 250],
		"mistyrose": [255, 228, 225],
		"moccasin": [255, 228, 181],
		"navajowhite": [255, 222, 173],
		"navy": [0, 0, 128],
		"oldlace": [253, 245, 230],
		"olive": [128, 128, 0],
		"olivedrab": [107, 142, 35],
		"orange": [255, 165, 0],
		"orangered": [255, 69, 0],
		"orchid": [218, 112, 214],
		"palegoldenrod": [238, 232, 170],
		"palegreen": [152, 251, 152],
		"paleturquoise": [175, 238, 238],
		"palevioletred": [219, 112, 147],
		"papayawhip": [255, 239, 213],
		"peachpuff": [255, 218, 185],
		"peru": [205, 133, 63],
		"pink": [255, 192, 203],
		"plum": [221, 160, 221],
		"powderblue": [176, 224, 230],
		"purple": [128, 0, 128],
		"rebeccapurple": [102, 51, 153],
		"red": [255, 0, 0],
		"rosybrown": [188, 143, 143],
		"royalblue": [65, 105, 225],
		"saddlebrown": [139, 69, 19],
		"salmon": [250, 128, 114],
		"sandybrown": [244, 164, 96],
		"seagreen": [46, 139, 87],
		"seashell": [255, 245, 238],
		"sienna": [160, 82, 45],
		"silver": [192, 192, 192],
		"skyblue": [135, 206, 235],
		"slateblue": [106, 90, 205],
		"slategray": [112, 128, 144],
		"slategrey": [112, 128, 144],
		"snow": [255, 250, 250],
		"springgreen": [0, 255, 127],
		"steelblue": [70, 130, 180],
		"tan": [210, 180, 140],
		"teal": [0, 128, 128],
		"thistle": [216, 191, 216],
		"tomato": [255, 99, 71],
		"turquoise": [64, 224, 208],
		"violet": [238, 130, 238],
		"wheat": [245, 222, 179],
		"white": [255, 255, 255],
		"whitesmoke": [245, 245, 245],
		"yellow": [255, 255, 0],
		"yellowgreen": [154, 205, 50]
	};

	var names = /*@__PURE__*/getDefaultExportFromCjs(colorName);

	var simpleSwizzle = {exports: {}};

	var isArrayish$1 = function isArrayish(obj) {
		if (!obj || typeof obj === 'string') {
			return false;
		}

		return obj instanceof Array || Array.isArray(obj) ||
			(obj.length >= 0 && (obj.splice instanceof Function ||
				(Object.getOwnPropertyDescriptor(obj, (obj.length - 1)) && obj.constructor.name !== 'String')));
	};

	var isArrayish = isArrayish$1;

	var concat = Array.prototype.concat;
	var slice = Array.prototype.slice;

	var swizzle$1 = simpleSwizzle.exports = function swizzle(args) {
		var results = [];

		for (var i = 0, len = args.length; i < len; i++) {
			var arg = args[i];

			if (isArrayish(arg)) {
				// http://jsperf.com/javascript-array-concat-vs-push/98
				results = concat.call(results, slice.call(arg));
			} else {
				results.push(arg);
			}
		}

		return results;
	};

	swizzle$1.wrap = function (fn) {
		return function () {
			return fn(swizzle$1(arguments));
		};
	};

	var simpleSwizzleExports = simpleSwizzle.exports;

	/* MIT license */

	var colorNames = colorName;
	var swizzle = simpleSwizzleExports;

	var reverseNames = {};

	// create a list of reverse color names
	for (var name in colorNames) {
		if (colorNames.hasOwnProperty(name)) {
			reverseNames[colorNames[name]] = name;
		}
	}

	var cs$1 = colorString$1.exports = {
		to: {},
		get: {}
	};

	cs$1.get = function (string) {
		var prefix = string.substring(0, 3).toLowerCase();
		var val;
		var model;
		switch (prefix) {
			case 'hsl':
				val = cs$1.get.hsl(string);
				model = 'hsl';
				break;
			case 'hwb':
				val = cs$1.get.hwb(string);
				model = 'hwb';
				break;
			default:
				val = cs$1.get.rgb(string);
				model = 'rgb';
				break;
		}

		if (!val) {
			return null;
		}

		return {model: model, value: val};
	};

	cs$1.get.rgb = function (string) {
		if (!string) {
			return null;
		}

		var abbr = /^#([a-f0-9]{3,4})$/i;
		var hex = /^#([a-f0-9]{6})([a-f0-9]{2})?$/i;
		var rgba = /^rgba?\(\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*,\s*([+-]?\d+)\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/;
		var per = /^rgba?\(\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*,\s*([+-]?[\d\.]+)\%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/;
		var keyword = /(\D+)/;

		var rgb = [0, 0, 0, 1];
		var match;
		var i;
		var hexAlpha;

		if (match = string.match(hex)) {
			hexAlpha = match[2];
			match = match[1];

			for (i = 0; i < 3; i++) {
				// https://jsperf.com/slice-vs-substr-vs-substring-methods-long-string/19
				var i2 = i * 2;
				rgb[i] = parseInt(match.slice(i2, i2 + 2), 16);
			}

			if (hexAlpha) {
				rgb[3] = parseInt(hexAlpha, 16) / 255;
			}
		} else if (match = string.match(abbr)) {
			match = match[1];
			hexAlpha = match[3];

			for (i = 0; i < 3; i++) {
				rgb[i] = parseInt(match[i] + match[i], 16);
			}

			if (hexAlpha) {
				rgb[3] = parseInt(hexAlpha + hexAlpha, 16) / 255;
			}
		} else if (match = string.match(rgba)) {
			for (i = 0; i < 3; i++) {
				rgb[i] = parseInt(match[i + 1], 0);
			}

			if (match[4]) {
				rgb[3] = parseFloat(match[4]);
			}
		} else if (match = string.match(per)) {
			for (i = 0; i < 3; i++) {
				rgb[i] = Math.round(parseFloat(match[i + 1]) * 2.55);
			}

			if (match[4]) {
				rgb[3] = parseFloat(match[4]);
			}
		} else if (match = string.match(keyword)) {
			if (match[1] === 'transparent') {
				return [0, 0, 0, 0];
			}

			rgb = colorNames[match[1]];

			if (!rgb) {
				return null;
			}

			rgb[3] = 1;

			return rgb;
		} else {
			return null;
		}

		for (i = 0; i < 3; i++) {
			rgb[i] = clamp$1(rgb[i], 0, 255);
		}
		rgb[3] = clamp$1(rgb[3], 0, 1);

		return rgb;
	};

	cs$1.get.hsl = function (string) {
		if (!string) {
			return null;
		}

		var hsl = /^hsla?\(\s*([+-]?(?:\d{0,3}\.)?\d+)(?:deg)?\s*,?\s*([+-]?[\d\.]+)%\s*,?\s*([+-]?[\d\.]+)%\s*(?:[,|\/]\s*([+-]?[\d\.]+)\s*)?\)$/;
		var match = string.match(hsl);

		if (match) {
			var alpha = parseFloat(match[4]);
			var h = (parseFloat(match[1]) + 360) % 360;
			var s = clamp$1(parseFloat(match[2]), 0, 100);
			var l = clamp$1(parseFloat(match[3]), 0, 100);
			var a = clamp$1(isNaN(alpha) ? 1 : alpha, 0, 1);

			return [h, s, l, a];
		}

		return null;
	};

	cs$1.get.hwb = function (string) {
		if (!string) {
			return null;
		}

		var hwb = /^hwb\(\s*([+-]?\d{0,3}(?:\.\d+)?)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?[\d\.]+)\s*)?\)$/;
		var match = string.match(hwb);

		if (match) {
			var alpha = parseFloat(match[4]);
			var h = ((parseFloat(match[1]) % 360) + 360) % 360;
			var w = clamp$1(parseFloat(match[2]), 0, 100);
			var b = clamp$1(parseFloat(match[3]), 0, 100);
			var a = clamp$1(isNaN(alpha) ? 1 : alpha, 0, 1);
			return [h, w, b, a];
		}

		return null;
	};

	cs$1.to.hex = function () {
		var rgba = swizzle(arguments);

		return (
			'#' +
			hexDouble(rgba[0]) +
			hexDouble(rgba[1]) +
			hexDouble(rgba[2]) +
			(rgba[3] < 1
				? (hexDouble(Math.round(rgba[3] * 255)))
				: '')
		);
	};

	cs$1.to.rgb = function () {
		var rgba = swizzle(arguments);

		return rgba.length < 4 || rgba[3] === 1
			? 'rgb(' + Math.round(rgba[0]) + ', ' + Math.round(rgba[1]) + ', ' + Math.round(rgba[2]) + ')'
			: 'rgba(' + Math.round(rgba[0]) + ', ' + Math.round(rgba[1]) + ', ' + Math.round(rgba[2]) + ', ' + rgba[3] + ')';
	};

	cs$1.to.rgb.percent = function () {
		var rgba = swizzle(arguments);

		var r = Math.round(rgba[0] / 255 * 100);
		var g = Math.round(rgba[1] / 255 * 100);
		var b = Math.round(rgba[2] / 255 * 100);

		return rgba.length < 4 || rgba[3] === 1
			? 'rgb(' + r + '%, ' + g + '%, ' + b + '%)'
			: 'rgba(' + r + '%, ' + g + '%, ' + b + '%, ' + rgba[3] + ')';
	};

	cs$1.to.hsl = function () {
		var hsla = swizzle(arguments);
		return hsla.length < 4 || hsla[3] === 1
			? 'hsl(' + hsla[0] + ', ' + hsla[1] + '%, ' + hsla[2] + '%)'
			: 'hsla(' + hsla[0] + ', ' + hsla[1] + '%, ' + hsla[2] + '%, ' + hsla[3] + ')';
	};

	// hwb is a bit different than rgb(a) & hsl(a) since there is no alpha specific syntax
	// (hwb have alpha optional & 1 is default value)
	cs$1.to.hwb = function () {
		var hwba = swizzle(arguments);

		var a = '';
		if (hwba.length >= 4 && hwba[3] !== 1) {
			a = ', ' + hwba[3];
		}

		return 'hwb(' + hwba[0] + ', ' + hwba[1] + '%, ' + hwba[2] + '%' + a + ')';
	};

	cs$1.to.keyword = function (rgb) {
		return reverseNames[rgb.slice(0, 3)];
	};

	// helpers
	function clamp$1(num, min, max) {
		return Math.min(Math.max(min, num), max);
	}

	function hexDouble(num) {
		var str = num.toString(16).toUpperCase();
		return (str.length < 2) ? '0' + str : str;
	}

	var colorStringExports = colorString$1.exports;

	var conversions$2 = {exports: {}};

	/* MIT license */

	var cssKeywords = colorName;

	// NOTE: conversions should only return primitive values (i.e. arrays, or
	//       values that give correct `typeof` results).
	//       do not use box values types (i.e. Number(), String(), etc.)

	var reverseKeywords = {};
	for (var key$1 in cssKeywords) {
		if (cssKeywords.hasOwnProperty(key$1)) {
			reverseKeywords[cssKeywords[key$1]] = key$1;
		}
	}

	var convert$8 = conversions$2.exports = {
		rgb: {channels: 3, labels: 'rgb'},
		hsl: {channels: 3, labels: 'hsl'},
		hsv: {channels: 3, labels: 'hsv'},
		hwb: {channels: 3, labels: 'hwb'},
		cmyk: {channels: 4, labels: 'cmyk'},
		xyz: {channels: 3, labels: 'xyz'},
		lab: {channels: 3, labels: 'lab'},
		lch: {channels: 3, labels: 'lch'},
		hex: {channels: 1, labels: ['hex']},
		keyword: {channels: 1, labels: ['keyword']},
		ansi16: {channels: 1, labels: ['ansi16']},
		ansi256: {channels: 1, labels: ['ansi256']},
		hcg: {channels: 3, labels: ['h', 'c', 'g']},
		apple: {channels: 3, labels: ['r16', 'g16', 'b16']},
		gray: {channels: 1, labels: ['gray']}
	};

	// hide .channels and .labels properties
	for (var model in convert$8) {
		if (convert$8.hasOwnProperty(model)) {
			if (!('channels' in convert$8[model])) {
				throw new Error('missing channels property: ' + model);
			}

			if (!('labels' in convert$8[model])) {
				throw new Error('missing channel labels property: ' + model);
			}

			if (convert$8[model].labels.length !== convert$8[model].channels) {
				throw new Error('channel and label counts mismatch: ' + model);
			}

			var channels = convert$8[model].channels;
			var labels = convert$8[model].labels;
			delete convert$8[model].channels;
			delete convert$8[model].labels;
			Object.defineProperty(convert$8[model], 'channels', {value: channels});
			Object.defineProperty(convert$8[model], 'labels', {value: labels});
		}
	}

	convert$8.rgb.hsl = function (rgb) {
		var r = rgb[0] / 255;
		var g = rgb[1] / 255;
		var b = rgb[2] / 255;
		var min = Math.min(r, g, b);
		var max = Math.max(r, g, b);
		var delta = max - min;
		var h;
		var s;
		var l;

		if (max === min) {
			h = 0;
		} else if (r === max) {
			h = (g - b) / delta;
		} else if (g === max) {
			h = 2 + (b - r) / delta;
		} else if (b === max) {
			h = 4 + (r - g) / delta;
		}

		h = Math.min(h * 60, 360);

		if (h < 0) {
			h += 360;
		}

		l = (min + max) / 2;

		if (max === min) {
			s = 0;
		} else if (l <= 0.5) {
			s = delta / (max + min);
		} else {
			s = delta / (2 - max - min);
		}

		return [h, s * 100, l * 100];
	};

	convert$8.rgb.hsv = function (rgb) {
		var rdif;
		var gdif;
		var bdif;
		var h;
		var s;

		var r = rgb[0] / 255;
		var g = rgb[1] / 255;
		var b = rgb[2] / 255;
		var v = Math.max(r, g, b);
		var diff = v - Math.min(r, g, b);
		var diffc = function (c) {
			return (v - c) / 6 / diff + 1 / 2;
		};

		if (diff === 0) {
			h = s = 0;
		} else {
			s = diff / v;
			rdif = diffc(r);
			gdif = diffc(g);
			bdif = diffc(b);

			if (r === v) {
				h = bdif - gdif;
			} else if (g === v) {
				h = (1 / 3) + rdif - bdif;
			} else if (b === v) {
				h = (2 / 3) + gdif - rdif;
			}
			if (h < 0) {
				h += 1;
			} else if (h > 1) {
				h -= 1;
			}
		}

		return [
			h * 360,
			s * 100,
			v * 100
		];
	};

	convert$8.rgb.hwb = function (rgb) {
		var r = rgb[0];
		var g = rgb[1];
		var b = rgb[2];
		var h = convert$8.rgb.hsl(rgb)[0];
		var w = 1 / 255 * Math.min(r, Math.min(g, b));

		b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));

		return [h, w * 100, b * 100];
	};

	convert$8.rgb.cmyk = function (rgb) {
		var r = rgb[0] / 255;
		var g = rgb[1] / 255;
		var b = rgb[2] / 255;
		var c;
		var m;
		var y;
		var k;

		k = Math.min(1 - r, 1 - g, 1 - b);
		c = (1 - r - k) / (1 - k) || 0;
		m = (1 - g - k) / (1 - k) || 0;
		y = (1 - b - k) / (1 - k) || 0;

		return [c * 100, m * 100, y * 100, k * 100];
	};

	/**
	 * See https://en.m.wikipedia.org/wiki/Euclidean_distance#Squared_Euclidean_distance
	 * */
	function comparativeDistance(x, y) {
		return (
			Math.pow(x[0] - y[0], 2) +
			Math.pow(x[1] - y[1], 2) +
			Math.pow(x[2] - y[2], 2)
		);
	}

	convert$8.rgb.keyword = function (rgb) {
		var reversed = reverseKeywords[rgb];
		if (reversed) {
			return reversed;
		}

		var currentClosestDistance = Infinity;
		var currentClosestKeyword;

		for (var keyword in cssKeywords) {
			if (cssKeywords.hasOwnProperty(keyword)) {
				var value = cssKeywords[keyword];

				// Compute comparative distance
				var distance = comparativeDistance(rgb, value);

				// Check if its less, if so set as closest
				if (distance < currentClosestDistance) {
					currentClosestDistance = distance;
					currentClosestKeyword = keyword;
				}
			}
		}

		return currentClosestKeyword;
	};

	convert$8.keyword.rgb = function (keyword) {
		return cssKeywords[keyword];
	};

	convert$8.rgb.xyz = function (rgb) {
		var r = rgb[0] / 255;
		var g = rgb[1] / 255;
		var b = rgb[2] / 255;

		// assume sRGB
		r = r > 0.04045 ? Math.pow(((r + 0.055) / 1.055), 2.4) : (r / 12.92);
		g = g > 0.04045 ? Math.pow(((g + 0.055) / 1.055), 2.4) : (g / 12.92);
		b = b > 0.04045 ? Math.pow(((b + 0.055) / 1.055), 2.4) : (b / 12.92);

		var x = (r * 0.4124) + (g * 0.3576) + (b * 0.1805);
		var y = (r * 0.2126) + (g * 0.7152) + (b * 0.0722);
		var z = (r * 0.0193) + (g * 0.1192) + (b * 0.9505);

		return [x * 100, y * 100, z * 100];
	};

	convert$8.rgb.lab = function (rgb) {
		var xyz = convert$8.rgb.xyz(rgb);
		var x = xyz[0];
		var y = xyz[1];
		var z = xyz[2];
		var l;
		var a;
		var b;

		x /= 95.047;
		y /= 100;
		z /= 108.883;

		x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
		y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
		z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);

		l = (116 * y) - 16;
		a = 500 * (x - y);
		b = 200 * (y - z);

		return [l, a, b];
	};

	convert$8.hsl.rgb = function (hsl) {
		var h = hsl[0] / 360;
		var s = hsl[1] / 100;
		var l = hsl[2] / 100;
		var t1;
		var t2;
		var t3;
		var rgb;
		var val;

		if (s === 0) {
			val = l * 255;
			return [val, val, val];
		}

		if (l < 0.5) {
			t2 = l * (1 + s);
		} else {
			t2 = l + s - l * s;
		}

		t1 = 2 * l - t2;

		rgb = [0, 0, 0];
		for (var i = 0; i < 3; i++) {
			t3 = h + 1 / 3 * -(i - 1);
			if (t3 < 0) {
				t3++;
			}
			if (t3 > 1) {
				t3--;
			}

			if (6 * t3 < 1) {
				val = t1 + (t2 - t1) * 6 * t3;
			} else if (2 * t3 < 1) {
				val = t2;
			} else if (3 * t3 < 2) {
				val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
			} else {
				val = t1;
			}

			rgb[i] = val * 255;
		}

		return rgb;
	};

	convert$8.hsl.hsv = function (hsl) {
		var h = hsl[0];
		var s = hsl[1] / 100;
		var l = hsl[2] / 100;
		var smin = s;
		var lmin = Math.max(l, 0.01);
		var sv;
		var v;

		l *= 2;
		s *= (l <= 1) ? l : 2 - l;
		smin *= lmin <= 1 ? lmin : 2 - lmin;
		v = (l + s) / 2;
		sv = l === 0 ? (2 * smin) / (lmin + smin) : (2 * s) / (l + s);

		return [h, sv * 100, v * 100];
	};

	convert$8.hsv.rgb = function (hsv) {
		var h = hsv[0] / 60;
		var s = hsv[1] / 100;
		var v = hsv[2] / 100;
		var hi = Math.floor(h) % 6;

		var f = h - Math.floor(h);
		var p = 255 * v * (1 - s);
		var q = 255 * v * (1 - (s * f));
		var t = 255 * v * (1 - (s * (1 - f)));
		v *= 255;

		switch (hi) {
			case 0:
				return [v, t, p];
			case 1:
				return [q, v, p];
			case 2:
				return [p, v, t];
			case 3:
				return [p, q, v];
			case 4:
				return [t, p, v];
			case 5:
				return [v, p, q];
		}
	};

	convert$8.hsv.hsl = function (hsv) {
		var h = hsv[0];
		var s = hsv[1] / 100;
		var v = hsv[2] / 100;
		var vmin = Math.max(v, 0.01);
		var lmin;
		var sl;
		var l;

		l = (2 - s) * v;
		lmin = (2 - s) * vmin;
		sl = s * vmin;
		sl /= (lmin <= 1) ? lmin : 2 - lmin;
		sl = sl || 0;
		l /= 2;

		return [h, sl * 100, l * 100];
	};

	// http://dev.w3.org/csswg/css-color/#hwb-to-rgb
	convert$8.hwb.rgb = function (hwb) {
		var h = hwb[0] / 360;
		var wh = hwb[1] / 100;
		var bl = hwb[2] / 100;
		var ratio = wh + bl;
		var i;
		var v;
		var f;
		var n;

		// wh + bl cant be > 1
		if (ratio > 1) {
			wh /= ratio;
			bl /= ratio;
		}

		i = Math.floor(6 * h);
		v = 1 - bl;
		f = 6 * h - i;

		if ((i & 0x01) !== 0) {
			f = 1 - f;
		}

		n = wh + f * (v - wh); // linear interpolation

		var r;
		var g;
		var b;
		switch (i) {
			default:
			case 6:
			case 0: r = v; g = n; b = wh; break;
			case 1: r = n; g = v; b = wh; break;
			case 2: r = wh; g = v; b = n; break;
			case 3: r = wh; g = n; b = v; break;
			case 4: r = n; g = wh; b = v; break;
			case 5: r = v; g = wh; b = n; break;
		}

		return [r * 255, g * 255, b * 255];
	};

	convert$8.cmyk.rgb = function (cmyk) {
		var c = cmyk[0] / 100;
		var m = cmyk[1] / 100;
		var y = cmyk[2] / 100;
		var k = cmyk[3] / 100;
		var r;
		var g;
		var b;

		r = 1 - Math.min(1, c * (1 - k) + k);
		g = 1 - Math.min(1, m * (1 - k) + k);
		b = 1 - Math.min(1, y * (1 - k) + k);

		return [r * 255, g * 255, b * 255];
	};

	convert$8.xyz.rgb = function (xyz) {
		var x = xyz[0] / 100;
		var y = xyz[1] / 100;
		var z = xyz[2] / 100;
		var r;
		var g;
		var b;

		r = (x * 3.2406) + (y * -1.5372) + (z * -0.4986);
		g = (x * -0.9689) + (y * 1.8758) + (z * 0.0415);
		b = (x * 0.0557) + (y * -0.2040) + (z * 1.0570);

		// assume sRGB
		r = r > 0.0031308
			? ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055)
			: r * 12.92;

		g = g > 0.0031308
			? ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055)
			: g * 12.92;

		b = b > 0.0031308
			? ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055)
			: b * 12.92;

		r = Math.min(Math.max(0, r), 1);
		g = Math.min(Math.max(0, g), 1);
		b = Math.min(Math.max(0, b), 1);

		return [r * 255, g * 255, b * 255];
	};

	convert$8.xyz.lab = function (xyz) {
		var x = xyz[0];
		var y = xyz[1];
		var z = xyz[2];
		var l;
		var a;
		var b;

		x /= 95.047;
		y /= 100;
		z /= 108.883;

		x = x > 0.008856 ? Math.pow(x, 1 / 3) : (7.787 * x) + (16 / 116);
		y = y > 0.008856 ? Math.pow(y, 1 / 3) : (7.787 * y) + (16 / 116);
		z = z > 0.008856 ? Math.pow(z, 1 / 3) : (7.787 * z) + (16 / 116);

		l = (116 * y) - 16;
		a = 500 * (x - y);
		b = 200 * (y - z);

		return [l, a, b];
	};

	convert$8.lab.xyz = function (lab) {
		var l = lab[0];
		var a = lab[1];
		var b = lab[2];
		var x;
		var y;
		var z;

		y = (l + 16) / 116;
		x = a / 500 + y;
		z = y - b / 200;

		var y2 = Math.pow(y, 3);
		var x2 = Math.pow(x, 3);
		var z2 = Math.pow(z, 3);
		y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
		x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
		z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;

		x *= 95.047;
		y *= 100;
		z *= 108.883;

		return [x, y, z];
	};

	convert$8.lab.lch = function (lab) {
		var l = lab[0];
		var a = lab[1];
		var b = lab[2];
		var hr;
		var h;
		var c;

		hr = Math.atan2(b, a);
		h = hr * 360 / 2 / Math.PI;

		if (h < 0) {
			h += 360;
		}

		c = Math.sqrt(a * a + b * b);

		return [l, c, h];
	};

	convert$8.lch.lab = function (lch) {
		var l = lch[0];
		var c = lch[1];
		var h = lch[2];
		var a;
		var b;
		var hr;

		hr = h / 360 * 2 * Math.PI;
		a = c * Math.cos(hr);
		b = c * Math.sin(hr);

		return [l, a, b];
	};

	convert$8.rgb.ansi16 = function (args) {
		var r = args[0];
		var g = args[1];
		var b = args[2];
		var value = 1 in arguments ? arguments[1] : convert$8.rgb.hsv(args)[2]; // hsv -> ansi16 optimization

		value = Math.round(value / 50);

		if (value === 0) {
			return 30;
		}

		var ansi = 30
			+ ((Math.round(b / 255) << 2)
			| (Math.round(g / 255) << 1)
			| Math.round(r / 255));

		if (value === 2) {
			ansi += 60;
		}

		return ansi;
	};

	convert$8.hsv.ansi16 = function (args) {
		// optimization here; we already know the value and don't need to get
		// it converted for us.
		return convert$8.rgb.ansi16(convert$8.hsv.rgb(args), args[2]);
	};

	convert$8.rgb.ansi256 = function (args) {
		var r = args[0];
		var g = args[1];
		var b = args[2];

		// we use the extended greyscale palette here, with the exception of
		// black and white. normal palette only has 4 greyscale shades.
		if (r === g && g === b) {
			if (r < 8) {
				return 16;
			}

			if (r > 248) {
				return 231;
			}

			return Math.round(((r - 8) / 247) * 24) + 232;
		}

		var ansi = 16
			+ (36 * Math.round(r / 255 * 5))
			+ (6 * Math.round(g / 255 * 5))
			+ Math.round(b / 255 * 5);

		return ansi;
	};

	convert$8.ansi16.rgb = function (args) {
		var color = args % 10;

		// handle greyscale
		if (color === 0 || color === 7) {
			if (args > 50) {
				color += 3.5;
			}

			color = color / 10.5 * 255;

			return [color, color, color];
		}

		var mult = (~~(args > 50) + 1) * 0.5;
		var r = ((color & 1) * mult) * 255;
		var g = (((color >> 1) & 1) * mult) * 255;
		var b = (((color >> 2) & 1) * mult) * 255;

		return [r, g, b];
	};

	convert$8.ansi256.rgb = function (args) {
		// handle greyscale
		if (args >= 232) {
			var c = (args - 232) * 10 + 8;
			return [c, c, c];
		}

		args -= 16;

		var rem;
		var r = Math.floor(args / 36) / 5 * 255;
		var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
		var b = (rem % 6) / 5 * 255;

		return [r, g, b];
	};

	convert$8.rgb.hex = function (args) {
		var integer = ((Math.round(args[0]) & 0xFF) << 16)
			+ ((Math.round(args[1]) & 0xFF) << 8)
			+ (Math.round(args[2]) & 0xFF);

		var string = integer.toString(16).toUpperCase();
		return '000000'.substring(string.length) + string;
	};

	convert$8.hex.rgb = function (args) {
		var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
		if (!match) {
			return [0, 0, 0];
		}

		var colorString = match[0];

		if (match[0].length === 3) {
			colorString = colorString.split('').map(function (char) {
				return char + char;
			}).join('');
		}

		var integer = parseInt(colorString, 16);
		var r = (integer >> 16) & 0xFF;
		var g = (integer >> 8) & 0xFF;
		var b = integer & 0xFF;

		return [r, g, b];
	};

	convert$8.rgb.hcg = function (rgb) {
		var r = rgb[0] / 255;
		var g = rgb[1] / 255;
		var b = rgb[2] / 255;
		var max = Math.max(Math.max(r, g), b);
		var min = Math.min(Math.min(r, g), b);
		var chroma = (max - min);
		var grayscale;
		var hue;

		if (chroma < 1) {
			grayscale = min / (1 - chroma);
		} else {
			grayscale = 0;
		}

		if (chroma <= 0) {
			hue = 0;
		} else
		if (max === r) {
			hue = ((g - b) / chroma) % 6;
		} else
		if (max === g) {
			hue = 2 + (b - r) / chroma;
		} else {
			hue = 4 + (r - g) / chroma + 4;
		}

		hue /= 6;
		hue %= 1;

		return [hue * 360, chroma * 100, grayscale * 100];
	};

	convert$8.hsl.hcg = function (hsl) {
		var s = hsl[1] / 100;
		var l = hsl[2] / 100;
		var c = 1;
		var f = 0;

		if (l < 0.5) {
			c = 2.0 * s * l;
		} else {
			c = 2.0 * s * (1.0 - l);
		}

		if (c < 1.0) {
			f = (l - 0.5 * c) / (1.0 - c);
		}

		return [hsl[0], c * 100, f * 100];
	};

	convert$8.hsv.hcg = function (hsv) {
		var s = hsv[1] / 100;
		var v = hsv[2] / 100;

		var c = s * v;
		var f = 0;

		if (c < 1.0) {
			f = (v - c) / (1 - c);
		}

		return [hsv[0], c * 100, f * 100];
	};

	convert$8.hcg.rgb = function (hcg) {
		var h = hcg[0] / 360;
		var c = hcg[1] / 100;
		var g = hcg[2] / 100;

		if (c === 0.0) {
			return [g * 255, g * 255, g * 255];
		}

		var pure = [0, 0, 0];
		var hi = (h % 1) * 6;
		var v = hi % 1;
		var w = 1 - v;
		var mg = 0;

		switch (Math.floor(hi)) {
			case 0:
				pure[0] = 1; pure[1] = v; pure[2] = 0; break;
			case 1:
				pure[0] = w; pure[1] = 1; pure[2] = 0; break;
			case 2:
				pure[0] = 0; pure[1] = 1; pure[2] = v; break;
			case 3:
				pure[0] = 0; pure[1] = w; pure[2] = 1; break;
			case 4:
				pure[0] = v; pure[1] = 0; pure[2] = 1; break;
			default:
				pure[0] = 1; pure[1] = 0; pure[2] = w;
		}

		mg = (1.0 - c) * g;

		return [
			(c * pure[0] + mg) * 255,
			(c * pure[1] + mg) * 255,
			(c * pure[2] + mg) * 255
		];
	};

	convert$8.hcg.hsv = function (hcg) {
		var c = hcg[1] / 100;
		var g = hcg[2] / 100;

		var v = c + g * (1.0 - c);
		var f = 0;

		if (v > 0.0) {
			f = c / v;
		}

		return [hcg[0], f * 100, v * 100];
	};

	convert$8.hcg.hsl = function (hcg) {
		var c = hcg[1] / 100;
		var g = hcg[2] / 100;

		var l = g * (1.0 - c) + 0.5 * c;
		var s = 0;

		if (l > 0.0 && l < 0.5) {
			s = c / (2 * l);
		} else
		if (l >= 0.5 && l < 1.0) {
			s = c / (2 * (1 - l));
		}

		return [hcg[0], s * 100, l * 100];
	};

	convert$8.hcg.hwb = function (hcg) {
		var c = hcg[1] / 100;
		var g = hcg[2] / 100;
		var v = c + g * (1.0 - c);
		return [hcg[0], (v - c) * 100, (1 - v) * 100];
	};

	convert$8.hwb.hcg = function (hwb) {
		var w = hwb[1] / 100;
		var b = hwb[2] / 100;
		var v = 1 - b;
		var c = v - w;
		var g = 0;

		if (c < 1) {
			g = (v - c) / (1 - c);
		}

		return [hwb[0], c * 100, g * 100];
	};

	convert$8.apple.rgb = function (apple) {
		return [(apple[0] / 65535) * 255, (apple[1] / 65535) * 255, (apple[2] / 65535) * 255];
	};

	convert$8.rgb.apple = function (rgb) {
		return [(rgb[0] / 255) * 65535, (rgb[1] / 255) * 65535, (rgb[2] / 255) * 65535];
	};

	convert$8.gray.rgb = function (args) {
		return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
	};

	convert$8.gray.hsl = convert$8.gray.hsv = function (args) {
		return [0, 0, args[0]];
	};

	convert$8.gray.hwb = function (gray) {
		return [0, 100, gray[0]];
	};

	convert$8.gray.cmyk = function (gray) {
		return [0, 0, 0, gray[0]];
	};

	convert$8.gray.lab = function (gray) {
		return [gray[0], 0, 0];
	};

	convert$8.gray.hex = function (gray) {
		var val = Math.round(gray[0] / 100 * 255) & 0xFF;
		var integer = (val << 16) + (val << 8) + val;

		var string = integer.toString(16).toUpperCase();
		return '000000'.substring(string.length) + string;
	};

	convert$8.rgb.gray = function (rgb) {
		var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
		return [val / 255 * 100];
	};

	var conversionsExports = conversions$2.exports;

	var conversions$1 = conversionsExports;

	/*
		this function routes a model to all other models.

		all functions that are routed have a property `.conversion` attached
		to the returned synthetic function. This property is an array
		of strings, each with the steps in between the 'from' and 'to'
		color models (inclusive).

		conversions that are not possible simply are not included.
	*/

	function buildGraph() {
		var graph = {};
		// https://jsperf.com/object-keys-vs-for-in-with-closure/3
		var models = Object.keys(conversions$1);

		for (var len = models.length, i = 0; i < len; i++) {
			graph[models[i]] = {
				// http://jsperf.com/1-vs-infinity
				// micro-opt, but this is simple.
				distance: -1,
				parent: null
			};
		}

		return graph;
	}

	// https://en.wikipedia.org/wiki/Breadth-first_search
	function deriveBFS(fromModel) {
		var graph = buildGraph();
		var queue = [fromModel]; // unshift -> queue -> pop

		graph[fromModel].distance = 0;

		while (queue.length) {
			var current = queue.pop();
			var adjacents = Object.keys(conversions$1[current]);

			for (var len = adjacents.length, i = 0; i < len; i++) {
				var adjacent = adjacents[i];
				var node = graph[adjacent];

				if (node.distance === -1) {
					node.distance = graph[current].distance + 1;
					node.parent = current;
					queue.unshift(adjacent);
				}
			}
		}

		return graph;
	}

	function link$1(from, to) {
		return function (args) {
			return to(from(args));
		};
	}

	function wrapConversion(toModel, graph) {
		var path = [graph[toModel].parent, toModel];
		var fn = conversions$1[graph[toModel].parent][toModel];

		var cur = graph[toModel].parent;
		while (graph[cur].parent) {
			path.unshift(graph[cur].parent);
			fn = link$1(conversions$1[graph[cur].parent][cur], fn);
			cur = graph[cur].parent;
		}

		fn.conversion = path;
		return fn;
	}

	var route$1 = function (fromModel) {
		var graph = deriveBFS(fromModel);
		var conversion = {};

		var models = Object.keys(graph);
		for (var len = models.length, i = 0; i < len; i++) {
			var toModel = models[i];
			var node = graph[toModel];

			if (node.parent === null) {
				// no possible conversion, or this node is the source model.
				continue;
			}

			conversion[toModel] = wrapConversion(toModel, graph);
		}

		return conversion;
	};

	var conversions = conversionsExports;
	var route = route$1;

	var convert$7 = {};

	var models = Object.keys(conversions);

	function wrapRaw(fn) {
		var wrappedFn = function (args) {
			if (args === undefined || args === null) {
				return args;
			}

			if (arguments.length > 1) {
				args = Array.prototype.slice.call(arguments);
			}

			return fn(args);
		};

		// preserve .conversion property if there is one
		if ('conversion' in fn) {
			wrappedFn.conversion = fn.conversion;
		}

		return wrappedFn;
	}

	function wrapRounded(fn) {
		var wrappedFn = function (args) {
			if (args === undefined || args === null) {
				return args;
			}

			if (arguments.length > 1) {
				args = Array.prototype.slice.call(arguments);
			}

			var result = fn(args);

			// we're assuming the result is an array here.
			// see notice in conversions.js; don't use box types
			// in conversion functions.
			if (typeof result === 'object') {
				for (var len = result.length, i = 0; i < len; i++) {
					result[i] = Math.round(result[i]);
				}
			}

			return result;
		};

		// preserve .conversion property if there is one
		if ('conversion' in fn) {
			wrappedFn.conversion = fn.conversion;
		}

		return wrappedFn;
	}

	models.forEach(function (fromModel) {
		convert$7[fromModel] = {};

		Object.defineProperty(convert$7[fromModel], 'channels', {value: conversions[fromModel].channels});
		Object.defineProperty(convert$7[fromModel], 'labels', {value: conversions[fromModel].labels});

		var routes = route(fromModel);
		var routeModels = Object.keys(routes);

		routeModels.forEach(function (toModel) {
			var fn = routes[toModel];

			convert$7[fromModel][toModel] = wrapRounded(fn);
			convert$7[fromModel][toModel].raw = wrapRaw(fn);
		});
	});

	var colorConvert = convert$7;

	var colorString = colorStringExports;
	var convert$6 = colorConvert;

	var _slice = [].slice;

	var skippedModels = [
		// to be honest, I don't really feel like keyword belongs in color convert, but eh.
		'keyword',

		// gray conflicts with some method names, and has its own method defined.
		'gray',

		// shouldn't really be in color-convert either...
		'hex'
	];

	var hashedModelKeys = {};
	Object.keys(convert$6).forEach(function (model) {
		hashedModelKeys[_slice.call(convert$6[model].labels).sort().join('')] = model;
	});

	var limiters = {};

	function Color(obj, model) {
		if (!(this instanceof Color)) {
			return new Color(obj, model);
		}

		if (model && model in skippedModels) {
			model = null;
		}

		if (model && !(model in convert$6)) {
			throw new Error('Unknown model: ' + model);
		}

		var i;
		var channels;

		if (obj == null) { // eslint-disable-line no-eq-null,eqeqeq
			this.model = 'rgb';
			this.color = [0, 0, 0];
			this.valpha = 1;
		} else if (obj instanceof Color) {
			this.model = obj.model;
			this.color = obj.color.slice();
			this.valpha = obj.valpha;
		} else if (typeof obj === 'string') {
			var result = colorString.get(obj);
			if (result === null) {
				throw new Error('Unable to parse color from string: ' + obj);
			}

			this.model = result.model;
			channels = convert$6[this.model].channels;
			this.color = result.value.slice(0, channels);
			this.valpha = typeof result.value[channels] === 'number' ? result.value[channels] : 1;
		} else if (obj.length) {
			this.model = model || 'rgb';
			channels = convert$6[this.model].channels;
			var newArr = _slice.call(obj, 0, channels);
			this.color = zeroArray(newArr, channels);
			this.valpha = typeof obj[channels] === 'number' ? obj[channels] : 1;
		} else if (typeof obj === 'number') {
			// this is always RGB - can be converted later on.
			obj &= 0xFFFFFF;
			this.model = 'rgb';
			this.color = [
				(obj >> 16) & 0xFF,
				(obj >> 8) & 0xFF,
				obj & 0xFF
			];
			this.valpha = 1;
		} else {
			this.valpha = 1;

			var keys = Object.keys(obj);
			if ('alpha' in obj) {
				keys.splice(keys.indexOf('alpha'), 1);
				this.valpha = typeof obj.alpha === 'number' ? obj.alpha : 0;
			}

			var hashedKeys = keys.sort().join('');
			if (!(hashedKeys in hashedModelKeys)) {
				throw new Error('Unable to parse color from object: ' + JSON.stringify(obj));
			}

			this.model = hashedModelKeys[hashedKeys];

			var labels = convert$6[this.model].labels;
			var color = [];
			for (i = 0; i < labels.length; i++) {
				color.push(obj[labels[i]]);
			}

			this.color = zeroArray(color);
		}

		// perform limitations (clamping, etc.)
		if (limiters[this.model]) {
			channels = convert$6[this.model].channels;
			for (i = 0; i < channels; i++) {
				var limit = limiters[this.model][i];
				if (limit) {
					this.color[i] = limit(this.color[i]);
				}
			}
		}

		this.valpha = Math.max(0, Math.min(1, this.valpha));

		if (Object.freeze) {
			Object.freeze(this);
		}
	}

	Color.prototype = {
		toString: function () {
			return this.string();
		},

		toJSON: function () {
			return this[this.model]();
		},

		string: function (places) {
			var self = this.model in colorString.to ? this : this.rgb();
			self = self.round(typeof places === 'number' ? places : 1);
			var args = self.valpha === 1 ? self.color : self.color.concat(this.valpha);
			return colorString.to[self.model](args);
		},

		percentString: function (places) {
			var self = this.rgb().round(typeof places === 'number' ? places : 1);
			var args = self.valpha === 1 ? self.color : self.color.concat(this.valpha);
			return colorString.to.rgb.percent(args);
		},

		array: function () {
			return this.valpha === 1 ? this.color.slice() : this.color.concat(this.valpha);
		},

		object: function () {
			var result = {};
			var channels = convert$6[this.model].channels;
			var labels = convert$6[this.model].labels;

			for (var i = 0; i < channels; i++) {
				result[labels[i]] = this.color[i];
			}

			if (this.valpha !== 1) {
				result.alpha = this.valpha;
			}

			return result;
		},

		unitArray: function () {
			var rgb = this.rgb().color;
			rgb[0] /= 255;
			rgb[1] /= 255;
			rgb[2] /= 255;

			if (this.valpha !== 1) {
				rgb.push(this.valpha);
			}

			return rgb;
		},

		unitObject: function () {
			var rgb = this.rgb().object();
			rgb.r /= 255;
			rgb.g /= 255;
			rgb.b /= 255;

			if (this.valpha !== 1) {
				rgb.alpha = this.valpha;
			}

			return rgb;
		},

		round: function (places) {
			places = Math.max(places || 0, 0);
			return new Color(this.color.map(roundToPlace(places)).concat(this.valpha), this.model);
		},

		alpha: function (val) {
			if (arguments.length) {
				return new Color(this.color.concat(Math.max(0, Math.min(1, val))), this.model);
			}

			return this.valpha;
		},

		// rgb
		red: getset('rgb', 0, maxfn(255)),
		green: getset('rgb', 1, maxfn(255)),
		blue: getset('rgb', 2, maxfn(255)),

		hue: getset(['hsl', 'hsv', 'hsl', 'hwb', 'hcg'], 0, function (val) { return ((val % 360) + 360) % 360; }), // eslint-disable-line brace-style

		saturationl: getset('hsl', 1, maxfn(100)),
		lightness: getset('hsl', 2, maxfn(100)),

		saturationv: getset('hsv', 1, maxfn(100)),
		value: getset('hsv', 2, maxfn(100)),

		chroma: getset('hcg', 1, maxfn(100)),
		gray: getset('hcg', 2, maxfn(100)),

		white: getset('hwb', 1, maxfn(100)),
		wblack: getset('hwb', 2, maxfn(100)),

		cyan: getset('cmyk', 0, maxfn(100)),
		magenta: getset('cmyk', 1, maxfn(100)),
		yellow: getset('cmyk', 2, maxfn(100)),
		black: getset('cmyk', 3, maxfn(100)),

		x: getset('xyz', 0, maxfn(100)),
		y: getset('xyz', 1, maxfn(100)),
		z: getset('xyz', 2, maxfn(100)),

		l: getset('lab', 0, maxfn(100)),
		a: getset('lab', 1),
		b: getset('lab', 2),

		keyword: function (val) {
			if (arguments.length) {
				return new Color(val);
			}

			return convert$6[this.model].keyword(this.color);
		},

		hex: function (val) {
			if (arguments.length) {
				return new Color(val);
			}

			return colorString.to.hex(this.rgb().round().color);
		},

		rgbNumber: function () {
			var rgb = this.rgb().color;
			return ((rgb[0] & 0xFF) << 16) | ((rgb[1] & 0xFF) << 8) | (rgb[2] & 0xFF);
		},

		luminosity: function () {
			// http://www.w3.org/TR/WCAG20/#relativeluminancedef
			var rgb = this.rgb().color;

			var lum = [];
			for (var i = 0; i < rgb.length; i++) {
				var chan = rgb[i] / 255;
				lum[i] = (chan <= 0.03928) ? chan / 12.92 : Math.pow(((chan + 0.055) / 1.055), 2.4);
			}

			return 0.2126 * lum[0] + 0.7152 * lum[1] + 0.0722 * lum[2];
		},

		contrast: function (color2) {
			// http://www.w3.org/TR/WCAG20/#contrast-ratiodef
			var lum1 = this.luminosity();
			var lum2 = color2.luminosity();

			if (lum1 > lum2) {
				return (lum1 + 0.05) / (lum2 + 0.05);
			}

			return (lum2 + 0.05) / (lum1 + 0.05);
		},

		level: function (color2) {
			var contrastRatio = this.contrast(color2);
			if (contrastRatio >= 7.1) {
				return 'AAA';
			}

			return (contrastRatio >= 4.5) ? 'AA' : '';
		},

		isDark: function () {
			// YIQ equation from http://24ways.org/2010/calculating-color-contrast
			var rgb = this.rgb().color;
			var yiq = (rgb[0] * 299 + rgb[1] * 587 + rgb[2] * 114) / 1000;
			return yiq < 128;
		},

		isLight: function () {
			return !this.isDark();
		},

		negate: function () {
			var rgb = this.rgb();
			for (var i = 0; i < 3; i++) {
				rgb.color[i] = 255 - rgb.color[i];
			}
			return rgb;
		},

		lighten: function (ratio) {
			var hsl = this.hsl();
			hsl.color[2] += hsl.color[2] * ratio;
			return hsl;
		},

		darken: function (ratio) {
			var hsl = this.hsl();
			hsl.color[2] -= hsl.color[2] * ratio;
			return hsl;
		},

		saturate: function (ratio) {
			var hsl = this.hsl();
			hsl.color[1] += hsl.color[1] * ratio;
			return hsl;
		},

		desaturate: function (ratio) {
			var hsl = this.hsl();
			hsl.color[1] -= hsl.color[1] * ratio;
			return hsl;
		},

		whiten: function (ratio) {
			var hwb = this.hwb();
			hwb.color[1] += hwb.color[1] * ratio;
			return hwb;
		},

		blacken: function (ratio) {
			var hwb = this.hwb();
			hwb.color[2] += hwb.color[2] * ratio;
			return hwb;
		},

		grayscale: function () {
			// http://en.wikipedia.org/wiki/Grayscale#Converting_color_to_grayscale
			var rgb = this.rgb().color;
			var val = rgb[0] * 0.3 + rgb[1] * 0.59 + rgb[2] * 0.11;
			return Color.rgb(val, val, val);
		},

		fade: function (ratio) {
			return this.alpha(this.valpha - (this.valpha * ratio));
		},

		opaquer: function (ratio) {
			return this.alpha(this.valpha + (this.valpha * ratio));
		},

		rotate: function (degrees) {
			var hsl = this.hsl();
			var hue = hsl.color[0];
			hue = (hue + degrees) % 360;
			hue = hue < 0 ? 360 + hue : hue;
			hsl.color[0] = hue;
			return hsl;
		},

		mix: function (mixinColor, weight) {
			// ported from sass implementation in C
			// https://github.com/sass/libsass/blob/0e6b4a2850092356aa3ece07c6b249f0221caced/functions.cpp#L209
			if (!mixinColor || !mixinColor.rgb) {
				throw new Error('Argument to "mix" was not a Color instance, but rather an instance of ' + typeof mixinColor);
			}
			var color1 = mixinColor.rgb();
			var color2 = this.rgb();
			var p = weight === undefined ? 0.5 : weight;

			var w = 2 * p - 1;
			var a = color1.alpha() - color2.alpha();

			var w1 = (((w * a === -1) ? w : (w + a) / (1 + w * a)) + 1) / 2.0;
			var w2 = 1 - w1;

			return Color.rgb(
					w1 * color1.red() + w2 * color2.red(),
					w1 * color1.green() + w2 * color2.green(),
					w1 * color1.blue() + w2 * color2.blue(),
					color1.alpha() * p + color2.alpha() * (1 - p));
		}
	};

	// model conversion methods and static constructors
	Object.keys(convert$6).forEach(function (model) {
		if (skippedModels.indexOf(model) !== -1) {
			return;
		}

		var channels = convert$6[model].channels;

		// conversion methods
		Color.prototype[model] = function () {
			if (this.model === model) {
				return new Color(this);
			}

			if (arguments.length) {
				return new Color(arguments, model);
			}

			var newAlpha = typeof arguments[channels] === 'number' ? channels : this.valpha;
			return new Color(assertArray(convert$6[this.model][model].raw(this.color)).concat(newAlpha), model);
		};

		// 'static' construction methods
		Color[model] = function (color) {
			if (typeof color === 'number') {
				color = zeroArray(_slice.call(arguments), channels);
			}
			return new Color(color, model);
		};
	});

	function roundTo(num, places) {
		return Number(num.toFixed(places));
	}

	function roundToPlace(places) {
		return function (num) {
			return roundTo(num, places);
		};
	}

	function getset(model, channel, modifier) {
		model = Array.isArray(model) ? model : [model];

		model.forEach(function (m) {
			(limiters[m] || (limiters[m] = []))[channel] = modifier;
		});

		model = model[0];

		return function (val) {
			var result;

			if (arguments.length) {
				if (modifier) {
					val = modifier(val);
				}

				result = this[model]();
				result.color[channel] = val;
				return result;
			}

			result = this[model]().color[channel];
			if (modifier) {
				result = modifier(result);
			}

			return result;
		};
	}

	function maxfn(max) {
		return function (v) {
			return Math.max(0, Math.min(max, v));
		};
	}

	function assertArray(val) {
		return Array.isArray(val) ? val : [val];
	}

	function zeroArray(arr, length) {
		for (var i = 0; i < length; i++) {
			if (typeof arr[i] !== 'number') {
				arr[i] = 0;
			}
		}

		return arr;
	}

	var color$1 = Color;

	Object.defineProperty(withAlphaVariable$2, "__esModule", {
	  value: true
	});
	withAlphaVariable$2.toRgba = toRgba;
	withAlphaVariable$2.toHsla = toHsla;
	withAlphaVariable$2.withAlphaValue = withAlphaValue;
	withAlphaVariable$2.default = withAlphaVariable$1;

	var _color = _interopRequireDefault(color$1);

	var _lodash = _interopRequireDefault(lodashExports);

	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

	function hasAlpha(color) {
	  return color.startsWith('rgba(') || color.startsWith('hsla(') || color.startsWith('#') && color.length === 9 || color.startsWith('#') && color.length === 5;
	}

	function toRgba(color) {
	  const [r, g, b, a] = (0, _color.default)(color).rgb().array();
	  return [r, g, b, a === undefined && hasAlpha(color) ? 1 : a];
	}

	function toHsla(color) {
	  const [h, s, l, a] = (0, _color.default)(color).hsl().array();
	  return [h, `${s}%`, `${l}%`, a === undefined && hasAlpha(color) ? 1 : a];
	}

	function withAlphaValue(color, alphaValue, defaultValue) {
	  if (_lodash.default.isFunction(color)) {
	    return color({
	      opacityValue: alphaValue
	    });
	  }

	  try {
	    const isHSL = color.startsWith('hsl');
	    const [i, j, k] = isHSL ? toHsla(color) : toRgba(color);
	    return `${isHSL ? 'hsla' : 'rgba'}(${i}, ${j}, ${k}, ${alphaValue})`;
	  } catch {
	    return defaultValue;
	  }
	}

	function withAlphaVariable$1({
	  color,
	  property,
	  variable
	}) {
	  if (_lodash.default.isFunction(color)) {
	    return {
	      [variable]: '1',
	      [property]: color({
	        opacityVariable: variable,
	        opacityValue: `var(${variable})`
	      })
	    };
	  }

	  try {
	    const isHSL = color.startsWith('hsl');
	    const [i, j, k, a] = isHSL ? toHsla(color) : toRgba(color);

	    if (a !== undefined) {
	      return {
	        [property]: color
	      };
	    }

	    return {
	      [variable]: '1',
	      [property]: `${isHSL ? 'hsla' : 'rgba'}(${i}, ${j}, ${k}, var(${variable}))`
	    };
	  } catch (error) {
	    return {
	      [property]: color
	    };
	  }
	}

	const flattenColorPalette = flattenColorPalette$2.default;
	const withAlphaVariable = withAlphaVariable$2.default;

	var borderColor = function({ config, corePlugins, matchUtilities, theme, variants }) {
	  if (config('mode') === 'jit') {
	    matchUtilities(
	      {
	        'border-bs': (value) => {
	          if (!corePlugins('borderOpacity')) {
	            return {
	              'border-block-start-color': value,
	            };
	          }

	          return withAlphaVariable({
	            color: value,
	            property: 'border-block-start-color',
	            variable: '--tw-border-opacity',
	          });
	        },
	        'border-be': (value) => {
	          if (!corePlugins('borderOpacity')) {
	            return {
	              'border-block-end-color': value,
	            };
	          }

	          return withAlphaVariable({
	            color: value,
	            property: 'border-block-end-color',
	            variable: '--tw-border-opacity',
	          });
	        },
	        'border-is': (value) => {
	          if (!corePlugins('borderOpacity')) {
	            return {
	              'border-inline-start-color': value,
	            };
	          }

	          return withAlphaVariable({
	            color: value,
	            property: 'border-inline-start-color',
	            variable: '--tw-border-opacity',
	          });
	        },
	        'border-ie': (value) => {
	          if (!corePlugins('borderOpacity')) {
	            return {
	              'border-inline-end-color': value,
	            };
	          }

	          return withAlphaVariable({
	            color: value,
	            property: 'border-inline-end-color',
	            variable: '--tw-border-opacity',
	          });
	        },
	      },
	      {
	        values: (({ DEFAULT: _, ...colors }) => colors)(
	          flattenColorPalette(theme('borderColor'))
	        ),
	        variants: variants('borderColor'),
	        type: 'color',
	      }
	    );
	  }
	};

	const plugin$2 = plugin$3;
	const prefixNegativeModifiers = prefixNegativeModifiers$2.default;
	const borderColorPlugin = borderColor;

	var tailwindcssLogical = plugin$2(function(helpers) {
	  const { addUtilities, e, theme, variants } = helpers;

	  const borderRadius = Object.entries(theme('borderRadius'));
	  const borderWidth = Object.entries(theme('borderWidth'));
	  const divideWidth = Object.entries(theme('divideWidth'));
	  const height = Object.entries(theme('height'));
	  const inset = Object.entries(theme('inset'));
	  const margin = Object.entries(theme('margin'));
	  const maxHeight = Object.entries(theme('maxHeight'));
	  const maxWidth = Object.entries(theme('maxWidth'));
	  const minHeight = Object.entries(theme('minHeight'));
	  const minWidth = Object.entries(theme('minWidth'));
	  const padding = Object.entries(theme('padding'));
	  const space = Object.entries(theme('space'));
	  const width = Object.entries(theme('width'));

	  const floatUtilities = {
	    '.float-start': { float: 'inline-start' },
	    '.float-end': { float: 'inline-end' }
	  };

	  const clearUtilities = {
	    '.clear-start': { clear: 'inline-start' },
	    '.clear-end': { clear: 'inline-end' }
	  };

	  const textAlignUtilities = {
	    '.text-start': { textAlign: 'start' },
	    '.text-end': { textAlign: 'end' }
	  };

	  const resizeUtilities = {
	    '.resize-block': { resize: 'block' },
	    '.resize-inline': { resize: 'inline' }
	  };

	  const overscrollBehaviorUtilities = {
	    '.overscroll-b-auto': { overscrollBehaviorBlock: 'auto' },
	    '.overscroll-b-contain': { overscrollBehaviorBlock: 'contain' },
	    '.overscroll-b-none': { overscrollBehaviorBlock: 'none' },
	    '.overscroll-i-auto': { overscrollBehaviorInline: 'auto' },
	    '.overscroll-i-contain': { overscrollBehaviorInline: 'contain'},
	    '.overscroll-i-none': { overscrollBehaviorInline: 'none' }
	  };

	  const blockSizeUtilities = height.map(([key, value]) => (
	    {
	      [`.${e(`bs-${key}`)}`]: {
	        blockSize: value
	      }
	    }
	  ));

	  const minBlockSizeUtilities = minHeight.map(([key, value]) => (
	    {
	      [`.${e(`min-bs-${key}`)}`]: {
	        minBlockSize: value
	      }
	    }
	  ));

	  const maxBlockSizeUtilities = maxHeight.map(([key, value]) => (
	    {
	      [`.${e(`max-bs-${key}`)}`]: {
	        maxBlockSize: value
	      }
	    }
	  ));

	  const inlineSizeUtilities = width.map(([key, value]) => (
	    {
	      [`.${e(`is-${key}`)}`]: {
	        inlineSize: value
	      }
	    }
	  ));

	  const minInlineSizeUtilities = minWidth.map(([key, value]) => (
	    {
	      [`.${e(`min-is-${key}`)}`]: {
	        minInlineSize: value
	      }
	    }
	  ));

	  const maxInlineSizeUtilities = maxWidth.map(([key, value]) => (
	    {
	      [`.${e(`max-is-${key}`)}`]: {
	        maxInlineSize: value
	      }
	    }
	  ));

	  const marginShorthandUtilities = margin.map(([key, value]) => (
	    {
	      [`.${e(prefixNegativeModifiers('mlb', key))}`]: {
	        marginBlock: value
	      },
	      [`.${e(prefixNegativeModifiers('mli', key))}`]: {
	        marginInline: value
	      }
	    }
	  ));

	  const marginSingleSideUtilities = margin.map(([key, value]) => (
	    {
	      [`.${e(prefixNegativeModifiers('mbs', key))}`]: {
	        marginBlockStart: value
	      },
	      [`.${e(prefixNegativeModifiers('mbe', key))}`]: {
	        marginBlockEnd: value
	      },
	      [`.${e(prefixNegativeModifiers('mis', key))}`]: {
	        marginInlineStart: value
	      },
	      [`.${e(prefixNegativeModifiers('mie', key))}`]: {
	        marginInlineEnd: value
	      }
	    }
	  ));

	  const paddingShorthandUtilities = padding.map(([key, value]) => (
	    {
	      [`.${e(`plb-${key}`)}`]: {
	        paddingBlock: value
	      },
	      [`.${e(`pli-${key}`)}`]: {
	        paddingInline: value
	      }
	    }
	  ));

	  const paddingSingleSideUtilities = padding.map(([key, value]) => (
	    {
	      [`.${e(`pbs-${key}`)}`]: {
	        paddingBlockStart: value
	      },
	      [`.${e(`pbe-${key}`)}`]: {
	        paddingBlockEnd: value
	      },
	      [`.${e(`pis-${key}`)}`]: {
	        paddingInlineStart: value
	      },
	      [`.${e(`pie-${key}`)}`]: {
	        paddingInlineEnd: value
	      }
	    }
	  ));

	  let spaceBetweenUtilities = space.map(([key, value]) => (
	    {
	      [`.${e(prefixNegativeModifiers('space-b', key))} > :not([hidden]) ~ :not([hidden])`]: {
	        '--tw-space-b-reverse': '0',
	        marginBlockStart: `calc(${value} * calc(1 - var(--tw-space-b-reverse)))`,
	        marginBlockEnd: `calc(${value} * var(--tw-space-b-reverse))`
	      },
	      [`.${e(prefixNegativeModifiers('space-i', key))} > :not([hidden]) ~ :not([hidden])`]: {
	        '--tw-space-i-reverse': '0',
	        marginInlineStart: `calc(${value} * calc(1 - var(--tw-space-i-reverse)))`,
	        marginInlineEnd: `calc(${value} * var(--tw-space-i-reverse))`
	      }
	    }
	  ));

	  if (spaceBetweenUtilities.length) {
	    spaceBetweenUtilities.push({
	      '.space-b-reverse > :not([hidden]) ~ :not([hidden])': {
	        '--tw-space-b-reverse': '1'
	      },
	      '.space-i-reverse > :not([hidden]) ~ :not([hidden])': {
	        '--tw-space-i-reverse': '1'
	      }
	    });
	  }

	  const insetShorthandUtilities = inset.map(([key, value]) => (
	    {
	      [`.${e(prefixNegativeModifiers('inset-block', key))}`]: {
	        insetBlock: value
	      },
	      [`.${e(prefixNegativeModifiers('inset-inline', key))}`]: {
	        insetInline: value
	      }
	    }
	  ));

	  const insetSingleSideUtilities = inset.map(([key, value]) => (
	    {
	      [`.${e(prefixNegativeModifiers('block-start', key))}`]: {
	        insetBlockStart: value
	      },
	      [`.${e(prefixNegativeModifiers('block-end', key))}`]: {
	        insetBlockEnd: value
	      },
	      [`.${e(prefixNegativeModifiers('inline-start', key))}`]: {
	        insetInlineStart: value
	      },
	      [`.${e(prefixNegativeModifiers('inline-end', key))}`]: {
	        insetInlineEnd: value
	      }
	    }
	  ));

	  const borderWidthUtilities = borderWidth.map(([key, value]) => {
	    const keyString = key.toLowerCase() === 'default' ? '' : `-${key}`;
	    return {
	      [`.${e(`border-bs${keyString}`)}`]: {
	        borderBlockStartWidth: value
	      },
	      [`.${e(`border-be${keyString}`)}`]: {
	        borderBlockEndWidth: value
	      },
	      [`.${e(`border-is${keyString}`)}`]: {
	        borderInlineStartWidth: value
	      },
	      [`.${e(`border-ie${keyString}`)}`]: {
	        borderInlineEndWidth: value
	      }
	    };
	  });

	  const borderRadiusSideUtilities = borderRadius.map(([key, value]) => {
	    const keyString = key.toLowerCase() === 'default' ? '' : `-${key}`;
	    return {
	      [`.${e(`rounded-bs${keyString}`)}`]: {
	        borderStartStartRadius: value,
	        borderStartEndRadius: value
	      },
	      [`.${e(`rounded-be${keyString}`)}`]: {
	        borderEndStartRadius: value,
	        borderEndEndRadius: value
	      },
	      [`.${e(`rounded-is${keyString}`)}`]: {
	        borderStartStartRadius: value,
	        borderEndStartRadius: value
	      },
	      [`.${e(`rounded-ie${keyString}`)}`]: {
	        borderStartEndRadius: value,
	        borderEndEndRadius: value
	      }
	    };
	  });

	  const borderRadiusCornerUtilities = borderRadius.map(([key, value]) => {
	    const keyString = key.toLowerCase() === 'default' ? '' : `-${key}`;
	    return {
	      [`.${e(`rounded-ss${keyString}`)}`]: {
	        borderStartStartRadius: value
	      },
	      [`.${e(`rounded-se${keyString}`)}`]: {
	        borderStartEndRadius: value
	      },
	      [`.${e(`rounded-es${keyString}`)}`]: {
	        borderEndStartRadius: value
	      },
	      [`.${e(`rounded-ee${keyString}`)}`]: {
	        borderEndEndRadius: value
	      }
	    };
	  });

	  let divideWidthUtilities = divideWidth.map(([key, value]) => {
	    const keyString = key.toLowerCase() === 'default' ? '' : `-${key}`;
	    return {
	      [`.${e(`divide-b${keyString}`)} > :not([hidden]) ~ :not([hidden])`]: {
	        '--tw-divide-b-reverse': '0',
	        borderBlockStartWidth: `calc(${value} * calc(1 - var(--tw-divide-b-reverse)))`,
	        borderBlockEndWidth: `calc(${value} * var(--tw-divide-b-reverse))`
	      },
	      [`.${e(`divide-i${keyString}`)} > :not([hidden]) ~ :not([hidden])`]: {
	        '--tw-divide-i-reverse': '0',
	        borderInlineStartWidth: `calc(${value} * calc(1 - var(--tw-divide-i-reverse)))`,
	        borderInlineEndWidth: `calc(${value} * var(--tw-divide-i-reverse))`
	      }
	    };
	  });

	  if (divideWidthUtilities.length) {
	    divideWidthUtilities.push({
	      '.divide-b-reverse > :not([hidden]) ~ :not([hidden])': {
	        '--tw-divide-b-reverse': '1'
	      },
	      '.divide-i-reverse > :not([hidden]) ~ :not([hidden])': {
	        '--tw-divide-i-reverse': '1'
	      }
	    });
	  }

	  addUtilities(floatUtilities, variants('logical'));
	  addUtilities(clearUtilities, variants('logical'));
	  addUtilities(textAlignUtilities, variants('logical'));
	  addUtilities(resizeUtilities, variants('logical'));
	  addUtilities(overscrollBehaviorUtilities, variants('logical'));

	  addUtilities(blockSizeUtilities, variants('logical'));
	  addUtilities(minBlockSizeUtilities, variants('logical'));
	  addUtilities(maxBlockSizeUtilities, variants('logical'));
	  addUtilities(inlineSizeUtilities, variants('logical'));
	  addUtilities(minInlineSizeUtilities, variants('logical'));
	  addUtilities(maxInlineSizeUtilities, variants('logical'));

	  addUtilities(marginShorthandUtilities, variants('logical'));
	  addUtilities(marginSingleSideUtilities, variants('logical'));
	  addUtilities(paddingShorthandUtilities, variants('logical'));
	  addUtilities(paddingSingleSideUtilities, variants('logical'));
	  addUtilities(spaceBetweenUtilities, variants('logical'));
	  addUtilities(insetShorthandUtilities, variants('logical'));
	  addUtilities(insetSingleSideUtilities, variants('logical'));

	  addUtilities(borderWidthUtilities, variants('logical'));
	  borderColorPlugin(helpers);
	  addUtilities(borderRadiusSideUtilities, variants('logical'));
	  addUtilities(borderRadiusCornerUtilities, variants('logical'));
	  addUtilities(divideWidthUtilities, variants('logical'));
	});

	var h$b=Object.create;var d$c=Object.defineProperty;var n$b=Object.getOwnPropertyDescriptor;var u$e=Object.getOwnPropertyNames;var r$8=Object.getPrototypeOf,$$c=Object.prototype.hasOwnProperty;var p$d=(e,a)=>{for(var t in a)d$c(e,t,{get:a[t],enumerable:!0});},o$9=(e,a,t,i)=>{if(a&&typeof a=="object"||typeof a=="function")for(let s of u$e(a))!$$c.call(e,s)&&s!==t&&d$c(e,s,{get:()=>a[s],enumerable:!(i=n$b(a,s))||i.enumerable});return e};var c$b=(e,a,t)=>(t=e!=null?h$b(r$8(e)):{},o$9(!e||!e.__esModule?d$c(t,"default",{value:e,enumerable:!0}):t,e)),f$b=e=>o$9(d$c({},"__esModule",{value:!0}),e);var O$8={};p$d(O$8,{default:()=>w$9});var headlessui_prod=f$b(O$8);var l$c=c$b(plugin$3),w$9=l$c.default.withOptions(({prefix:e="ui"}={})=>({addVariant:a})=>{for(let t of ["open","checked","selected","active","disabled"])a(`${e}-${t}`,[`&[data-headlessui-state~="${t}"]`,`:where([data-headlessui-state~="${t}"]) &`]),a(`${e}-not-${t}`,[`&[data-headlessui-state]:not([data-headlessui-state~="${t}"])`,`:where([data-headlessui-state]:not([data-headlessui-state~="${t}"])) &:not([data-headlessui-state])`]);});

	let plugin$1 =
	  headlessui_prod
	    ;

	var dist$2 = (plugin$1.__esModule ? plugin$1 : { default: plugin$1 }).default;

	/** @type {import('tailwindcss').Config} */

	function withOpacityValue(variable) {
	    return ({ opacityValue }) => {
	        if (opacityValue === undefined) {
	            return `rgb(var(${variable}))`;
	        }
	        return `rgb(var(${variable}) / ${opacityValue})`;
	    };
	}

	const plugin = plugin$3;
	const defaultTheme = defaultTheme_1;

	const atkinsonStack = [
	    "Atkinson Hyperlegible",
	    ...defaultTheme.fontFamily.sans,
	];
	const leagueStack = ["League Mono", ...defaultTheme.fontFamily.mono];

	var tailwind_config = {
	    content: ["./client/**/*.tsx", "./src/**/*.tsx", "./client/**/*.mdx"],
	    theme: {
	        fontFamily: {
	            display: leagueStack,
	            body: atkinsonStack,
	            league: leagueStack,
	            atkinson: atkinsonStack,
	            sans: atkinsonStack,
	        },
	        extend: {
	            colors: {
	                text: withOpacityValue("--color-text"),
	                accent: withOpacityValue("--color-accent"),
	                secondary: {
	                    100: withOpacityValue("--color-secondary-100"),
	                    200: withOpacityValue("--color-secondary-200"),
	                    300: withOpacityValue("--color-secondary-300"),
	                    400: withOpacityValue("--color-secondary-400"),
	                    500: withOpacityValue("--color-secondary-500"),
	                    600: withOpacityValue("--color-secondary-600"),
	                    700: withOpacityValue("--color-secondary-700"),
	                    800: withOpacityValue("--color-secondary-800"),
	                    DEFAULT: withOpacityValue("--color-secondary"),
	                },
	                tertiary: {
	                    200: withOpacityValue("--color-tertiary-200"),
	                    300: withOpacityValue("--color-tertiary-300"),
	                    400: withOpacityValue("--color-tertiary-400"),
	                    500: withOpacityValue("--color-tertiary-500"),
	                    600: withOpacityValue("--color-tertiary-600"),
	                    700: withOpacityValue("--color-tertiary-700"),
	                    800: withOpacityValue("--color-tertiary-800"),
	                    DEFAULT: withOpacityValue("--color-tertiary"),
	                },
	                foreground: {
	                    100: withOpacityValue("--color-foreground-100"),
	                    200: withOpacityValue("--color-foreground-200"),
	                    300: withOpacityValue("--color-foreground-300"),
	                    400: withOpacityValue("--color-foreground-400"),
	                    500: withOpacityValue("--color-foreground-500"),
	                    600: withOpacityValue("--color-foreground-600"),
	                    700: withOpacityValue("--color-foreground-700"),
	                    800: withOpacityValue("--color-foreground-800"),
	                    DEFAULT: withOpacityValue("--color-foreground"),
	                },
	                bgText: withOpacityValue("--color-bg-text"),
	                background: withOpacityValue("--color-background"),
	                sidebarBg: withOpacityValue("--color-sidebar-bg"),
	                sidebarText: withOpacityValue("--color-sidebar-text"),
	                sidebarAccent: withOpacityValue("--color-sidebar-accent"),
	                composeButton: {
	                    DEFAULT: withOpacityValue("--color-compose-button"),
	                    500: withOpacityValue("--color-compose-button"),
	                    400: withOpacityValue("--color-compose-button-400"),
	                    600: withOpacityValue("--color-compose-button-600"),
	                },
	                longan: {
	                    100: "#FFF1DF",
	                    200: "#FFE5C4",
	                    300: "#FFD8A8",
	                    400: "#FFCA7A",
	                    500: "#DFA44E",
	                    600: "#B7853D",
	                    700: "#845E26",
	                    800: "#573707",
	                    900: "#281800",
	                    DEFAULT: "#FFD8A8",
	                },
	                mango: {
	                    100: "#FFE8D4",
	                    200: "#FFD0AC",
	                    300: "#FFBF83",
	                    400: "#FFAB5C",
	                    500: "#E58F3E",
	                    600: "#BC6D28",
	                    700: "#934A15",
	                    800: "#673104",
	                    900: "#281400",
	                    DEFAULT: "#FFAB5C",
	                },
	                strawberry: {
	                    100: "#FAD8D6",
	                    200: "#F4BBBB",
	                    300: "#EE999B",
	                    400: "#E56B6F",
	                    500: "#D54A50",
	                    600: "#A42A2F",
	                    700: "#7B1B1F",
	                    800: "#52070A",
	                    900: "#310004",
	                    DEFAULT: "#E56B6F",
	                },
	                cherry: {
	                    100: "#FDCEE0",
	                    200: "#EEADC7",
	                    300: "#D3749B",
	                    400: "#AE4473",
	                    500: "#83254F",
	                    600: "#671A3D",
	                    700: "#51112E",
	                    800: "#3B0920",
	                    900: "#220010",
	                    DEFAULT: "#83254F",
	                },
	                gray: {
	                    100: "#FFF9F2",
	                    200: "#DED9D3",
	                    300: "#BFBAB5",
	                    400: "#A09C98",
	                    500: "#827F7C",
	                    600: "#686664",
	                    700: "#4A4847",
	                    800: "#2E2D2C",
	                    900: "#191919",
	                    DEFAULT: "#191919",
	                },
	                notWhite: "#fff9f2",
	                notBlack: "#191919",
	                green: {
	                    DEFAULT: "#319D35",
	                    100: "#E2F6D0",
	                    200: "#B2DDA6",
	                    300: "#82C67B",
	                    400: "#4BAC4A",
	                    500: "#319D35",
	                    600: "#1F7622",
	                    700: "#175919",
	                    800: "#0E3B10",
	                    900: "#061E07",
	                },
	                red: {
	                    DEFAULT: "#FF4949",
	                    200: "#FFB3AD",
	                    300: "#FF8E8A",
	                    400: "#FF6C6A",
	                    500: "#FF4949",
	                    600: "#CC3A3A",
	                    700: "#992C2C",
	                    800: "#661D1D",
	                    900: "#330F0F",
	                },
	            },
	            typography: (theme) => ({
	                DEFAULT: {
	                    css: {
	                        color: theme("colors.notBlack"),
	                        a: {
	                            color: theme("colors.cherry"),
	                        },
	                        hr: {
	                            marginTop: "1em",
	                            marginBottom: "1em",
	                        },
	                    },
	                },
	                dark: {
	                    css: {
	                        // text outside any tag doesn't actually seem to get
	                        // --tw-prose-body?
	                        color: theme("colors.notWhite"),
	                        "--tw-prose-body": theme("colors.notWhite"),
	                        "--tw-prose-headings": theme("colors.notWhite"),
	                        "--tw-prose-lead": theme("colors.notWhite"),
	                        "--tw-prose-links": theme("colors.notWhite"),
	                        "--tw-prose-bold": theme("colors.notWhite"),
	                        "--tw-prose-counters": theme("colors.notWhite"),
	                        "--tw-prose-bullets": theme("colors.notWhite"),
	                        "--tw-prose-hr": theme("colors.gray[300]"),
	                        "--tw-prose-quotes": theme("colors.notWhite"),
	                        "--tw-prose-quote-borders": theme("colors.gray[300]"),
	                        "--tw-prose-captions": theme("colors.notWhite"),
	                        "--tw-prose-code": theme("colors.notWhite"),
	                        "--tw-prose-pre-code": theme("colors.notWhite"),
	                        "--tw-prose-pre-bg": theme("colors.notBlack"),
	                        "--tw-prose-th-borders": theme("colors.gray[300]"),
	                        "--tw-prose-td-borders": theme("colors.gray[300]"),
	                    },
	                },
	                sidebar: {
	                    css: {
	                        "--tw-prose-body": theme("colors.sidebarText"),
	                        "--tw-prose-headings": theme("colors.sidebarText"),
	                        "--tw-prose-lead": theme("colors.sidebarText"),
	                        "--tw-prose-links": theme("colors.sidebarText"),
	                        "--tw-prose-bold": theme("colors.sidebarText"),
	                        "--tw-prose-counters": theme("colors.sidebarText"),
	                        "--tw-prose-bullets": theme("colors.sidebarText"),
	                        "--tw-prose-hr": theme("colors.sidebarText"),
	                        "--tw-prose-quotes": theme("colors.sidebarText"),
	                        "--tw-prose-quote-borders": theme("colors.sidebarText"),
	                        "--tw-prose-captions": theme("colors.sidebarText"),
	                        "--tw-prose-code": theme("colors.sidebarText"),
	                        "--tw-prose-pre-code": theme("colors.pink[100]"),
	                        "--tw-prose-pre-bg": theme("colors.sidebarText"),
	                        "--tw-prose-th-borders": theme("colors.sidebarText"),
	                        "--tw-prose-td-borders": theme("colors.pink[200]"),
	                    },
	                },
	            }),
	        },
	    },
	    plugins: [
	        require$$4,
	        require$$4,
	        tailwindcssLogical,
	        dist$2,
	        plugin(function ({ addVariant }) {
	            addVariant("no-hover", "@media (hover: none)");
	        }),
	    ],
	};

	var tailwindConfig = /*@__PURE__*/getDefaultExportFromCjs(tailwind_config);

	/**
	 * @module color-parse
	 */

	/**
	 * Base hues
	 * http://dev.w3.org/csswg/css-color/#typedef-named-hue
	 */
	//FIXME: use external hue detector
	var baseHues = {
		red: 0,
		orange: 60,
		yellow: 120,
		green: 180,
		blue: 240,
		purple: 300
	};

	/**
	 * Parse color from the string passed
	 *
	 * @return {Object} A space indicator `space`, an array `values` and `alpha`
	 */
	function parse$5 (cstr) {
		var m, parts = [], alpha = 1, space;

		if (typeof cstr === 'string') {
			//keyword
			if (names[cstr]) {
				parts = names[cstr].slice();
				space = 'rgb';
			}

			//reserved words
			else if (cstr === 'transparent') {
				alpha = 0;
				space = 'rgb';
				parts = [0,0,0];
			}

			//hex
			else if (/^#[A-Fa-f0-9]+$/.test(cstr)) {
				var base = cstr.slice(1);
				var size = base.length;
				var isShort = size <= 4;
				alpha = 1;

				if (isShort) {
					parts = [
						parseInt(base[0] + base[0], 16),
						parseInt(base[1] + base[1], 16),
						parseInt(base[2] + base[2], 16)
					];
					if (size === 4) {
						alpha = parseInt(base[3] + base[3], 16) / 255;
					}
				}
				else {
					parts = [
						parseInt(base[0] + base[1], 16),
						parseInt(base[2] + base[3], 16),
						parseInt(base[4] + base[5], 16)
					];
					if (size === 8) {
						alpha = parseInt(base[6] + base[7], 16) / 255;
					}
				}

				if (!parts[0]) parts[0] = 0;
				if (!parts[1]) parts[1] = 0;
				if (!parts[2]) parts[2] = 0;

				space = 'rgb';
			}

			//color space
			else if (m = /^((?:rgb|hs[lvb]|hwb|cmyk?|xy[zy]|gray|lab|lchu?v?|[ly]uv|lms)a?)\s*\(([^\)]*)\)/.exec(cstr)) {
				var name = m[1];
				var isRGB = name === 'rgb';
				var base = name.replace(/a$/, '');
				space = base;
				var size = base === 'cmyk' ? 4 : base === 'gray' ? 1 : 3;
				parts = m[2].trim()
					.split(/\s*[,\/]\s*|\s+/)
					.map(function (x, i) {
						//<percentage>
						if (/%$/.test(x)) {
							//alpha
							if (i === size)	return parseFloat(x) / 100
							//rgb
							if (base === 'rgb') return parseFloat(x) * 255 / 100
							return parseFloat(x)
						}
						//hue
						else if (base[i] === 'h') {
							//<deg>
							if (/deg$/.test(x)) {
								return parseFloat(x)
							}
							//<base-hue>
							else if (baseHues[x] !== undefined) {
								return baseHues[x]
							}
						}
						return parseFloat(x)
					});

				if (name === base) parts.push(1);
				alpha = (isRGB) ? 1 : (parts[size] === undefined) ? 1 : parts[size];
				parts = parts.slice(0, size);
			}

			//named channels case
			else if (cstr.length > 10 && /[0-9](?:\s|\/)/.test(cstr)) {
				parts = cstr.match(/([0-9]+)/g).map(function (value) {
					return parseFloat(value)
				});

				space = cstr.match(/([a-z])/ig).join('').toLowerCase();
			}
		}

		//numeric case
		else if (!isNaN(cstr)) {
			space = 'rgb';
			parts = [cstr >>> 16, (cstr & 0x00ff00) >>> 8, cstr & 0x0000ff];
		}

		//array-like
		else if (Array.isArray(cstr) || cstr.length) {
			parts = [cstr[0], cstr[1], cstr[2]];
			space = 'rgb';
			alpha = cstr.length === 4 ? cstr[3] : 1;
		}

		//object case - detects css cases of rgb and hsl
		else if (cstr instanceof Object) {
			if (cstr.r != null || cstr.red != null || cstr.R != null) {
				space = 'rgb';
				parts = [
					cstr.r || cstr.red || cstr.R || 0,
					cstr.g || cstr.green || cstr.G || 0,
					cstr.b || cstr.blue || cstr.B || 0
				];
			}
			else {
				space = 'hsl';
				parts = [
					cstr.h || cstr.hue || cstr.H || 0,
					cstr.s || cstr.saturation || cstr.S || 0,
					cstr.l || cstr.lightness || cstr.L || cstr.b || cstr.brightness
				];
			}

			alpha = cstr.a || cstr.alpha || cstr.opacity || 1;

			if (cstr.opacity != null) alpha /= 100;
		}

		return {
			space: space,
			values: parts,
			alpha: alpha
		}
	}

	/**
	 * RGB space.
	 *
	 * @module  color-space/rgb
	 */

	var rgb = {
		name: 'rgb',
		min: [0,0,0],
		max: [255,255,255],
		channel: ['red', 'green', 'blue'],
		alias: ['RGB']
	};

	/**
	 * @module color-space/hsl
	 */

	var hsl = {
		name: 'hsl',
		min: [0,0,0],
		max: [360,100,100],
		channel: ['hue', 'saturation', 'lightness'],
		alias: ['HSL'],

		rgb: function(hsl) {
			var h = hsl[0] / 360,
					s = hsl[1] / 100,
					l = hsl[2] / 100,
					t1, t2, t3, rgb, val;

			if (s === 0) {
				val = l * 255;
				return [val, val, val];
			}

			if (l < 0.5) {
				t2 = l * (1 + s);
			}
			else {
				t2 = l + s - l * s;
			}
			t1 = 2 * l - t2;

			rgb = [0, 0, 0];
			for (var i = 0; i < 3; i++) {
				t3 = h + 1 / 3 * - (i - 1);
				if (t3 < 0) {
					t3++;
				}
				else if (t3 > 1) {
					t3--;
				}

				if (6 * t3 < 1) {
					val = t1 + (t2 - t1) * 6 * t3;
				}
				else if (2 * t3 < 1) {
					val = t2;
				}
				else if (3 * t3 < 2) {
					val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
				}
				else {
					val = t1;
				}

				rgb[i] = val * 255;
			}

			return rgb;
		}
	};


	//extend rgb
	rgb.hsl = function(rgb) {
		var r = rgb[0]/255,
				g = rgb[1]/255,
				b = rgb[2]/255,
				min = Math.min(r, g, b),
				max = Math.max(r, g, b),
				delta = max - min,
				h, s, l;

		if (max === min) {
			h = 0;
		}
		else if (r === max) {
			h = (g - b) / delta;
		}
		else if (g === max) {
			h = 2 + (b - r) / delta;
		}
		else if (b === max) {
			h = 4 + (r - g)/ delta;
		}

		h = Math.min(h * 60, 360);

		if (h < 0) {
			h += 360;
		}

		l = (min + max) / 2;

		if (max === min) {
			s = 0;
		}
		else if (l <= 0.5) {
			s = delta / (max + min);
		}
		else {
			s = delta / (2 - max - min);
		}

		return [h, s * 100, l * 100];
	};

	/** @module  color-rgba */

	function rgba (color) {
		// template literals
		if (Array.isArray(color) && color.raw) color = String.raw(...arguments);

		var values;

		//attempt to parse non-array arguments
		var parsed = parse$5(color);

		if (!parsed.space) return []

		const min = parsed.space[0] === 'h' ? hsl.min : rgb.min;
		const max = parsed.space[0] === 'h' ? hsl.max : rgb.max;

		values = Array(3);
		values[0] = Math.min(Math.max(parsed.values[0], min[0]), max[0]);
		values[1] = Math.min(Math.max(parsed.values[1], min[1]), max[1]);
		values[2] = Math.min(Math.max(parsed.values[2], min[2]), max[2]);

		if (parsed.space[0] === 'h') {
			values = hsl.rgb(values);
		}

		values.push(Math.min(Math.max(parsed.alpha, 0), 1));

		return values
	}

	// we need to disable this rule here since otherwise eslint gets upset. one of
	// those edge cases.
	// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
	const colors = tailwindConfig.theme.extend
	    ?.colors ;

	function tailwindColor(name, variant = "DEFAULT") {
	    if (typeof colors !== "object") {
	        return "fuschia";
	    }

	    const colorFamily = colors[name];
	    if (typeof colorFamily === "object") {
	        const candidate = colorFamily[variant] ?? colorFamily[500];
	        if (typeof candidate === "string") {
	            return candidate;
	        }
	    } else if (typeof colorFamily === "string") {
	        return colorFamily;
	    }

	    // this is an error state
	    return "fuschia";
	}

	function varForTailwindColor(name, variant = "DEFAULT") {
	    const color = tailwindColor(name, variant);
	    return varForColor(color);
	}

	function varForColor(color) {
	    const parsed = rgba(color) ?? [0, 0, 0, 0];
	    return parsed.slice(0, 3).join(" ");
	}

	var appleTouchIcon = "7ec6f0f3aef87d734f9b.png";

	var favicon16 = "3c154cde88b7ed1ca92a.png";

	var favicon32 = "a4f72033a674e35d4cc9.png";

	var faviconIco = "1ba8b89b7a2ed8dd1d04.ico";

	function serverPathFromImport(path) {
	    return sitemap.public.static.staticAsset({ path }).toString();
	}

	const Favicons = () => (
	    React$2.createElement(Helmet, null
	        , React$2.createElement('link', {
	            rel: "apple-touch-icon",
	            sizes: "180x180",
	            href: serverPathFromImport(appleTouchIcon),}
	        )
	        , React$2.createElement('link', {
	            rel: "icon",
	            type: "image/png",
	            sizes: "32x32",
	            href: serverPathFromImport(favicon32),}
	        )
	        , React$2.createElement('link', {
	            rel: "icon",
	            type: "image/png",
	            sizes: "16x16",
	            href: serverPathFromImport(favicon16),}
	        )
	        /* append the app version to the manifest file for cache busting. we use this same trick with locales. */
	        , React$2.createElement('link', { rel: "manifest", href: `/static/manifest.json?${env.VERSION}`,} )
	        , React$2.createElement('link', { rel: "shortcut icon" , href: serverPathFromImport(faviconIco),} )
	        , React$2.createElement('meta', { name: "apple-mobile-web-app-title", content: "cohost",} )
	        , React$2.createElement('meta', { name: "application-name", content: "cohost",} )
	        /* TODO: make this work correctly with themes */
	        /* <meta name="theme-color" content="#83254f" /> */

	        /* re-add this later, currently not a way to refresh with it enabled */
	        /* <meta name="apple-mobile-web-app-capable" content="yes" /> */
	    )
	);

	const infoFlash = (message) => React$2.createElement('div', null, message);
	const errorFlash = (message) => React$2.createElement('div', null, "error: " , message);

	const Flashes

	 = (props) => {
	    const { info, error } = reactExports.useContext(FlashesProvider);

	    return info.length || error.length ? (
	        React$2.createElement('div', {
	            className: `rounded-lg border-notBlack bg-notWhite p-3 text-notBlack ${
                props.className || ""
            } ${props.className || ""}`,}

	            , info.length ? (
	                React$2.createElement('ul', null
	                    , info.map((msg) => (
	                        React$2.createElement('li', { key: msg,}, infoFlash(msg))
	                    ))
	                )
	            ) : null
	            , error.length ? (
	                React$2.createElement('ul', null
	                    , error.map((msg) => (
	                        React$2.createElement('li', { key: msg,}, errorFlash(msg))
	                    ))
	                )
	            ) : null
	        )
	    ) : null;
	};

	function ArrowLeftOnRectangleIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M15.75 9V5.25A2.25 2.25 0 0013.5 3h-6a2.25 2.25 0 00-2.25 2.25v13.5A2.25 2.25 0 007.5 21h6a2.25 2.25 0 002.25-2.25V15M12 9l-3 3m0 0l3 3m-3-3h12.75"
	  }));
	}

	const ForwardRef$1j = reactExports.forwardRef(ArrowLeftOnRectangleIcon);

	function LifebuoyIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M16.712 4.33a9.027 9.027 0 011.652 1.306c.51.51.944 1.064 1.306 1.652M16.712 4.33l-3.448 4.138m3.448-4.138a9.014 9.014 0 00-9.424 0M19.67 7.288l-4.138 3.448m4.138-3.448a9.014 9.014 0 010 9.424m-4.138-5.976a3.736 3.736 0 00-.88-1.388 3.737 3.737 0 00-1.388-.88m2.268 2.268a3.765 3.765 0 010 2.528m-2.268-4.796a3.765 3.765 0 00-2.528 0m4.796 4.796c-.181.506-.475.982-.88 1.388a3.736 3.736 0 01-1.388.88m2.268-2.268l4.138 3.448m0 0a9.027 9.027 0 01-1.306 1.652c-.51.51-1.064.944-1.652 1.306m0 0l-3.448-4.138m3.448 4.138a9.014 9.014 0 01-9.424 0m5.976-4.138a3.765 3.765 0 01-2.528 0m0 0a3.736 3.736 0 01-1.388-.88 3.737 3.737 0 01-.88-1.388m2.268 2.268L7.288 19.67m0 0a9.024 9.024 0 01-1.652-1.306 9.027 9.027 0 01-1.306-1.652m0 0l4.138-3.448M4.33 16.712a9.014 9.014 0 010-9.424m4.138 5.976a3.765 3.765 0 010-2.528m0 0c.181-.506.475-.982.88-1.388a3.736 3.736 0 011.388-.88m-2.268 2.268L4.33 7.288m6.406 1.18L7.288 4.33m0 0a9.024 9.024 0 00-1.652 1.306A9.025 9.025 0 004.33 7.288"
	  }));
	}

	const ForwardRef$1i = reactExports.forwardRef(LifebuoyIcon$1);

	function ArrowPathIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M16.023 9.348h4.992v-.001M2.985 19.644v-4.992m0 0h4.992m-4.993 0l3.181 3.183a8.25 8.25 0 0013.803-3.7M4.031 9.865a8.25 8.25 0 0113.803-3.7l3.181 3.182m0-4.991v4.99"
	  }));
	}

	const ForwardRef$1h = reactExports.forwardRef(ArrowPathIcon$1);

	function LightBulbIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M12 18v-5.25m0 0a6.01 6.01 0 001.5-.189m-1.5.189a6.01 6.01 0 01-1.5-.189m3.75 7.478a12.06 12.06 0 01-4.5 0m3.75 2.383a14.406 14.406 0 01-3 0M14.25 18v-.192c0-.983.658-1.823 1.508-2.316a7.5 7.5 0 10-7.517 0c.85.493 1.509 1.333 1.509 2.316V18"
	  }));
	}

	const ForwardRef$1g = reactExports.forwardRef(LightBulbIcon);

	function ArrowRightOnRectangleIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M15.75 9V5.25A2.25 2.25 0 0013.5 3h-6a2.25 2.25 0 00-2.25 2.25v13.5A2.25 2.25 0 007.5 21h6a2.25 2.25 0 002.25-2.25V15m3 0l3-3m0 0l-3-3m3 3H9"
	  }));
	}

	const ForwardRef$1f = reactExports.forwardRef(ArrowRightOnRectangleIcon);

	function LockClosedIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M16.5 10.5V6.75a4.5 4.5 0 10-9 0v3.75m-.75 11.25h10.5a2.25 2.25 0 002.25-2.25v-6.75a2.25 2.25 0 00-2.25-2.25H6.75a2.25 2.25 0 00-2.25 2.25v6.75a2.25 2.25 0 002.25 2.25z"
	  }));
	}

	const ForwardRef$1e = reactExports.forwardRef(LockClosedIcon$1);

	function ArrowUpTrayIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M3 16.5v2.25A2.25 2.25 0 005.25 21h13.5A2.25 2.25 0 0021 18.75V16.5m-13.5-9L12 3m0 0l4.5 4.5M12 3v13.5"
	  }));
	}

	const ForwardRef$1d = reactExports.forwardRef(ArrowUpTrayIcon$1);

	function LockOpenIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M13.5 10.5V6.75a4.5 4.5 0 119 0v3.75M3.75 21.75h10.5a2.25 2.25 0 002.25-2.25v-6.75a2.25 2.25 0 00-2.25-2.25H3.75a2.25 2.25 0 00-2.25 2.25v6.75a2.25 2.25 0 002.25 2.25z"
	  }));
	}

	const ForwardRef$1c = reactExports.forwardRef(LockOpenIcon);

	function BellIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M14.857 17.082a23.848 23.848 0 005.454-1.31A8.967 8.967 0 0118 9.75v-.7V9A6 6 0 006 9v.75a8.967 8.967 0 01-2.312 6.022c1.733.64 3.56 1.085 5.455 1.31m5.714 0a24.255 24.255 0 01-5.714 0m5.714 0a3 3 0 11-5.714 0"
	  }));
	}

	const ForwardRef$1b = reactExports.forwardRef(BellIcon$1);

	function MagnifyingGlassIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M21 21l-5.197-5.197m0 0A7.5 7.5 0 105.196 5.196a7.5 7.5 0 0010.607 10.607z"
	  }));
	}

	const ForwardRef$1a = reactExports.forwardRef(MagnifyingGlassIcon$1);

	function ChatBubbleOvalLeftEllipsisIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M8.625 12a.375.375 0 11-.75 0 .375.375 0 01.75 0zm0 0H8.25m4.125 0a.375.375 0 11-.75 0 .375.375 0 01.75 0zm0 0H12m4.125 0a.375.375 0 11-.75 0 .375.375 0 01.75 0zm0 0h-.375M21 12c0 4.556-4.03 8.25-9 8.25a9.764 9.764 0 01-2.555-.337A5.972 5.972 0 015.41 20.97a5.969 5.969 0 01-.474-.065 4.48 4.48 0 00.978-2.025c.09-.457-.133-.901-.467-1.226C3.93 16.178 3 14.189 3 12c0-4.556 4.03-8.25 9-8.25s9 3.694 9 8.25z"
	  }));
	}

	const ForwardRef$19 = reactExports.forwardRef(ChatBubbleOvalLeftEllipsisIcon$1);

	function NewspaperIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M12 7.5h1.5m-1.5 3h1.5m-7.5 3h7.5m-7.5 3h7.5m3-9h3.375c.621 0 1.125.504 1.125 1.125V18a2.25 2.25 0 01-2.25 2.25M16.5 7.5V18a2.25 2.25 0 002.25 2.25M16.5 7.5V4.875c0-.621-.504-1.125-1.125-1.125H4.125C3.504 3.75 3 4.254 3 4.875V18a2.25 2.25 0 002.25 2.25h13.5M6 7.5h3v3H6v-3z"
	  }));
	}

	const ForwardRef$18 = reactExports.forwardRef(NewspaperIcon$1);

	function CheckCircleIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M9 12.75L11.25 15 15 9.75M21 12a9 9 0 11-18 0 9 9 0 0118 0z"
	  }));
	}

	const ForwardRef$17 = reactExports.forwardRef(CheckCircleIcon$1);

	function NoSymbolIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M18.364 18.364A9 9 0 005.636 5.636m12.728 12.728A9 9 0 015.636 5.636m12.728 12.728L5.636 5.636"
	  }));
	}

	const ForwardRef$16 = reactExports.forwardRef(NoSymbolIcon);

	function CheckIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M4.5 12.75l6 6 9-13.5"
	  }));
	}

	const ForwardRef$15 = reactExports.forwardRef(CheckIcon$1);

	function PaintBrushIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M9.53 16.122a3 3 0 00-5.78 1.128 2.25 2.25 0 01-2.4 2.245 4.5 4.5 0 008.4-2.245c0-.399-.078-.78-.22-1.128zm0 0a15.998 15.998 0 003.388-1.62m-5.043-.025a15.994 15.994 0 011.622-3.395m3.42 3.42a15.995 15.995 0 004.764-4.648l3.876-5.814a1.151 1.151 0 00-1.597-1.597L14.146 6.32a15.996 15.996 0 00-4.649 4.763m3.42 3.42a6.776 6.776 0 00-3.42-3.42"
	  }));
	}

	const ForwardRef$14 = reactExports.forwardRef(PaintBrushIcon$1);

	function ChevronDoubleLeftIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M18.75 19.5l-7.5-7.5 7.5-7.5m-6 15L5.25 12l7.5-7.5"
	  }));
	}

	reactExports.forwardRef(ChevronDoubleLeftIcon);

	function PaperClipIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M18.375 12.739l-7.693 7.693a4.5 4.5 0 01-6.364-6.364l10.94-10.94A3 3 0 1119.5 7.372L8.552 18.32m.009-.01l-.01.01m5.699-9.941l-7.81 7.81a1.5 1.5 0 002.112 2.13"
	  }));
	}

	const ForwardRef$13 = reactExports.forwardRef(PaperClipIcon);

	function ChevronDownIcon$2({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M19.5 8.25l-7.5 7.5-7.5-7.5"
	  }));
	}

	const ForwardRef$12 = reactExports.forwardRef(ChevronDownIcon$2);

	function PauseCircleIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M14.25 9v6m-4.5 0V9M21 12a9 9 0 11-18 0 9 9 0 0118 0z"
	  }));
	}

	const ForwardRef$11 = reactExports.forwardRef(PauseCircleIcon);

	function ChevronLeftIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M15.75 19.5L8.25 12l7.5-7.5"
	  }));
	}

	reactExports.forwardRef(ChevronLeftIcon$1);

	function PencilIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M16.862 4.487l1.687-1.688a1.875 1.875 0 112.652 2.652L6.832 19.82a4.5 4.5 0 01-1.897 1.13l-2.685.8.8-2.685a4.5 4.5 0 011.13-1.897L16.863 4.487zm0 0L19.5 7.125"
	  }));
	}

	const ForwardRef$10 = reactExports.forwardRef(PencilIcon);

	function ChevronRightIcon$2({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M8.25 4.5l7.5 7.5-7.5 7.5"
	  }));
	}

	reactExports.forwardRef(ChevronRightIcon$2);

	function PencilSquareIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M16.862 4.487l1.687-1.688a1.875 1.875 0 112.652 2.652L10.582 16.07a4.5 4.5 0 01-1.897 1.13L6 18l.8-2.685a4.5 4.5 0 011.13-1.897l8.932-8.931zm0 0L19.5 7.125M18 14v4.75A2.25 2.25 0 0115.75 21H5.25A2.25 2.25 0 013 18.75V8.25A2.25 2.25 0 015.25 6H10"
	  }));
	}

	const ForwardRef$$ = reactExports.forwardRef(PencilSquareIcon);

	function CloudArrowDownIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M12 9.75v6.75m0 0l-3-3m3 3l3-3m-8.25 6a4.5 4.5 0 01-1.41-8.775 5.25 5.25 0 0110.233-2.33 3 3 0 013.758 3.848A3.752 3.752 0 0118 19.5H6.75z"
	  }));
	}

	const ForwardRef$_ = reactExports.forwardRef(CloudArrowDownIcon);

	function PlayCircleIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M21 12a9 9 0 11-18 0 9 9 0 0118 0z"
	  }), /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M15.91 11.672a.375.375 0 010 .656l-5.603 3.113a.375.375 0 01-.557-.328V8.887c0-.286.307-.466.557-.327l5.603 3.112z"
	  }));
	}

	const ForwardRef$Z = reactExports.forwardRef(PlayCircleIcon);

	function CogIcon$2({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M4.5 12a7.5 7.5 0 0015 0m-15 0a7.5 7.5 0 1115 0m-15 0H3m16.5 0H21m-1.5 0H12m-8.457 3.077l1.41-.513m14.095-5.13l1.41-.513M5.106 17.785l1.15-.964m11.49-9.642l1.149-.964M7.501 19.795l.75-1.3m7.5-12.99l.75-1.3m-6.063 16.658l.26-1.477m2.605-14.772l.26-1.477m0 17.726l-.26-1.477M10.698 4.614l-.26-1.477M16.5 19.794l-.75-1.299M7.5 4.205L12 12m6.894 5.785l-1.149-.964M6.256 7.178l-1.15-.964m15.352 8.864l-1.41-.513M4.954 9.435l-1.41-.514M12.002 12l-3.75 6.495"
	  }));
	}

	const ForwardRef$Y = reactExports.forwardRef(CogIcon$2);

	function PlusIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M12 4.5v15m7.5-7.5h-15"
	  }));
	}

	const ForwardRef$X = reactExports.forwardRef(PlusIcon);

	function DocumentPlusIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M19.5 14.25v-2.625a3.375 3.375 0 00-3.375-3.375h-1.5A1.125 1.125 0 0113.5 7.125v-1.5a3.375 3.375 0 00-3.375-3.375H8.25m3.75 9v6m3-3H9m1.5-12H5.625c-.621 0-1.125.504-1.125 1.125v17.25c0 .621.504 1.125 1.125 1.125h12.75c.621 0 1.125-.504 1.125-1.125V11.25a9 9 0 00-9-9z"
	  }));
	}

	const ForwardRef$W = reactExports.forwardRef(DocumentPlusIcon);

	function QuestionMarkCircleIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M9.879 7.519c1.171-1.025 3.071-1.025 4.242 0 1.172 1.025 1.172 2.687 0 3.712-.203.179-.43.326-.67.442-.745.361-1.45.999-1.45 1.827v.75M21 12a9 9 0 11-18 0 9 9 0 0118 0zm-9 5.25h.008v.008H12v-.008z"
	  }));
	}

	const ForwardRef$V = reactExports.forwardRef(QuestionMarkCircleIcon$1);

	function DocumentTextIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M19.5 14.25v-2.625a3.375 3.375 0 00-3.375-3.375h-1.5A1.125 1.125 0 0113.5 7.125v-1.5a3.375 3.375 0 00-3.375-3.375H8.25m0 12.75h7.5m-7.5 3H12M10.5 2.25H5.625c-.621 0-1.125.504-1.125 1.125v17.25c0 .621.504 1.125 1.125 1.125h12.75c.621 0 1.125-.504 1.125-1.125V11.25a9 9 0 00-9-9z"
	  }));
	}

	const ForwardRef$U = reactExports.forwardRef(DocumentTextIcon$1);

	function ShareIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M7.217 10.907a2.25 2.25 0 100 2.186m0-2.186c.18.324.283.696.283 1.093s-.103.77-.283 1.093m0-2.186l9.566-5.314m-9.566 7.5l9.566 5.314m0 0a2.25 2.25 0 103.935 2.186 2.25 2.25 0 00-3.935-2.186zm0-12.814a2.25 2.25 0 103.933-2.185 2.25 2.25 0 00-3.933 2.185z"
	  }));
	}

	const ForwardRef$T = reactExports.forwardRef(ShareIcon);

	function EllipsisHorizontalIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M6.75 12a.75.75 0 11-1.5 0 .75.75 0 011.5 0zM12.75 12a.75.75 0 11-1.5 0 .75.75 0 011.5 0zM18.75 12a.75.75 0 11-1.5 0 .75.75 0 011.5 0z"
	  }));
	}

	const ForwardRef$S = reactExports.forwardRef(EllipsisHorizontalIcon$1);

	function ShieldExclamationIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M12 9v3.75m0-10.036A11.959 11.959 0 013.598 6 11.99 11.99 0 003 9.75c0 5.592 3.824 10.29 9 11.622 5.176-1.332 9-6.03 9-11.622 0-1.31-.21-2.57-.598-3.75h-.152c-3.196 0-6.1-1.249-8.25-3.286zm0 13.036h.008v.008H12v-.008z"
	  }));
	}

	const ForwardRef$R = reactExports.forwardRef(ShieldExclamationIcon);

	function ExclamationCircleIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M12 9v3.75m9-.75a9 9 0 11-18 0 9 9 0 0118 0zm-9 3.75h.008v.008H12v-.008z"
	  }));
	}

	const ForwardRef$Q = reactExports.forwardRef(ExclamationCircleIcon$1);

	function SpeakerWaveIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M19.114 5.636a9 9 0 010 12.728M16.463 8.288a5.25 5.25 0 010 7.424M6.75 8.25l4.72-4.72a.75.75 0 011.28.53v15.88a.75.75 0 01-1.28.53l-4.72-4.72H4.51c-.88 0-1.704-.507-1.938-1.354A9.01 9.01 0 012.25 12c0-.83.112-1.633.322-2.396C2.806 8.756 3.63 8.25 4.51 8.25H6.75z"
	  }));
	}

	reactExports.forwardRef(SpeakerWaveIcon);

	function ExclamationTriangleIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M12 9v3.75m-9.303 3.376c-.866 1.5.217 3.374 1.948 3.374h14.71c1.73 0 2.813-1.874 1.948-3.374L13.949 3.378c-.866-1.5-3.032-1.5-3.898 0L2.697 16.126zM12 15.75h.007v.008H12v-.008z"
	  }));
	}

	const ForwardRef$P = reactExports.forwardRef(ExclamationTriangleIcon$1);

	function TagIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M9.568 3H5.25A2.25 2.25 0 003 5.25v4.318c0 .597.237 1.17.659 1.591l9.581 9.581c.699.699 1.78.872 2.607.33a18.095 18.095 0 005.223-5.223c.542-.827.369-1.908-.33-2.607L11.16 3.66A2.25 2.25 0 009.568 3z"
	  }), /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M6 6h.008v.008H6V6z"
	  }));
	}

	const ForwardRef$O = reactExports.forwardRef(TagIcon);

	function EyeIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M2.036 12.322a1.012 1.012 0 010-.639C3.423 7.51 7.36 4.5 12 4.5c4.638 0 8.573 3.007 9.963 7.178.07.207.07.431 0 .639C20.577 16.49 16.64 19.5 12 19.5c-4.638 0-8.573-3.007-9.963-7.178z"
	  }), /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M15 12a3 3 0 11-6 0 3 3 0 016 0z"
	  }));
	}

	const ForwardRef$N = reactExports.forwardRef(EyeIcon);

	function TrashIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M14.74 9l-.346 9m-4.788 0L9.26 9m9.968-3.21c.342.052.682.107 1.022.166m-1.022-.165L18.16 19.673a2.25 2.25 0 01-2.244 2.077H8.084a2.25 2.25 0 01-2.244-2.077L4.772 5.79m14.456 0a48.108 48.108 0 00-3.478-.397m-12 .562c.34-.059.68-.114 1.022-.165m0 0a48.11 48.11 0 013.478-.397m7.5 0v-.916c0-1.18-.91-2.164-2.09-2.201a51.964 51.964 0 00-3.32 0c-1.18.037-2.09 1.022-2.09 2.201v.916m7.5 0a48.667 48.667 0 00-7.5 0"
	  }));
	}

	const ForwardRef$M = reactExports.forwardRef(TrashIcon);

	function EyeSlashIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M3.98 8.223A10.477 10.477 0 001.934 12C3.226 16.338 7.244 19.5 12 19.5c.993 0 1.953-.138 2.863-.395M6.228 6.228A10.45 10.45 0 0112 4.5c4.756 0 8.773 3.162 10.065 7.498a10.523 10.523 0 01-4.293 5.774M6.228 6.228L3 3m3.228 3.228l3.65 3.65m7.894 7.894L21 21m-3.228-3.228l-3.65-3.65m0 0a3 3 0 10-4.243-4.243m4.242 4.242L9.88 9.88"
	  }));
	}

	const ForwardRef$L = reactExports.forwardRef(EyeSlashIcon);

	function UserCircleIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M17.982 18.725A7.488 7.488 0 0012 15.75a7.488 7.488 0 00-5.982 2.975m11.963 0a9 9 0 10-11.963 0m11.963 0A8.966 8.966 0 0112 21a8.966 8.966 0 01-5.982-2.275M15 9.75a3 3 0 11-6 0 3 3 0 016 0z"
	  }));
	}

	const ForwardRef$K = reactExports.forwardRef(UserCircleIcon$1);

	function FaceSmileIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M15.182 15.182a4.5 4.5 0 01-6.364 0M21 12a9 9 0 11-18 0 9 9 0 0118 0zM9.75 9.75c0 .414-.168.75-.375.75S9 10.164 9 9.75 9.168 9 9.375 9s.375.336.375.75zm-.375 0h.008v.015h-.008V9.75zm5.625 0c0 .414-.168.75-.375.75s-.375-.336-.375-.75.168-.75.375-.75.375.336.375.75zm-.375 0h.008v.015h-.008V9.75z"
	  }));
	}

	const ForwardRef$J = reactExports.forwardRef(FaceSmileIcon);

	function UserGroupIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M18 18.72a9.094 9.094 0 003.741-.479 3 3 0 00-4.682-2.72m.94 3.198l.001.031c0 .225-.012.447-.037.666A11.944 11.944 0 0112 21c-2.17 0-4.207-.576-5.963-1.584A6.062 6.062 0 016 18.719m12 0a5.971 5.971 0 00-.941-3.197m0 0A5.995 5.995 0 0012 12.75a5.995 5.995 0 00-5.058 2.772m0 0a3 3 0 00-4.681 2.72 8.986 8.986 0 003.74.477m.94-3.197a5.971 5.971 0 00-.94 3.197M15 6.75a3 3 0 11-6 0 3 3 0 016 0zm6 3a2.25 2.25 0 11-4.5 0 2.25 2.25 0 014.5 0zm-13.5 0a2.25 2.25 0 11-4.5 0 2.25 2.25 0 014.5 0z"
	  }));
	}

	const ForwardRef$I = reactExports.forwardRef(UserGroupIcon$1);

	function HashtagIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M5.25 8.25h15m-16.5 7.5h15m-1.8-13.5l-3.9 19.5m-2.1-19.5l-3.9 19.5"
	  }));
	}

	const ForwardRef$H = reactExports.forwardRef(HashtagIcon$1);

	function UserPlusIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M19 7.5v3m0 0v3m0-3h3m-3 0h-3m-2.25-4.125a3.375 3.375 0 11-6.75 0 3.375 3.375 0 016.75 0zM4 19.235v-.11a6.375 6.375 0 0112.75 0v.109A12.318 12.318 0 0110.374 21c-2.331 0-4.512-.645-6.374-1.766z"
	  }));
	}

	const ForwardRef$G = reactExports.forwardRef(UserPlusIcon$1);

	function HeartIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M21 8.25c0-2.485-2.099-4.5-4.688-4.5-1.935 0-3.597 1.126-4.312 2.733-.715-1.607-2.377-2.733-4.313-2.733C5.1 3.75 3 5.765 3 8.25c0 7.22 9 12 9 12s9-4.78 9-12z"
	  }));
	}

	const ForwardRef$F = reactExports.forwardRef(HeartIcon$1);

	function UsersIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M15 19.128a9.38 9.38 0 002.625.372 9.337 9.337 0 004.121-.952 4.125 4.125 0 00-7.533-2.493M15 19.128v-.003c0-1.113-.285-2.16-.786-3.07M15 19.128v.106A12.318 12.318 0 018.624 21c-2.331 0-4.512-.645-6.374-1.766l-.001-.109a6.375 6.375 0 0111.964-3.07M12 6.375a3.375 3.375 0 11-6.75 0 3.375 3.375 0 016.75 0zm8.25 2.25a2.625 2.625 0 11-5.25 0 2.625 2.625 0 015.25 0z"
	  }));
	}

	const ForwardRef$E = reactExports.forwardRef(UsersIcon$1);

	function InboxIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M2.25 13.5h3.86a2.25 2.25 0 012.012 1.244l.256.512a2.25 2.25 0 002.013 1.244h3.218a2.25 2.25 0 002.013-1.244l.256-.512a2.25 2.25 0 012.013-1.244h3.859m-19.5.338V18a2.25 2.25 0 002.25 2.25h15A2.25 2.25 0 0021.75 18v-4.162c0-.224-.034-.447-.1-.661L19.24 5.338a2.25 2.25 0 00-2.15-1.588H6.911a2.25 2.25 0 00-2.15 1.588L2.35 13.177a2.25 2.25 0 00-.1.661z"
	  }));
	}

	const ForwardRef$D = reactExports.forwardRef(InboxIcon$1);

	function XMarkIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M6 18L18 6M6 6l12 12"
	  }));
	}

	const ForwardRef$C = reactExports.forwardRef(XMarkIcon$1);

	function InformationCircleIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    fill: "none",
	    viewBox: "0 0 24 24",
	    strokeWidth: 1.5,
	    stroke: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    strokeLinecap: "round",
	    strokeLinejoin: "round",
	    d: "M11.25 11.25l.041-.02a.75.75 0 011.063.852l-.708 2.836a.75.75 0 001.063.853l.041-.021M21 12a9 9 0 11-18 0 9 9 0 0118 0zm-9-3.75h.008v.008H12V8.25z"
	  }));
	}

	const ForwardRef$B = reactExports.forwardRef(InformationCircleIcon);

	let e$6={data:""},t$c=t=>"object"==typeof window?((t?t.querySelector("#_goober"):window._goober)||Object.assign((t||document.head).appendChild(document.createElement("style")),{innerHTML:" ",id:"_goober"})).firstChild:t||e$6,l$b=/(?:([\u0080-\uFFFF\w-%@]+) *:? *([^{;]+?);|([^;}{]*?) *{)|(}\s*)/g,a$b=/\/\*[^]*?\*\/|  +/g,n$a=/\n+/g,o$8=(e,t)=>{let r="",l="",a="";for(let n in e){let c=e[n];"@"==n[0]?"i"==n[1]?r=n+" "+c+";":l+="f"==n[1]?o$8(c,n):n+"{"+o$8(c,"k"==n[1]?"":t)+"}":"object"==typeof c?l+=o$8(c,t?t.replace(/([^,])+/g,e=>n.replace(/(^:.*)|([^,])+/g,t=>/&/.test(t)?t.replace(/&/g,e):e?e+" "+t:t)):n):null!=c&&(n=/^--/.test(n)?n:n.replace(/[A-Z]/g,"-$&").toLowerCase(),a+=o$8.p?o$8.p(n,c):n+":"+c+";");}return r+(t&&a?t+"{"+a+"}":a)+l},c$a={},s$e=e=>{if("object"==typeof e){let t="";for(let r in e)t+=r+s$e(e[r]);return t}return e},i$8=(e,t,r,i,p)=>{let u=s$e(e),d=c$a[u]||(c$a[u]=(e=>{let t=0,r=11;for(;t<e.length;)r=101*r+e.charCodeAt(t++)>>>0;return "go"+r})(u));if(!c$a[d]){let t=u!==e?e:(e=>{let t,r,o=[{}];for(;t=l$b.exec(e.replace(a$b,""));)t[4]?o.shift():t[3]?(r=t[3].replace(n$a," ").trim(),o.unshift(o[0][r]=o[0][r]||{})):o[0][t[1]]=t[2].replace(n$a," ").trim();return o[0]})(e);c$a[d]=o$8(p?{["@keyframes "+d]:t}:t,r?"":"."+d);}let f=r&&c$a.g?c$a.g:null;return r&&(c$a.g=c$a[d]),((e,t,r,l)=>{l?t.data=t.data.replace(l,e):-1===t.data.indexOf(e)&&(t.data=r?e+t.data:t.data+e);})(c$a[d],t,i,f),d},p$c=(e,t,r)=>e.reduce((e,l,a)=>{let n=t[a];if(n&&n.call){let e=n(r),t=e&&e.props&&e.props.className||/^go/.test(e)&&e;n=t?"."+t:e&&"object"==typeof e?e.props?"":o$8(e,""):!1===e?"":e;}return e+l+(null==n?"":n)},"");function u$d(e){let r=this||{},l=e.call?e(r.p):e;return i$8(l.unshift?l.raw?p$c(l,[].slice.call(arguments,1),r.p):l.reduce((e,t)=>Object.assign(e,t&&t.call?t(r.p):t),{}):l,t$c(r.target),r.g,r.o,r.k)}let d$b,f$a,g$4;u$d.bind({g:1});let h$a=u$d.bind({k:1});function m$6(e,t,r,l){o$8.p=t,d$b=e,f$a=r,g$4=l;}function j$3(e,t){let r=this||{};return function(){let l=arguments;function a(n,o){let c=Object.assign({},n),s=c.className||a.className;r.p=Object.assign({theme:f$a&&f$a()},c),r.o=/ *go\d+/.test(s),c.className=u$d.apply(r,l)+(s?" "+s:"");let i=e;return e[0]&&(i=c.as||e,delete c.as),g$4&&i[0]&&g$4(c),d$b(i,c)}return a}}

	var W$4=e=>typeof e=="function",T$7=(e,t)=>W$4(e)?e(t):e;var U$5=(()=>{let e=0;return ()=>(++e).toString()})(),b$3=(()=>{let e;return ()=>{if(e===void 0&&typeof window<"u"){let t=matchMedia("(prefers-reduced-motion: reduce)");e=!t||t.matches;}return e}})();var Q$5=20;var S$b=new Map,X$7=1e3,$$b=e=>{if(S$b.has(e))return;let t=setTimeout(()=>{S$b.delete(e),u$c({type:4,toastId:e});},X$7);S$b.set(e,t);},J$3=e=>{let t=S$b.get(e);t&&clearTimeout(t);},v$8=(e,t)=>{switch(t.type){case 0:return {...e,toasts:[t.toast,...e.toasts].slice(0,Q$5)};case 1:return t.toast.id&&J$3(t.toast.id),{...e,toasts:e.toasts.map(r=>r.id===t.toast.id?{...r,...t.toast}:r)};case 2:let{toast:o}=t;return e.toasts.find(r=>r.id===o.id)?v$8(e,{type:1,toast:o}):v$8(e,{type:0,toast:o});case 3:let{toastId:s}=t;return s?$$b(s):e.toasts.forEach(r=>{$$b(r.id);}),{...e,toasts:e.toasts.map(r=>r.id===s||s===void 0?{...r,visible:!1}:r)};case 4:return t.toastId===void 0?{...e,toasts:[]}:{...e,toasts:e.toasts.filter(r=>r.id!==t.toastId)};case 5:return {...e,pausedAt:t.time};case 6:let a=t.time-(e.pausedAt||0);return {...e,pausedAt:void 0,toasts:e.toasts.map(r=>({...r,pauseDuration:r.pauseDuration+a}))}}},A$6=[],P$5={toasts:[],pausedAt:void 0},u$c=e=>{P$5=v$8(P$5,e),A$6.forEach(t=>{t(P$5);});},Y$6={blank:4e3,error:4e3,success:2e3,loading:1/0,custom:4e3},I$7=(e={})=>{let[t,o]=reactExports.useState(P$5);reactExports.useEffect(()=>(A$6.push(o),()=>{let a=A$6.indexOf(o);a>-1&&A$6.splice(a,1);}),[t]);let s=t.toasts.map(a=>{var r,c;return {...e,...e[a.type],...a,duration:a.duration||((r=e[a.type])==null?void 0:r.duration)||(e==null?void 0:e.duration)||Y$6[a.type],style:{...e.style,...(c=e[a.type])==null?void 0:c.style,...a.style}}});return {...t,toasts:s}};var G$3=(e,t="blank",o)=>({createdAt:Date.now(),visible:!0,type:t,ariaProps:{role:"status","aria-live":"polite"},message:e,pauseDuration:0,...o,id:(o==null?void 0:o.id)||U$5()}),h$9=e=>(t,o)=>{let s=G$3(t,e,o);return u$c({type:2,toast:s}),s.id},n$9=(e,t)=>h$9("blank")(e,t);n$9.error=h$9("error");n$9.success=h$9("success");n$9.loading=h$9("loading");n$9.custom=h$9("custom");n$9.dismiss=e=>{u$c({type:3,toastId:e});};n$9.remove=e=>u$c({type:4,toastId:e});n$9.promise=(e,t,o)=>{let s=n$9.loading(t.loading,{...o,...o==null?void 0:o.loading});return e.then(a=>(n$9.success(T$7(t.success,a),{id:s,...o,...o==null?void 0:o.success}),a)).catch(a=>{n$9.error(T$7(t.error,a),{id:s,...o,...o==null?void 0:o.error});}),e};var Z$7=(e,t)=>{u$c({type:1,toast:{id:e,height:t}});},ee$3=()=>{u$c({type:5,time:Date.now()});},D$7=e=>{let{toasts:t,pausedAt:o}=I$7(e);reactExports.useEffect(()=>{if(o)return;let r=Date.now(),c=t.map(i=>{if(i.duration===1/0)return;let d=(i.duration||0)+i.pauseDuration-(r-i.createdAt);if(d<0){i.visible&&n$9.dismiss(i.id);return}return setTimeout(()=>n$9.dismiss(i.id),d)});return ()=>{c.forEach(i=>i&&clearTimeout(i));}},[t,o]);let s=reactExports.useCallback(()=>{o&&u$c({type:6,time:Date.now()});},[o]),a=reactExports.useCallback((r,c)=>{let{reverseOrder:i=!1,gutter:d=8,defaultPosition:p}=c||{},g=t.filter(m=>(m.position||p)===(r.position||p)&&m.height),E=g.findIndex(m=>m.id===r.id),x=g.filter((m,R)=>R<E&&m.visible).length;return g.filter(m=>m.visible).slice(...i?[x+1]:[0,x]).reduce((m,R)=>m+(R.height||0)+d,0)},[t]);return {toasts:t,handlers:{updateHeight:Z$7,startPause:ee$3,endPause:s,calculateOffset:a}}};var oe$2=h$a`
from {
  transform: scale(0) rotate(45deg);
	opacity: 0;
}
to {
 transform: scale(1) rotate(45deg);
  opacity: 1;
}`,re$4=h$a`
from {
  transform: scale(0);
  opacity: 0;
}
to {
  transform: scale(1);
  opacity: 1;
}`,se$3=h$a`
from {
  transform: scale(0) rotate(90deg);
	opacity: 0;
}
to {
  transform: scale(1) rotate(90deg);
	opacity: 1;
}`,_$4=j$3("div")`
  width: 20px;
  opacity: 0;
  height: 20px;
  border-radius: 10px;
  background: ${e=>e.primary||"#ff4b4b"};
  position: relative;
  transform: rotate(45deg);

  animation: ${oe$2} 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275)
    forwards;
  animation-delay: 100ms;

  &:after,
  &:before {
    content: '';
    animation: ${re$4} 0.15s ease-out forwards;
    animation-delay: 150ms;
    position: absolute;
    border-radius: 3px;
    opacity: 0;
    background: ${e=>e.secondary||"#fff"};
    bottom: 9px;
    left: 4px;
    height: 2px;
    width: 12px;
  }

  &:before {
    animation: ${se$3} 0.15s ease-out forwards;
    animation-delay: 180ms;
    transform: rotate(90deg);
  }
`;var ne$4=h$a`
  from {
    transform: rotate(0deg);
  }
  to {
    transform: rotate(360deg);
  }
`,V$5=j$3("div")`
  width: 12px;
  height: 12px;
  box-sizing: border-box;
  border: 2px solid;
  border-radius: 100%;
  border-color: ${e=>e.secondary||"#e0e0e0"};
  border-right-color: ${e=>e.primary||"#616161"};
  animation: ${ne$4} 1s linear infinite;
`;var pe$3=h$a`
from {
  transform: scale(0) rotate(45deg);
	opacity: 0;
}
to {
  transform: scale(1) rotate(45deg);
	opacity: 1;
}`,de$3=h$a`
0% {
	height: 0;
	width: 0;
	opacity: 0;
}
40% {
  height: 0;
	width: 6px;
	opacity: 1;
}
100% {
  opacity: 1;
  height: 10px;
}`,w$8=j$3("div")`
  width: 20px;
  opacity: 0;
  height: 20px;
  border-radius: 10px;
  background: ${e=>e.primary||"#61d345"};
  position: relative;
  transform: rotate(45deg);

  animation: ${pe$3} 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275)
    forwards;
  animation-delay: 100ms;
  &:after {
    content: '';
    box-sizing: border-box;
    animation: ${de$3} 0.2s ease-out forwards;
    opacity: 0;
    animation-delay: 200ms;
    position: absolute;
    border-right: 2px solid;
    border-bottom: 2px solid;
    border-color: ${e=>e.secondary||"#fff"};
    bottom: 6px;
    left: 6px;
    height: 10px;
    width: 6px;
  }
`;var ue$3=j$3("div")`
  position: absolute;
`,le$3=j$3("div")`
  position: relative;
  display: flex;
  justify-content: center;
  align-items: center;
  min-width: 20px;
  min-height: 20px;
`,Te$3=h$a`
from {
  transform: scale(0.6);
  opacity: 0.4;
}
to {
  transform: scale(1);
  opacity: 1;
}`,fe$2=j$3("div")`
  position: relative;
  transform: scale(0.6);
  opacity: 0.4;
  min-width: 20px;
  animation: ${Te$3} 0.3s 0.12s cubic-bezier(0.175, 0.885, 0.32, 1.275)
    forwards;
`,M$a=({toast:e})=>{let{icon:t,type:o,iconTheme:s}=e;return t!==void 0?typeof t=="string"?reactExports.createElement(fe$2,null,t):t:o==="blank"?null:reactExports.createElement(le$3,null,reactExports.createElement(V$5,{...s}),o!=="loading"&&reactExports.createElement(ue$3,null,o==="error"?reactExports.createElement(_$4,{...s}):reactExports.createElement(w$8,{...s})))};var ye$4=e=>`
0% {transform: translate3d(0,${e*-200}%,0) scale(.6); opacity:.5;}
100% {transform: translate3d(0,0,0) scale(1); opacity:1;}
`,ge$3=e=>`
0% {transform: translate3d(0,0,-1px) scale(1); opacity:1;}
100% {transform: translate3d(0,${e*-150}%,-1px) scale(.6); opacity:0;}
`,he$6="0%{opacity:0;} 100%{opacity:1;}",xe$5="0%{opacity:1;} 100%{opacity:0;}",be$3=j$3("div")`
  display: flex;
  align-items: center;
  background: #fff;
  color: #363636;
  line-height: 1.3;
  will-change: transform;
  box-shadow: 0 3px 10px rgba(0, 0, 0, 0.1), 0 3px 3px rgba(0, 0, 0, 0.05);
  max-width: 350px;
  pointer-events: auto;
  padding: 8px 10px;
  border-radius: 8px;
`,Se$5=j$3("div")`
  display: flex;
  justify-content: center;
  margin: 4px 10px;
  color: inherit;
  flex: 1 1 auto;
  white-space: pre-line;
`,Ae$3=(e,t)=>{let s=e.includes("top")?1:-1,[a,r]=b$3()?[he$6,xe$5]:[ye$4(s),ge$3(s)];return {animation:t?`${h$a(a)} 0.35s cubic-bezier(.21,1.02,.73,1) forwards`:`${h$a(r)} 0.4s forwards cubic-bezier(.06,.71,.55,1)`}},F$8=reactExports.memo(({toast:e,position:t,style:o,children:s})=>{let a=e.height?Ae$3(e.position||t||"top-center",e.visible):{opacity:0},r=reactExports.createElement(M$a,{toast:e}),c=reactExports.createElement(Se$5,{...e.ariaProps},T$7(e.message,e));return reactExports.createElement(be$3,{className:e.className,style:{...a,...o,...e.style}},typeof s=="function"?s({icon:r,message:c}):reactExports.createElement(reactExports.Fragment,null,r,c))});m$6(reactExports.createElement);var Ee$4=({id:e,className:t,style:o,onHeightUpdate:s,children:a})=>{let r=reactExports.useCallback(c=>{if(c){let i=()=>{let d=c.getBoundingClientRect().height;s(e,d);};i(),new MutationObserver(i).observe(c,{subtree:!0,childList:!0,characterData:!0});}},[e,s]);return reactExports.createElement("div",{ref:r,className:t,style:o},a)},Re$5=(e,t)=>{let o=e.includes("top"),s=o?{top:0}:{bottom:0},a=e.includes("center")?{justifyContent:"center"}:e.includes("right")?{justifyContent:"flex-end"}:{};return {left:0,right:0,display:"flex",position:"absolute",transition:b$3()?void 0:"all 230ms cubic-bezier(.21,1.02,.73,1)",transform:`translateY(${t*(o?1:-1)}px)`,...s,...a}},ve$4=u$d`
  z-index: 9999;
  > * {
    pointer-events: auto;
  }
`,O$7=16,Ie$5=({reverseOrder:e,position:t="top-center",toastOptions:o,gutter:s,children:a,containerStyle:r,containerClassName:c})=>{let{toasts:i,handlers:d}=D$7(o);return reactExports.createElement("div",{style:{position:"fixed",zIndex:9999,top:O$7,left:O$7,right:O$7,bottom:O$7,pointerEvents:"none",...r},className:c,onMouseEnter:d.startPause,onMouseLeave:d.endPause},i.map(p=>{let g=p.position||t,E=d.calculateOffset(p,{reverseOrder:e,gutter:s,defaultPosition:t}),x=Re$5(g,E);return reactExports.createElement(Ee$4,{id:p.id,key:p.id,onHeightUpdate:d.updateHeight,className:p.visible?ve$4:"",style:x},p.type==="custom"?T$7(p.message,p):a?a(p):reactExports.createElement(F$8,{toast:p,position:g}))}))};var _t$1=n$9;

	function assertPath$2(path) {
	  if (typeof path !== 'string') {
	    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));
	  }
	}

	// Resolves . and .. elements in a path with directory names
	function normalizeStringPosix(path, allowAboveRoot) {
	  var res = '';
	  var lastSegmentLength = 0;
	  var lastSlash = -1;
	  var dots = 0;
	  var code;
	  for (var i = 0; i <= path.length; ++i) {
	    if (i < path.length)
	      code = path.charCodeAt(i);
	    else if (code === 47 /*/*/)
	      break;
	    else
	      code = 47 /*/*/;
	    if (code === 47 /*/*/) {
	      if (lastSlash === i - 1 || dots === 1) ; else if (lastSlash !== i - 1 && dots === 2) {
	        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {
	          if (res.length > 2) {
	            var lastSlashIndex = res.lastIndexOf('/');
	            if (lastSlashIndex !== res.length - 1) {
	              if (lastSlashIndex === -1) {
	                res = '';
	                lastSegmentLength = 0;
	              } else {
	                res = res.slice(0, lastSlashIndex);
	                lastSegmentLength = res.length - 1 - res.lastIndexOf('/');
	              }
	              lastSlash = i;
	              dots = 0;
	              continue;
	            }
	          } else if (res.length === 2 || res.length === 1) {
	            res = '';
	            lastSegmentLength = 0;
	            lastSlash = i;
	            dots = 0;
	            continue;
	          }
	        }
	        if (allowAboveRoot) {
	          if (res.length > 0)
	            res += '/..';
	          else
	            res = '..';
	          lastSegmentLength = 2;
	        }
	      } else {
	        if (res.length > 0)
	          res += '/' + path.slice(lastSlash + 1, i);
	        else
	          res = path.slice(lastSlash + 1, i);
	        lastSegmentLength = i - lastSlash - 1;
	      }
	      lastSlash = i;
	      dots = 0;
	    } else if (code === 46 /*.*/ && dots !== -1) {
	      ++dots;
	    } else {
	      dots = -1;
	    }
	  }
	  return res;
	}

	function _format(sep, pathObject) {
	  var dir = pathObject.dir || pathObject.root;
	  var base = pathObject.base || (pathObject.name || '') + (pathObject.ext || '');
	  if (!dir) {
	    return base;
	  }
	  if (dir === pathObject.root) {
	    return dir + base;
	  }
	  return dir + sep + base;
	}

	var posix = {
	  // path.resolve([from ...], to)
	  resolve: function resolve() {
	    var resolvedPath = '';
	    var resolvedAbsolute = false;
	    var cwd;

	    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
	      var path;
	      if (i >= 0)
	        path = arguments[i];
	      else {
	        if (cwd === undefined)
	          cwd = process.cwd();
	        path = cwd;
	      }

	      assertPath$2(path);

	      // Skip empty entries
	      if (path.length === 0) {
	        continue;
	      }

	      resolvedPath = path + '/' + resolvedPath;
	      resolvedAbsolute = path.charCodeAt(0) === 47 /*/*/;
	    }

	    // At this point the path should be resolved to a full absolute path, but
	    // handle relative paths to be safe (might happen when process.cwd() fails)

	    // Normalize the path
	    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);

	    if (resolvedAbsolute) {
	      if (resolvedPath.length > 0)
	        return '/' + resolvedPath;
	      else
	        return '/';
	    } else if (resolvedPath.length > 0) {
	      return resolvedPath;
	    } else {
	      return '.';
	    }
	  },

	  normalize: function normalize(path) {
	    assertPath$2(path);

	    if (path.length === 0) return '.';

	    var isAbsolute = path.charCodeAt(0) === 47 /*/*/;
	    var trailingSeparator = path.charCodeAt(path.length - 1) === 47 /*/*/;

	    // Normalize the path
	    path = normalizeStringPosix(path, !isAbsolute);

	    if (path.length === 0 && !isAbsolute) path = '.';
	    if (path.length > 0 && trailingSeparator) path += '/';

	    if (isAbsolute) return '/' + path;
	    return path;
	  },

	  isAbsolute: function isAbsolute(path) {
	    assertPath$2(path);
	    return path.length > 0 && path.charCodeAt(0) === 47 /*/*/;
	  },

	  join: function join() {
	    if (arguments.length === 0)
	      return '.';
	    var joined;
	    for (var i = 0; i < arguments.length; ++i) {
	      var arg = arguments[i];
	      assertPath$2(arg);
	      if (arg.length > 0) {
	        if (joined === undefined)
	          joined = arg;
	        else
	          joined += '/' + arg;
	      }
	    }
	    if (joined === undefined)
	      return '.';
	    return posix.normalize(joined);
	  },

	  relative: function relative(from, to) {
	    assertPath$2(from);
	    assertPath$2(to);

	    if (from === to) return '';

	    from = posix.resolve(from);
	    to = posix.resolve(to);

	    if (from === to) return '';

	    // Trim any leading backslashes
	    var fromStart = 1;
	    for (; fromStart < from.length; ++fromStart) {
	      if (from.charCodeAt(fromStart) !== 47 /*/*/)
	        break;
	    }
	    var fromEnd = from.length;
	    var fromLen = fromEnd - fromStart;

	    // Trim any leading backslashes
	    var toStart = 1;
	    for (; toStart < to.length; ++toStart) {
	      if (to.charCodeAt(toStart) !== 47 /*/*/)
	        break;
	    }
	    var toEnd = to.length;
	    var toLen = toEnd - toStart;

	    // Compare paths to find the longest common path from root
	    var length = fromLen < toLen ? fromLen : toLen;
	    var lastCommonSep = -1;
	    var i = 0;
	    for (; i <= length; ++i) {
	      if (i === length) {
	        if (toLen > length) {
	          if (to.charCodeAt(toStart + i) === 47 /*/*/) {
	            // We get here if `from` is the exact base path for `to`.
	            // For example: from='/foo/bar'; to='/foo/bar/baz'
	            return to.slice(toStart + i + 1);
	          } else if (i === 0) {
	            // We get here if `from` is the root
	            // For example: from='/'; to='/foo'
	            return to.slice(toStart + i);
	          }
	        } else if (fromLen > length) {
	          if (from.charCodeAt(fromStart + i) === 47 /*/*/) {
	            // We get here if `to` is the exact base path for `from`.
	            // For example: from='/foo/bar/baz'; to='/foo/bar'
	            lastCommonSep = i;
	          } else if (i === 0) {
	            // We get here if `to` is the root.
	            // For example: from='/foo'; to='/'
	            lastCommonSep = 0;
	          }
	        }
	        break;
	      }
	      var fromCode = from.charCodeAt(fromStart + i);
	      var toCode = to.charCodeAt(toStart + i);
	      if (fromCode !== toCode)
	        break;
	      else if (fromCode === 47 /*/*/)
	        lastCommonSep = i;
	    }

	    var out = '';
	    // Generate the relative path based on the path difference between `to`
	    // and `from`
	    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
	      if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {
	        if (out.length === 0)
	          out += '..';
	        else
	          out += '/..';
	      }
	    }

	    // Lastly, append the rest of the destination (`to`) path that comes after
	    // the common path parts
	    if (out.length > 0)
	      return out + to.slice(toStart + lastCommonSep);
	    else {
	      toStart += lastCommonSep;
	      if (to.charCodeAt(toStart) === 47 /*/*/)
	        ++toStart;
	      return to.slice(toStart);
	    }
	  },

	  _makeLong: function _makeLong(path) {
	    return path;
	  },

	  dirname: function dirname(path) {
	    assertPath$2(path);
	    if (path.length === 0) return '.';
	    var code = path.charCodeAt(0);
	    var hasRoot = code === 47 /*/*/;
	    var end = -1;
	    var matchedSlash = true;
	    for (var i = path.length - 1; i >= 1; --i) {
	      code = path.charCodeAt(i);
	      if (code === 47 /*/*/) {
	          if (!matchedSlash) {
	            end = i;
	            break;
	          }
	        } else {
	        // We saw the first non-path separator
	        matchedSlash = false;
	      }
	    }

	    if (end === -1) return hasRoot ? '/' : '.';
	    if (hasRoot && end === 1) return '//';
	    return path.slice(0, end);
	  },

	  basename: function basename(path, ext) {
	    if (ext !== undefined && typeof ext !== 'string') throw new TypeError('"ext" argument must be a string');
	    assertPath$2(path);

	    var start = 0;
	    var end = -1;
	    var matchedSlash = true;
	    var i;

	    if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
	      if (ext.length === path.length && ext === path) return '';
	      var extIdx = ext.length - 1;
	      var firstNonSlashEnd = -1;
	      for (i = path.length - 1; i >= 0; --i) {
	        var code = path.charCodeAt(i);
	        if (code === 47 /*/*/) {
	            // If we reached a path separator that was not part of a set of path
	            // separators at the end of the string, stop now
	            if (!matchedSlash) {
	              start = i + 1;
	              break;
	            }
	          } else {
	          if (firstNonSlashEnd === -1) {
	            // We saw the first non-path separator, remember this index in case
	            // we need it if the extension ends up not matching
	            matchedSlash = false;
	            firstNonSlashEnd = i + 1;
	          }
	          if (extIdx >= 0) {
	            // Try to match the explicit extension
	            if (code === ext.charCodeAt(extIdx)) {
	              if (--extIdx === -1) {
	                // We matched the extension, so mark this as the end of our path
	                // component
	                end = i;
	              }
	            } else {
	              // Extension does not match, so our result is the entire path
	              // component
	              extIdx = -1;
	              end = firstNonSlashEnd;
	            }
	          }
	        }
	      }

	      if (start === end) end = firstNonSlashEnd;else if (end === -1) end = path.length;
	      return path.slice(start, end);
	    } else {
	      for (i = path.length - 1; i >= 0; --i) {
	        if (path.charCodeAt(i) === 47 /*/*/) {
	            // If we reached a path separator that was not part of a set of path
	            // separators at the end of the string, stop now
	            if (!matchedSlash) {
	              start = i + 1;
	              break;
	            }
	          } else if (end === -1) {
	          // We saw the first non-path separator, mark this as the end of our
	          // path component
	          matchedSlash = false;
	          end = i + 1;
	        }
	      }

	      if (end === -1) return '';
	      return path.slice(start, end);
	    }
	  },

	  extname: function extname(path) {
	    assertPath$2(path);
	    var startDot = -1;
	    var startPart = 0;
	    var end = -1;
	    var matchedSlash = true;
	    // Track the state of characters (if any) we see before our first dot and
	    // after any path separator we find
	    var preDotState = 0;
	    for (var i = path.length - 1; i >= 0; --i) {
	      var code = path.charCodeAt(i);
	      if (code === 47 /*/*/) {
	          // If we reached a path separator that was not part of a set of path
	          // separators at the end of the string, stop now
	          if (!matchedSlash) {
	            startPart = i + 1;
	            break;
	          }
	          continue;
	        }
	      if (end === -1) {
	        // We saw the first non-path separator, mark this as the end of our
	        // extension
	        matchedSlash = false;
	        end = i + 1;
	      }
	      if (code === 46 /*.*/) {
	          // If this is our first dot, mark it as the start of our extension
	          if (startDot === -1)
	            startDot = i;
	          else if (preDotState !== 1)
	            preDotState = 1;
	      } else if (startDot !== -1) {
	        // We saw a non-dot and non-path separator before our dot, so we should
	        // have a good chance at having a non-empty extension
	        preDotState = -1;
	      }
	    }

	    if (startDot === -1 || end === -1 ||
	        // We saw a non-dot character immediately before the dot
	        preDotState === 0 ||
	        // The (right-most) trimmed path component is exactly '..'
	        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
	      return '';
	    }
	    return path.slice(startDot, end);
	  },

	  format: function format(pathObject) {
	    if (pathObject === null || typeof pathObject !== 'object') {
	      throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
	    }
	    return _format('/', pathObject);
	  },

	  parse: function parse(path) {
	    assertPath$2(path);

	    var ret = { root: '', dir: '', base: '', ext: '', name: '' };
	    if (path.length === 0) return ret;
	    var code = path.charCodeAt(0);
	    var isAbsolute = code === 47 /*/*/;
	    var start;
	    if (isAbsolute) {
	      ret.root = '/';
	      start = 1;
	    } else {
	      start = 0;
	    }
	    var startDot = -1;
	    var startPart = 0;
	    var end = -1;
	    var matchedSlash = true;
	    var i = path.length - 1;

	    // Track the state of characters (if any) we see before our first dot and
	    // after any path separator we find
	    var preDotState = 0;

	    // Get non-dir info
	    for (; i >= start; --i) {
	      code = path.charCodeAt(i);
	      if (code === 47 /*/*/) {
	          // If we reached a path separator that was not part of a set of path
	          // separators at the end of the string, stop now
	          if (!matchedSlash) {
	            startPart = i + 1;
	            break;
	          }
	          continue;
	        }
	      if (end === -1) {
	        // We saw the first non-path separator, mark this as the end of our
	        // extension
	        matchedSlash = false;
	        end = i + 1;
	      }
	      if (code === 46 /*.*/) {
	          // If this is our first dot, mark it as the start of our extension
	          if (startDot === -1) startDot = i;else if (preDotState !== 1) preDotState = 1;
	        } else if (startDot !== -1) {
	        // We saw a non-dot and non-path separator before our dot, so we should
	        // have a good chance at having a non-empty extension
	        preDotState = -1;
	      }
	    }

	    if (startDot === -1 || end === -1 ||
	    // We saw a non-dot character immediately before the dot
	    preDotState === 0 ||
	    // The (right-most) trimmed path component is exactly '..'
	    preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
	      if (end !== -1) {
	        if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);else ret.base = ret.name = path.slice(startPart, end);
	      }
	    } else {
	      if (startPart === 0 && isAbsolute) {
	        ret.name = path.slice(1, startDot);
	        ret.base = path.slice(1, end);
	      } else {
	        ret.name = path.slice(startPart, startDot);
	        ret.base = path.slice(startPart, end);
	      }
	      ret.ext = path.slice(startDot, end);
	    }

	    if (startPart > 0) ret.dir = path.slice(0, startPart - 1);else if (isAbsolute) ret.dir = '/';

	    return ret;
	  },

	  sep: '/',
	  delimiter: ':',
	  win32: null,
	  posix: null
	};

	posix.posix = posix;

	var pathBrowserify = posix;

	var path$3 = /*@__PURE__*/getDefaultExportFromCjs(pathBrowserify);

	// copied/modified from emoji.ts, we can't use that directly because Loading can
	// be used before the home env is available so using emoji directly crashes the
	// app.
	function importAll$1(
	    r
	) {
	    return r.keys().map((key) => {
	        const name = path$3.basename(key, path$3.extname(key));
	        return {
	            baseUrl: r(key),
	            name,
	        };
	    });
	}

	const customEmoji$1 =
	    // require.context is webpack runtime specific and thus not available under jest
	    typeof process !== "undefined" && process.env?.RUN_MODE === "test"
	        ? []
	        : importAll$1(
	              require.context("../../images/emoji", false, /\.(png|jpe?g|svg)$/)
	          );

	const cohostPlusCustomEmoji$1 =
	    // require.context is webpack runtime specific and thus not available under jest
	    typeof process !== "undefined" && process.env?.RUN_MODE === "test"
	        ? []
	        : importAll$1(
	              require.context(
	                  "../../images/plus-emoji",
	                  false,
	                  /\.(png|jpe?g|svg)$/
	              )
	          );

	const eggbugEmojiOnly = [...customEmoji$1, ...cohostPlusCustomEmoji$1].filter(
	    (emoji) => emoji.name.includes("eggbug") && emoji.name !== "eggbug-classic"
	);

	const Loading = ({
	    className,
	}) => {
	    return (
	        React$2.createElement('div', {
	            className: `flex flex-row items-center gap-2 motion-safe:animate-bounce motion-reduce:animate-pulse ${
                className ?? ""
            }`,}

	            , React$2.createElement(LoadingIcon, null ), "loading..."

	        )
	    );
	};

	const LoadingIcon = () => {
	    const loadingEmoji = _$5.sample(eggbugEmojiOnly)?.baseUrl;
	    return loadingEmoji ? (
	        React$2.createElement('img', {
	            className: "inline-block h-6 flex-none"  ,
	            src: sitemap.public.static
	                .staticAsset({ path: loadingEmoji })
	                .toString(),
	            alt: "",}
	        )
	    ) : null;
	};

	const toastClasses = (type) => {
	    const baseClassName =
	        "cohost-shadow-light dark:cohost-shadow-dark rounded-lg px-3 py-2 font-bold";
	    switch (type) {
	        case "success":
	            return `!bg-green-200 !text-green-800 ${baseClassName}`;
	        case "error":
	            return `!bg-red-200 !text-red-800 ${baseClassName}`;
	        default:
	            return `!bg-mango-200 !text-mango-800 ${baseClassName}`;
	    }
	};

	const CohostToaster = () => {
	    return (
	        React$2.createElement(Ie$5, {
	            position: "bottom-center",
	            toastOptions: {
	                success: {
	                    className: toastClasses("success"),
	                    icon: (
	                        React$2.createElement(ForwardRef$17, { className: "h-6 flex-none text-green-800"  ,} )
	                    ),
	                },
	                error: {
	                    className: toastClasses("error"),
	                    icon: (
	                        React$2.createElement(ForwardRef$P, { className: "h-6 flex-none text-red-800"  ,} )
	                    ),
	                },
	                loading: {
	                    className: toastClasses("loading"),
	                    icon: React$2.createElement(LoadingIcon, null ),
	                },
	                icon: (
	                    React$2.createElement(ForwardRef$V, { className: "h-6 flex-none text-mango-800"  ,} )
	                ),
	            },}
	        )
	    );
	};

	const coverUrl = (width) => {
	    const base = new URL(
	        "https://staging.cohostcdn.org/site-assets/login-graphic.png?auto=webp"
	    );

	    base.searchParams.set("width", width.toString());
	    return base.toString();
	};

	const AuthnLayout = ({ children }) => {
	    return (
	        React$2.createElement('div', { className: "flex flex-col" ,}
	            , React$2.createElement(CohostToaster, null )
	            , React$2.createElement(Favicons, null )
	            , React$2.createElement(Helmet, { defaultTitle: "cohost!", titleTemplate: "cohost! - %s"  ,}
	                /* don't use shared themes, this page is always default */
	                , React$2.createElement('meta', { name: "theme-color", content: "rgb(25 25 25)"  ,} )
	                , React$2.createElement('style', null, `
                    /*
                     * colors specified as bare RGB components so they can get
                     * merged with opacity if needed. see \`tailwind.config.js\`
                     * for more info. */

                    :root {
                        --color-text: 255 249 242;
                        
                        --color-foreground-200: ${varForTailwindColor(
                            "cherry",
                            "200"
                        )};
                        --color-foreground-300: ${varForTailwindColor(
                            "cherry",
                            "300"
                        )};
                        --color-foreground-400: ${varForTailwindColor(
                            "cherry",
                            "400"
                        )};
                        --color-foreground-600: ${varForTailwindColor(
                            "cherry",
                            "600"
                        )};    
                        --color-foreground-700: ${varForTailwindColor(
                            "cherry",
                            "700"
                        )};
                        --color-foreground: ${varForTailwindColor("cherry")};
                        
                        --color-accent: 255 171 92;    
                        --color-background: 25 25 25;
                    }
                `)
	            )
	            , React$2.createElement(Flashes, { className: "cohost-shadow-light absolute left-0 right-0 top-20 z-10 mx-auto max-w-prose"       ,} )
	            , React$2.createElement('div', { className: "grid w-full flex-grow grid-cols-1 lg:grid-cols-2"    ,}
	                , React$2.createElement('div', { className: "hidden h-full lg:block"  ,}
	                    /*
	                        login graphic is only visible at breakpoint lg
	                        (1024px and above). it's half width so our lowest real
	                        size is 512px. we include a 1px fallback so mobile users
	                        don't need to download the whole dang thing.
	                    */
	                    , React$2.createElement('img', {
	                        className: "h-full w-full max-w-full origin-center object-cover"    ,
	                        sizes: " (min-width: 512px) 50vw, 1px "


	                        ,
	                        srcSet: `
                            ${coverUrl(1)} 1w,
                            ${coverUrl(512)} 512w,
                            ${coverUrl(640)} 640w,
                            ${coverUrl(768)} 768w,
                            ${coverUrl(1024)} 1024w,
                            ${coverUrl(1280)} 1280w,
                            ${coverUrl(1536)} 1536w,
                        `,
	                        alt: "",}
	                    )
	                )
	                , React$2.createElement('div', {
	                    className: `flex w-full flex-col justify-center gap-6
                    bg-notBlack px-12 py-8
                    lg:max-w-lg lg:px-24`,}

	                    , children
	                )
	            )
	        )
	    );
	};

	const FeatureFlag = mod.enum([
	    // tumblr theme
	    "chaos-day-2022",
	    // Numbers
	    "chaos-day-2023",
	    "disable-account-signup",
	    "notifications-trpc",
	    "attachment-composer-v2",

	    // artist alley
	    "artist-alley-listings",

	    // user-facing UI for submitting tag relation requests
	    "tag-relation-request-ui",
	]);

	const CohostEgg = (
	    props
	) => (
	    React$2.createElement('svg', {
	        viewBox: "0 0 416 300"   ,
	        fill: "none",
	        xmlns: "http://www.w3.org/2000/svg",
	        ...props,}

	        , React$2.createElement('path', {
	            fillRule: "evenodd",
	            clipRule: "evenodd",
	            d: "M335.13 249.687c-26.067 15.965-56.123 28.509-90.166 37.631-37.809 10.131-73.445 14.192-106.908 12.183-33.463-2.008-61.9733-10.738-85.5305-26.188-23.5573-15.45-39.4399-38.491-47.64762-69.123-8.2548-30.807-6.03245-58.746 6.66702-83.818 12.6995-25.0714 33.0606-46.755 61.0832-65.0511 28.0229-18.296 60.9379-32.5095 98.7469-42.6402C209.008 2.59678 244.501-1.47294 277.854.471489 300.262 1.778 320.475 6.10779 338.49 13.4609c8.799 3.591 17.073 7.9031 24.824 12.9363 23.621 15.3393 39.536 38.325 47.744 68.957 8.208 30.6318 5.93 58.5388-6.834 83.7218-1.783 3.518-3.714 6.97-5.793 10.358-1.468-6.614-4.418-12.382-8.849-17.302-2.175-2.415-4.593-4.634-7.255-6.655-5.451-4.138-11.924-7.448-19.418-9.932-11.153-3.697-23.582-5.545-37.285-5.545-13.766 0-26.242 1.832-37.428 5.497-11.185 3.665-20.076 9.178-26.673 16.539-6.597 7.362-9.895 16.651-9.895 27.868 0 11.154 3.298 20.427 9.895 27.821 6.597 7.393 15.488 12.954 26.673 16.682 11.186 3.729 23.662 5.593 37.428 5.593 3.24 0 6.408-.104 9.506-.313Zm-119.254-19.859c-2.613 2.804-7.218 5.784-13.814 8.939-6.597 3.155-14.548 5.816-23.853 7.982-9.305 2.167-19.311 3.251-30.019 3.251-9.369 0-18.547-.908-27.533-2.725-8.987-1.816-17.113-4.7-24.379-8.652-7.2658-3.951-13.0497-9.114-17.3519-15.487-4.302-6.374-6.4531-14.118-6.4531-23.232 0-9.241 2.1511-17.049 6.4531-23.422 4.3022-6.374 10.0861-11.504 17.3519-15.392 7.266-3.888 15.392-6.708 24.379-8.461 8.986-1.753 18.164-2.629 27.533-2.629 10.771 0 20.714.956 29.828 2.868s16.937 4.414 23.47 7.505c6.533 3.091 11.265 6.389 14.197 9.895l-24.474 16.061c-3.569-3.888-8.987-6.995-16.252-9.321-7.266-2.327-16.093-3.49-26.482-3.49-5.099 0-10.246.399-15.44 1.195-5.194.797-9.958 2.151-14.292 4.063s-7.824 4.589-10.469 8.031c-2.645 3.442-3.967 7.807-3.967 13.097 0 5.227 1.322 9.545 3.967 12.954 2.645 3.41 6.135 6.119 10.469 8.127 4.334 2.007 9.098 3.425 14.292 4.254 5.194.829 10.341 1.243 15.44 1.243 10.197 0 19.041-1.275 26.529-3.824 7.489-2.55 12.763-5.482 15.823-8.796l25.047 15.966Zm109.748-3.729c13.321 0 23.646-2.39 30.976-7.17 7.329-4.78 10.994-11.121 10.994-19.025 0-8.094-3.681-14.451-11.042-19.072-7.362-4.621-17.671-6.931-30.928-6.931-13.32 0-23.693 2.31-31.118 6.931-7.425 4.621-11.138 10.978-11.138 19.072 0 8.031 3.713 14.404 11.138 19.121 7.425 4.716 17.798 7.074 31.118 7.074Z"                                                                                                                                                                              ,
	            fill: "currentColor",}
	        )
	    )
	);

	const CohostLogo = (
	    props
	) => (
	    React$2.createElement('svg', {
	        ...props,
	        viewBox: "0 0 506 128"   ,
	        fill: "none",
	        xmlns: "http://www.w3.org/2000/svg",
	        'aria-label': "cohost",}

	        , React$2.createElement('path', {
	            fillRule: "evenodd",
	            clipRule: "evenodd",
	            d: "M142.814 106.403C131.705 113.206 118.897 118.552 104.39 122.439C88.2779 126.756 73.0919 128.487 58.8317 127.631C44.5716 126.775 32.4222 123.055 22.3834 116.471C12.3446 109.887 5.57634 100.068 2.07868 87.0142C-1.43905 73.886 -0.492012 61.9799 4.9198 51.2958C10.3316 40.6118 19.0083 31.3714 30.95 23.5747C42.8917 15.7779 56.9185 9.72092 73.0304 5.40379C89.0677 1.1066 104.193 -0.627685 118.406 0.200922C127.955 0.757684 136.568 2.6028 144.246 5.73626C147.995 7.26657 151.521 9.10414 154.824 11.249C164.89 17.7858 171.672 27.581 175.17 40.6346C178.667 53.6882 177.697 65.5807 172.258 76.312C171.498 77.8112 170.675 79.2823 169.789 80.7261C169.163 77.9074 167.906 75.4497 166.018 73.353C165.091 72.3236 164.061 71.3784 162.926 70.5172C160.603 68.7538 157.845 67.3429 154.652 66.2845C149.898 64.7092 144.602 63.9216 138.763 63.9216C132.896 63.9216 127.58 64.7024 122.813 66.2641C118.046 67.8259 114.257 70.1752 111.446 73.3122C108.635 76.4492 107.23 80.4078 107.23 85.188C107.23 89.9411 108.635 93.8928 111.446 97.0434C114.257 100.194 118.046 102.564 122.813 104.153C127.58 105.741 132.896 106.536 138.763 106.536C140.143 106.536 141.493 106.492 142.814 106.403ZM91.9944 97.9397C90.8808 99.1348 88.9185 100.404 86.1074 101.749C83.2963 103.093 79.9081 104.227 75.9427 105.151C71.9773 106.074 67.7132 106.536 63.1502 106.536C59.1577 106.536 55.2466 106.149 51.417 105.375C47.5875 104.601 44.1245 103.372 41.0283 101.688C37.932 100.004 35.4672 97.8039 33.6339 95.0879C31.8006 92.3719 30.8839 89.0719 30.8839 85.188C30.8839 81.2498 31.8006 77.9227 33.6339 75.2066C35.4672 72.4906 37.932 70.3042 41.0283 68.6475C44.1245 66.9907 47.5875 65.7888 51.417 65.0419C55.2466 64.295 59.1577 63.9216 63.1502 63.9216C67.7403 63.9216 71.9773 64.329 75.8612 65.1438C79.7451 65.9586 83.079 67.0246 85.8629 68.3419C88.6469 69.6592 90.6635 71.0647 91.9129 72.5585L81.4834 79.4028C79.9624 77.7461 77.6538 76.4221 74.5575 75.4307C71.4613 74.4394 67.6996 73.9437 63.2725 73.9437C61.0997 73.9437 58.9065 74.1135 56.6929 74.4529C54.4793 74.7925 52.4491 75.3696 50.6022 76.1844C48.7554 76.9992 47.2683 78.1399 46.1412 79.6066C45.014 81.0732 44.4504 82.9337 44.4504 85.188C44.4504 87.4151 45.014 89.2553 46.1412 90.7083C47.2683 92.1614 48.7554 93.3157 50.6022 94.1712C52.4491 95.0268 54.4793 95.6311 56.6929 95.9842C58.9065 96.3373 61.0997 96.5138 63.2725 96.5138C67.6181 96.5138 71.3866 95.9706 74.5779 94.8842C77.7692 93.7978 80.0167 92.5484 81.3204 91.1361L91.9944 97.9397ZM138.763 96.3508C144.439 96.3508 148.839 95.3323 151.963 93.2953C155.086 91.2583 156.648 88.5559 156.648 85.188C156.648 81.7386 155.079 79.0294 151.942 77.0603C148.805 75.0912 144.412 74.1066 138.763 74.1066C133.086 74.1066 128.666 75.0912 125.502 77.0603C122.338 79.0294 120.756 81.7386 120.756 85.188C120.756 88.6102 122.338 91.3262 125.502 93.3361C128.666 95.3459 133.086 96.3508 138.763 96.3508Z"                                                                                                                                                                                                                                                                                                       ,
	            fill: "currentColor",}
	        )
	        , React$2.createElement('path', {
	            d: "M194.473 106.424V42.5023H207.737V72.5055C210.187 70.215 213.403 68.4904 217.385 67.3319C221.366 66.1733 225.888 65.594 230.948 65.594C238.592 65.594 244.285 67.2054 248.027 70.4281C251.769 73.6508 253.64 78.871 253.64 86.0889V106.424H240.297V87.2474C240.297 84.078 239.824 81.6543 238.878 79.9764C237.933 78.2984 236.415 77.1465 234.324 76.5206C232.233 75.8947 229.457 75.5818 225.994 75.5818C222.984 75.5818 220.135 75.9413 217.445 76.6604C214.755 77.3796 212.524 78.4183 210.753 79.7766C208.982 81.135 207.976 82.7596 207.737 84.6506V106.424H194.473V106.424Z"                                                   ,
	            fill: "currentColor",}
	        )
	        , React$2.createElement('path', {
	            d: "M394.498 106.615C387.518 106.615 381.312 106.167 375.88 105.27C370.448 104.374 366.36 103.22 363.617 101.808L373.313 93.9039C374.943 94.8273 377.707 95.649 381.604 96.3687C385.502 97.0884 389.895 97.4484 394.784 97.4484C400.352 97.4484 404.69 97.0816 407.8 96.3483C410.91 95.615 412.465 94.6101 412.465 93.3335C412.465 92.573 411.766 91.962 410.367 91.5002C408.968 91.0385 406.7 90.6379 403.563 90.2984C400.426 89.9589 396.237 89.6262 390.995 89.3003C382.466 88.7299 375.941 87.4398 371.419 85.43C366.897 83.4201 364.636 80.3781 364.636 76.3041C364.636 74.1041 365.512 72.2233 367.264 70.6616C369.015 69.0998 371.378 67.8301 374.352 66.8524C377.326 65.8746 380.681 65.1548 384.415 64.6931C388.15 64.2314 391.986 64.0005 395.924 64.0005C404.1 64.0005 410.455 64.503 414.991 65.5079C419.527 66.5128 422.256 67.3005 423.18 67.8709L414.217 76.7523C413.809 76.4535 412.961 76.1072 411.67 75.7133C410.38 75.3196 408.819 74.9325 406.985 74.5523C405.152 74.172 403.21 73.8529 401.159 73.5949C399.109 73.3369 397.119 73.2078 395.191 73.2078C392.04 73.2078 389.168 73.3233 386.574 73.5541C383.981 73.785 381.923 74.1381 380.402 74.6134C378.881 75.0887 378.121 75.7202 378.121 76.5078C378.121 77.5399 379.486 78.2936 382.215 78.7689C384.945 79.2442 389.637 79.6991 396.291 80.1337C399.713 80.3781 403.169 80.738 406.659 81.2133C410.15 81.6886 413.341 82.3812 416.233 83.2911C419.126 84.2009 421.448 85.4163 423.2 86.9373C424.952 88.4583 425.828 90.3595 425.828 92.641C425.828 95.194 425.006 97.3532 423.363 99.1187C421.72 100.884 419.445 102.324 416.539 103.437C413.633 104.551 410.292 105.359 406.517 105.861C402.742 106.364 398.735 106.615 394.498 106.615Z"                                                                                                                                                                             ,
	            fill: "currentColor",}
	        )
	        , React$2.createElement('path', {
	            d: "M449.364 76.7974V67.4755H469.77V53.3752H482.617V67.4755H506V76.7974H482.617V98.0654H501.3V106.643H469.77V76.7974H449.364Z" ,
	            fill: "currentColor",}
	        )
	        , React$2.createElement('path', {
	            d: "M308.663 106.615C302.797 106.615 297.48 105.82 292.713 104.232C287.947 102.643 284.158 100.273 281.347 97.1224C278.536 93.9718 277.13 90.02 277.13 85.267C277.13 80.4868 278.536 76.5282 281.347 73.3912C284.158 70.2542 287.947 67.9048 292.713 66.3431C297.48 64.7814 302.797 64.0005 308.663 64.0005C314.503 64.0005 319.799 64.7882 324.552 66.3635C329.305 67.9387 333.094 70.2949 335.918 73.4319C338.743 76.5689 340.155 80.5139 340.155 85.267C340.155 90.02 338.743 93.9718 335.918 97.1224C333.094 100.273 329.305 102.643 324.552 104.232C319.799 105.82 314.503 106.615 308.663 106.615ZM308.663 96.4298C314.34 96.4298 318.74 95.4113 321.863 93.3743C324.986 91.3373 326.548 88.6348 326.548 85.267C326.548 81.8176 324.98 79.1084 321.843 77.1393C318.706 75.1701 314.312 74.1856 308.663 74.1856C302.987 74.1856 298.566 75.1701 295.402 77.1393C292.238 79.1084 290.656 81.8176 290.656 85.267C290.656 88.6892 292.238 91.4052 295.402 93.415C298.566 95.4249 302.987 96.4298 308.663 96.4298Z"                                                                                                      ,
	            fill: "currentColor",}
	        )
	    )
	);

	const SilenceIcon

	 = (props) => (
	    React$2.createElement('svg', {
	        viewBox: "0 0 24 24"   ,
	        fill: "none",
	        xmlns: "http://www.w3.org/2000/svg",
	        ...props,}

	        , React$2.createElement('path', {
	            fillRule: "evenodd",
	            clipRule: "evenodd",
	            d: "M8.58579 15.002H7C6.44772 15.002 6 14.5543 6 14.002V10.002C6 9.44972 6.44772 9.002 7 9.002H8.58579L13.2929 4.2949C13.9229 3.66493 15 4.1111 15 5.002V19.002C15 19.8929 13.9229 20.3391 13.2929 19.7091L8.58579 15.002Z"                       ,
	            stroke: "currentColor",
	            strokeWidth: "2",
	            strokeLinecap: "round",
	            strokeLinejoin: "round",}
	        )
	        , React$2.createElement('path', {
	            d: "M20 4L16.8096 7.19036M4 20L7.19005 16.81L10.1144 13.8856M10.1144 13.8856L13.8856 10.1144L16.8096 7.19036M10.1144 13.8856L16.8096 7.19036"          ,
	            stroke: "currentColor",
	            strokeWidth: "2",
	            strokeLinecap: "round",
	            strokeLinejoin: "round",}
	        )
	    )
	);

	const CohostEggBookman

	 = (props) => (
	    React$2.createElement('svg', {
	        viewBox: "0 0 69 25"   ,
	        xmlns: "http://www.w3.org/2000/svg",
	        xmlSpace: "preserve",
	        ...props,
	        style: {
	            fillRule: "evenodd",
	            clipRule: "evenodd",
	            strokeLinejoin: "round",
	            strokeMiterlimit: 2,
	        },}

	        , React$2.createElement('path', {
	            d: "m275.723 316.744 3.445 10.118c-1.844 7.478-3.758 12.916-5.742 16.315-1.985 3.399-4.11 5.099-6.375 5.099-3.625 0-6.653-3.948-9.082-11.844-2.43-7.896-3.645-17.518-3.645-28.865 0-7.687.566-14.72 1.699-21.099 1.133-6.38 2.688-11.347 4.664-14.903 1.977-3.556 4.309-5.334 6.996-5.334 3.219 0 5.848 2.497 7.887 7.491 2.039 4.994 3.059 10.262 3.059 15.805 0 2.353-.16 4.458-.481 6.314-.32 1.856-.808 3.36-1.465 4.51-.656 1.15-1.351 1.726-2.085 1.726-.594 0-1.125-.393-1.594-1.177-.469-.784-.86-1.778-1.172-2.981-.141-.522-.414-2.143-.82-4.863-.516-3.399-.914-5.647-1.196-6.745-.281-1.098-.617-1.948-1.008-2.549-.39-.602-.835-.902-1.335-.902-.813 0-1.59.876-2.333 2.627-.742 1.752-1.351 4.406-1.828 7.962-.476 3.555-.714 7.529-.714 11.922 0 4.811.281 9.138.843 12.981.563 3.844 1.317 6.759 2.262 8.746.945 1.987 1.988 2.98 3.129 2.98 1.094 0 2.195-.993 3.305-2.98 1.109-1.987 2.304-5.438 3.586-10.354ZM295.223 266.231c2.671 0 5 1.752 6.984 5.255 1.984 3.504 3.512 8.275 4.582 14.315 1.07 6.04 1.605 13.112 1.605 21.217 0 12.236-1.187 22.171-3.562 29.806-2.375 7.634-5.547 11.452-9.516 11.452-4.047 0-7.265-3.844-9.656-11.531-2.312-7.32-3.469-17.229-3.469-29.727 0-8.21.528-15.269 1.582-21.178 1.055-5.909 2.582-10.654 4.582-14.236 2-3.582 4.289-5.373 6.868-5.373Zm.093 17.178c-.89 0-1.726.889-2.508 2.667-.781 1.777-1.386 4.392-1.816 7.843-.43 3.451-.644 7.844-.644 13.178 0 5.49.21 10.039.632 13.647.422 3.609 1.004 6.275 1.746 8.001.743 1.726 1.559 2.588 2.45 2.588 1.375 0 2.554-1.947 3.539-5.843.984-3.896 1.476-9.948 1.476-18.158 0-7.948-.457-13.923-1.371-17.923-.914-4-2.082-6-3.504-6ZM318.355 318.47c1.203 0 2.231 1.425 3.082 4.275.852 2.849 1.278 6.288 1.278 10.314s-.426 7.464-1.278 10.314c-.851 2.85-1.879 4.275-3.082 4.275-1.218 0-2.254-1.425-3.105-4.275-.852-2.85-1.277-6.288-1.277-10.314s.425-7.465 1.277-10.314c.851-2.85 1.887-4.275 3.105-4.275Z"                                                                                                                                                          ,
	            style: {
	                fillRule: "nonzero",
	                fill: "currentcolor",
	            },
	            transform: "matrix(1 0 0 .2988 -254.324 -79.5522)"     ,}
	        )
	    )
	);

	const CohostLogoBookman

	 = (props) => (
	    React$2.createElement('svg', {
	        ...props,
	        viewBox: "0 0 742 150"   ,
	        xmlns: "http://www.w3.org/2000/svg",
	        xmlSpace: "preserve",}

	        , React$2.createElement('path', {
	            d: "m89.16 106.445 14.356 12.598c-7.683 9.31-15.658 16.081-23.926 20.312-8.268 4.232-17.123 6.348-26.563 6.348-15.104 0-27.718-4.915-37.841-14.746C5.062 121.126 0 109.147 0 95.02c0-9.571 2.36-18.327 7.08-26.27 4.72-7.943 11.198-14.128 19.434-18.555 8.235-4.427 17.952-6.64 29.15-6.64 13.412 0 24.365 3.108 32.861 9.326 8.496 6.217 12.745 12.777 12.745 19.678 0 2.929-.668 5.55-2.002 7.861-1.335 2.311-3.37 4.183-6.104 5.615-2.734 1.432-5.631 2.149-8.691 2.149-2.474 0-4.688-.489-6.641-1.465-1.953-.977-3.581-2.214-4.883-3.711-.586-.651-1.725-2.669-3.418-6.055-2.148-4.232-3.808-7.031-4.98-8.398-1.172-1.367-2.572-2.425-4.199-3.174-1.628-.749-3.484-1.123-5.567-1.123-3.385 0-6.624 1.09-9.717 3.271-3.092 2.181-5.631 5.485-7.617 9.912-1.986 4.427-2.978 9.375-2.978 14.844 0 5.99 1.172 11.377 3.515 16.162 2.344 4.785 5.485 8.415 9.424 10.889 3.939 2.474 8.285 3.711 13.037 3.711 4.558 0 9.147-1.237 13.77-3.711 4.622-2.474 9.603-6.771 14.941-12.891ZM170.41 43.555c11.133 0 20.833 2.181 29.102 6.543 8.268 4.362 14.632 10.302 19.092 17.822 4.459 7.519 6.689 16.325 6.689 26.416 0 15.234-4.948 27.604-14.844 37.109-9.896 9.506-23.112 14.258-39.648 14.258-16.862 0-30.274-4.785-40.235-14.355-9.635-9.115-14.453-21.452-14.453-37.012 0-10.221 2.198-19.01 6.592-26.367 4.395-7.357 10.759-13.265 19.092-17.725 8.333-4.459 17.871-6.689 28.613-6.689Zm.391 21.386c-3.711 0-7.194 1.107-10.449 3.321-3.256 2.213-5.778 5.468-7.569 9.765-1.79 4.297-2.685 9.766-2.685 16.407 0 6.836.879 12.5 2.636 16.992 1.758 4.492 4.183 7.812 7.276 9.961 3.092 2.148 6.494 3.222 10.205 3.222 5.729 0 10.644-2.425 14.746-7.275 4.102-4.85 6.152-12.386 6.152-22.607 0-9.896-1.904-17.334-5.713-22.315-3.808-4.98-8.675-7.471-14.599-7.471ZM286.523 0v54.199c6.446-3.906 12.142-6.657 17.09-8.252 4.948-1.595 9.733-2.392 14.356-2.392 6.185 0 11.702 1.318 16.552 3.955 4.851 2.636 8.415 5.941 10.694 9.912 2.278 3.971 3.418 9.277 3.418 15.918v40.723c0 3.971.163 6.38.488 7.226.521 1.237 1.497 2.149 2.93 2.734.846.326 3.157.489 6.933.489h4.59v18.847h-57.422v-18.847h2.93c2.8 0 4.72-.261 5.762-.782 1.041-.52 1.758-1.253 2.148-2.197.391-.944.586-3.239.586-6.885V80.957c0-4.427-.277-7.373-.83-8.838-.553-1.465-1.546-2.669-2.978-3.613-1.433-.944-3.223-1.416-5.372-1.416-3.059 0-6.266.618-9.619 1.855-3.353 1.237-7.438 3.516-12.256 6.836v38.867c0 3.711.196 6.023.586 6.934.391.911 1.14 1.628 2.246 2.148 1.107.521 3.191.782 6.25.782h2.149v18.847h-56.836v-18.847h5.469c3.19 0 5.224-.212 6.103-.635.879-.423 1.546-1.139 2.002-2.148.456-1.01.684-3.012.684-6.006V27.246h-14.258V8.301c5.404-.326 11.475-1.253 18.213-2.783 6.738-1.53 12.809-3.37 18.213-5.518h9.179ZM430.469 43.555c11.133 0 20.833 2.181 29.101 6.543 8.269 4.362 14.632 10.302 19.092 17.822 4.46 7.519 6.69 16.325 6.69 26.416 0 15.234-4.948 27.604-14.844 37.109-9.896 9.506-23.112 14.258-39.649 14.258-16.862 0-30.273-4.785-40.234-14.355-9.635-9.115-14.453-21.452-14.453-37.012 0-10.221 2.197-19.01 6.592-26.367 4.394-7.357 10.758-13.265 19.091-17.725 8.334-4.459 17.872-6.689 28.614-6.689Zm.39 21.386c-3.711 0-7.194 1.107-10.449 3.321-3.255 2.213-5.778 5.468-7.568 9.765-1.791 4.297-2.686 9.766-2.686 16.407 0 6.836.879 12.5 2.637 16.992 1.758 4.492 4.183 7.812 7.275 9.961 3.093 2.148 6.495 3.222 10.205 3.222 5.73 0 10.645-2.425 14.747-7.275 4.101-4.85 6.152-12.386 6.152-22.607 0-9.896-1.904-17.334-5.713-22.315-3.809-4.98-8.675-7.471-14.6-7.471ZM566.504 45.898h12.793l7.91 27.149-18.457 7.422c-3.516-5.664-7.926-10.108-13.232-13.33-5.306-3.223-10.564-4.834-15.772-4.834-3.45 0-6.022.586-7.715 1.758-1.692 1.171-2.539 2.571-2.539 4.199 0 1.367.602 2.636 1.807 3.808 1.204 1.172 3.694 2.409 7.471 3.711l26.855 9.571c4.753 1.692 9.31 3.808 13.672 6.347 4.362 2.539 7.633 5.648 9.814 9.326 2.181 3.679 3.272 7.992 3.272 12.94 0 8.854-3.386 16.113-10.156 21.777-7.943 6.641-17.839 9.961-29.688 9.961-10.156 0-19.01-2.571-26.562-7.715l-2.735 5.371h-12.988l-12.012-32.031 18.457-7.812c4.623 7.226 10.319 12.907 17.09 17.041 6.771 4.134 12.988 6.201 18.652 6.201 3.516 0 6.478-.814 8.887-2.442 1.823-1.302 2.734-2.832 2.734-4.589 0-1.498-.716-2.93-2.148-4.297-1.432-1.367-4.59-2.897-9.473-4.59l-21.093-7.324c-11.654-4.102-19.58-8.48-23.78-13.135-4.199-4.655-6.298-10.173-6.298-16.553 0-8.203 3.287-15.104 9.863-20.703 7.487-6.38 16.732-9.57 27.734-9.57 9.766 0 18.132 2.213 25.098 6.64l2.539-4.297ZM648.145 12.402v33.496h31.445v20.801h-31.445v33.985c0 7.682.406 12.614 1.22 14.795.814 2.181 2.328 3.922 4.541 5.224 2.93 1.758 6.283 2.637 10.059 2.637 6.706 0 13.379-2.181 20.019-6.543v20.898c-5.664 2.67-10.791 4.541-15.38 5.616-4.59 1.074-9.555 1.611-14.893 1.611-6.055 0-11.41-.765-16.065-2.295-4.654-1.53-8.626-3.711-11.914-6.543-3.287-2.832-5.566-5.843-6.836-9.033-1.269-3.19-1.904-7.813-1.904-13.867V66.699h-14.648v-18.75c5.208-1.692 9.668-4.118 13.379-7.275 3.711-3.158 6.689-6.95 8.935-11.377 2.246-4.427 3.793-10.059 4.639-16.895h18.848ZM722.852 108.594c5.013 0 9.293 1.774 12.841 5.322 3.549 3.548 5.323 7.829 5.323 12.842 0 5.013-1.774 9.293-5.323 12.842-3.548 3.548-7.828 5.322-12.841 5.322-5.079 0-9.392-1.774-12.94-5.322-3.548-3.549-5.322-7.829-5.322-12.842 0-5.013 1.774-9.294 5.322-12.842s7.861-5.322 12.94-5.322Z"                                                                                                                                                                                                                                                                                                                                                                                                                                      ,
	            fill: "currentColor",}
	        )
	    )
	);

	// adapted from pushpin.svg in primaries
	const PushpinIcon = (
	    props
	) => (
	    React$2.createElement('svg', {
	        version: "1.1",
	        viewBox: "0 0 64 64"   ,
	        xmlns: "http://www.w3.org/2000/svg",
	        ...props,}

	        , React$2.createElement('path', {
	            d: "M33.9858,39.98h-3.9769l-5.73312e-08,-3.45466e-10c-0.555202,-0.00334555 -1.00799,0.444022 -1.01134,0.999224c-9.55879e-05,0.0158631 0.000184309,0.0317262 0.000839456,0.047576l0.09,1.8926l8.1077e-07,1.69924e-05c0.224947,4.71451 0.713306,9.41275 1.46279,14.0727l-3.37575e-08,-8.77512e-08c0.307198,0.798549 1.20358,1.19687 2.00213,0.889668c0.409051,-0.15736 0.732308,-0.480618 0.889668,-0.889668l1.85145e-06,-1.15151e-05c0.74926,-4.66004 1.23769,-9.35829 1.463,-14.0728l0.09,-1.8926l-9.29513e-09,2.2352e-07c0.0230619,-0.554567 -0.407808,-1.02283 -0.962375,-1.04589c-0.0159302,-0.000662462 -0.0318738,-0.000945741 -0.0478175,-0.000849598Zm5.9856,-11.717l1.33361e-07,4.48278e-08c-0.58324,-0.196049 -0.99529,-0.718529 -1.05,-1.3314l-0.8205,-10.667l-4.90502e-10,-6.9529e-09c-0.0497118,-0.704677 0.367623,-1.35886 1.0276,-1.6108l-6.42663e-07,2.67145e-07c2.01747,-0.838631 3.67436,-2.36219 4.6789,-4.3024l2.26452e-08,-4.19035e-08c0.128914,-0.238548 0.195862,-0.505649 0.1947,-0.7768v0c0,-0.878133 -0.711867,-1.59 -1.59,-1.59c0,0 0,0 0,0h-20.8193h-6.95011e-08c-0.878133,3.83844e-08 -1.59,0.711867 -1.59,1.59l7.33895e-09,-1.713e-06c-0.00116183,0.271151 0.0657851,0.538252 0.194699,0.7768l-8.24693e-07,-1.59257e-06c1.00466,1.94011 2.66151,3.46364 4.6789,4.3024l1.00815e-08,3.848e-09c0.660013,0.251921 1.07742,0.906088 1.0278,1.6108l-0.82,10.667l6.01455e-08,-6.73762e-07c-0.0547098,0.612871 -0.46676,1.13535 -1.05,1.3314c-2.4539,0.8713 -6.0307,3.2637 -6.0307,7.7171v0.4093l2.13163e-14,-2.40083e-07c-1.32594e-07,0.878133 0.711867,1.59 1.59,1.59c0,0 3.55271e-15,0 3.55271e-15,0h24.8183l-6.95011e-08,-7.10543e-15c0.878133,3.83844e-08 1.59,-0.711867 1.59,-1.59c0,0 0,-7.10543e-15 0,-7.10543e-15v-0.409398c0.0005,-4.4533 -3.5765,-6.8457 -6.0304,-7.717Z"                                                  ,
	            fill: "currentColor",
	            fillRule: "evenodd",}
	        )
	    )
	);

	function ArrowDownIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M12 2.25a.75.75 0 01.75.75v16.19l6.22-6.22a.75.75 0 111.06 1.06l-7.5 7.5a.75.75 0 01-1.06 0l-7.5-7.5a.75.75 0 111.06-1.06l6.22 6.22V3a.75.75 0 01.75-.75z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$A = reactExports.forwardRef(ArrowDownIcon);

	function ArrowPathIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M4.755 10.059a7.5 7.5 0 0112.548-3.364l1.903 1.903h-3.183a.75.75 0 100 1.5h4.992a.75.75 0 00.75-.75V4.356a.75.75 0 00-1.5 0v3.18l-1.9-1.9A9 9 0 003.306 9.67a.75.75 0 101.45.388zm15.408 3.352a.75.75 0 00-.919.53 7.5 7.5 0 01-12.548 3.364l-1.902-1.903h3.183a.75.75 0 000-1.5H2.984a.75.75 0 00-.75.75v4.992a.75.75 0 001.5 0v-3.18l1.9 1.9a9 9 0 0015.059-4.035.75.75 0 00-.53-.918z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$z = reactExports.forwardRef(ArrowPathIcon);

	function ArrowUpIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M11.47 2.47a.75.75 0 011.06 0l7.5 7.5a.75.75 0 11-1.06 1.06l-6.22-6.22V21a.75.75 0 01-1.5 0V4.81l-6.22 6.22a.75.75 0 11-1.06-1.06l7.5-7.5z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$y = reactExports.forwardRef(ArrowUpIcon);

	function ArrowUturnLeftIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M9.53 2.47a.75.75 0 010 1.06L4.81 8.25H15a6.75 6.75 0 010 13.5h-3a.75.75 0 010-1.5h3a5.25 5.25 0 100-10.5H4.81l4.72 4.72a.75.75 0 11-1.06 1.06l-6-6a.75.75 0 010-1.06l6-6a.75.75 0 011.06 0z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$x = reactExports.forwardRef(ArrowUturnLeftIcon);

	function Bars3Icon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M3 6.75A.75.75 0 013.75 6h16.5a.75.75 0 010 1.5H3.75A.75.75 0 013 6.75zM3 12a.75.75 0 01.75-.75h16.5a.75.75 0 010 1.5H3.75A.75.75 0 013 12zm0 5.25a.75.75 0 01.75-.75h16.5a.75.75 0 010 1.5H3.75a.75.75 0 01-.75-.75z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$w = reactExports.forwardRef(Bars3Icon);

	function BellIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M5.25 9a6.75 6.75 0 0113.5 0v.75c0 2.123.8 4.057 2.118 5.52a.75.75 0 01-.297 1.206c-1.544.57-3.16.99-4.831 1.243a3.75 3.75 0 11-7.48 0 24.585 24.585 0 01-4.831-1.244.75.75 0 01-.298-1.205A8.217 8.217 0 005.25 9.75V9zm4.502 8.9a2.25 2.25 0 104.496 0 25.057 25.057 0 01-4.496 0z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$v = reactExports.forwardRef(BellIcon);

	function ChatBubbleOvalLeftEllipsisIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M4.804 21.644A6.707 6.707 0 006 21.75a6.721 6.721 0 003.583-1.029c.774.182 1.584.279 2.417.279 5.322 0 9.75-3.97 9.75-9 0-5.03-4.428-9-9.75-9s-9.75 3.97-9.75 9c0 2.409 1.025 4.587 2.674 6.192.232.226.277.428.254.543a3.73 3.73 0 01-.814 1.686.75.75 0 00.44 1.223zM8.25 10.875a1.125 1.125 0 100 2.25 1.125 1.125 0 000-2.25zM10.875 12a1.125 1.125 0 112.25 0 1.125 1.125 0 01-2.25 0zm4.875-1.125a1.125 1.125 0 100 2.25 1.125 1.125 0 000-2.25z",
	    clipRule: "evenodd"
	  }));
	}

	reactExports.forwardRef(ChatBubbleOvalLeftEllipsisIcon);

	function CheckBadgeIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M8.603 3.799A4.49 4.49 0 0112 2.25c1.357 0 2.573.6 3.397 1.549a4.49 4.49 0 013.498 1.307 4.491 4.491 0 011.307 3.497A4.49 4.49 0 0121.75 12a4.49 4.49 0 01-1.549 3.397 4.491 4.491 0 01-1.307 3.497 4.491 4.491 0 01-3.497 1.307A4.49 4.49 0 0112 21.75a4.49 4.49 0 01-3.397-1.549 4.49 4.49 0 01-3.498-1.306 4.491 4.491 0 01-1.307-3.498A4.49 4.49 0 012.25 12c0-1.357.6-2.573 1.549-3.397a4.49 4.49 0 011.307-3.497 4.49 4.49 0 013.497-1.307zm7.007 6.387a.75.75 0 10-1.22-.872l-3.236 4.53L9.53 12.22a.75.75 0 00-1.06 1.06l2.25 2.25a.75.75 0 001.14-.094l3.75-5.25z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$u = reactExports.forwardRef(CheckBadgeIcon);

	function CheckIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M19.916 4.626a.75.75 0 01.208 1.04l-9 13.5a.75.75 0 01-1.154.114l-6-6a.75.75 0 011.06-1.06l5.353 5.353 8.493-12.739a.75.75 0 011.04-.208z",
	    clipRule: "evenodd"
	  }));
	}

	reactExports.forwardRef(CheckIcon);

	function ChevronDownIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M12.53 16.28a.75.75 0 01-1.06 0l-7.5-7.5a.75.75 0 011.06-1.06L12 14.69l6.97-6.97a.75.75 0 111.06 1.06l-7.5 7.5z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$t = reactExports.forwardRef(ChevronDownIcon$1);

	function ChevronLeftIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M7.72 12.53a.75.75 0 010-1.06l7.5-7.5a.75.75 0 111.06 1.06L9.31 12l6.97 6.97a.75.75 0 11-1.06 1.06l-7.5-7.5z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$s = reactExports.forwardRef(ChevronLeftIcon);

	function ChevronRightIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M16.28 11.47a.75.75 0 010 1.06l-7.5 7.5a.75.75 0 01-1.06-1.06L14.69 12 7.72 5.03a.75.75 0 011.06-1.06l7.5 7.5z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$r = reactExports.forwardRef(ChevronRightIcon$1);

	function ChevronUpDownIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M11.47 4.72a.75.75 0 011.06 0l3.75 3.75a.75.75 0 01-1.06 1.06L12 6.31 8.78 9.53a.75.75 0 01-1.06-1.06l3.75-3.75zm-3.75 9.75a.75.75 0 011.06 0L12 17.69l3.22-3.22a.75.75 0 111.06 1.06l-3.75 3.75a.75.75 0 01-1.06 0l-3.75-3.75a.75.75 0 010-1.06z",
	    clipRule: "evenodd"
	  }));
	}

	reactExports.forwardRef(ChevronUpDownIcon);

	function ChevronUpIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M11.47 7.72a.75.75 0 011.06 0l7.5 7.5a.75.75 0 11-1.06 1.06L12 9.31l-6.97 6.97a.75.75 0 01-1.06-1.06l7.5-7.5z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$q = reactExports.forwardRef(ChevronUpIcon);

	function CogIcon$1({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    d: "M17.004 10.407c.138.435-.216.842-.672.842h-3.465a.75.75 0 01-.65-.375l-1.732-3c-.229-.396-.053-.907.393-1.004a5.252 5.252 0 016.126 3.537zM8.12 8.464c.307-.338.838-.235 1.066.16l1.732 3a.75.75 0 010 .75l-1.732 3.001c-.229.396-.76.498-1.067.16A5.231 5.231 0 016.75 12c0-1.362.519-2.603 1.37-3.536zM10.878 17.13c-.447-.097-.623-.608-.394-1.003l1.733-3.003a.75.75 0 01.65-.375h3.465c.457 0 .81.408.672.843a5.252 5.252 0 01-6.126 3.538z"
	  }), /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M21 12.75a.75.75 0 000-1.5h-.783a8.22 8.22 0 00-.237-1.357l.734-.267a.75.75 0 10-.513-1.41l-.735.268a8.24 8.24 0 00-.689-1.191l.6-.504a.75.75 0 10-.964-1.149l-.6.504a8.3 8.3 0 00-1.054-.885l.391-.678a.75.75 0 10-1.299-.75l-.39.677a8.188 8.188 0 00-1.295-.471l.136-.77a.75.75 0 00-1.477-.26l-.136.77a8.364 8.364 0 00-1.377 0l-.136-.77a.75.75 0 10-1.477.26l.136.77c-.448.121-.88.28-1.294.47l-.39-.676a.75.75 0 00-1.3.75l.392.678a8.29 8.29 0 00-1.054.885l-.6-.504a.75.75 0 00-.965 1.149l.6.503a8.243 8.243 0 00-.689 1.192L3.8 8.217a.75.75 0 10-.513 1.41l.735.267a8.222 8.222 0 00-.238 1.355h-.783a.75.75 0 000 1.5h.783c.042.464.122.917.238 1.356l-.735.268a.75.75 0 10.513 1.41l.735-.268c.197.417.428.816.69 1.192l-.6.504a.75.75 0 10.963 1.149l.601-.505c.326.323.679.62 1.054.885l-.392.68a.75.75 0 101.3.75l.39-.679c.414.192.847.35 1.294.471l-.136.771a.75.75 0 101.477.26l.137-.772a8.376 8.376 0 001.376 0l.136.773a.75.75 0 101.477-.26l-.136-.772a8.19 8.19 0 001.294-.47l.391.677a.75.75 0 101.3-.75l-.393-.679a8.282 8.282 0 001.054-.885l.601.504a.75.75 0 10.964-1.15l-.6-.503a8.24 8.24 0 00.69-1.191l.735.268a.75.75 0 10.512-1.41l-.734-.268c.115-.438.195-.892.237-1.356h.784zm-2.657-3.06a6.744 6.744 0 00-1.19-2.053 6.784 6.784 0 00-1.82-1.51A6.704 6.704 0 0012 5.25a6.801 6.801 0 00-1.225.111 6.7 6.7 0 00-2.15.792 6.784 6.784 0 00-2.952 3.489.758.758 0 01-.036.099A6.74 6.74 0 005.251 12a6.739 6.739 0 003.355 5.835l.01.006.01.005a6.706 6.706 0 002.203.802c.007 0 .014.002.021.004a6.792 6.792 0 002.301 0l.022-.004a6.707 6.707 0 002.228-.816 6.781 6.781 0 001.762-1.483l.009-.01.009-.012a6.744 6.744 0 001.18-2.064c.253-.708.39-1.47.39-2.264a6.74 6.74 0 00-.408-2.308z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$p = reactExports.forwardRef(CogIcon$1);

	function DocumentTextIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M5.625 1.5c-1.036 0-1.875.84-1.875 1.875v17.25c0 1.035.84 1.875 1.875 1.875h12.75c1.035 0 1.875-.84 1.875-1.875V12.75A3.75 3.75 0 0016.5 9h-1.875a1.875 1.875 0 01-1.875-1.875V5.25A3.75 3.75 0 009 1.5H5.625zM7.5 15a.75.75 0 01.75-.75h7.5a.75.75 0 010 1.5h-7.5A.75.75 0 017.5 15zm.75 2.25a.75.75 0 000 1.5H12a.75.75 0 000-1.5H8.25z",
	    clipRule: "evenodd"
	  }), /*#__PURE__*/reactExports.createElement("path", {
	    d: "M12.971 1.816A5.23 5.23 0 0114.25 5.25v1.875c0 .207.168.375.375.375H16.5a5.23 5.23 0 013.434 1.279 9.768 9.768 0 00-6.963-6.963z"
	  }));
	}

	const ForwardRef$o = reactExports.forwardRef(DocumentTextIcon);

	function EllipsisHorizontalIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M4.5 12a1.5 1.5 0 113 0 1.5 1.5 0 01-3 0zm6 0a1.5 1.5 0 113 0 1.5 1.5 0 01-3 0zm6 0a1.5 1.5 0 113 0 1.5 1.5 0 01-3 0z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$n = reactExports.forwardRef(EllipsisHorizontalIcon);

	function ExclamationCircleIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M2.25 12c0-5.385 4.365-9.75 9.75-9.75s9.75 4.365 9.75 9.75-4.365 9.75-9.75 9.75S2.25 17.385 2.25 12zM12 8.25a.75.75 0 01.75.75v3.75a.75.75 0 01-1.5 0V9a.75.75 0 01.75-.75zm0 8.25a.75.75 0 100-1.5.75.75 0 000 1.5z",
	    clipRule: "evenodd"
	  }));
	}

	reactExports.forwardRef(ExclamationCircleIcon);

	function HeartIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    d: "M11.645 20.91l-.007-.003-.022-.012a15.247 15.247 0 01-.383-.218 25.18 25.18 0 01-4.244-3.17C4.688 15.36 2.25 12.174 2.25 8.25 2.25 5.322 4.714 3 7.688 3A5.5 5.5 0 0112 5.052 5.5 5.5 0 0116.313 3c2.973 0 5.437 2.322 5.437 5.25 0 3.925-2.438 7.111-4.739 9.256a25.175 25.175 0 01-4.244 3.17 15.247 15.247 0 01-.383.219l-.022.012-.007.004-.003.001a.752.752 0 01-.704 0l-.003-.001z"
	  }));
	}

	const ForwardRef$m = reactExports.forwardRef(HeartIcon);

	function InboxIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M6.912 3a3 3 0 00-2.868 2.118l-2.411 7.838a3 3 0 00-.133.882V18a3 3 0 003 3h15a3 3 0 003-3v-4.162c0-.299-.045-.596-.133-.882l-2.412-7.838A3 3 0 0017.088 3H6.912zm13.823 9.75l-2.213-7.191A1.5 1.5 0 0017.088 4.5H6.912a1.5 1.5 0 00-1.434 1.059L3.265 12.75H6.11a3 3 0 012.684 1.658l.256.513a1.5 1.5 0 001.342.829h3.218a1.5 1.5 0 001.342-.83l.256-.512a3 3 0 012.684-1.658h2.844z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$l = reactExports.forwardRef(InboxIcon);

	function LifebuoyIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M19.449 8.448L16.388 11a4.52 4.52 0 010 2.002l3.061 2.55a8.275 8.275 0 000-7.103zM15.552 19.45L13 16.388a4.52 4.52 0 01-2.002 0l-2.55 3.061a8.275 8.275 0 007.103 0zM4.55 15.552L7.612 13a4.52 4.52 0 010-2.002L4.551 8.45a8.275 8.275 0 000 7.103zM8.448 4.55L11 7.612a4.52 4.52 0 012.002 0l2.55-3.061a8.275 8.275 0 00-7.103 0zm8.657-.86a9.776 9.776 0 011.79 1.415 9.776 9.776 0 011.414 1.788 9.764 9.764 0 010 10.211 9.777 9.777 0 01-1.415 1.79 9.777 9.777 0 01-1.788 1.414 9.764 9.764 0 01-10.212 0 9.776 9.776 0 01-1.788-1.415 9.776 9.776 0 01-1.415-1.788 9.764 9.764 0 010-10.212 9.774 9.774 0 011.415-1.788A9.774 9.774 0 016.894 3.69a9.764 9.764 0 0110.211 0zM14.121 9.88a2.985 2.985 0 00-1.11-.704 3.015 3.015 0 00-2.022 0 2.985 2.985 0 00-1.11.704c-.326.325-.56.705-.704 1.11a3.015 3.015 0 000 2.022c.144.405.378.785.704 1.11.325.326.705.56 1.11.704.652.233 1.37.233 2.022 0a2.985 2.985 0 001.11-.704c.326-.325.56-.705.704-1.11a3.016 3.016 0 000-2.022 2.985 2.985 0 00-.704-1.11z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$k = reactExports.forwardRef(LifebuoyIcon);

	function LinkIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M19.902 4.098a3.75 3.75 0 00-5.304 0l-4.5 4.5a3.75 3.75 0 001.035 6.037.75.75 0 01-.646 1.353 5.25 5.25 0 01-1.449-8.45l4.5-4.5a5.25 5.25 0 117.424 7.424l-1.757 1.757a.75.75 0 11-1.06-1.06l1.757-1.757a3.75 3.75 0 000-5.304zm-7.389 4.267a.75.75 0 011-.353 5.25 5.25 0 011.449 8.45l-4.5 4.5a5.25 5.25 0 11-7.424-7.424l1.757-1.757a.75.75 0 111.06 1.06l-1.757 1.757a3.75 3.75 0 105.304 5.304l4.5-4.5a3.75 3.75 0 00-1.035-6.037.75.75 0 01-.354-1z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$j = reactExports.forwardRef(LinkIcon);

	function LockClosedIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M12 1.5a5.25 5.25 0 00-5.25 5.25v3a3 3 0 00-3 3v6.75a3 3 0 003 3h10.5a3 3 0 003-3v-6.75a3 3 0 00-3-3v-3c0-2.9-2.35-5.25-5.25-5.25zm3.75 8.25v-3a3.75 3.75 0 10-7.5 0v3h7.5z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$i = reactExports.forwardRef(LockClosedIcon);

	function MagnifyingGlassIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M10.5 3.75a6.75 6.75 0 100 13.5 6.75 6.75 0 000-13.5zM2.25 10.5a8.25 8.25 0 1114.59 5.28l4.69 4.69a.75.75 0 11-1.06 1.06l-4.69-4.69A8.25 8.25 0 012.25 10.5z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$h = reactExports.forwardRef(MagnifyingGlassIcon);

	function NewspaperIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M4.125 3C3.089 3 2.25 3.84 2.25 4.875V18a3 3 0 003 3h15a3 3 0 01-3-3V4.875C17.25 3.839 16.41 3 15.375 3H4.125zM12 9.75a.75.75 0 000 1.5h1.5a.75.75 0 000-1.5H12zm-.75-2.25a.75.75 0 01.75-.75h1.5a.75.75 0 010 1.5H12a.75.75 0 01-.75-.75zM6 12.75a.75.75 0 000 1.5h7.5a.75.75 0 000-1.5H6zm-.75 3.75a.75.75 0 01.75-.75h7.5a.75.75 0 010 1.5H6a.75.75 0 01-.75-.75zM6 6.75a.75.75 0 00-.75.75v3c0 .414.336.75.75.75h3a.75.75 0 00.75-.75v-3A.75.75 0 009 6.75H6z",
	    clipRule: "evenodd"
	  }), /*#__PURE__*/reactExports.createElement("path", {
	    d: "M18.75 6.75h1.875c.621 0 1.125.504 1.125 1.125V18a1.5 1.5 0 01-3 0V6.75z"
	  }));
	}

	const ForwardRef$g = reactExports.forwardRef(NewspaperIcon);

	function PaintBrushIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M20.599 1.5c-.376 0-.743.111-1.055.32l-5.08 3.385a18.747 18.747 0 00-3.471 2.987 10.04 10.04 0 014.815 4.815 18.748 18.748 0 002.987-3.472l3.386-5.079A1.902 1.902 0 0020.599 1.5zm-8.3 14.025a18.76 18.76 0 001.896-1.207 8.026 8.026 0 00-4.513-4.513A18.75 18.75 0 008.475 11.7l-.278.5a5.26 5.26 0 013.601 3.602l.502-.278zM6.75 13.5A3.75 3.75 0 003 17.25a1.5 1.5 0 01-1.601 1.497.75.75 0 00-.7 1.123 5.25 5.25 0 009.8-2.62 3.75 3.75 0 00-3.75-3.75z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$f = reactExports.forwardRef(PaintBrushIcon);

	function UserCircleIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M18.685 19.097A9.723 9.723 0 0021.75 12c0-5.385-4.365-9.75-9.75-9.75S2.25 6.615 2.25 12a9.723 9.723 0 003.065 7.097A9.716 9.716 0 0012 21.75a9.716 9.716 0 006.685-2.653zm-12.54-1.285A7.486 7.486 0 0112 15a7.486 7.486 0 015.855 2.812A8.224 8.224 0 0112 20.25a8.224 8.224 0 01-5.855-2.438zM15.75 9a3.75 3.75 0 11-7.5 0 3.75 3.75 0 017.5 0z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$e = reactExports.forwardRef(UserCircleIcon);

	function UserGroupIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M8.25 6.75a3.75 3.75 0 117.5 0 3.75 3.75 0 01-7.5 0zM15.75 9.75a3 3 0 116 0 3 3 0 01-6 0zM2.25 9.75a3 3 0 116 0 3 3 0 01-6 0zM6.31 15.117A6.745 6.745 0 0112 12a6.745 6.745 0 016.709 7.498.75.75 0 01-.372.568A12.696 12.696 0 0112 21.75c-2.305 0-4.47-.612-6.337-1.684a.75.75 0 01-.372-.568 6.787 6.787 0 011.019-4.38z",
	    clipRule: "evenodd"
	  }), /*#__PURE__*/reactExports.createElement("path", {
	    d: "M5.082 14.254a8.287 8.287 0 00-1.308 5.135 9.687 9.687 0 01-1.764-.44l-.115-.04a.563.563 0 01-.373-.487l-.01-.121a3.75 3.75 0 013.57-4.047zM20.226 19.389a8.287 8.287 0 00-1.308-5.135 3.75 3.75 0 013.57 4.047l-.01.121a.563.563 0 01-.373.486l-.115.04c-.567.2-1.156.349-1.764.441z"
	  }));
	}

	const ForwardRef$d = reactExports.forwardRef(UserGroupIcon);

	function UserIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M7.5 6a4.5 4.5 0 119 0 4.5 4.5 0 01-9 0zM3.751 20.105a8.25 8.25 0 0116.498 0 .75.75 0 01-.437.695A18.683 18.683 0 0112 22.5c-2.786 0-5.433-.608-7.812-1.7a.75.75 0 01-.437-.695z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$c = reactExports.forwardRef(UserIcon);

	function UserPlusIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    d: "M6.25 6.375a4.125 4.125 0 118.25 0 4.125 4.125 0 01-8.25 0zM3.25 19.125a7.125 7.125 0 0114.25 0v.003l-.001.119a.75.75 0 01-.363.63 13.067 13.067 0 01-6.761 1.873c-2.472 0-4.786-.684-6.76-1.873a.75.75 0 01-.364-.63l-.001-.122zM19.75 7.5a.75.75 0 00-1.5 0v2.25H16a.75.75 0 000 1.5h2.25v2.25a.75.75 0 001.5 0v-2.25H22a.75.75 0 000-1.5h-2.25V7.5z"
	  }));
	}

	const ForwardRef$b = reactExports.forwardRef(UserPlusIcon);

	function UsersIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    d: "M4.5 6.375a4.125 4.125 0 118.25 0 4.125 4.125 0 01-8.25 0zM14.25 8.625a3.375 3.375 0 116.75 0 3.375 3.375 0 01-6.75 0zM1.5 19.125a7.125 7.125 0 0114.25 0v.003l-.001.119a.75.75 0 01-.363.63 13.067 13.067 0 01-6.761 1.873c-2.472 0-4.786-.684-6.76-1.873a.75.75 0 01-.364-.63l-.001-.122zM17.25 19.128l-.001.144a2.25 2.25 0 01-.233.96 10.088 10.088 0 005.06-1.01.75.75 0 00.42-.643 4.875 4.875 0 00-6.957-4.611 8.586 8.586 0 011.71 5.157v.003z"
	  }));
	}

	const ForwardRef$a = reactExports.forwardRef(UsersIcon);

	function XMarkIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 24 24",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M5.47 5.47a.75.75 0 011.06 0L12 10.94l5.47-5.47a.75.75 0 111.06 1.06L13.06 12l5.47 5.47a.75.75 0 11-1.06 1.06L12 13.06l-5.47 5.47a.75.75 0 01-1.06-1.06L10.94 12 5.47 6.53a.75.75 0 010-1.06z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$9 = reactExports.forwardRef(XMarkIcon);

	function ArrowUpTrayIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 20 20",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    d: "M9.25 13.25a.75.75 0 001.5 0V4.636l2.955 3.129a.75.75 0 001.09-1.03l-4.25-4.5a.75.75 0 00-1.09 0l-4.25 4.5a.75.75 0 101.09 1.03L9.25 4.636v8.614z"
	  }), /*#__PURE__*/reactExports.createElement("path", {
	    d: "M3.5 12.75a.75.75 0 00-1.5 0v2.5A2.75 2.75 0 004.75 18h10.5A2.75 2.75 0 0018 15.25v-2.5a.75.75 0 00-1.5 0v2.5c0 .69-.56 1.25-1.25 1.25H4.75c-.69 0-1.25-.56-1.25-1.25v-2.5z"
	  }));
	}

	const ForwardRef$8 = reactExports.forwardRef(ArrowUpTrayIcon);

	function CheckCircleIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 20 20",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M10 18a8 8 0 100-16 8 8 0 000 16zm3.857-9.809a.75.75 0 00-1.214-.882l-3.483 4.79-1.88-1.88a.75.75 0 10-1.06 1.061l2.5 2.5a.75.75 0 001.137-.089l4-5.5z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$7 = reactExports.forwardRef(CheckCircleIcon);

	function ChevronDownIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 20 20",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M5.23 7.21a.75.75 0 011.06.02L10 11.168l3.71-3.938a.75.75 0 111.08 1.04l-4.25 4.5a.75.75 0 01-1.08 0l-4.25-4.5a.75.75 0 01.02-1.06z",
	    clipRule: "evenodd"
	  }));
	}

	reactExports.forwardRef(ChevronDownIcon);

	function ChevronRightIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 20 20",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M7.21 14.77a.75.75 0 01.02-1.06L11.168 10 7.23 6.29a.75.75 0 111.04-1.08l4.5 4.25a.75.75 0 010 1.08l-4.5 4.25a.75.75 0 01-1.06-.02z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$6 = reactExports.forwardRef(ChevronRightIcon);

	function ClockIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 20 20",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M10 18a8 8 0 100-16 8 8 0 000 16zm.75-13a.75.75 0 00-1.5 0v5c0 .414.336.75.75.75h4a.75.75 0 000-1.5h-3.25V5z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$5 = reactExports.forwardRef(ClockIcon);

	function CogIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 20 20",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    d: "M13.024 9.25c.47 0 .827-.433.637-.863a4 4 0 00-4.094-2.364c-.468.05-.665.576-.43.984l1.08 1.868a.75.75 0 00.649.375h2.158zM7.84 7.758c-.236-.408-.79-.5-1.068-.12A3.982 3.982 0 006 10c0 .884.287 1.7.772 2.363.278.38.832.287 1.068-.12l1.078-1.868a.75.75 0 000-.75L7.839 7.758zM9.138 12.993c-.235.408-.039.934.43.984a4 4 0 004.094-2.364c.19-.43-.168-.863-.638-.863h-2.158a.75.75 0 00-.65.375l-1.078 1.868z"
	  }), /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M14.13 4.347l.644-1.117a.75.75 0 00-1.299-.75l-.644 1.116a6.954 6.954 0 00-2.081-.556V1.75a.75.75 0 00-1.5 0v1.29a6.954 6.954 0 00-2.081.556L6.525 2.48a.75.75 0 10-1.3.75l.645 1.117A7.04 7.04 0 004.347 5.87L3.23 5.225a.75.75 0 10-.75 1.3l1.116.644A6.954 6.954 0 003.04 9.25H1.75a.75.75 0 000 1.5h1.29c.078.733.27 1.433.556 2.081l-1.116.645a.75.75 0 10.75 1.298l1.117-.644a7.04 7.04 0 001.523 1.523l-.645 1.117a.75.75 0 101.3.75l.644-1.116a6.954 6.954 0 002.081.556v1.29a.75.75 0 001.5 0v-1.29a6.954 6.954 0 002.081-.556l.645 1.116a.75.75 0 001.299-.75l-.645-1.117a7.042 7.042 0 001.523-1.523l1.117.644a.75.75 0 00.75-1.298l-1.116-.645a6.954 6.954 0 00.556-2.081h1.29a.75.75 0 000-1.5h-1.29a6.954 6.954 0 00-.556-2.081l1.116-.644a.75.75 0 00-.75-1.3l-1.117.645a7.04 7.04 0 00-1.524-1.523zM10 4.5a5.475 5.475 0 00-2.781.754A5.527 5.527 0 005.22 7.277 5.475 5.475 0 004.5 10a5.475 5.475 0 00.752 2.777 5.527 5.527 0 002.028 2.004c.802.458 1.73.719 2.72.719a5.474 5.474 0 002.78-.753 5.527 5.527 0 002.001-2.027c.458-.802.719-1.73.719-2.72a5.475 5.475 0 00-.753-2.78 5.528 5.528 0 00-2.028-2.002A5.475 5.475 0 0010 4.5z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$4 = reactExports.forwardRef(CogIcon);

	function ExclamationTriangleIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 20 20",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M8.485 2.495c.673-1.167 2.357-1.167 3.03 0l6.28 10.875c.673 1.167-.17 2.625-1.516 2.625H3.72c-1.347 0-2.189-1.458-1.515-2.625L8.485 2.495zM10 5a.75.75 0 01.75.75v3.5a.75.75 0 01-1.5 0v-3.5A.75.75 0 0110 5zm0 9a1 1 0 100-2 1 1 0 000 2z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$3 = reactExports.forwardRef(ExclamationTriangleIcon);

	function HashtagIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 20 20",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M9.493 2.853a.75.75 0 00-1.486-.205L7.545 6H4.198a.75.75 0 000 1.5h3.14l-.69 5H3.302a.75.75 0 000 1.5h3.14l-.435 3.148a.75.75 0 001.486.205L7.955 14h2.986l-.434 3.148a.75.75 0 001.486.205L12.456 14h3.346a.75.75 0 000-1.5h-3.14l.69-5h3.346a.75.75 0 000-1.5h-3.14l.435-3.147a.75.75 0 00-1.486-.205L12.045 6H9.059l.434-3.147zM8.852 7.5l-.69 5h2.986l.69-5H8.852z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$2 = reactExports.forwardRef(HashtagIcon);

	function QuestionMarkCircleIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 20 20",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M18 10a8 8 0 11-16 0 8 8 0 0116 0zM8.94 6.94a.75.75 0 11-1.061-1.061 3 3 0 112.871 5.026v.345a.75.75 0 01-1.5 0v-.5c0-.72.57-1.172 1.081-1.287A1.5 1.5 0 108.94 6.94zM10 15a1 1 0 100-2 1 1 0 000 2z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef$1 = reactExports.forwardRef(QuestionMarkCircleIcon);

	function XCircleIcon({
	  title,
	  titleId,
	  ...props
	}, svgRef) {
	  return /*#__PURE__*/reactExports.createElement("svg", Object.assign({
	    xmlns: "http://www.w3.org/2000/svg",
	    viewBox: "0 0 20 20",
	    fill: "currentColor",
	    "aria-hidden": "true",
	    ref: svgRef,
	    "aria-labelledby": titleId
	  }, props), title ? /*#__PURE__*/reactExports.createElement("title", {
	    id: titleId
	  }, title) : null, /*#__PURE__*/reactExports.createElement("path", {
	    fillRule: "evenodd",
	    d: "M10 18a8 8 0 100-16 8 8 0 000 16zM8.28 7.22a.75.75 0 00-1.06 1.06L8.94 10l-1.72 1.72a.75.75 0 101.06 1.06L10 11.06l1.72 1.72a.75.75 0 101.06-1.06L11.06 10l1.72-1.72a.75.75 0 00-1.06-1.06L10 8.94 8.28 7.22z",
	    clipRule: "evenodd"
	  }));
	}

	const ForwardRef = reactExports.forwardRef(XCircleIcon);

	mod.enum([
	    "cohost-logo",
	    "cohost-egg",
	    "bouba",
	    "kiki",
	    "pushpin",
	    "silence",
	    "hashtag",
	    "warning",
	    "cohost-egg-bookman",
	    "cohost-logo-bookman",
	]);

	const chaosDay22Theme = `
:root {
    --color-text: 249 254 255; /* white-ish */
    --color-bg-text: 249 254 255; /* same white-ish */
    
    /* used https://uicolors.app/ to generate these */
    --color-foreground-100: ${varForColor("#ebeff3")};
    --color-foreground-200: ${varForColor("#d2dbe5")};
    --color-foreground-300: ${varForColor("#abbdce")};
    --color-foreground-400: ${varForColor("#7e99b2")};
    --color-foreground-500: ${varForColor("#5e7d99")};
    --color-foreground-600: ${varForColor("#4a647f")};
    --color-foreground-700: ${varForColor("#435972")};
    --color-foreground-800: ${varForColor("#354557")};
    --color-foreground: ${varForColor("#435972")}; /* tumblr blue (light) */
    
    --color-accent: 138 174 117; /* green-ish */    
    
    /* a darker blue, poor contrast */
    --color-secondary: ${varForColor("#668093")};
    --color-secondary-100: ${varForColor("#e2e8eb")};
    --color-secondary-200: ${varForColor("#c7d2da")};
    --color-secondary-300: ${varForColor("#a1b3bf")};
    --color-secondary-400: ${varForColor("#668093")};
    --color-secondary-500: ${varForColor("#576f83")};
    --color-secondary-600: ${varForColor("#4b5e6f")};
    --color-secondary-700: ${varForColor("#414f5d")};
    --color-secondary-800: ${varForColor("#3b444f")};

    --color-tertiary: ${varForColor("#2c4763")};
    --color-tertiary-200: ${varForColor("#cddbea")};
    --color-tertiary-300: ${varForColor("#a1bdd8")};
    --color-tertiary-400: ${varForColor("#6f9bc1")};
    --color-tertiary-500: ${varForColor("#4d7eaa")};
    --color-tertiary-600: ${varForColor("#3a648f")};
    --color-tertiary-700: ${varForColor("#305174")};
    --color-tertiary-800: ${varForColor("#2c4763")};
    
    
    --color-background: 44 71 99; /* tumblr blue (dark) */
    --color-sidebar-bg: 219 233 244; /* tumblr placeholder bg */
    --color-sidebar-text: 25 25 25; /* not-black */
    --color-sidebar-accent: ${varForColor("#2c4763")}; /* tumblr blue (light) */
    
    --color-compose-button: ${varForColor("#83B05F")};
    --color-compose-button-400: ${varForColor("#98BD7A")};
    --color-compose-button-600: ${varForColor("#679047")};

    /* default brand colors to avoid breaking shit by accident */
    --color-notWhite: ${varForTailwindColor("notWhite")};
    --color-notBlack: ${varForTailwindColor("notBlack")};
    --color-cherry: var(--color-foreground);
    --color-strawberry: var(--color-secondary);
    --color-mango: var(--color-accent);
    --color-longan: var(--color-tertiary);
}`;

	const normalTheme = `
/*
 * colors specified as bare RGB components so they can get
 * merged with opacity if needed. see \`tailwind.config.js\`
 * for more info. */

:root {
    --color-notWhite: ${varForTailwindColor("notWhite")};
    --color-notBlack: ${varForTailwindColor("notBlack")};
    --color-cherry: ${varForTailwindColor("cherry")};
    --color-strawberry: ${varForTailwindColor("strawberry")};
    --color-mango: ${varForTailwindColor("mango")};
    --color-longan: ${varForTailwindColor("longan")};


    --color-text: var(--color-notWhite);
    --color-bg-text: var(--color-notBlack);

    --color-foreground-100: ${varForTailwindColor("cherry", "100")};
    --color-foreground-200: ${varForTailwindColor("cherry", "200")};
    --color-foreground-300: ${varForTailwindColor("cherry", "300")};
    --color-foreground-400: ${varForTailwindColor("cherry", "400")};
    --color-foreground-500: ${varForTailwindColor("cherry", "500")};
    --color-foreground-600: ${varForTailwindColor("cherry", "600")};    
    --color-foreground-700: ${varForTailwindColor("cherry", "700")};
    --color-foreground-800: ${varForTailwindColor("cherry", "800")};
    --color-foreground: var(--color-cherry);

    --color-secondary-200: ${varForTailwindColor("strawberry", "200")};
    --color-secondary-300: ${varForTailwindColor("strawberry", "300")};
    --color-secondary-400: ${varForTailwindColor("strawberry", "400")};
    --color-secondary-600: ${varForTailwindColor("strawberry", "600")};
    --color-secondary-700: ${varForTailwindColor("strawberry", "700")};
    --color-secondary: var(--color-strawberry);

    --color-tertiary: var(--color-longan);
    --color-tertiary-200: ${varForTailwindColor("longan", "200")};
    --color-tertiary-300: ${varForTailwindColor("longan", "300")};
    --color-tertiary-400: ${varForTailwindColor("longan", "400")};
    --color-tertiary-500: ${varForTailwindColor("longan", "600")};
    --color-tertiary-600: ${varForTailwindColor("longan", "600")};
    --color-tertiary-700: ${varForTailwindColor("longan", "700")};

    --color-accent: var(--color-mango);
    --color-background: var(--color-notWhite);
    --color-sidebar-bg: var(--color-notWhite);
    --color-sidebar-text: var(--color-notBlack);
    --color-sidebar-accent: var(--color-cherry);

    --color-compose-button: var(--color-foreground);
    --color-compose-button-400: var(--color-foreground-400);
    --color-compose-button-600: var(--color-foreground-600);
}

@media (max-width: 767px) {
    :root {
        --color-foreground: ${varForTailwindColor("cherry", "600")};
    }
}
`;

	const darkTheme = `@media (prefers-color-scheme: dark) {
    :root {
        --color-text: var(--color-notWhite);
        --color-bg-text: var(--color-notWhite);

        --color-foreground-100: ${varForTailwindColor("cherry", "100")};
        --color-foreground-200: ${varForTailwindColor("cherry", "200")};
        --color-foreground-300: ${varForTailwindColor("cherry", "300")};
        --color-foreground-400: ${varForTailwindColor("cherry", "400")};
        --color-foreground-500: ${varForTailwindColor("cherry", "500")};
        --color-foreground-600: ${varForTailwindColor("cherry", "600")};
        --color-foreground-700: ${varForTailwindColor("cherry", "700")};
        --color-foreground-800: ${varForTailwindColor("cherry", "800")};
        --color-foreground: var(--color-cherry);
        
        --color-secondary-200: ${varForTailwindColor("mango", "200")};
        --color-secondary-300: ${varForTailwindColor("mango", "300")};
        --color-secondary-400: ${varForTailwindColor("mango", "400")};
        --color-secondary-600: ${varForTailwindColor("mango", "600")};
        --color-secondary-700: ${varForTailwindColor("mango", "700")};
        --color-secondary: var(--color-mango);

        --color-accent: var(--color-mango);
        --color-background: var(--color-notBlack);
        --color-sidebar-bg: var(--color-notBlack);
        --color-sidebar-text: var(--color-notWhite);    
        --color-sidebar-accent: var(--color-mango);

        --color-compose-button: var(--color-foreground);
        --color-compose-button-400: var(--color-foreground-400);
        --color-compose-button-600: var(--color-foreground-600);
    }

    @media (max-width: 767px) {
        :root {
            --color-foreground: ${varForTailwindColor("cherry", "600")};
        }
    }    
}`;

	const combined = normalTheme + "\n" + darkTheme;

	const ThemeCSSVars

	 = ({ mode = "dynamic" }) => {
	    const chaosDay22 = index_browserExports.useFlag(FeatureFlag.Enum["chaos-day-2022"]);
	    const reqMutableStore = useReqMutableStore();
	    const defaultLightOnly = reqMutableStore.get("lightThemeOnly");

	    const selected = reactExports.useMemo(() => {
	        if (defaultLightOnly || mode === "light") {
	            return normalTheme;
	        }

	        if (mode === "light_with_themes" && chaosDay22) {
	            return chaosDay22Theme;
	        }

	        if (chaosDay22) {
	            return chaosDay22Theme;
	        }

	        return combined;
	    }, [chaosDay22, defaultLightOnly, mode]);

	    const foregroundColor = chaosDay22 ? "#435972" : "#83254f";
	    const mobileThemeColor = chaosDay22 ? "#435972" : "#671A3D";

	    return (
	        React$2.createElement(Helmet, null
	            , React$2.createElement('style', null, selected)
	            , React$2.createElement('style', null, `
            :root {
                --emoji-scale: 1.25em;
            }
            `)
	            , React$2.createElement('meta', {
	                name: "theme-color",
	                content: mobileThemeColor,
	                media: "(max-width: 1023px)" ,}
	            )
	            , React$2.createElement('meta', { name: "theme-color", content: foregroundColor,} )
	        )
	    );
	};

	const ErrorLayout = ({ children }) => {
	    const { t } = useTranslation();
	    const chaosDay22 = index_browserExports.useFlag(FeatureFlag.Enum["chaos-day-2022"]);

	    return (
	        React$2.createElement('div', { className: "flex flex-col" ,}
	            , React$2.createElement(CohostToaster, null )
	            , React$2.createElement(Favicons, null )
	            , React$2.createElement(ThemeCSSVars, { mode: "light_with_themes",} )
	            , React$2.createElement(Helmet, null
	                , React$2.createElement('title', null, "cohost!")
	            )
	            , React$2.createElement('header', { className: "cohost-shadow-light dark:cohost-shadow-dark fixed left-0 right-0 top-0 z-50 h-16 bg-foreground text-text"         ,}
	                , React$2.createElement('div', { className: "container mx-auto flex h-full flex-row items-center justify-between px-2 lg:p-0"        ,}
	                    , React$2.createElement('a', {
	                        href: sitemap.public.home().toString(),
	                        className: "text-text hover:text-accent" ,}

	                        , chaosDay22 ? (
	                            React$2.createElement(React$2.Fragment, null
	                                , React$2.createElement(CohostLogoBookman, {
	                                    className: "hidden h-8 lg:block"  ,
	                                    role: "img",
	                                    'aria-label': t("common:brand-name"),}
	                                )
	                                , React$2.createElement(CohostEggBookman, {
	                                    className: "block h-8 lg:hidden"  ,
	                                    role: "img",
	                                    'aria-label': t("common:brand-name"),}
	                                )
	                            )
	                        ) : (
	                            React$2.createElement(React$2.Fragment, null
	                                , React$2.createElement(CohostLogo, {
	                                    className: "hidden h-8 lg:block"  ,
	                                    role: "img",
	                                    'aria-label': t("common:brand-name"),}
	                                )
	                                , React$2.createElement(CohostEgg, {
	                                    className: "block h-8 lg:hidden"  ,
	                                    role: "img",
	                                    'aria-label': t("common:brand-name"),}
	                                )
	                            )
	                        )
	                    )
	                )
	            )
	            , React$2.createElement('div', { className: "mt-16 flex flex-grow flex-col"   ,}, children)
	        )
	    );
	};

	const IFrameLayout = ({ children }) => {
	    return (
	        React$2.createElement('div', null
	            , React$2.createElement(Helmet, null
	                , React$2.createElement('base', { target: "_parent",} )
	                , React$2.createElement('meta', { name: "robots", content: "noindex",} )
	            )
	            , children
	        )
	    );
	};

	var i$7=Object.defineProperty;var d$a=(t,e,n)=>e in t?i$7(t,e,{enumerable:!0,configurable:!0,writable:!0,value:n}):t[e]=n;var r$7=(t,e,n)=>(d$a(t,typeof e!="symbol"?e+"":e,n),n);let o$7 = class o{constructor(){r$7(this,"current",this.detect());r$7(this,"handoffState","pending");r$7(this,"currentId",0);}set(e){this.current!==e&&(this.handoffState="pending",this.currentId=0,this.current=e);}reset(){this.set(this.detect());}nextId(){return ++this.currentId}get isServer(){return this.current==="server"}get isClient(){return this.current==="client"}detect(){return typeof window=="undefined"||typeof document=="undefined"?"server":"client"}handoff(){this.handoffState==="pending"&&(this.handoffState="complete");}get isHandoffComplete(){return this.handoffState==="complete"}};let s$d=new o$7;

	let l$a=(e,f)=>{s$d.isServer?reactExports.useEffect(e,f):reactExports.useLayoutEffect(e,f);};

	function l$9(){let[e,f]=reactExports.useState(s$d.isHandoffComplete);return e&&s$d.isHandoffComplete===!1&&f(!1),reactExports.useEffect(()=>{e!==!0&&f(!0);},[e]),reactExports.useEffect(()=>s$d.handoff(),[]),e}

	var o$6;let I$6=(o$6=React$2.useId)!=null?o$6:function(){let n=l$9(),[e,u]=React$2.useState(n?()=>s$d.nextId():null);return l$a(()=>{e===null&&u(s$d.nextId());},[e]),e!=null?""+e:void 0};

	function e$5(...n){return n.filter(Boolean).join(" ")}

	function u$b(r,n,...a){if(r in n){let e=n[r];return typeof e=="function"?e(...a):e}let t=new Error(`Tried to handle "${r}" but there is no handler defined. Only defined handlers are: ${Object.keys(n).map(e=>`"${e}"`).join(", ")}.`);throw Error.captureStackTrace&&Error.captureStackTrace(t,u$b),t}

	var S$a=(a=>(a[a.None=0]="None",a[a.RenderStrategy=1]="RenderStrategy",a[a.Static=2]="Static",a))(S$a||{}),j$2=(e=>(e[e.Unmount=0]="Unmount",e[e.Hidden=1]="Hidden",e))(j$2||{});function X$6({ourProps:r,theirProps:t,slot:e,defaultTag:a,features:s,visible:n=!0,name:f}){let o=N$3(t,r);if(n)return c$9(o,e,a,f);let u=s!=null?s:0;if(u&2){let{static:l=!1,...p}=o;if(l)return c$9(p,e,a,f)}if(u&1){let{unmount:l=!0,...p}=o;return u$b(l?0:1,{[0](){return null},[1](){return c$9({...p,hidden:!0,style:{display:"none"}},e,a,f)}})}return c$9(o,e,a,f)}function c$9(r,t={},e,a){let{as:s=e,children:n,refName:f="ref",...o}=g$3(r,["unmount","static"]),u=r.ref!==void 0?{[f]:r.ref}:{},l=typeof n=="function"?n(t):n;"className"in o&&o.className&&typeof o.className=="function"&&(o.className=o.className(t));let p={};if(t){let i=!1,m=[];for(let[y,d]of Object.entries(t))typeof d=="boolean"&&(i=!0),d===!0&&m.push(y);i&&(p["data-headlessui-state"]=m.join(" "));}if(s===reactExports.Fragment&&Object.keys(R$4(o)).length>0){if(!reactExports.isValidElement(l)||Array.isArray(l)&&l.length>1)throw new Error(['Passing props on "Fragment"!',"",`The current component <${a} /> is rendering a "Fragment".`,"However we need to passthrough the following props:",Object.keys(o).map(d=>`  - ${d}`).join(`
`),"","You can apply a few solutions:",['Add an `as="..."` prop, to ensure that we render an actual element instead of a "Fragment".',"Render a single element as the child so that we can forward the props onto that element."].map(d=>`  - ${d}`).join(`
`)].join(`
`));let i=l.props,m=typeof(i==null?void 0:i.className)=="function"?(...d)=>e$5(i==null?void 0:i.className(...d),o.className):e$5(i==null?void 0:i.className,o.className),y=m?{className:m}:{};return reactExports.cloneElement(l,Object.assign({},N$3(l.props,R$4(g$3(o,["ref"]))),p,u,w$7(l.ref,u.ref),y))}return reactExports.createElement(s,Object.assign({},g$3(o,["ref"]),s!==reactExports.Fragment&&u,s!==reactExports.Fragment&&p),l)}function w$7(...r){return {ref:r.every(t=>t==null)?void 0:t=>{for(let e of r)e!=null&&(typeof e=="function"?e(t):e.current=t);}}}function N$3(...r){if(r.length===0)return {};if(r.length===1)return r[0];let t={},e={};for(let s of r)for(let n in s)n.startsWith("on")&&typeof s[n]=="function"?((e[n])!=null||(e[n]=[]),e[n].push(s[n])):t[n]=s[n];if(t.disabled||t["aria-disabled"])return Object.assign(t,Object.fromEntries(Object.keys(e).map(s=>[s,void 0])));for(let s in e)Object.assign(t,{[s](n,...f){let o=e[s];for(let u of o){if((n instanceof Event||(n==null?void 0:n.nativeEvent)instanceof Event)&&n.defaultPrevented)return;u(n,...f);}}});return t}function D$6(r){var t;return Object.assign(reactExports.forwardRef(r),{displayName:(t=r.displayName)!=null?t:r.name})}function R$4(r){let t=Object.assign({},r);for(let e in t)t[e]===void 0&&delete t[e];return t}function g$3(r,t=[]){let e=Object.assign({},r);for(let a of t)a in e&&delete e[a];return e}

	function s$c(e){let r=reactExports.useRef(e);return l$a(()=>{r.current=e;},[e]),r}

	let o$5=function(t){let e=s$c(t);return React$2.useCallback((...r)=>e.current(...r),[e])};

	let u$a=Symbol();function T$6(t,n=!0){return Object.assign(t,{[u$a]:n})}function y$9(...t){let n=reactExports.useRef(t);reactExports.useEffect(()=>{n.current=t;},[t]);let c=o$5(e=>{for(let o of n.current)o!=null&&(typeof o=="function"?o(e):o.current=e);});return t.every(e=>e==null||(e==null?void 0:e[u$a]))?void 0:c}

	let d$9=reactExports.createContext(null);function f$9(){let r=reactExports.useContext(d$9);if(r===null){let t=new Error("You used a <Description /> component, but it is not inside a relevant parent.");throw Error.captureStackTrace&&Error.captureStackTrace(t,f$9),t}return r}function M$9(){let[r,t]=reactExports.useState([]);return [r.length>0?r.join(" "):void 0,reactExports.useMemo(()=>function(e){let i=o$5(s=>(t(o=>[...o,s]),()=>t(o=>{let p=o.slice(),c=p.indexOf(s);return c!==-1&&p.splice(c,1),p}))),n=reactExports.useMemo(()=>({register:i,slot:e.slot,name:e.name,props:e.props}),[i,e.slot,e.name,e.props]);return React$2.createElement(d$9.Provider,{value:n},e.children)},[t])]}let S$9="p";function h$8(r,t){let a=I$6(),{id:e=`headlessui-description-${a}`,...i}=r,n=f$9(),s=y$9(t);l$a(()=>n.register(e),[e,n.register]);let o={ref:s,...n.props,id:e};return X$6({ourProps:o,theirProps:i,slot:n.slot||{},defaultTag:S$9,name:n.name||"Description"})}let y$8=D$6(h$8),b$2=Object.assign(y$8,{});

	var o$4=(r=>(r.Space=" ",r.Enter="Enter",r.Escape="Escape",r.Backspace="Backspace",r.Delete="Delete",r.ArrowLeft="ArrowLeft",r.ArrowUp="ArrowUp",r.ArrowRight="ArrowRight",r.ArrowDown="ArrowDown",r.Home="Home",r.End="End",r.PageUp="PageUp",r.PageDown="PageDown",r.Tab="Tab",r))(o$4||{});

	function r$6(n){let e=n.parentElement,l=null;for(;e&&!(e instanceof HTMLFieldSetElement);)e instanceof HTMLLegendElement&&(l=e),e=e.parentElement;let t=(e==null?void 0:e.getAttribute("disabled"))==="";return t&&i$6(l)?!1:t}function i$6(n){if(!n)return !1;let e=n.previousElementSibling;for(;e!==null;){if(e instanceof HTMLLegendElement)return !1;e=e.previousElementSibling;}return !0}

	let a$a="div";var p$b=(e=>(e[e.None=1]="None",e[e.Focusable=2]="Focusable",e[e.Hidden=4]="Hidden",e))(p$b||{});function s$b(t,o){let{features:n=1,...e}=t,d={ref:o,"aria-hidden":(n&2)===2?!0:void 0,style:{position:"fixed",top:1,left:1,width:1,height:0,padding:0,margin:-1,overflow:"hidden",clip:"rect(0, 0, 0, 0)",whiteSpace:"nowrap",borderWidth:"0",...(n&4)===4&&(n&2)!==2&&{display:"none"}}};return X$6({ourProps:d,theirProps:e,slot:{},defaultTag:a$a,name:"Hidden"})}let c$8=D$6(s$b);

	function t$b(e){typeof queueMicrotask=="function"?queueMicrotask(e):Promise.resolve().then(e).catch(o=>setTimeout(()=>{throw o}));}

	function o$3(){let n=[],r={addEventListener(e,t,s,a){return e.addEventListener(t,s,a),r.add(()=>e.removeEventListener(t,s,a))},requestAnimationFrame(...e){let t=requestAnimationFrame(...e);return r.add(()=>cancelAnimationFrame(t))},nextFrame(...e){return r.requestAnimationFrame(()=>r.requestAnimationFrame(...e))},setTimeout(...e){let t=setTimeout(...e);return r.add(()=>clearTimeout(t))},microTask(...e){let t={current:!0};return t$b(()=>{t.current&&e[0]();}),r.add(()=>{t.current=!1;})},style(e,t,s){let a=e.style.getPropertyValue(t);return Object.assign(e.style,{[t]:s}),this.add(()=>{Object.assign(e.style,{[t]:a});})},group(e){let t=o$3();return e(t),this.add(()=>t.dispose())},add(e){return n.push(e),()=>{let t=n.indexOf(e);if(t>=0)for(let s of n.splice(t,1))s();}},dispose(){for(let e of n.splice(0))e();}};return r}

	function e$4(r){return s$d.isServer?null:r instanceof Node?r.ownerDocument:r!=null&&r.hasOwnProperty("current")&&r.current instanceof Node?r.current.ownerDocument:document}

	let c$7=["[contentEditable=true]","[tabindex]","a[href]","area[href]","button:not([disabled])","iframe","input:not([disabled])","select:not([disabled])","textarea:not([disabled])"].map(e=>`${e}:not([tabindex='-1'])`).join(",");var M$8=(n=>(n[n.First=1]="First",n[n.Previous=2]="Previous",n[n.Next=4]="Next",n[n.Last=8]="Last",n[n.WrapAround=16]="WrapAround",n[n.NoScroll=32]="NoScroll",n))(M$8||{}),N$2=(o=>(o[o.Error=0]="Error",o[o.Overflow=1]="Overflow",o[o.Success=2]="Success",o[o.Underflow=3]="Underflow",o))(N$2||{}),F$7=(t=>(t[t.Previous=-1]="Previous",t[t.Next=1]="Next",t))(F$7||{});function f$8(e=document.body){return e==null?[]:Array.from(e.querySelectorAll(c$7)).sort((r,t)=>Math.sign((r.tabIndex||Number.MAX_SAFE_INTEGER)-(t.tabIndex||Number.MAX_SAFE_INTEGER)))}var T$5=(t=>(t[t.Strict=0]="Strict",t[t.Loose=1]="Loose",t))(T$5||{});function h$7(e,r=0){var t;return e===((t=e$4(e))==null?void 0:t.body)?!1:u$b(r,{[0](){return e.matches(c$7)},[1](){let l=e;for(;l!==null;){if(l.matches(c$7))return !0;l=l.parentElement;}return !1}})}function D$5(e){let r=e$4(e);o$3().nextFrame(()=>{r&&!h$7(r.activeElement,0)&&y$7(e);});}var w$6=(t=>(t[t.Keyboard=0]="Keyboard",t[t.Mouse=1]="Mouse",t))(w$6||{});typeof window!="undefined"&&typeof document!="undefined"&&(document.addEventListener("keydown",e=>{e.metaKey||e.altKey||e.ctrlKey||(document.documentElement.dataset.headlessuiFocusVisible="");},!0),document.addEventListener("click",e=>{e.detail===1?delete document.documentElement.dataset.headlessuiFocusVisible:e.detail===0&&(document.documentElement.dataset.headlessuiFocusVisible="");},!0));function y$7(e){e==null||e.focus({preventScroll:!0});}let S$8=["textarea","input"].join(",");function H$7(e){var r,t;return (t=(r=e==null?void 0:e.matches)==null?void 0:r.call(e,S$8))!=null?t:!1}function I$5(e,r=t=>t){return e.slice().sort((t,l)=>{let o=r(t),i=r(l);if(o===null||i===null)return 0;let n=o.compareDocumentPosition(i);return n&Node.DOCUMENT_POSITION_FOLLOWING?-1:n&Node.DOCUMENT_POSITION_PRECEDING?1:0})}function _$3(e,r){return O$6(f$8(),r,{relativeTo:e})}function O$6(e,r,{sorted:t=!0,relativeTo:l=null,skipElements:o=[]}={}){let i=Array.isArray(e)?e.length>0?e[0].ownerDocument:document:e.ownerDocument,n=Array.isArray(e)?t?I$5(e):e:f$8(e);o.length>0&&n.length>1&&(n=n.filter(s=>!o.includes(s))),l=l!=null?l:i.activeElement;let E=(()=>{if(r&5)return 1;if(r&10)return -1;throw new Error("Missing Focus.First, Focus.Previous, Focus.Next or Focus.Last")})(),x=(()=>{if(r&1)return 0;if(r&2)return Math.max(0,n.indexOf(l))-1;if(r&4)return Math.max(0,n.indexOf(l))+1;if(r&8)return n.length-1;throw new Error("Missing Focus.First, Focus.Previous, Focus.Next or Focus.Last")})(),p=r&32?{preventScroll:!0}:{},d=0,a=n.length,u;do{if(d>=a||d+a<=0)return 0;let s=x+d;if(r&16)s=(s+a)%a;else {if(s<0)return 3;if(s>=a)return 1}u=n[s],u==null||u.focus(p),d+=E;}while(u!==i.activeElement);return r&6&&H$7(u)&&u.select(),2}

	function s$a(e,r,n){let o=s$c(r);reactExports.useEffect(()=>{function t(i){o.current(i);}return window.addEventListener(e,t,n),()=>window.removeEventListener(e,t,n)},[e,n]);}

	var s$9=(r=>(r[r.Forwards=0]="Forwards",r[r.Backwards=1]="Backwards",r))(s$9||{});function n$8(){let e=reactExports.useRef(0);return s$a("keydown",o=>{o.key==="Tab"&&(e.current=o.shiftKey?1:0);},!0),e}

	function f$7(){let e=reactExports.useRef(!1);return l$a(()=>(e.current=!0,()=>{e.current=!1;}),[]),e}

	function n$7(...e){return reactExports.useMemo(()=>e$4(...e),[...e])}

	function E$3(n,e,a,t){let i=s$c(a);reactExports.useEffect(()=>{n=n!=null?n:window;function r(o){i.current(o);}return n.addEventListener(e,r,t),()=>n.removeEventListener(e,r,t)},[n,e,t]);}

	function m$5(u,t){let e=reactExports.useRef([]),r=o$5(u);reactExports.useEffect(()=>{let o=[...e.current];for(let[n,a]of t.entries())if(e.current[n]!==a){let l=r(t,o);return e.current=t,l}},[r,...t]);}

	function p$a(){let[e]=reactExports.useState(o$3);return reactExports.useEffect(()=>()=>e.dispose(),[e]),e}

	function t$a(n){function e(){document.readyState!=="loading"&&(n(),document.removeEventListener("DOMContentLoaded",e));}typeof window!="undefined"&&typeof document!="undefined"&&(document.addEventListener("DOMContentLoaded",e),e());}

	function P$4(t){if(!t)return new Set;if(typeof t=="function")return new Set(t());let n=new Set;for(let e of t.current)e.current instanceof HTMLElement&&n.add(e.current);return n}let J$2="div";var h$6=(r=>(r[r.None=1]="None",r[r.InitialFocus=2]="InitialFocus",r[r.TabLock=4]="TabLock",r[r.FocusLock=8]="FocusLock",r[r.RestoreFocus=16]="RestoreFocus",r[r.All=30]="All",r))(h$6||{});function X$5(t,n){let e=reactExports.useRef(null),o=y$9(e,n),{initialFocus:u,containers:i,features:r=30,...l}=t;l$9()||(r=1);let m=n$7(e);Y$5({ownerDocument:m},Boolean(r&16));let c=Z$6({ownerDocument:m,container:e,initialFocus:u},Boolean(r&2));$$a({ownerDocument:m,container:e,containers:i,previousActiveElement:c},Boolean(r&8));let v=n$8(),R=o$5(s=>{let T=e.current;if(!T)return;(B=>B())(()=>{u$b(v.current,{[s$9.Forwards]:()=>{O$6(T,M$8.First,{skipElements:[s.relatedTarget]});},[s$9.Backwards]:()=>{O$6(T,M$8.Last,{skipElements:[s.relatedTarget]});}});});}),_=p$a(),H=reactExports.useRef(!1),j={ref:o,onKeyDown(s){s.key=="Tab"&&(H.current=!0,_.requestAnimationFrame(()=>{H.current=!1;}));},onBlur(s){let T=P$4(i);e.current instanceof HTMLElement&&T.add(e.current);let E=s.relatedTarget;E instanceof HTMLElement&&E.dataset.headlessuiFocusGuard!=="true"&&(S$7(T,E)||(H.current?O$6(e.current,u$b(v.current,{[s$9.Forwards]:()=>M$8.Next,[s$9.Backwards]:()=>M$8.Previous})|M$8.WrapAround,{relativeTo:s.target}):s.target instanceof HTMLElement&&y$7(s.target)));}};return React$2.createElement(React$2.Fragment,null,Boolean(r&4)&&React$2.createElement(c$8,{as:"button",type:"button","data-headlessui-focus-guard":!0,onFocus:R,features:p$b.Focusable}),X$6({ourProps:j,theirProps:l,defaultTag:J$2,name:"FocusTrap"}),Boolean(r&4)&&React$2.createElement(c$8,{as:"button",type:"button","data-headlessui-focus-guard":!0,onFocus:R,features:p$b.Focusable}))}let z$5=D$6(X$5),Re$4=Object.assign(z$5,{features:h$6}),a$9=[];t$a(()=>{function t(n){n.target instanceof HTMLElement&&n.target!==document.body&&a$9[0]!==n.target&&(a$9.unshift(n.target),a$9=a$9.filter(e=>e!=null&&e.isConnected),a$9.splice(10));}window.addEventListener("click",t,{capture:!0}),window.addEventListener("mousedown",t,{capture:!0}),window.addEventListener("focus",t,{capture:!0}),document.body.addEventListener("click",t,{capture:!0}),document.body.addEventListener("mousedown",t,{capture:!0}),document.body.addEventListener("focus",t,{capture:!0});});function Q$4(t=!0){let n=reactExports.useRef(a$9.slice());return m$5(([e],[o])=>{o===!0&&e===!1&&t$b(()=>{n.current.splice(0);}),o===!1&&e===!0&&(n.current=a$9.slice());},[t,a$9,n]),o$5(()=>{var e;return (e=n.current.find(o=>o!=null&&o.isConnected))!=null?e:null})}function Y$5({ownerDocument:t},n){let e=Q$4(n);m$5(()=>{n||(t==null?void 0:t.activeElement)===(t==null?void 0:t.body)&&y$7(e());},[n]);let o=reactExports.useRef(!1);reactExports.useEffect(()=>(o.current=!1,()=>{o.current=!0,t$b(()=>{o.current&&y$7(e());});}),[]);}function Z$6({ownerDocument:t,container:n,initialFocus:e},o){let u=reactExports.useRef(null),i=f$7();return m$5(()=>{if(!o)return;let r=n.current;r&&t$b(()=>{if(!i.current)return;let l=t==null?void 0:t.activeElement;if(e!=null&&e.current){if((e==null?void 0:e.current)===l){u.current=l;return}}else if(r.contains(l)){u.current=l;return}e!=null&&e.current?y$7(e.current):O$6(r,M$8.First)===N$2.Error&&console.warn("There are no focusable elements inside the <FocusTrap />"),u.current=t==null?void 0:t.activeElement;});},[o]),u}function $$a({ownerDocument:t,container:n,containers:e,previousActiveElement:o},u){let i=f$7();E$3(t==null?void 0:t.defaultView,"focus",r=>{if(!u||!i.current)return;let l=P$4(e);n.current instanceof HTMLElement&&l.add(n.current);let m=o.current;if(!m)return;let c=r.target;c&&c instanceof HTMLElement?S$7(l,c)?(o.current=c,y$7(c)):(r.preventDefault(),r.stopPropagation(),y$7(m)):y$7(o.current);},!0);}function S$7(t,n){for(let e of t)if(e.contains(n))return !0;return !1}

	let e$3=reactExports.createContext(!1);function l$8(){return reactExports.useContext(e$3)}function P$3(o){return React$2.createElement(e$3.Provider,{value:o.force},o.children)}

	function H$6(u){let a=l$8(),o=reactExports.useContext(c$6),e=n$7(u),[l,n]=reactExports.useState(()=>{if(!a&&o!==null||s$d.isServer)return null;let t=e==null?void 0:e.getElementById("headlessui-portal-root");if(t)return t;if(e===null)return null;let r=e.createElement("div");return r.setAttribute("id","headlessui-portal-root"),e.body.appendChild(r)});return reactExports.useEffect(()=>{l!==null&&(e!=null&&e.body.contains(l)||e==null||e.body.appendChild(l));},[l,e]),reactExports.useEffect(()=>{a||o!==null&&n(o.current);},[o,n,a]),l}let O$5=reactExports.Fragment;function _$2(u,a){let o=u,e=reactExports.useRef(null),l=y$9(T$6(p=>{e.current=p;}),a),n=n$7(e),t=H$6(e),[r]=reactExports.useState(()=>{var p;return s$d.isServer?null:(p=n==null?void 0:n.createElement("div"))!=null?p:null}),y=l$9(),f=reactExports.useRef(!1);return l$a(()=>{if(f.current=!1,!(!t||!r))return t.contains(r)||(r.setAttribute("data-headlessui-portal",""),t.appendChild(r)),()=>{f.current=!0,t$b(()=>{var p;f.current&&(!t||!r||(r instanceof Node&&t.contains(r)&&t.removeChild(r),t.childNodes.length<=0&&((p=t.parentElement)==null||p.removeChild(t))));});}},[t,r]),y?!t||!r?null:reactDomExports.createPortal(X$6({ourProps:{ref:l},theirProps:o,defaultTag:O$5,name:"Portal"}),r):null}let F$6=reactExports.Fragment,c$6=reactExports.createContext(null);function U$4(u,a){let{target:o,...e}=u,n={ref:y$9(a)};return React$2.createElement(c$6.Provider,{value:o},X$6({ourProps:n,theirProps:e,defaultTag:F$6,name:"Popover.Group"}))}let S$6=D$6(_$2),j$1=D$6(U$4),te$2=Object.assign(S$6,{Group:j$1});

	let n$6=reactExports.createContext(null);n$6.displayName="OpenClosedContext";var d$8=(e=>(e[e.Open=1]="Open",e[e.Closed=2]="Closed",e[e.Closing=4]="Closing",e[e.Opening=8]="Opening",e))(d$8||{});function C$3(){return reactExports.useContext(n$6)}function c$5({value:o,children:r}){return React$2.createElement(n$6.Provider,{value:o},r)}

	let a$8=reactExports.createContext(()=>{});a$8.displayName="StackContext";var s$8=(e=>(e[e.Add=0]="Add",e[e.Remove=1]="Remove",e))(s$8||{});function x$4(){return reactExports.useContext(a$8)}function M$7({children:i,onUpdate:r,type:e,element:n,enabled:u}){let l=x$4(),o=o$5((...t)=>{r==null||r(...t),l(...t);});return l$a(()=>{let t=u===void 0||u===!0;return t&&o(0,e,n),()=>{t&&o(1,e,n);}},[o,e,n,u]),React$2.createElement(a$8.Provider,{value:o},i)}

	function d$7(e,r,n){let o=s$c(r);reactExports.useEffect(()=>{function t(u){o.current(u);}return document.addEventListener(e,t,n),()=>document.removeEventListener(e,t,n)},[e,n]);}

	function L$5(m,E,c=!0){let i=reactExports.useRef(!1);reactExports.useEffect(()=>{requestAnimationFrame(()=>{i.current=c;});},[c]);function f(e,o){if(!i.current||e.defaultPrevented)return;let l=function r(t){return typeof t=="function"?r(t()):Array.isArray(t)||t instanceof Set?t:[t]}(m),n=o(e);if(n!==null&&n.getRootNode().contains(n)){for(let r of l){if(r===null)continue;let t=r instanceof HTMLElement?r:r.current;if(t!=null&&t.contains(n)||e.composed&&e.composedPath().includes(t))return}return !h$7(n,T$5.Loose)&&n.tabIndex!==-1&&e.preventDefault(),E(e,n)}}let u=reactExports.useRef(null);d$7("mousedown",e=>{var o,l;i.current&&(u.current=((l=(o=e.composedPath)==null?void 0:o.call(e))==null?void 0:l[0])||e.target);},!0),d$7("click",e=>{u.current&&(f(e,()=>u.current),u.current=null);},!0),d$7("blur",e=>f(e,()=>window.document.activeElement instanceof HTMLIFrameElement?window.document.activeElement:null),!0);}

	function i$5(e,t){return e===t&&(e!==0||1/e===1/t)||e!==e&&t!==t}const d$6=typeof Object.is=="function"?Object.is:i$5,{useState:u$9,useEffect:h$5,useLayoutEffect:f$6,useDebugValue:p$9}=ReactOriginal;function y$6(e,t,c){const a=t(),[{inst:n},o]=u$9({inst:{value:a,getSnapshot:t}});return f$6(()=>{n.value=a,n.getSnapshot=t,r$5(n)&&o({inst:n});},[e,a,t]),h$5(()=>(r$5(n)&&o({inst:n}),e(()=>{r$5(n)&&o({inst:n});})),[e]),p$9(a),a}function r$5(e){const t=e.getSnapshot,c=e.value;try{const a=t();return !d$6(c,a)}catch{return !0}}

	const useSyncExternalStore = null;

	const r$4=typeof window!="undefined"&&typeof window.document!="undefined"&&typeof window.document.createElement!="undefined",s$7=!r$4,c$4=s$7?useSyncExternalStore:y$6,a$7="useSyncExternalStore"in ReactOriginal?(n=>n.useSyncExternalStore)(ReactOriginal):c$4;

	function S$5(t){return a$7(t.subscribe,t.getSnapshot,t.getSnapshot)}

	function a$6(o,r){let t=o(),n=new Set;return {getSnapshot(){return t},subscribe(e){return n.add(e),()=>n.delete(e)},dispatch(e,...s){let i=r[e].call(t,...s);i&&(t=i,n.forEach(c=>c()));}}}

	function c$3(){let o;return {before({doc:e}){var l;let n=e.documentElement;o=((l=e.defaultView)!=null?l:window).innerWidth-n.clientWidth;},after({doc:e,d:n}){let t=e.documentElement,l=t.clientWidth-t.offsetWidth,r=o-l;n.style(t,"paddingRight",`${r}px`);}}}

	function t$9(){return /iPhone/gi.test(window.navigator.platform)||/Mac/gi.test(window.navigator.platform)&&window.navigator.maxTouchPoints>0}

	function p$8(){if(!t$9())return {};let o;return {before(){o=window.pageYOffset;},after({doc:r,d:l,meta:s}){function i(e){return s.containers.flatMap(t=>t()).some(t=>t.contains(e))}l.style(r.body,"marginTop",`-${o}px`),window.scrollTo(0,0);let n=null;l.addEventListener(r,"click",e=>{if(e.target instanceof HTMLElement)try{let t=e.target.closest("a");if(!t)return;let{hash:c}=new URL(t.href),a=r.querySelector(c);a&&!i(a)&&(n=a);}catch{}},!0),l.addEventListener(r,"touchmove",e=>{e.target instanceof HTMLElement&&!i(e.target)&&e.preventDefault();},{passive:!1}),l.add(()=>{window.scrollTo(0,window.pageYOffset+o),n&&n.isConnected&&(n.scrollIntoView({block:"nearest"}),n=null);});}}}

	function l$7(){return {before({doc:e,d:o}){o.style(e.documentElement,"overflow","hidden");}}}

	function m$4(e){let n={};for(let t of e)Object.assign(n,t(n));return n}let a$5=a$6(()=>new Map,{PUSH(e,n){var o;let t=(o=this.get(e))!=null?o:{doc:e,count:0,d:o$3(),meta:new Set};return t.count++,t.meta.add(n),this.set(e,t),this},POP(e,n){let t=this.get(e);return t&&(t.count--,t.meta.delete(n)),this},SCROLL_PREVENT({doc:e,d:n,meta:t}){let o={doc:e,d:n,meta:m$4(t)},c=[p$8(),c$3(),l$7()];c.forEach(({before:r})=>r==null?void 0:r(o)),c.forEach(({after:r})=>r==null?void 0:r(o));},SCROLL_ALLOW({d:e}){e.dispose();},TEARDOWN({doc:e}){this.delete(e);}});a$5.subscribe(()=>{let e=a$5.getSnapshot(),n=new Map;for(let[t]of e)n.set(t,t.documentElement.style.overflow);for(let t of e.values()){let o=n.get(t.doc)==="hidden",c=t.count!==0;(c&&!o||!c&&o)&&a$5.dispatch(t.count>0?"SCROLL_PREVENT":"SCROLL_ALLOW",t),t.count===0&&a$5.dispatch("TEARDOWN",t);}});

	function p$7(e,r,n){let f=S$5(a$5),o=e?f.get(e):void 0,i=o?o.count>0:!1;return l$a(()=>{if(!(!e||!r))return a$5.dispatch("PUSH",e,n),()=>a$5.dispatch("POP",e,n)},[r,e]),i}

	let u$8=new Map,t$8=new Map;function h$4(r,l=!0){l$a(()=>{var o;if(!l)return;let e=typeof r=="function"?r():r.current;if(!e)return;function a(){var d;if(!e)return;let i=(d=t$8.get(e))!=null?d:1;if(i===1?t$8.delete(e):t$8.set(e,i-1),i!==1)return;let n=u$8.get(e);n&&(n["aria-hidden"]===null?e.removeAttribute("aria-hidden"):e.setAttribute("aria-hidden",n["aria-hidden"]),e.inert=n.inert,u$8.delete(e));}let f=(o=t$8.get(e))!=null?o:0;return t$8.set(e,f+1),f!==0||(u$8.set(e,{"aria-hidden":e.getAttribute("aria-hidden"),inert:e.inert}),e.setAttribute("aria-hidden","true"),e.inert=!0),a},[r,l]);}

	var Se$4=(o=>(o[o.Open=0]="Open",o[o.Closed=1]="Closed",o))(Se$4||{}),Fe$3=(e=>(e[e.SetTitleId=0]="SetTitleId",e))(Fe$3||{});let ke$1={[0](t,e){return t.titleId===e.id?t:{...t,titleId:e.id}}},M$6=reactExports.createContext(null);M$6.displayName="DialogContext";function S$4(t){let e=reactExports.useContext(M$6);if(e===null){let o=new Error(`<${t} /> is missing a parent <Dialog /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(o,S$4),o}return e}function xe$4(t,e,o=()=>[document.body]){p$7(t,e,s=>{var n;return {containers:[...(n=s.containers)!=null?n:[],o]}});}function _e$2(t,e){return u$b(e.type,ke$1,t,e)}let Me$4="div",He$4=S$a.RenderStrategy|S$a.Static;function Ie$4(t,e){let o=I$6(),{id:s=`headlessui-dialog-${o}`,open:n,onClose:l,initialFocus:d,__demoMode:c=!1,...D}=t,[P,F]=reactExports.useState(0),i=C$3();n===void 0&&i!==null&&(n=(i&d$8.Open)===d$8.Open);let m=reactExports.useRef(null),Q=y$9(m,e),y=reactExports.useRef(null),p=n$7(m),U=t.hasOwnProperty("open")||i!==null,N=t.hasOwnProperty("onClose");if(!U&&!N)throw new Error("You have to provide an `open` and an `onClose` prop to the `Dialog` component.");if(!U)throw new Error("You provided an `onClose` prop to the `Dialog`, but forgot an `open` prop.");if(!N)throw new Error("You provided an `open` prop to the `Dialog`, but forgot an `onClose` prop.");if(typeof n!="boolean")throw new Error(`You provided an \`open\` prop to the \`Dialog\`, but the value is not a boolean. Received: ${n}`);if(typeof l!="function")throw new Error(`You provided an \`onClose\` prop to the \`Dialog\`, but the value is not a function. Received: ${l}`);let u=n?0:1,[E,Z]=reactExports.useReducer(_e$2,{titleId:null,descriptionId:null,panelRef:reactExports.createRef()}),A=o$5(()=>l(!1)),Y=o$5(r=>Z({type:0,id:r})),k=l$9()?c?!1:u===0:!1,x=P>1,$=reactExports.useContext(M$6)!==null,ee=x?"parent":"leaf",W=i!==null?(i&d$8.Closing)===d$8.Closing:!1,te=(()=>$||W?!1:k)(),oe=reactExports.useCallback(()=>{var r,f;return (f=Array.from((r=p==null?void 0:p.querySelectorAll("body > *"))!=null?r:[]).find(a=>a.id==="headlessui-portal-root"?!1:a.contains(y.current)&&a instanceof HTMLElement))!=null?f:null},[y]);h$4(oe,te);let re=(()=>x?!0:k)(),ne=reactExports.useCallback(()=>{var r,f;return (f=Array.from((r=p==null?void 0:p.querySelectorAll("[data-headlessui-portal]"))!=null?r:[]).find(a=>a.contains(y.current)&&a instanceof HTMLElement))!=null?f:null},[y]);h$4(ne,re);let H=o$5(()=>{var f,a;return [...Array.from((f=p==null?void 0:p.querySelectorAll("html > *, body > *, [data-headlessui-portal]"))!=null?f:[]).filter(T=>!(T===document.body||T===document.head||!(T instanceof HTMLElement)||T.contains(y.current)||E.panelRef.current&&T.contains(E.panelRef.current))),(a=E.panelRef.current)!=null?a:m.current]}),le=(()=>!(!k||x))();L$5(()=>H(),A,le);let ae=(()=>!(x||u!==0))();E$3(p==null?void 0:p.defaultView,"keydown",r=>{ae&&(r.defaultPrevented||r.key===o$4.Escape&&(r.preventDefault(),r.stopPropagation(),A()));});let ie=(()=>!(W||u!==0||$))();xe$4(p,ie,H),reactExports.useEffect(()=>{if(u!==0||!m.current)return;let r=new ResizeObserver(f=>{for(let a of f){let T=a.target.getBoundingClientRect();T.x===0&&T.y===0&&T.width===0&&T.height===0&&A();}});return r.observe(m.current),()=>r.disconnect()},[u,m,A]);let[se,pe]=M$9(),de=reactExports.useMemo(()=>[{dialogState:u,close:A,setTitleId:Y},E],[u,E,A,Y]),J=reactExports.useMemo(()=>({open:u===0}),[u]),ue={ref:Q,id:s,role:"dialog","aria-modal":u===0?!0:void 0,"aria-labelledby":E.titleId,"aria-describedby":se};return React$2.createElement(M$7,{type:"Dialog",enabled:u===0,element:m,onUpdate:o$5((r,f)=>{f==="Dialog"&&u$b(r,{[s$8.Add]:()=>F(a=>a+1),[s$8.Remove]:()=>F(a=>a-1)});})},React$2.createElement(P$3,{force:!0},React$2.createElement(te$2,null,React$2.createElement(M$6.Provider,{value:de},React$2.createElement(te$2.Group,{target:m},React$2.createElement(P$3,{force:!1},React$2.createElement(pe,{slot:J,name:"Dialog.Description"},React$2.createElement(Re$4,{initialFocus:d,containers:H,features:k?u$b(ee,{parent:Re$4.features.RestoreFocus,leaf:Re$4.features.All&~Re$4.features.FocusLock}):Re$4.features.None},X$6({ourProps:ue,theirProps:D,slot:J,defaultTag:Me$4,features:He$4,visible:u===0,name:"Dialog"})))))))),React$2.createElement(c$8,{features:p$b.Hidden,ref:y}))}let we$2="div";function Be$3(t,e){let o=I$6(),{id:s=`headlessui-dialog-overlay-${o}`,...n}=t,[{dialogState:l,close:d}]=S$4("Dialog.Overlay"),c=y$9(e),D=o$5(i=>{if(i.target===i.currentTarget){if(r$6(i.currentTarget))return i.preventDefault();i.preventDefault(),i.stopPropagation(),d();}}),P=reactExports.useMemo(()=>({open:l===0}),[l]);return X$6({ourProps:{ref:c,id:s,"aria-hidden":!0,onClick:D},theirProps:n,slot:P,defaultTag:we$2,name:"Dialog.Overlay"})}let Ge$3="div";function Ue$2(t,e){let o=I$6(),{id:s=`headlessui-dialog-backdrop-${o}`,...n}=t,[{dialogState:l},d]=S$4("Dialog.Backdrop"),c=y$9(e);reactExports.useEffect(()=>{if(d.panelRef.current===null)throw new Error("A <Dialog.Backdrop /> component is being used, but a <Dialog.Panel /> component is missing.")},[d.panelRef]);let D=reactExports.useMemo(()=>({open:l===0}),[l]);return React$2.createElement(P$3,{force:!0},React$2.createElement(te$2,null,X$6({ourProps:{ref:c,id:s,"aria-hidden":!0},theirProps:n,slot:D,defaultTag:Ge$3,name:"Dialog.Backdrop"})))}let Ne$4="div";function Ye$2(t,e){let o=I$6(),{id:s=`headlessui-dialog-panel-${o}`,...n}=t,[{dialogState:l},d]=S$4("Dialog.Panel"),c=y$9(e,d.panelRef),D=reactExports.useMemo(()=>({open:l===0}),[l]),P=o$5(i=>{i.stopPropagation();});return X$6({ourProps:{ref:c,id:s,onClick:P},theirProps:n,slot:D,defaultTag:Ne$4,name:"Dialog.Panel"})}let $e$3="h2";function We$3(t,e){let o=I$6(),{id:s=`headlessui-dialog-title-${o}`,...n}=t,[{dialogState:l,setTitleId:d}]=S$4("Dialog.Title"),c=y$9(e);reactExports.useEffect(()=>(d(s),()=>d(null)),[s,d]);let D=reactExports.useMemo(()=>({open:l===0}),[l]);return X$6({ourProps:{ref:c,id:s},theirProps:n,slot:D,defaultTag:$e$3,name:"Dialog.Title"})}let Je$3=D$6(Ie$4),Xe$3=D$6(Ue$2),je$3=D$6(Ye$2),Ke$3=D$6(Be$3),Ve$3=D$6(We$3),St$1=Object.assign(Je$3,{Backdrop:Xe$3,Panel:je$3,Overlay:Ke$3,Title:Ve$3,Description:b$2});

	function i$4(t){var n;if(t.type)return t.type;let e=(n=t.as)!=null?n:"button";if(typeof e=="string"&&e.toLowerCase()==="button")return "button"}function s$6(t,e){let[n,u]=reactExports.useState(()=>i$4(t));return l$a(()=>{u(i$4(t));},[t.type,t.as]),l$a(()=>{n||e.current&&e.current instanceof HTMLButtonElement&&!e.current.hasAttribute("type")&&u("button");},[n,e]),n}

	var t$7;let a$4=(t$7=React$2.startTransition)!=null?t$7:function(i){i();};

	var q$6=(o=>(o[o.Open=0]="Open",o[o.Closed=1]="Closed",o))(q$6||{}),z$4=(t=>(t[t.ToggleDisclosure=0]="ToggleDisclosure",t[t.CloseDisclosure=1]="CloseDisclosure",t[t.SetButtonId=2]="SetButtonId",t[t.SetPanelId=3]="SetPanelId",t[t.LinkPanel=4]="LinkPanel",t[t.UnlinkPanel=5]="UnlinkPanel",t))(z$4||{});let Q$3={[0]:e=>({...e,disclosureState:u$b(e.disclosureState,{[0]:1,[1]:0})}),[1]:e=>e.disclosureState===1?e:{...e,disclosureState:1},[4](e){return e.linkedPanel===!0?e:{...e,linkedPanel:!0}},[5](e){return e.linkedPanel===!1?e:{...e,linkedPanel:!1}},[2](e,n){return e.buttonId===n.buttonId?e:{...e,buttonId:n.buttonId}},[3](e,n){return e.panelId===n.panelId?e:{...e,panelId:n.panelId}}},k$5=reactExports.createContext(null);k$5.displayName="DisclosureContext";function M$5(e){let n=reactExports.useContext(k$5);if(n===null){let o=new Error(`<${e} /> is missing a parent <Disclosure /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(o,M$5),o}return n}let v$7=reactExports.createContext(null);v$7.displayName="DisclosureAPIContext";function w$5(e){let n=reactExports.useContext(v$7);if(n===null){let o=new Error(`<${e} /> is missing a parent <Disclosure /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(o,w$5),o}return n}let H$5=reactExports.createContext(null);H$5.displayName="DisclosurePanelContext";function V$4(){return reactExports.useContext(H$5)}function Y$4(e,n){return u$b(n.type,Q$3,e,n)}let Z$5=reactExports.Fragment;function ee$2(e,n){let{defaultOpen:o=!1,...u}=e,T=reactExports.useRef(null),l=y$9(n,T$6(a=>{T.current=a;},e.as===void 0||e.as===reactExports.Fragment)),t=reactExports.useRef(null),f=reactExports.useRef(null),s=reactExports.useReducer(Y$4,{disclosureState:o?0:1,linkedPanel:!1,buttonRef:f,panelRef:t,buttonId:null,panelId:null}),[{disclosureState:i,buttonId:c},D]=s,d=o$5(a=>{D({type:1});let r=e$4(T);if(!r||!c)return;let p=(()=>a?a instanceof HTMLElement?a:a.current instanceof HTMLElement?a.current:r.getElementById(c):r.getElementById(c))();p==null||p.focus();}),P=reactExports.useMemo(()=>({close:d}),[d]),b=reactExports.useMemo(()=>({open:i===0,close:d}),[i,d]),y={ref:l};return React$2.createElement(k$5.Provider,{value:s},React$2.createElement(v$7.Provider,{value:P},React$2.createElement(c$5,{value:u$b(i,{[0]:d$8.Open,[1]:d$8.Closed})},X$6({ourProps:y,theirProps:u,slot:b,defaultTag:Z$5,name:"Disclosure"}))))}let te$1="button";function ne$3(e,n){let o=I$6(),{id:u=`headlessui-disclosure-button-${o}`,...T}=e,[l,t]=M$5("Disclosure.Button"),f=V$4(),s=f===null?!1:f===l.panelId,i=reactExports.useRef(null),c=y$9(i,n,s?null:l.buttonRef);reactExports.useEffect(()=>{if(!s)return t({type:2,buttonId:u}),()=>{t({type:2,buttonId:null});}},[u,t,s]);let D=o$5(r=>{var p;if(s){if(l.disclosureState===1)return;switch(r.key){case o$4.Space:case o$4.Enter:r.preventDefault(),r.stopPropagation(),t({type:0}),(p=l.buttonRef.current)==null||p.focus();break}}else switch(r.key){case o$4.Space:case o$4.Enter:r.preventDefault(),r.stopPropagation(),t({type:0});break}}),d=o$5(r=>{switch(r.key){case o$4.Space:r.preventDefault();break}}),P=o$5(r=>{var p;r$6(r.currentTarget)||e.disabled||(s?(t({type:0}),(p=l.buttonRef.current)==null||p.focus()):t({type:0}));}),b=reactExports.useMemo(()=>({open:l.disclosureState===0}),[l]),y=s$6(e,i),a=s?{ref:c,type:y,onKeyDown:D,onClick:P}:{ref:c,id:u,type:y,"aria-expanded":e.disabled?void 0:l.disclosureState===0,"aria-controls":l.linkedPanel?l.panelId:void 0,onKeyDown:D,onKeyUp:d,onClick:P};return X$6({ourProps:a,theirProps:T,slot:b,defaultTag:te$1,name:"Disclosure.Button"})}let le$2="div",oe$1=S$a.RenderStrategy|S$a.Static;function re$3(e,n){let o=I$6(),{id:u=`headlessui-disclosure-panel-${o}`,...T}=e,[l,t]=M$5("Disclosure.Panel"),{close:f}=w$5("Disclosure.Panel"),s=y$9(n,l.panelRef,P=>{a$4(()=>t({type:P?4:5}));});reactExports.useEffect(()=>(t({type:3,panelId:u}),()=>{t({type:3,panelId:null});}),[u,t]);let i=C$3(),c=(()=>i!==null?(i&d$8.Open)===d$8.Open:l.disclosureState===0)(),D=reactExports.useMemo(()=>({open:l.disclosureState===0,close:f}),[l,f]),d={ref:s,id:u};return React$2.createElement(H$5.Provider,{value:l.panelId},X$6({ourProps:d,theirProps:T,slot:D,defaultTag:le$2,features:oe$1,visible:c,name:"Disclosure.Panel"}))}let se$2=D$6(ee$2),ue$2=D$6(ne$3),ie$2=D$6(re$3),ve$3=Object.assign(se$2,{Button:ue$2,Panel:ie$2});

	let d$5=reactExports.createContext(null);function u$7(){let o=reactExports.useContext(d$5);if(o===null){let t=new Error("You used a <Label /> component, but it is not inside a relevant parent.");throw Error.captureStackTrace&&Error.captureStackTrace(t,u$7),t}return o}function H$4(){let[o,t]=reactExports.useState([]);return [o.length>0?o.join(" "):void 0,reactExports.useMemo(()=>function(e){let s=o$5(r=>(t(l=>[...l,r]),()=>t(l=>{let n=l.slice(),p=n.indexOf(r);return p!==-1&&n.splice(p,1),n}))),a=reactExports.useMemo(()=>({register:s,slot:e.slot,name:e.name,props:e.props}),[s,e.slot,e.name,e.props]);return React$2.createElement(d$5.Provider,{value:a},e.children)},[t])]}let A$5="label";function h$3(o,t){let i=I$6(),{id:e=`headlessui-label-${i}`,passive:s=!1,...a}=o,r=u$7(),l=y$9(t);l$a(()=>r.register(e),[e,r.register]);let n={ref:l,...r.props,id:e};return s&&("onClick"in n&&(delete n.htmlFor,delete n.onClick),"onClick"in a&&delete a.onClick),X$6({ourProps:n,theirProps:a,slot:r.slot||{},defaultTag:A$5,name:r.name||"Label"})}let v$6=D$6(h$3),M$4=Object.assign(v$6,{});

	function i$3(e,o){let[u,t]=reactExports.useState(e),r=s$c(e);return l$a(()=>t(r.current),[r,t,...o]),u}

	function f$5(r){throw new Error("Unexpected object: "+r)}var a$3=(e=>(e[e.First=0]="First",e[e.Previous=1]="Previous",e[e.Next=2]="Next",e[e.Last=3]="Last",e[e.Specific=4]="Specific",e[e.Nothing=5]="Nothing",e))(a$3||{});function x$3(r,n){let t=n.resolveItems();if(t.length<=0)return null;let l=n.resolveActiveIndex(),s=l!=null?l:-1,d=(()=>{switch(r.focus){case 0:return t.findIndex(e=>!n.resolveDisabled(e));case 1:{let e=t.slice().reverse().findIndex((i,c,u)=>s!==-1&&u.length-c-1>=s?!1:!n.resolveDisabled(i));return e===-1?e:t.length-1-e}case 2:return t.findIndex((e,i)=>i<=s?!1:!n.resolveDisabled(e));case 3:{let e=t.slice().reverse().findIndex(i=>!n.resolveDisabled(i));return e===-1?e:t.length-1-e}case 4:return t.findIndex(e=>n.resolveId(e)===r.id);case 5:return null;default:f$5(r);}})();return d===-1?l:d}

	function e$2(n={},r=null,t=[]){for(let[i,o]of Object.entries(n))f$4(t,s$5(r,i),o);return t}function s$5(n,r){return n?n+"["+r+"]":r}function f$4(n,r,t){if(Array.isArray(t))for(let[i,o]of t.entries())f$4(n,s$5(r,i.toString()),o);else t instanceof Date?n.push([r,t.toISOString()]):typeof t=="boolean"?n.push([r,t?"1":"0"]):typeof t=="string"?n.push([r,t]):typeof t=="number"?n.push([r,`${t}`]):t==null?n.push([r,""]):e$2(t,r,n);}function p$6(n){var t;let r=(t=n==null?void 0:n.form)!=null?t:n.closest("form");if(r){for(let i of r.elements)if(i.tagName==="INPUT"&&i.type==="submit"||i.tagName==="BUTTON"&&i.type==="submit"||i.nodeName==="INPUT"&&i.type==="image"){i.click();return}}}

	function T$4(l,r,c){let[i,s]=reactExports.useState(c),e=l!==void 0,t=reactExports.useRef(e),u=reactExports.useRef(!1),d=reactExports.useRef(!1);return e&&!t.current&&!u.current?(u.current=!0,t.current=e,console.error("A component is changing from uncontrolled to controlled. This may be caused by the value changing from undefined to a defined value, which should not happen.")):!e&&t.current&&!d.current&&(d.current=!0,t.current=e,console.error("A component is changing from controlled to uncontrolled. This may be caused by the value changing from a defined value to undefined, which should not happen.")),[e?l:i,o$5(n=>(e||s(n),r==null?void 0:r(n)))]}

	function t$6(e){return [e.screenX,e.screenY]}function u$6(){let e=reactExports.useRef([-1,-1]);return {wasMoved(r){let n=t$6(r);return e.current[0]===n[0]&&e.current[1]===n[1]?!1:(e.current=n,!0)},update(r){e.current=t$6(r);}}}

	var Ue$1=(o=>(o[o.Open=0]="Open",o[o.Closed=1]="Closed",o))(Ue$1||{}),Be$2=(o=>(o[o.Single=0]="Single",o[o.Multi=1]="Multi",o))(Be$2||{}),He$3=(o=>(o[o.Pointer=0]="Pointer",o[o.Other=1]="Other",o))(He$3||{}),Ge$2=(i=>(i[i.OpenListbox=0]="OpenListbox",i[i.CloseListbox=1]="CloseListbox",i[i.GoToOption=2]="GoToOption",i[i.Search=3]="Search",i[i.ClearSearch=4]="ClearSearch",i[i.RegisterOption=5]="RegisterOption",i[i.UnregisterOption=6]="UnregisterOption",i[i.RegisterLabel=7]="RegisterLabel",i))(Ge$2||{});function X$4(e,a=o=>o){let o=e.activeOptionIndex!==null?e.options[e.activeOptionIndex]:null,r=I$5(a(e.options.slice()),t=>t.dataRef.current.domRef.current),l=o?r.indexOf(o):null;return l===-1&&(l=null),{options:r,activeOptionIndex:l}}let Ne$3={[1](e){return e.dataRef.current.disabled||e.listboxState===1?e:{...e,activeOptionIndex:null,listboxState:1}},[0](e){if(e.dataRef.current.disabled||e.listboxState===0)return e;let a=e.activeOptionIndex,{isSelected:o}=e.dataRef.current,r=e.options.findIndex(l=>o(l.dataRef.current.value));return r!==-1&&(a=r),{...e,listboxState:0,activeOptionIndex:a}},[2](e,a){var l;if(e.dataRef.current.disabled||e.listboxState===1)return e;let o=X$4(e),r=x$3(a,{resolveItems:()=>o.options,resolveActiveIndex:()=>o.activeOptionIndex,resolveId:t=>t.id,resolveDisabled:t=>t.dataRef.current.disabled});return {...e,...o,searchQuery:"",activeOptionIndex:r,activationTrigger:(l=a.trigger)!=null?l:1}},[3]:(e,a)=>{if(e.dataRef.current.disabled||e.listboxState===1)return e;let r=e.searchQuery!==""?0:1,l=e.searchQuery+a.value.toLowerCase(),p=(e.activeOptionIndex!==null?e.options.slice(e.activeOptionIndex+r).concat(e.options.slice(0,e.activeOptionIndex+r)):e.options).find(i=>{var b;return !i.dataRef.current.disabled&&((b=i.dataRef.current.textValue)==null?void 0:b.startsWith(l))}),u=p?e.options.indexOf(p):-1;return u===-1||u===e.activeOptionIndex?{...e,searchQuery:l}:{...e,searchQuery:l,activeOptionIndex:u,activationTrigger:1}},[4](e){return e.dataRef.current.disabled||e.listboxState===1||e.searchQuery===""?e:{...e,searchQuery:""}},[5]:(e,a)=>{let o={id:a.id,dataRef:a.dataRef},r=X$4(e,l=>[...l,o]);return e.activeOptionIndex===null&&e.dataRef.current.isSelected(a.dataRef.current.value)&&(r.activeOptionIndex=r.options.indexOf(o)),{...e,...r}},[6]:(e,a)=>{let o=X$4(e,r=>{let l=r.findIndex(t=>t.id===a.id);return l!==-1&&r.splice(l,1),r});return {...e,...o,activationTrigger:1}},[7]:(e,a)=>({...e,labelId:a.id})},$$9=reactExports.createContext(null);$$9.displayName="ListboxActionsContext";function U$3(e){let a=reactExports.useContext($$9);if(a===null){let o=new Error(`<${e} /> is missing a parent <Listbox /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(o,U$3),o}return a}let z$3=reactExports.createContext(null);z$3.displayName="ListboxDataContext";function B$4(e){let a=reactExports.useContext(z$3);if(a===null){let o=new Error(`<${e} /> is missing a parent <Listbox /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(o,B$4),o}return a}function je$2(e,a){return u$b(a.type,Ne$3,e,a)}let Ve$2=reactExports.Fragment;function Ke$2(e,a){let{value:o,defaultValue:r,form:l,name:t,onChange:p,by:u=(s,d)=>s===d,disabled:i=!1,horizontal:b=!1,multiple:R=!1,...m}=e;const P=b?"horizontal":"vertical";let E=y$9(a),[L=R?[]:void 0,v]=T$4(o,p,r),[c,n]=reactExports.useReducer(je$2,{dataRef:reactExports.createRef(),listboxState:1,options:[],searchQuery:"",labelId:null,activeOptionIndex:null,activationTrigger:1}),x=reactExports.useRef({static:!1,hold:!1}),h=reactExports.useRef(null),Q=reactExports.useRef(null),J=reactExports.useRef(null),y=o$5(typeof u=="string"?(s,d)=>{let O=u;return (s==null?void 0:s[O])===(d==null?void 0:d[O])}:u),S=reactExports.useCallback(s=>u$b(T.mode,{[1]:()=>L.some(d=>y(d,s)),[0]:()=>y(L,s)}),[L]),T=reactExports.useMemo(()=>({...c,value:L,disabled:i,mode:R?1:0,orientation:P,compare:y,isSelected:S,optionsPropsRef:x,labelRef:h,buttonRef:Q,optionsRef:J}),[L,i,R,c]);l$a(()=>{c.dataRef.current=T;},[T]),L$5([T.buttonRef,T.optionsRef],(s,d)=>{var O;n({type:1}),h$7(d,T$5.Loose)||(s.preventDefault(),(O=T.buttonRef.current)==null||O.focus());},T.listboxState===0);let ne=reactExports.useMemo(()=>({open:T.listboxState===0,disabled:i,value:L}),[T,i,L]),ie=o$5(s=>{let d=T.options.find(O=>O.id===s);d&&F(d.dataRef.current.value);}),re=o$5(()=>{if(T.activeOptionIndex!==null){let{dataRef:s,id:d}=T.options[T.activeOptionIndex];F(s.current.value),n({type:2,focus:a$3.Specific,id:d});}}),ae=o$5(()=>n({type:0})),le=o$5(()=>n({type:1})),se=o$5((s,d,O)=>s===a$3.Specific?n({type:2,focus:a$3.Specific,id:d,trigger:O}):n({type:2,focus:s,trigger:O})),pe=o$5((s,d)=>(n({type:5,id:s,dataRef:d}),()=>n({type:6,id:s}))),ue=o$5(s=>(n({type:7,id:s}),()=>n({type:7,id:null}))),F=o$5(s=>u$b(T.mode,{[0](){return v==null?void 0:v(s)},[1](){let d=T.value.slice(),O=d.findIndex(M=>y(M,s));return O===-1?d.push(s):d.splice(O,1),v==null?void 0:v(d)}})),de=o$5(s=>n({type:3,value:s})),ce=o$5(()=>n({type:4})),fe=reactExports.useMemo(()=>({onChange:F,registerOption:pe,registerLabel:ue,goToOption:se,closeListbox:le,openListbox:ae,selectActiveOption:re,selectOption:ie,search:de,clearSearch:ce}),[]),Te={ref:E},H=reactExports.useRef(null),be=p$a();return reactExports.useEffect(()=>{H.current&&r!==void 0&&be.addEventListener(H.current,"reset",()=>{F(r);});},[H,F]),React$2.createElement($$9.Provider,{value:fe},React$2.createElement(z$3.Provider,{value:T},React$2.createElement(c$5,{value:u$b(T.listboxState,{[0]:d$8.Open,[1]:d$8.Closed})},t!=null&&L!=null&&e$2({[t]:L}).map(([s,d],O)=>React$2.createElement(c$8,{features:p$b.Hidden,ref:O===0?M=>{var q;H.current=(q=M==null?void 0:M.closest("form"))!=null?q:null;}:void 0,...R$4({key:s,as:"input",type:"hidden",hidden:!0,readOnly:!0,form:l,name:s,value:d})})),X$6({ourProps:Te,theirProps:m,slot:ne,defaultTag:Ve$2,name:"Listbox"}))))}let Qe$1="button";function We$2(e,a){var v;let o=I$6(),{id:r=`headlessui-listbox-button-${o}`,...l}=e,t=B$4("Listbox.Button"),p=U$3("Listbox.Button"),u=y$9(t.buttonRef,a),i=p$a(),b=o$5(c=>{switch(c.key){case o$4.Space:case o$4.Enter:case o$4.ArrowDown:c.preventDefault(),p.openListbox(),i.nextFrame(()=>{t.value||p.goToOption(a$3.First);});break;case o$4.ArrowUp:c.preventDefault(),p.openListbox(),i.nextFrame(()=>{t.value||p.goToOption(a$3.Last);});break}}),R=o$5(c=>{switch(c.key){case o$4.Space:c.preventDefault();break}}),m=o$5(c=>{if(r$6(c.currentTarget))return c.preventDefault();t.listboxState===0?(p.closeListbox(),i.nextFrame(()=>{var n;return (n=t.buttonRef.current)==null?void 0:n.focus({preventScroll:!0})})):(c.preventDefault(),p.openListbox());}),P=i$3(()=>{if(t.labelId)return [t.labelId,r].join(" ")},[t.labelId,r]),E=reactExports.useMemo(()=>({open:t.listboxState===0,disabled:t.disabled,value:t.value}),[t]),L={ref:u,id:r,type:s$6(e,t.buttonRef),"aria-haspopup":"listbox","aria-controls":(v=t.optionsRef.current)==null?void 0:v.id,"aria-expanded":t.disabled?void 0:t.listboxState===0,"aria-labelledby":P,disabled:t.disabled,onKeyDown:b,onKeyUp:R,onClick:m};return X$6({ourProps:L,theirProps:l,slot:E,defaultTag:Qe$1,name:"Listbox.Button"})}let Xe$2="label";function $e$2(e,a){let o=I$6(),{id:r=`headlessui-listbox-label-${o}`,...l}=e,t=B$4("Listbox.Label"),p=U$3("Listbox.Label"),u=y$9(t.labelRef,a);l$a(()=>p.registerLabel(r),[r]);let i=o$5(()=>{var m;return (m=t.buttonRef.current)==null?void 0:m.focus({preventScroll:!0})}),b=reactExports.useMemo(()=>({open:t.listboxState===0,disabled:t.disabled}),[t]);return X$6({ourProps:{ref:u,id:r,onClick:i},theirProps:l,slot:b,defaultTag:Xe$2,name:"Listbox.Label"})}let ze$1="ul",Je$2=S$a.RenderStrategy|S$a.Static;function qe$1(e,a){var c;let o=I$6(),{id:r=`headlessui-listbox-options-${o}`,...l}=e,t=B$4("Listbox.Options"),p=U$3("Listbox.Options"),u=y$9(t.optionsRef,a),i=p$a(),b=p$a(),R=C$3(),m=(()=>R!==null?(R&d$8.Open)===d$8.Open:t.listboxState===0)();reactExports.useEffect(()=>{var x;let n=t.optionsRef.current;n&&t.listboxState===0&&n!==((x=e$4(n))==null?void 0:x.activeElement)&&n.focus({preventScroll:!0});},[t.listboxState,t.optionsRef]);let P=o$5(n=>{switch(b.dispose(),n.key){case o$4.Space:if(t.searchQuery!=="")return n.preventDefault(),n.stopPropagation(),p.search(n.key);case o$4.Enter:if(n.preventDefault(),n.stopPropagation(),t.activeOptionIndex!==null){let{dataRef:x}=t.options[t.activeOptionIndex];p.onChange(x.current.value);}t.mode===0&&(p.closeListbox(),o$3().nextFrame(()=>{var x;return (x=t.buttonRef.current)==null?void 0:x.focus({preventScroll:!0})}));break;case u$b(t.orientation,{vertical:o$4.ArrowDown,horizontal:o$4.ArrowRight}):return n.preventDefault(),n.stopPropagation(),p.goToOption(a$3.Next);case u$b(t.orientation,{vertical:o$4.ArrowUp,horizontal:o$4.ArrowLeft}):return n.preventDefault(),n.stopPropagation(),p.goToOption(a$3.Previous);case o$4.Home:case o$4.PageUp:return n.preventDefault(),n.stopPropagation(),p.goToOption(a$3.First);case o$4.End:case o$4.PageDown:return n.preventDefault(),n.stopPropagation(),p.goToOption(a$3.Last);case o$4.Escape:return n.preventDefault(),n.stopPropagation(),p.closeListbox(),i.nextFrame(()=>{var x;return (x=t.buttonRef.current)==null?void 0:x.focus({preventScroll:!0})});case o$4.Tab:n.preventDefault(),n.stopPropagation();break;default:n.key.length===1&&(p.search(n.key),b.setTimeout(()=>p.clearSearch(),350));break}}),E=i$3(()=>{var n,x,h;return (h=(n=t.labelRef.current)==null?void 0:n.id)!=null?h:(x=t.buttonRef.current)==null?void 0:x.id},[t.labelRef.current,t.buttonRef.current]),L=reactExports.useMemo(()=>({open:t.listboxState===0}),[t]),v={"aria-activedescendant":t.activeOptionIndex===null||(c=t.options[t.activeOptionIndex])==null?void 0:c.id,"aria-multiselectable":t.mode===1?!0:void 0,"aria-labelledby":E,"aria-orientation":t.orientation,id:r,onKeyDown:P,role:"listbox",tabIndex:0,ref:u};return X$6({ourProps:v,theirProps:l,slot:L,defaultTag:ze$1,features:Je$2,visible:m,name:"Listbox.Options"})}let Ye$1="li";function Ze$1(e,a){let o=I$6(),{id:r=`headlessui-listbox-option-${o}`,disabled:l=!1,value:t,...p}=e,u=B$4("Listbox.Option"),i=U$3("Listbox.Option"),b=u.activeOptionIndex!==null?u.options[u.activeOptionIndex].id===r:!1,R=u.isSelected(t),m=reactExports.useRef(null),P=s$c({disabled:l,value:t,domRef:m,get textValue(){var y,S;return (S=(y=m.current)==null?void 0:y.textContent)==null?void 0:S.toLowerCase()}}),E=y$9(a,m);l$a(()=>{if(u.listboxState!==0||!b||u.activationTrigger===0)return;let y=o$3();return y.requestAnimationFrame(()=>{var S,T;(T=(S=m.current)==null?void 0:S.scrollIntoView)==null||T.call(S,{block:"nearest"});}),y.dispose},[m,b,u.listboxState,u.activationTrigger,u.activeOptionIndex]),l$a(()=>i.registerOption(r,P),[P,r]);let L=o$5(y=>{if(l)return y.preventDefault();i.onChange(t),u.mode===0&&(i.closeListbox(),o$3().nextFrame(()=>{var S;return (S=u.buttonRef.current)==null?void 0:S.focus({preventScroll:!0})}));}),v=o$5(()=>{if(l)return i.goToOption(a$3.Nothing);i.goToOption(a$3.Specific,r);}),c=u$6(),n=o$5(y=>c.update(y)),x=o$5(y=>{c.wasMoved(y)&&(l||b||i.goToOption(a$3.Specific,r,0));}),h=o$5(y=>{c.wasMoved(y)&&(l||b&&i.goToOption(a$3.Nothing));}),Q=reactExports.useMemo(()=>({active:b,selected:R,disabled:l}),[b,R,l]);return X$6({ourProps:{id:r,ref:E,role:"option",tabIndex:l===!0?void 0:-1,"aria-disabled":l===!0?!0:void 0,"aria-selected":R,disabled:void 0,onClick:L,onFocus:v,onPointerEnter:n,onMouseEnter:n,onPointerMove:x,onMouseMove:x,onPointerLeave:h,onMouseLeave:h},theirProps:p,slot:Q,defaultTag:Ye$1,name:"Listbox.Option"})}let et$1=D$6(Ke$2),tt$2=D$6(We$2),ot$1=D$6($e$2),nt=D$6(qe$1),it$1=D$6(Ze$1),Ht$1=Object.assign(et$1,{Button:tt$2,Label:ot$1,Options:nt,Option:it$1});

	function F$5({container:e,accept:t,walk:r,enabled:c=!0}){let o=reactExports.useRef(t),l=reactExports.useRef(r);reactExports.useEffect(()=>{o.current=t,l.current=r;},[t,r]),l$a(()=>{if(!e||!c)return;let n=e$4(e);if(!n)return;let f=o.current,p=l.current,d=Object.assign(i=>f(i),{acceptNode:f}),u=n.createTreeWalker(e,NodeFilter.SHOW_ELEMENT,d,!1);for(;u.nextNode();)p(u.currentNode);},[e,c,o,l]);}

	var pe$2=(r=>(r[r.Open=0]="Open",r[r.Closed=1]="Closed",r))(pe$2||{}),ce$2=(r=>(r[r.Pointer=0]="Pointer",r[r.Other=1]="Other",r))(ce$2||{}),me$2=(a=>(a[a.OpenMenu=0]="OpenMenu",a[a.CloseMenu=1]="CloseMenu",a[a.GoToItem=2]="GoToItem",a[a.Search=3]="Search",a[a.ClearSearch=4]="ClearSearch",a[a.RegisterItem=5]="RegisterItem",a[a.UnregisterItem=6]="UnregisterItem",a))(me$2||{});function w$4(e,u=r=>r){let r=e.activeItemIndex!==null?e.items[e.activeItemIndex]:null,i=I$5(u(e.items.slice()),t=>t.dataRef.current.domRef.current),s=r?i.indexOf(r):null;return s===-1&&(s=null),{items:i,activeItemIndex:s}}let de$2={[1](e){return e.menuState===1?e:{...e,activeItemIndex:null,menuState:1}},[0](e){return e.menuState===0?e:{...e,menuState:0}},[2]:(e,u)=>{var s;let r=w$4(e),i=x$3(u,{resolveItems:()=>r.items,resolveActiveIndex:()=>r.activeItemIndex,resolveId:t=>t.id,resolveDisabled:t=>t.dataRef.current.disabled});return {...e,...r,searchQuery:"",activeItemIndex:i,activationTrigger:(s=u.trigger)!=null?s:1}},[3]:(e,u)=>{let i=e.searchQuery!==""?0:1,s=e.searchQuery+u.value.toLowerCase(),o=(e.activeItemIndex!==null?e.items.slice(e.activeItemIndex+i).concat(e.items.slice(0,e.activeItemIndex+i)):e.items).find(l=>{var m;return ((m=l.dataRef.current.textValue)==null?void 0:m.startsWith(s))&&!l.dataRef.current.disabled}),a=o?e.items.indexOf(o):-1;return a===-1||a===e.activeItemIndex?{...e,searchQuery:s}:{...e,searchQuery:s,activeItemIndex:a,activationTrigger:1}},[4](e){return e.searchQuery===""?e:{...e,searchQuery:"",searchActiveItemIndex:null}},[5]:(e,u)=>{let r=w$4(e,i=>[...i,{id:u.id,dataRef:u.dataRef}]);return {...e,...r}},[6]:(e,u)=>{let r=w$4(e,i=>{let s=i.findIndex(t=>t.id===u.id);return s!==-1&&i.splice(s,1),i});return {...e,...r,activationTrigger:1}}},U$2=reactExports.createContext(null);U$2.displayName="MenuContext";function F$4(e){let u=reactExports.useContext(U$2);if(u===null){let r=new Error(`<${e} /> is missing a parent <Menu /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(r,F$4),r}return u}function fe$1(e,u){return u$b(u.type,de$2,e,u)}let Te$2=reactExports.Fragment;function ye$3(e,u){let r=reactExports.useReducer(fe$1,{menuState:1,buttonRef:reactExports.createRef(),itemsRef:reactExports.createRef(),items:[],searchQuery:"",activeItemIndex:null,activationTrigger:1}),[{menuState:i,itemsRef:s,buttonRef:t},o]=r,a=y$9(u);L$5([t,s],(g,A)=>{var I;o({type:1}),h$7(A,T$5.Loose)||(g.preventDefault(),(I=t.current)==null||I.focus());},i===0);let l=o$5(()=>{o({type:1});}),m=reactExports.useMemo(()=>({open:i===0,close:l}),[i,l]),M=e,f={ref:a};return React$2.createElement(U$2.Provider,{value:r},React$2.createElement(c$5,{value:u$b(i,{[0]:d$8.Open,[1]:d$8.Closed})},X$6({ourProps:f,theirProps:M,slot:m,defaultTag:Te$2,name:"Menu"})))}let Ie$3="button";function Me$3(e,u){var I;let r=I$6(),{id:i=`headlessui-menu-button-${r}`,...s}=e,[t,o]=F$4("Menu.Button"),a=y$9(t.buttonRef,u),l=p$a(),m=o$5(p=>{switch(p.key){case o$4.Space:case o$4.Enter:case o$4.ArrowDown:p.preventDefault(),p.stopPropagation(),o({type:0}),l.nextFrame(()=>o({type:2,focus:a$3.First}));break;case o$4.ArrowUp:p.preventDefault(),p.stopPropagation(),o({type:0}),l.nextFrame(()=>o({type:2,focus:a$3.Last}));break}}),M=o$5(p=>{switch(p.key){case o$4.Space:p.preventDefault();break}}),f=o$5(p=>{if(r$6(p.currentTarget))return p.preventDefault();e.disabled||(t.menuState===0?(o({type:1}),l.nextFrame(()=>{var R;return (R=t.buttonRef.current)==null?void 0:R.focus({preventScroll:!0})})):(p.preventDefault(),o({type:0})));}),g=reactExports.useMemo(()=>({open:t.menuState===0}),[t]),A={ref:a,id:i,type:s$6(e,t.buttonRef),"aria-haspopup":"menu","aria-controls":(I=t.itemsRef.current)==null?void 0:I.id,"aria-expanded":e.disabled?void 0:t.menuState===0,onKeyDown:m,onKeyUp:M,onClick:f};return X$6({ourProps:A,theirProps:s,slot:g,defaultTag:Ie$3,name:"Menu.Button"})}let ge$2="div",Re$3=S$a.RenderStrategy|S$a.Static;function Ae$2(e,u){var R,E;let r=I$6(),{id:i=`headlessui-menu-items-${r}`,...s}=e,[t,o]=F$4("Menu.Items"),a=y$9(t.itemsRef,u),l=n$7(t.itemsRef),m=p$a(),M=C$3(),f=(()=>M!==null?(M&d$8.Open)===d$8.Open:t.menuState===0)();reactExports.useEffect(()=>{let n=t.itemsRef.current;n&&t.menuState===0&&n!==(l==null?void 0:l.activeElement)&&n.focus({preventScroll:!0});},[t.menuState,t.itemsRef,l]),F$5({container:t.itemsRef.current,enabled:t.menuState===0,accept(n){return n.getAttribute("role")==="menuitem"?NodeFilter.FILTER_REJECT:n.hasAttribute("role")?NodeFilter.FILTER_SKIP:NodeFilter.FILTER_ACCEPT},walk(n){n.setAttribute("role","none");}});let g=o$5(n=>{var S,O;switch(m.dispose(),n.key){case o$4.Space:if(t.searchQuery!=="")return n.preventDefault(),n.stopPropagation(),o({type:3,value:n.key});case o$4.Enter:if(n.preventDefault(),n.stopPropagation(),o({type:1}),t.activeItemIndex!==null){let{dataRef:c}=t.items[t.activeItemIndex];(O=(S=c.current)==null?void 0:S.domRef.current)==null||O.click();}D$5(t.buttonRef.current);break;case o$4.ArrowDown:return n.preventDefault(),n.stopPropagation(),o({type:2,focus:a$3.Next});case o$4.ArrowUp:return n.preventDefault(),n.stopPropagation(),o({type:2,focus:a$3.Previous});case o$4.Home:case o$4.PageUp:return n.preventDefault(),n.stopPropagation(),o({type:2,focus:a$3.First});case o$4.End:case o$4.PageDown:return n.preventDefault(),n.stopPropagation(),o({type:2,focus:a$3.Last});case o$4.Escape:n.preventDefault(),n.stopPropagation(),o({type:1}),o$3().nextFrame(()=>{var c;return (c=t.buttonRef.current)==null?void 0:c.focus({preventScroll:!0})});break;case o$4.Tab:n.preventDefault(),n.stopPropagation(),o({type:1}),o$3().nextFrame(()=>{_$3(t.buttonRef.current,n.shiftKey?M$8.Previous:M$8.Next);});break;default:n.key.length===1&&(o({type:3,value:n.key}),m.setTimeout(()=>o({type:4}),350));break}}),A=o$5(n=>{switch(n.key){case o$4.Space:n.preventDefault();break}}),I=reactExports.useMemo(()=>({open:t.menuState===0}),[t]),p={"aria-activedescendant":t.activeItemIndex===null||(R=t.items[t.activeItemIndex])==null?void 0:R.id,"aria-labelledby":(E=t.buttonRef.current)==null?void 0:E.id,id:i,onKeyDown:g,onKeyUp:A,role:"menu",tabIndex:0,ref:a};return X$6({ourProps:p,theirProps:s,slot:I,defaultTag:ge$2,features:Re$3,visible:f,name:"Menu.Items"})}let be$2=reactExports.Fragment;function Ee$3(e,u){let r=I$6(),{id:i=`headlessui-menu-item-${r}`,disabled:s=!1,...t}=e,[o,a]=F$4("Menu.Item"),l=o.activeItemIndex!==null?o.items[o.activeItemIndex].id===i:!1,m=reactExports.useRef(null),M=y$9(u,m);l$a(()=>{if(o.menuState!==0||!l||o.activationTrigger===0)return;let c=o$3();return c.requestAnimationFrame(()=>{var b,_;(_=(b=m.current)==null?void 0:b.scrollIntoView)==null||_.call(b,{block:"nearest"});}),c.dispose},[m,l,o.menuState,o.activationTrigger,o.activeItemIndex]);let f=reactExports.useRef({disabled:s,domRef:m});l$a(()=>{f.current.disabled=s;},[f,s]),l$a(()=>{var c,b;f.current.textValue=(b=(c=m.current)==null?void 0:c.textContent)==null?void 0:b.toLowerCase();},[f,m]),l$a(()=>(a({type:5,id:i,dataRef:f}),()=>a({type:6,id:i})),[f,i]);let g=o$5(()=>{a({type:1});}),A=o$5(c=>{if(s)return c.preventDefault();a({type:1}),D$5(o.buttonRef.current);}),I=o$5(()=>{if(s)return a({type:2,focus:a$3.Nothing});a({type:2,focus:a$3.Specific,id:i});}),p=u$6(),R=o$5(c=>p.update(c)),E=o$5(c=>{p.wasMoved(c)&&(s||l||a({type:2,focus:a$3.Specific,id:i,trigger:0}));}),n=o$5(c=>{p.wasMoved(c)&&(s||l&&a({type:2,focus:a$3.Nothing}));}),S=reactExports.useMemo(()=>({active:l,disabled:s,close:g}),[l,s,g]);return X$6({ourProps:{id:i,ref:M,role:"menuitem",tabIndex:s===!0?void 0:-1,"aria-disabled":s===!0?!0:void 0,disabled:void 0,onClick:A,onFocus:I,onPointerEnter:R,onMouseEnter:R,onPointerMove:E,onMouseMove:E,onPointerLeave:n,onMouseLeave:n},theirProps:t,slot:S,defaultTag:be$2,name:"Menu.Item"})}let Se$3=D$6(ye$3),Pe$3=D$6(Me$3),ve$2=D$6(Ae$2),xe$3=D$6(Ee$3),ot=Object.assign(Se$3,{Button:Pe$3,Items:ve$2,Item:xe$3});

	var Fe$2=(s=>(s[s.Open=0]="Open",s[s.Closed=1]="Closed",s))(Fe$2||{}),Ie$2=(t=>(t[t.TogglePopover=0]="TogglePopover",t[t.ClosePopover=1]="ClosePopover",t[t.SetButton=2]="SetButton",t[t.SetButtonId=3]="SetButtonId",t[t.SetPanel=4]="SetPanel",t[t.SetPanelId=5]="SetPanelId",t))(Ie$2||{});let xe$2={[0]:o=>({...o,popoverState:u$b(o.popoverState,{[0]:1,[1]:0})}),[1](o){return o.popoverState===1?o:{...o,popoverState:1}},[2](o,l){return o.button===l.button?o:{...o,button:l.button}},[3](o,l){return o.buttonId===l.buttonId?o:{...o,buttonId:l.buttonId}},[4](o,l){return o.panel===l.panel?o:{...o,panel:l.panel}},[5](o,l){return o.panelId===l.panelId?o:{...o,panelId:l.panelId}}},le$1=reactExports.createContext(null);le$1.displayName="PopoverContext";function Q$2(o){let l=reactExports.useContext(le$1);if(l===null){let s=new Error(`<${o} /> is missing a parent <Popover /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(s,Q$2),s}return l}let ae=reactExports.createContext(null);ae.displayName="PopoverAPIContext";function pe$1(o){let l=reactExports.useContext(ae);if(l===null){let s=new Error(`<${o} /> is missing a parent <Popover /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(s,pe$1),s}return l}let se$1=reactExports.createContext(null);se$1.displayName="PopoverGroupContext";function ve$1(){return reactExports.useContext(se$1)}let Z$4=reactExports.createContext(null);Z$4.displayName="PopoverPanelContext";function Le$1(){return reactExports.useContext(Z$4)}function Me$2(o,l){return u$b(l.type,xe$2,o,l)}let Be$1="div";function De$3(o,l){var B;let s=reactExports.useRef(null),R=y$9(l,T$6(e=>{s.current=e;})),C=reactExports.useRef([]),r=reactExports.useReducer(Me$2,{popoverState:1,buttons:C,button:null,buttonId:null,panel:null,panelId:null,beforePanelSentinel:reactExports.createRef(),afterPanelSentinel:reactExports.createRef()}),[{popoverState:t,button:a,buttonId:v,panel:f,panelId:F,beforePanelSentinel:T,afterPanelSentinel:d},i]=r,p=n$7((B=s.current)!=null?B:a),P=reactExports.useMemo(()=>{if(!a||!f)return !1;for(let N of document.querySelectorAll("body > *"))if(Number(N==null?void 0:N.contains(a))^Number(N==null?void 0:N.contains(f)))return !0;let e=f$8(),n=e.indexOf(a),A=(n+e.length-1)%e.length,g=(n+1)%e.length,G=e[A],Te=e[g];return !f.contains(G)&&!f.contains(Te)},[a,f]),S=s$c(v),y=s$c(F),x=reactExports.useMemo(()=>({buttonId:S,panelId:y,close:()=>i({type:1})}),[S,y,i]),O=ve$1(),L=O==null?void 0:O.registerPopover,j=o$5(()=>{var e;return (e=O==null?void 0:O.isFocusWithinPopoverGroup())!=null?e:(p==null?void 0:p.activeElement)&&((a==null?void 0:a.contains(p.activeElement))||(f==null?void 0:f.contains(p.activeElement)))});reactExports.useEffect(()=>L==null?void 0:L(x),[L,x]),E$3(p==null?void 0:p.defaultView,"focus",e=>{var n,A,g,G;t===0&&(j()||a&&f&&e.target!==window&&((A=(n=T.current)==null?void 0:n.contains)!=null&&A.call(n,e.target)||(G=(g=d.current)==null?void 0:g.contains)!=null&&G.call(g,e.target)||i({type:1})));},!0),L$5([a,f],(e,n)=>{i({type:1}),h$7(n,T$5.Loose)||(e.preventDefault(),a==null||a.focus());},t===0);let M=o$5(e=>{i({type:1});let n=(()=>e?e instanceof HTMLElement?e:"current"in e&&e.current instanceof HTMLElement?e.current:a:a)();n==null||n.focus();}),u=reactExports.useMemo(()=>({close:M,isPortalled:P}),[M,P]),m=reactExports.useMemo(()=>({open:t===0,close:M}),[t,M]),E=o,c={ref:R};return React$2.createElement(Z$4.Provider,{value:null},React$2.createElement(le$1.Provider,{value:r},React$2.createElement(ae.Provider,{value:u},React$2.createElement(c$5,{value:u$b(t,{[0]:d$8.Open,[1]:d$8.Closed})},X$6({ourProps:c,theirProps:E,slot:m,defaultTag:Be$1,name:"Popover"})))))}let he$5="button";function He$2(o,l){let s=I$6(),{id:R=`headlessui-popover-button-${s}`,...C}=o,[r,t]=Q$2("Popover.Button"),{isPortalled:a}=pe$1("Popover.Button"),v=reactExports.useRef(null),f=`headlessui-focus-sentinel-${I$6()}`,F=ve$1(),T=F==null?void 0:F.closeOthers,i=Le$1()!==null;reactExports.useEffect(()=>{if(!i)return t({type:3,buttonId:R}),()=>{t({type:3,buttonId:null});}},[i,R,t]);let[p]=reactExports.useState(()=>Symbol()),P=y$9(v,l,i?null:e=>{if(e)r.buttons.current.push(p);else {let n=r.buttons.current.indexOf(p);n!==-1&&r.buttons.current.splice(n,1);}r.buttons.current.length>1&&console.warn("You are already using a <Popover.Button /> but only 1 <Popover.Button /> is supported."),e&&t({type:2,button:e});}),S=y$9(v,l),y=n$7(v),x=o$5(e=>{var n,A,g;if(i){if(r.popoverState===1)return;switch(e.key){case o$4.Space:case o$4.Enter:e.preventDefault(),(A=(n=e.target).click)==null||A.call(n),t({type:1}),(g=r.button)==null||g.focus();break}}else switch(e.key){case o$4.Space:case o$4.Enter:e.preventDefault(),e.stopPropagation(),r.popoverState===1&&(T==null||T(r.buttonId)),t({type:0});break;case o$4.Escape:if(r.popoverState!==0)return T==null?void 0:T(r.buttonId);if(!v.current||y!=null&&y.activeElement&&!v.current.contains(y.activeElement))return;e.preventDefault(),e.stopPropagation(),t({type:1});break}}),O=o$5(e=>{i||e.key===o$4.Space&&e.preventDefault();}),L=o$5(e=>{var n,A;r$6(e.currentTarget)||o.disabled||(i?(t({type:1}),(n=r.button)==null||n.focus()):(e.preventDefault(),e.stopPropagation(),r.popoverState===1&&(T==null||T(r.buttonId)),t({type:0}),(A=r.button)==null||A.focus()));}),j=o$5(e=>{e.preventDefault(),e.stopPropagation();}),M=r.popoverState===0,u=reactExports.useMemo(()=>({open:M}),[M]),m=s$6(o,v),E=i?{ref:S,type:m,onKeyDown:x,onClick:L}:{ref:P,id:r.buttonId,type:m,"aria-expanded":o.disabled?void 0:r.popoverState===0,"aria-controls":r.panel?r.panelId:void 0,onKeyDown:x,onKeyUp:O,onClick:L,onMouseDown:j},c=n$8(),B=o$5(()=>{let e=r.panel;if(!e)return;function n(){u$b(c.current,{[s$9.Forwards]:()=>O$6(e,M$8.First),[s$9.Backwards]:()=>O$6(e,M$8.Last)})===N$2.Error&&O$6(f$8().filter(g=>g.dataset.headlessuiFocusGuard!=="true"),u$b(c.current,{[s$9.Forwards]:M$8.Next,[s$9.Backwards]:M$8.Previous}),{relativeTo:r.button});}n();});return React$2.createElement(React$2.Fragment,null,X$6({ourProps:E,theirProps:C,slot:u,defaultTag:he$5,name:"Popover.Button"}),M&&!i&&a&&React$2.createElement(c$8,{id:f,features:p$b.Focusable,"data-headlessui-focus-guard":!0,as:"button",type:"button",onFocus:B}))}let Ge$1="div",_e$1=S$a.RenderStrategy|S$a.Static;function ke(o,l){let s=I$6(),{id:R=`headlessui-popover-overlay-${s}`,...C}=o,[{popoverState:r},t]=Q$2("Popover.Overlay"),a=y$9(l),v=C$3(),f=(()=>v!==null?(v&d$8.Open)===d$8.Open:r===0)(),F=o$5(i=>{if(r$6(i.currentTarget))return i.preventDefault();t({type:1});}),T=reactExports.useMemo(()=>({open:r===0}),[r]);return X$6({ourProps:{ref:a,id:R,"aria-hidden":!0,onClick:F},theirProps:C,slot:T,defaultTag:Ge$1,features:_e$1,visible:f,name:"Popover.Overlay"})}let we$1="div",Ne$2=S$a.RenderStrategy|S$a.Static;function Ue(o,l){let s=I$6(),{id:R=`headlessui-popover-panel-${s}`,focus:C=!1,...r}=o,[t,a]=Q$2("Popover.Panel"),{close:v,isPortalled:f}=pe$1("Popover.Panel"),F=`headlessui-focus-sentinel-before-${I$6()}`,T=`headlessui-focus-sentinel-after-${I$6()}`,d=reactExports.useRef(null),i=y$9(d,l,u=>{a({type:4,panel:u});}),p=n$7(d);l$a(()=>(a({type:5,panelId:R}),()=>{a({type:5,panelId:null});}),[R,a]);let P=C$3(),S=(()=>P!==null?(P&d$8.Open)===d$8.Open:t.popoverState===0)(),y=o$5(u=>{var m;switch(u.key){case o$4.Escape:if(t.popoverState!==0||!d.current||p!=null&&p.activeElement&&!d.current.contains(p.activeElement))return;u.preventDefault(),u.stopPropagation(),a({type:1}),(m=t.button)==null||m.focus();break}});reactExports.useEffect(()=>{var u;o.static||t.popoverState===1&&((u=o.unmount)==null||u)&&a({type:4,panel:null});},[t.popoverState,o.unmount,o.static,a]),reactExports.useEffect(()=>{if(!C||t.popoverState!==0||!d.current)return;let u=p==null?void 0:p.activeElement;d.current.contains(u)||O$6(d.current,M$8.First);},[C,d,t.popoverState]);let x=reactExports.useMemo(()=>({open:t.popoverState===0,close:v}),[t,v]),O={ref:i,id:R,onKeyDown:y,onBlur:C&&t.popoverState===0?u=>{var E,c,B,e,n;let m=u.relatedTarget;m&&d.current&&((E=d.current)!=null&&E.contains(m)||(a({type:1}),((B=(c=t.beforePanelSentinel.current)==null?void 0:c.contains)!=null&&B.call(c,m)||(n=(e=t.afterPanelSentinel.current)==null?void 0:e.contains)!=null&&n.call(e,m))&&m.focus({preventScroll:!0})));}:void 0,tabIndex:-1},L=n$8(),j=o$5(()=>{let u=d.current;if(!u)return;function m(){u$b(L.current,{[s$9.Forwards]:()=>{var c;O$6(u,M$8.First)===N$2.Error&&((c=t.afterPanelSentinel.current)==null||c.focus());},[s$9.Backwards]:()=>{var E;(E=t.button)==null||E.focus({preventScroll:!0});}});}m();}),M=o$5(()=>{let u=d.current;if(!u)return;function m(){u$b(L.current,{[s$9.Forwards]:()=>{var A;if(!t.button)return;let E=f$8(),c=E.indexOf(t.button),B=E.slice(0,c+1),n=[...E.slice(c+1),...B];for(let g of n.slice())if(g.dataset.headlessuiFocusGuard==="true"||(A=t.panel)!=null&&A.contains(g)){let G=n.indexOf(g);G!==-1&&n.splice(G,1);}O$6(n,M$8.First,{sorted:!1});},[s$9.Backwards]:()=>{var c;O$6(u,M$8.Previous)===N$2.Error&&((c=t.button)==null||c.focus());}});}m();});return React$2.createElement(Z$4.Provider,{value:R},S&&f&&React$2.createElement(c$8,{id:F,ref:t.beforePanelSentinel,features:p$b.Focusable,"data-headlessui-focus-guard":!0,as:"button",type:"button",onFocus:j}),X$6({ourProps:O,theirProps:r,slot:x,defaultTag:we$1,features:Ne$2,visible:S,name:"Popover.Panel"}),S&&f&&React$2.createElement(c$8,{id:T,ref:t.afterPanelSentinel,features:p$b.Focusable,"data-headlessui-focus-guard":!0,as:"button",type:"button",onFocus:M}))}let Ke$1="div";function We$1(o,l){let s=reactExports.useRef(null),R=y$9(s,l),[C,r]=reactExports.useState([]),t=o$5(p=>{r(P=>{let S=P.indexOf(p);if(S!==-1){let y=P.slice();return y.splice(S,1),y}return P});}),a=o$5(p=>(r(P=>[...P,p]),()=>t(p))),v=o$5(()=>{var S;let p=e$4(s);if(!p)return !1;let P=p.activeElement;return (S=s.current)!=null&&S.contains(P)?!0:C.some(y=>{var x,O;return ((x=p.getElementById(y.buttonId.current))==null?void 0:x.contains(P))||((O=p.getElementById(y.panelId.current))==null?void 0:O.contains(P))})}),f=o$5(p=>{for(let P of C)P.buttonId.current!==p&&P.close();}),F=reactExports.useMemo(()=>({registerPopover:a,unregisterPopover:t,isFocusWithinPopoverGroup:v,closeOthers:f}),[a,t,v,f]),T=reactExports.useMemo(()=>({}),[]),d=o,i={ref:R};return React$2.createElement(se$1.Provider,{value:F},X$6({ourProps:i,theirProps:d,slot:T,defaultTag:Ke$1,name:"Popover.Group"}))}let je$1=D$6(De$3),Ve$1=D$6(He$2),$e$1=D$6(ke),Je$1=D$6(Ue),Xe$1=D$6(We$1),Lt=Object.assign(je$1,{Button:Ve$1,Overlay:$e$1,Panel:Je$1,Group:Xe$1});

	let y$5=reactExports.createContext(null);y$5.displayName="GroupContext";let Y$3=reactExports.Fragment;function Z$3(s){var d;let[n,p]=reactExports.useState(null),[c,f]=H$4(),[r,h]=M$9(),l=reactExports.useMemo(()=>({switch:n,setSwitch:p,labelledby:c,describedby:r}),[n,p,c,r]),T={},b=s;return React$2.createElement(h,{name:"Switch.Description"},React$2.createElement(f,{name:"Switch.Label",props:{htmlFor:(d=l.switch)==null?void 0:d.id,onClick(t){n&&(t.currentTarget.tagName==="LABEL"&&t.preventDefault(),n.click(),n.focus({preventScroll:!0}));}}},React$2.createElement(y$5.Provider,{value:l},X$6({ourProps:T,theirProps:b,defaultTag:Y$3,name:"Switch.Group"}))))}let ee$1="button";function te(s,n){let p=I$6(),{id:c=`headlessui-switch-${p}`,checked:f,defaultChecked:r=!1,onChange:h,name:l,value:T,form:b,...d}=s,t=reactExports.useContext(y$5),u=reactExports.useRef(null),D=y$9(u,n,t===null?null:t.setSwitch),[o,a]=T$4(f,h,r),S=o$5(()=>a==null?void 0:a(!o)),C=o$5(e=>{if(r$6(e.currentTarget))return e.preventDefault();e.preventDefault(),S();}),L=o$5(e=>{e.key===o$4.Space?(e.preventDefault(),S()):e.key===o$4.Enter&&p$6(e.currentTarget);}),v=o$5(e=>e.preventDefault()),G=reactExports.useMemo(()=>({checked:o}),[o]),R={id:c,ref:D,role:"switch",type:s$6(s,u),tabIndex:0,"aria-checked":o,"aria-labelledby":t==null?void 0:t.labelledby,"aria-describedby":t==null?void 0:t.describedby,onClick:C,onKeyUp:L,onKeyPress:v},k=p$a();return reactExports.useEffect(()=>{var w;let e=(w=u.current)==null?void 0:w.closest("form");e&&r!==void 0&&k.addEventListener(e,"reset",()=>{a(r);});},[u,a]),React$2.createElement(React$2.Fragment,null,l!=null&&o&&React$2.createElement(c$8,{features:p$b.Hidden,...R$4({as:"input",type:"checkbox",hidden:!0,readOnly:!0,form:b,checked:o,name:l,value:T})}),X$6({ourProps:R,theirProps:d,slot:G,defaultTag:ee$1,name:"Switch"}))}let ne$2=D$6(te),re$2=Z$3;Object.assign(ne$2,{Group:re$2,Label:M$4,Description:b$2});

	function p$5({onFocus:n}){let[r,o]=reactExports.useState(!0);return r?React$2.createElement(c$8,{as:"button",type:"button",features:p$b.Focusable,onFocus:a=>{a.preventDefault();let e,u=50;function t(){if(u--<=0){e&&cancelAnimationFrame(e);return}if(n()){o(!1),cancelAnimationFrame(e);return}e=requestAnimationFrame(t);}e=requestAnimationFrame(t);}}):null}

	const s$4=reactExports.createContext(null);function a$2(){return {groups:new Map,get(n,t){var c;let e=this.groups.get(n);e||(e=new Map,this.groups.set(n,e));let l=(c=e.get(t))!=null?c:0;e.set(t,l+1);let o=Array.from(e.keys()).indexOf(t);function i(){let u=e.get(t);u>1?e.set(t,u-1):e.delete(t);}return [o,i]}}}function C$2({children:n}){let t=reactExports.useRef(a$2());return reactExports.createElement(s$4.Provider,{value:t},n)}function d$4(n){let t=reactExports.useContext(s$4);if(!t)throw new Error("You must wrap your component in a <StableCollection>");let e=f$3(),[l,o]=t.current.get(n,e);return reactExports.useEffect(()=>o,[]),l}function f$3(){var l,o,i;let n=(i=(o=(l=reactExports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED)==null?void 0:l.ReactCurrentOwner)==null?void 0:o.current)!=null?i:null;if(!n)return Symbol();let t=[],e=n;for(;e;)t.push(e.index),e=e.return;return "$."+t.join(".")}

	var ue$1=(t=>(t[t.Forwards=0]="Forwards",t[t.Backwards=1]="Backwards",t))(ue$1||{}),Te$1=(o=>(o[o.Less=-1]="Less",o[o.Equal=0]="Equal",o[o.Greater=1]="Greater",o))(Te$1||{}),de$1=(r=>(r[r.SetSelectedIndex=0]="SetSelectedIndex",r[r.RegisterTab=1]="RegisterTab",r[r.UnregisterTab=2]="UnregisterTab",r[r.RegisterPanel=3]="RegisterPanel",r[r.UnregisterPanel=4]="UnregisterPanel",r))(de$1||{});let ce$1={[0](e,n){var u;let t=I$5(e.tabs,T=>T.current),o=I$5(e.panels,T=>T.current),s=t.filter(T=>{var l;return !((l=T.current)!=null&&l.hasAttribute("disabled"))}),r={...e,tabs:t,panels:o};if(n.index<0||n.index>t.length-1){let T=u$b(Math.sign(n.index-e.selectedIndex),{[-1]:()=>1,[0]:()=>u$b(Math.sign(n.index),{[-1]:()=>0,[0]:()=>0,[1]:()=>1}),[1]:()=>0});return s.length===0?r:{...r,selectedIndex:u$b(T,{[0]:()=>t.indexOf(s[0]),[1]:()=>t.indexOf(s[s.length-1])})}}let i=t.slice(0,n.index),b=[...t.slice(n.index),...i].find(T=>s.includes(T));if(!b)return r;let c=(u=t.indexOf(b))!=null?u:e.selectedIndex;return c===-1&&(c=e.selectedIndex),{...r,selectedIndex:c}},[1](e,n){var r;if(e.tabs.includes(n.tab))return e;let t=e.tabs[e.selectedIndex],o=I$5([...e.tabs,n.tab],i=>i.current),s=(r=o.indexOf(t))!=null?r:e.selectedIndex;return s===-1&&(s=e.selectedIndex),{...e,tabs:o,selectedIndex:s}},[2](e,n){return {...e,tabs:e.tabs.filter(t=>t!==n.tab)}},[3](e,n){return e.panels.includes(n.panel)?e:{...e,panels:I$5([...e.panels,n.panel],t=>t.current)}},[4](e,n){return {...e,panels:e.panels.filter(t=>t!==n.panel)}}},X$3=reactExports.createContext(null);X$3.displayName="TabsDataContext";function M$3(e){let n=reactExports.useContext(X$3);if(n===null){let t=new Error(`<${e} /> is missing a parent <Tab.Group /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(t,M$3),t}return n}let $$8=reactExports.createContext(null);$$8.displayName="TabsActionsContext";function q$5(e){let n=reactExports.useContext($$8);if(n===null){let t=new Error(`<${e} /> is missing a parent <Tab.Group /> component.`);throw Error.captureStackTrace&&Error.captureStackTrace(t,q$5),t}return n}function fe(e,n){return u$b(n.type,ce$1,e,n)}let be$1=reactExports.Fragment;function me$1(e,n){let{defaultIndex:t=0,vertical:o=!1,manual:s=!1,onChange:r,selectedIndex:i=null,...R}=e;const b=o?"vertical":"horizontal",c=s?"manual":"auto";let u=i!==null,T=y$9(n),[l,d]=reactExports.useReducer(fe,{selectedIndex:i!=null?i:t,tabs:[],panels:[]}),y=reactExports.useMemo(()=>({selectedIndex:l.selectedIndex}),[l.selectedIndex]),m=s$c(r||(()=>{})),x=s$c(l.tabs),E=reactExports.useMemo(()=>({orientation:b,activation:c,...l}),[b,c,l]),S=o$5(p=>(d({type:1,tab:p}),()=>d({type:2,tab:p}))),A=o$5(p=>(d({type:3,panel:p}),()=>d({type:4,panel:p}))),L=o$5(p=>{C.current!==p&&m.current(p),u||d({type:0,index:p});}),C=s$c(u?e.selectedIndex:l.selectedIndex),N=reactExports.useMemo(()=>({registerTab:S,registerPanel:A,change:L}),[]);l$a(()=>{d({type:0,index:i!=null?i:t});},[i]),l$a(()=>{if(C.current===void 0||l.tabs.length<=0)return;let p=I$5(l.tabs,a=>a.current);p.some((a,f)=>l.tabs[f]!==a)&&L(p.indexOf(l.tabs[C.current]));});let B={ref:T};return React$2.createElement(C$2,null,React$2.createElement($$8.Provider,{value:N},React$2.createElement(X$3.Provider,{value:E},E.tabs.length<=0&&React$2.createElement(p$5,{onFocus:()=>{var p,I;for(let a of x.current)if(((p=a.current)==null?void 0:p.tabIndex)===0)return (I=a.current)==null||I.focus(),!0;return !1}}),X$6({ourProps:B,theirProps:R,slot:y,defaultTag:be$1,name:"Tabs"}))))}let Pe$2="div";function ge$1(e,n){let{orientation:t,selectedIndex:o}=M$3("Tab.List"),s=y$9(n);return X$6({ourProps:{ref:s,role:"tablist","aria-orientation":t},theirProps:e,slot:{selectedIndex:o},defaultTag:Pe$2,name:"Tabs.List"})}let ye$2="button";function xe$1(e,n){var p,I;let t=I$6(),{id:o=`headlessui-tabs-tab-${t}`,...s}=e,{orientation:r,activation:i,selectedIndex:R,tabs:b,panels:c}=M$3("Tab"),u=q$5("Tab"),T=M$3("Tab"),l=reactExports.useRef(null),d=y$9(l,n);l$a(()=>u.registerTab(l),[u,l]);let y=d$4("tabs"),m=b.indexOf(l);m===-1&&(m=y);let x=m===R,E=o$5(a=>{var j;let f=a();if(f===N$2.Success&&i==="auto"){let W=(j=e$4(l))==null?void 0:j.activeElement,z=T.tabs.findIndex(te=>te.current===W);z!==-1&&u.change(z);}return f}),S=o$5(a=>{let f=b.map(W=>W.current).filter(Boolean);if(a.key===o$4.Space||a.key===o$4.Enter){a.preventDefault(),a.stopPropagation(),u.change(m);return}switch(a.key){case o$4.Home:case o$4.PageUp:return a.preventDefault(),a.stopPropagation(),E(()=>O$6(f,M$8.First));case o$4.End:case o$4.PageDown:return a.preventDefault(),a.stopPropagation(),E(()=>O$6(f,M$8.Last))}if(E(()=>u$b(r,{vertical(){return a.key===o$4.ArrowUp?O$6(f,M$8.Previous|M$8.WrapAround):a.key===o$4.ArrowDown?O$6(f,M$8.Next|M$8.WrapAround):N$2.Error},horizontal(){return a.key===o$4.ArrowLeft?O$6(f,M$8.Previous|M$8.WrapAround):a.key===o$4.ArrowRight?O$6(f,M$8.Next|M$8.WrapAround):N$2.Error}}))===N$2.Success)return a.preventDefault()}),A=reactExports.useRef(!1),L=o$5(()=>{var a;A.current||(A.current=!0,(a=l.current)==null||a.focus(),u.change(m),t$b(()=>{A.current=!1;}));}),C=o$5(a=>{a.preventDefault();}),N=reactExports.useMemo(()=>({selected:x}),[x]),B={ref:d,onKeyDown:S,onMouseDown:C,onClick:L,id:o,role:"tab",type:s$6(e,l),"aria-controls":(I=(p=c[m])==null?void 0:p.current)==null?void 0:I.id,"aria-selected":x,tabIndex:x?0:-1};return X$6({ourProps:B,theirProps:s,slot:N,defaultTag:ye$2,name:"Tabs.Tab"})}let Ee$2="div";function Ae$1(e,n){let{selectedIndex:t}=M$3("Tab.Panels"),o=y$9(n),s=reactExports.useMemo(()=>({selectedIndex:t}),[t]);return X$6({ourProps:{ref:o},theirProps:e,slot:s,defaultTag:Ee$2,name:"Tabs.Panels"})}let Re$2="div",Le=S$a.RenderStrategy|S$a.Static;function De$2(e,n){var E,S,A,L;let t=I$6(),{id:o=`headlessui-tabs-panel-${t}`,tabIndex:s=0,...r}=e,{selectedIndex:i,tabs:R,panels:b}=M$3("Tab.Panel"),c=q$5("Tab.Panel"),u=reactExports.useRef(null),T=y$9(u,n);l$a(()=>c.registerPanel(u),[c,u]);let l=d$4("panels"),d=b.indexOf(u);d===-1&&(d=l);let y=d===i,m=reactExports.useMemo(()=>({selected:y}),[y]),x={ref:T,id:o,role:"tabpanel","aria-labelledby":(S=(E=R[d])==null?void 0:E.current)==null?void 0:S.id,tabIndex:y?s:-1};return !y&&((A=r.unmount)==null||A)&&!((L=r.static)!=null&&L)?React$2.createElement(c$8,{as:"span",...x}):X$6({ourProps:x,theirProps:r,slot:m,defaultTag:Re$2,features:Le,visible:y,name:"Tabs.Panel"})}let Se$2=D$6(xe$1),Ie$1=D$6(me$1),Fe$1=D$6(ge$1),he$4=D$6(Ae$1),Me$1=D$6(De$2),rt$1=Object.assign(Se$2,{Group:Ie$1,List:Fe$1,Panels:he$4,Panel:Me$1});

	function l$6(r){let e={called:!1};return (...t)=>{if(!e.called)return e.called=!0,r(...t)}}

	function d$3(t,...e){t&&e.length>0&&t.classList.add(...e);}function v$5(t,...e){t&&e.length>0&&t.classList.remove(...e);}function F$3(t,e){let n=o$3();if(!t)return n.dispose;let{transitionDuration:m,transitionDelay:o}=getComputedStyle(t),[u,p]=[m,o].map(a=>{let[r=0]=a.split(",").filter(Boolean).map(i=>i.includes("ms")?parseFloat(i):parseFloat(i)*1e3).sort((i,f)=>f-i);return r}),l=u+p;if(l!==0){n.group(r=>{r.setTimeout(()=>{e(),r.dispose();},l),r.addEventListener(t,"transitionrun",i=>{i.target===i.currentTarget&&r.dispose();});});let a=n.addEventListener(t,"transitionend",r=>{r.target===r.currentTarget&&(e(),a());});}else e();return n.add(()=>e()),n.dispose}function y$4(t,e,n,m){let o=n?"enter":"leave",u=o$3(),p=m!==void 0?l$6(m):()=>{};o==="enter"&&(t.removeAttribute("hidden"),t.style.display="");let l=u$b(o,{enter:()=>e.enter,leave:()=>e.leave}),a=u$b(o,{enter:()=>e.enterTo,leave:()=>e.leaveTo}),r=u$b(o,{enter:()=>e.enterFrom,leave:()=>e.leaveFrom});return v$5(t,...e.enter,...e.enterTo,...e.enterFrom,...e.leave,...e.leaveFrom,...e.leaveTo,...e.entered),d$3(t,...l,...r),u.nextFrame(()=>{v$5(t,...r),d$3(t,...a),F$3(t,()=>(v$5(t,...l),d$3(t,...e.entered),p()));}),u.dispose}

	function D$4({container:i,direction:t,classes:o,onStart:s,onStop:u}){let a=f$7(),c=p$a(),r=s$c(t);l$a(()=>{let e=o$3();c.add(e.dispose);let n=i.current;if(n&&r.current!=="idle"&&a.current)return e.dispose(),s.current(r.current),e.add(y$4(n,o.current,r.current==="enter",()=>{e.dispose(),u.current(r.current);})),e.dispose},[t]);}

	function c$2(a=0){let[l,r]=reactExports.useState(a),t=f$7(),o=reactExports.useCallback(e=>{t.current&&r(u=>u|e);},[l,t]),m=reactExports.useCallback(e=>Boolean(l&e),[l]),s=reactExports.useCallback(e=>{t.current&&r(u=>u&~e);},[r,t]),g=reactExports.useCallback(e=>{t.current&&r(u=>u^e);},[r]);return {flags:l,addFlag:o,hasFlag:m,removeFlag:s,toggleFlag:g}}

	function S$3(n=""){return n.split(" ").filter(t=>t.trim().length>1)}let A$4=reactExports.createContext(null);A$4.displayName="TransitionContext";var Ce$1=(r=>(r.Visible="visible",r.Hidden="hidden",r))(Ce$1||{});function Ee$1(){let n=reactExports.useContext(A$4);if(n===null)throw new Error("A <Transition.Child /> is used but it is missing a parent <Transition /> or <Transition.Root />.");return n}function be(){let n=reactExports.useContext(I$4);if(n===null)throw new Error("A <Transition.Child /> is used but it is missing a parent <Transition /> or <Transition.Root />.");return n}let I$4=reactExports.createContext(null);I$4.displayName="NestingContext";function _$1(n){return "children"in n?_$1(n.children):n.current.filter(({el:t})=>t.current!==null).filter(({state:t})=>t==="visible").length>0}function ne$1(n,t){let r=s$c(n),o=reactExports.useRef([]),y=f$7(),N=p$a(),p=o$5((s,e=j$2.Hidden)=>{let a=o.current.findIndex(({el:i})=>i===s);a!==-1&&(u$b(e,{[j$2.Unmount](){o.current.splice(a,1);},[j$2.Hidden](){o.current[a].state="hidden";}}),N.microTask(()=>{var i;!_$1(o)&&y.current&&((i=r.current)==null||i.call(r));}));}),x=o$5(s=>{let e=o.current.find(({el:a})=>a===s);return e?e.state!=="visible"&&(e.state="visible"):o.current.push({el:s,state:"visible"}),()=>p(s,j$2.Unmount)}),m=reactExports.useRef([]),c=reactExports.useRef(Promise.resolve()),u=reactExports.useRef({enter:[],leave:[],idle:[]}),h=o$5((s,e,a)=>{m.current.splice(0),t&&(t.chains.current[e]=t.chains.current[e].filter(([i])=>i!==s)),t==null||t.chains.current[e].push([s,new Promise(i=>{m.current.push(i);})]),t==null||t.chains.current[e].push([s,new Promise(i=>{Promise.all(u.current[e].map(([l,T])=>T)).then(()=>i());})]),e==="enter"?c.current=c.current.then(()=>t==null?void 0:t.wait.current).then(()=>a(e)):a(e);}),v=o$5((s,e,a)=>{Promise.all(u.current[e].splice(0).map(([i,l])=>l)).then(()=>{var i;(i=m.current.shift())==null||i();}).then(()=>a(e));});return reactExports.useMemo(()=>({children:o,register:x,unregister:p,onStart:h,onStop:v,wait:c,chains:u}),[x,p,o,h,v,u,c])}function Se$1(){}let xe=["beforeEnter","afterEnter","beforeLeave","afterLeave"];function re$1(n){var r;let t={};for(let o of xe)t[o]=(r=n[o])!=null?r:Se$1;return t}function Pe$1(n){let t=reactExports.useRef(re$1(n));return reactExports.useEffect(()=>{t.current=re$1(n);},[n]),t}let Re$1="div",ie$1=S$a.RenderStrategy;function ye$1(n,t){let{beforeEnter:r,afterEnter:o,beforeLeave:y,afterLeave:N,enter:p,enterFrom:x,enterTo:m,entered:c,leave:u,leaveFrom:h,leaveTo:v,...s}=n,e=reactExports.useRef(null),a=y$9(e,t),i=s.unmount?j$2.Unmount:j$2.Hidden,{show:l,appear:T,initial:se}=Ee$1(),[g,M]=reactExports.useState(l?"visible":"hidden"),z=be(),{register:F,unregister:L}=z,U=reactExports.useRef(null);reactExports.useEffect(()=>F(e),[F,e]),reactExports.useEffect(()=>{if(i===j$2.Hidden&&e.current){if(l&&g!=="visible"){M("visible");return}return u$b(g,{["hidden"]:()=>L(e),["visible"]:()=>F(e)})}},[g,e,F,L,l,i]);let j=s$c({enter:S$3(p),enterFrom:S$3(x),enterTo:S$3(m),entered:S$3(c),leave:S$3(u),leaveFrom:S$3(h),leaveTo:S$3(v)}),w=Pe$1({beforeEnter:r,afterEnter:o,beforeLeave:y,afterLeave:N}),k=l$9();reactExports.useEffect(()=>{if(k&&g==="visible"&&e.current===null)throw new Error("Did you forget to passthrough the `ref` to the actual DOM node?")},[e,g,k]);let G=se&&!T,ae=(()=>!k||G||U.current===l?"idle":l?"enter":"leave")(),H=c$2(0),le=o$5(C=>u$b(C,{enter:()=>{H.addFlag(d$8.Opening),w.current.beforeEnter();},leave:()=>{H.addFlag(d$8.Closing),w.current.beforeLeave();},idle:()=>{}})),ue=o$5(C=>u$b(C,{enter:()=>{H.removeFlag(d$8.Opening),w.current.afterEnter();},leave:()=>{H.removeFlag(d$8.Closing),w.current.afterLeave();},idle:()=>{}})),O=ne$1(()=>{M("hidden"),L(e);},z);D$4({container:e,classes:j,direction:ae,onStart:s$c(C=>{O.onStart(e,C,le);}),onStop:s$c(C=>{O.onStop(e,C,ue),C==="leave"&&!_$1(O)&&(M("hidden"),L(e));})}),reactExports.useEffect(()=>{G&&(i===j$2.Hidden?U.current=null:U.current=l);},[l,G,g]);let B=s,Te={ref:a};return T&&l&&(B={...B,className:e$5(s.className,...j.current.enter,...j.current.enterFrom)}),React$2.createElement(I$4.Provider,{value:O},React$2.createElement(c$5,{value:u$b(g,{["visible"]:d$8.Open,["hidden"]:d$8.Closed})|H.flags},X$6({ourProps:Te,theirProps:B,defaultTag:Re$1,features:ie$1,visible:g==="visible",name:"Transition.Child"})))}function Ne$1(n,t){let{show:r,appear:o=!1,unmount:y,...N}=n,p=reactExports.useRef(null),x=y$9(p,t);l$9();let m=C$3();if(r===void 0&&m!==null&&(r=(m&d$8.Open)===d$8.Open),![!0,!1].includes(r))throw new Error("A <Transition /> is used but it is missing a `show={true | false}` prop.");let[c,u]=reactExports.useState(r?"visible":"hidden"),h=ne$1(()=>{u("hidden");}),[v,s]=reactExports.useState(!0),e=reactExports.useRef([r]);l$a(()=>{v!==!1&&e.current[e.current.length-1]!==r&&(e.current.push(r),s(!1));},[e,r]);let a=reactExports.useMemo(()=>({show:r,appear:o,initial:v}),[r,o,v]);reactExports.useEffect(()=>{if(r)u("visible");else if(!_$1(h))u("hidden");else {let l=p.current;if(!l)return;let T=l.getBoundingClientRect();T.x===0&&T.y===0&&T.width===0&&T.height===0&&u("hidden");}},[r,h]);let i={unmount:y};return React$2.createElement(I$4.Provider,{value:h},React$2.createElement(A$4.Provider,{value:a},X$6({ourProps:{...i,as:reactExports.Fragment,children:React$2.createElement(oe,{ref:x,...i,...N})},theirProps:{},defaultTag:reactExports.Fragment,features:ie$1,visible:c==="visible",name:"Transition"})))}function He$1(n,t){let r=reactExports.useContext(A$4)!==null,o=C$3()!==null;return React$2.createElement(React$2.Fragment,null,!r&&o?React$2.createElement(q$4,{ref:t,...n}):React$2.createElement(oe,{ref:t,...n}))}let q$4=D$6(Ne$1),oe=D$6(ye$1),De$1=D$6(He$1),tt$1=Object.assign(q$4,{Child:De$1,Root:q$4});

	const useEditedProjects = () => {
	    const { loggedIn } = useUserInfo();
	    const result = trpc.projects.listEditedProjects.useQuery(undefined, {
	        suspense: true,
	        enabled: loggedIn,
	        placeholderData: { projects: [] },
	    });
	    // will never actually be undefined due to inclusion of placeholder data.
	    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
	    return result.data;
	};

	const useDataLoader = (
	    url,
	    providedOnError
	) => {
	    const [data, setData] = reactExports.useState();
	    const isLoading = reactExports.useRef(false);

	    const onError = reactExports.useCallback(
	        (e) => {
	            if (providedOnError) providedOnError(e);
	            else throw e;
	        },
	        [providedOnError]
	    );

	    reactExports.useEffect(() => {
	        if (isLoading.current) return;

	        isLoading.current = true;
	        axios$1
	            .get(url)
	            .then((resp) => {
	                isLoading.current = false;
	                setData(resp.data);
	            })
	            .catch(onError);
	    }, [url, onError]);

	    return {
	        isLoading: isLoading.current,
	        data,
	    };
	};

	const useNotificationCount = ({
	    projectHandle,
	} = {}) => {
	    const { loggedIn } = useUserInfo();
	    const currentProject = useCurrentProject();
	    const { data: notificationCount } = trpc.notifications.count.useQuery(
	        { projectHandle: projectHandle ?? currentProject?.handle ?? undefined },
	        {
	            refetchInterval: false, refetchOnReconnect: false, refetchOnWindowFocus: false, refetchIntervalInBackground: false, // 30 seconds
	            enabled: loggedIn,
	            notifyOnChangeProps: ["data"],
	            placeholderData: {
	                count: 0,
	            },
	        }
	    );
	    return notificationCount ?? { count: 0 };
	};

	const useFollowRequestCount = ({
	    projectHandle,
	} = {}) => {
	    const { loggedIn } = useUserInfo();
	    const currentProject = useCurrentProject();
	    const { data: followReqCount } =
	        trpc.relationships.countFollowRequests.useQuery(
	            {
	                projectHandle:
	                    projectHandle ?? currentProject?.handle ?? undefined,
	            },
	            {
	                refetchInterval: false, refetchOnReconnect: false, refetchOnWindowFocus: false, refetchIntervalInBackground: false, // 30 seconds
	                enabled: loggedIn,
	                notifyOnChangeProps: ["data"],
	                placeholderData: {
	                    count: 0,
	                },
	            }
	        );
	    return followReqCount ?? { count: 0 };
	};

	const useUnreadAskCount = ({
	    projectHandle,
	} = {}) => {
	    const { loggedIn } = useUserInfo();
	    const currentProject = useCurrentProject();
	    const { data: unreadCount } = trpc.asks.unreadCount.useQuery(
	        {
	            projectHandle: projectHandle ?? currentProject?.handle ?? undefined,
	        },
	        {
	            refetchInterval: false, refetchOnReconnect: false, refetchOnWindowFocus: false, refetchIntervalInBackground: false, // 30 seconds
	            enabled: loggedIn,
	            notifyOnChangeProps: ["data"],
	            placeholderData: {
	                count: 0,
	            },
	        }
	    );
	    return unreadCount ?? { count: 0 };
	};

	const useBookmarkedTags = (defaults, enabled = true) => {
	    const { loggedIn } = useUserInfo();
	    return trpc.bookmarks.tags.list.useQuery(undefined, {
	        placeholderData: defaults ? { tags: defaults } : undefined,
	        suspense: true,
	        enabled: enabled && loggedIn,
	    });
	};

	const useCurrentProject = () => {
	    const { projectId } = useUserInfo();
	    const { projects } = useEditedProjects();
	    const currentProject = reactExports.useMemo(
	        () => projects.find((project) => project.projectId === projectId),
	        [projectId, projects]
	    );
	    return currentProject;
	};

	const useHasCohostPlus = () => {
	    return (
	        trpc.subscriptions.hasActiveSubscription.useQuery(undefined, {
	            suspense: true,
	            notifyOnChangeProps: ["data", "error"],
	        }).data ?? false
	    );
	};

	const HomeView = mod.enum(["dashboard", "following"]);
	 

	const PostBoxTheme = mod.enum(["light", "dark"]);
	 

	const PostBoxThemeSetting = PostBoxTheme.or(
	    mod.enum(["prefers-color-scheme"])
	);
	 

	const DisplayPrefs = mod.object({
	    isAdult: mod.boolean().default(false),
	    explicitlyCollapseAdultContent: mod.boolean().default(false),
	    collapseLongThreads: mod.boolean().default(false),
	    gifsStartPaused: mod.boolean().default(true),
	    pauseProfileGifs: mod.boolean().default(false),
	    disableEmbeds: mod.boolean().default(false),
	    externalLinksInNewTab: mod.boolean().default(true),
	    enableNotificationCount: mod.boolean().default(false),
	    autoexpandCWs: mod.array(mod.string()).default([]),
	    collapsedTags: mod.array(mod.string()).default([]),
	    suggestedFollowsDismissed: mod.boolean().default(false),
	    enableMobileQuickShare: mod.boolean().default(true),
	    beatsTimestamps: mod.boolean().default(false),
	    autoExpandAllCws: mod.boolean().default(false),
	    disableModalPostComposer: mod.boolean().default(false),
	    homeView: HomeView.default("dashboard"),
	    defaultShow18PlusPostsInSearches: mod.boolean().default(true),
	    defaultPostBoxTheme: PostBoxThemeSetting.default("prefers-color-scheme"),
	    previewFeatures_lexicalPostEditor: mod.boolean().default(true),
	    // chaos day 2023 specific
	    chaosDay2023_showNumbers: mod.boolean().default(true),
	});

	const useDisplayPrefs = () => {
	    const result = trpc.users.displayPrefs.useQuery(undefined, {
	        suspense: true,
	        keepPreviousData: true,
	        notifyOnChangeProps: ["data", "error"],
	    });

	    return result.data ?? DisplayPrefs.parse({});
	};

	const NestedEgg = reactExports.forwardRef


	(({ children, ...props }, ref) => (
	    React$2.createElement('svg', {
	        viewBox: "0 0 25 18"   ,
	        xmlns: "http://www.w3.org/2000/svg",
	        style: {
	            fillRule: "evenodd",
	            clipRule: "evenodd",
	            strokeLinejoin: "round",
	            strokeMiterlimit: 2,
	        },
	        ...props,
	        ref: ref,
	        role: "button",}

	        , React$2.createElement('path', {
	            d: "M14.923 17.087c-2.254.666-4.388.967-6.402.905-2.014-.062-3.742-.532-5.183-1.409-1.442-.877-2.436-2.217-2.982-4.022-.549-1.814-.463-3.476.257-4.985.719-1.51 1.905-2.832 3.557-3.965C5.823 2.478 7.776 1.578 10.03.913c2.243-.663 4.369-.965 6.376-.906 2.007.059 3.733.523 5.178 1.394 1.446.87 2.441 2.207 2.987 4.011.546 1.804.457 3.464-.266 4.981-.724 1.516-1.908 2.845-3.551 3.987-1.644 1.143-3.588 2.045-5.831 2.707Z"                           ,
	            style: {
	                fillRule: "nonzero",
	            },}
	        )
	        , children
	    )
	));
	NestedEgg.displayName = "NestedEgg";

	const IconEgg = reactExports.forwardRef




	(({ children, scale = 0.8, rotation = 0, ...props }, ref) => (
	    React$2.createElement(NestedEgg, { ...props, ref: ref,}
	        , React$2.createElement('g', {
	            'transform-origin': "center center" ,
	            transform: `scale(${scale} ${scale}) rotate(${rotation})`,}

	            , children
	        )
	    )
	));
	IconEgg.displayName = "IconEgg";

	const TextEgg = reactExports.forwardRef


	(({ children, ...props }, ref) => (
	    React$2.createElement(NestedEgg, { ...props, ref: ref,}
	        , React$2.createElement('text', {
	            x: "50%",
	            y: "50%",
	            textAnchor: "middle",
	            dominantBaseline: "middle",
	            className: "cursor-pointer select-none fill-current font-atkinson text-[10px] font-bold leading-none"      ,}

	            , children
	        )
	    )
	));
	TextEgg.displayName = "TextEgg";

	const consoleLogger = {
	  type: 'logger',
	  log(args) {
	    this.output('log', args);
	  },
	  warn(args) {
	    this.output('warn', args);
	  },
	  error(args) {
	    this.output('error', args);
	  },
	  output(type, args) {
	    if (console && console[type]) console[type].apply(console, args);
	  }
	};
	class Logger {
	  constructor(concreteLogger) {
	    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	    this.init(concreteLogger, options);
	  }
	  init(concreteLogger) {
	    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	    this.prefix = options.prefix || 'i18next:';
	    this.logger = concreteLogger || consoleLogger;
	    this.options = options;
	    this.debug = options.debug;
	  }
	  log() {
	    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	    return this.forward(args, 'log', '', true);
	  }
	  warn() {
	    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
	      args[_key2] = arguments[_key2];
	    }
	    return this.forward(args, 'warn', '', true);
	  }
	  error() {
	    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
	      args[_key3] = arguments[_key3];
	    }
	    return this.forward(args, 'error', '');
	  }
	  deprecate() {
	    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
	      args[_key4] = arguments[_key4];
	    }
	    return this.forward(args, 'warn', 'WARNING DEPRECATED: ', true);
	  }
	  forward(args, lvl, prefix, debugOnly) {
	    if (debugOnly && !this.debug) return null;
	    if (typeof args[0] === 'string') args[0] = `${prefix}${this.prefix} ${args[0]}`;
	    return this.logger[lvl](args);
	  }
	  create(moduleName) {
	    return new Logger(this.logger, {
	      ...{
	        prefix: `${this.prefix}:${moduleName}:`
	      },
	      ...this.options
	    });
	  }
	  clone(options) {
	    options = options || this.options;
	    options.prefix = options.prefix || this.prefix;
	    return new Logger(this.logger, options);
	  }
	}
	var baseLogger = new Logger();

	class EventEmitter {
	  constructor() {
	    this.observers = {};
	  }
	  on(events, listener) {
	    events.split(' ').forEach(event => {
	      this.observers[event] = this.observers[event] || [];
	      this.observers[event].push(listener);
	    });
	    return this;
	  }
	  off(event, listener) {
	    if (!this.observers[event]) return;
	    if (!listener) {
	      delete this.observers[event];
	      return;
	    }
	    this.observers[event] = this.observers[event].filter(l => l !== listener);
	  }
	  emit(event) {
	    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
	      args[_key - 1] = arguments[_key];
	    }
	    if (this.observers[event]) {
	      const cloned = [].concat(this.observers[event]);
	      cloned.forEach(observer => {
	        observer(...args);
	      });
	    }
	    if (this.observers['*']) {
	      const cloned = [].concat(this.observers['*']);
	      cloned.forEach(observer => {
	        observer.apply(observer, [event, ...args]);
	      });
	    }
	  }
	}

	function defer() {
	  let res;
	  let rej;
	  const promise = new Promise((resolve, reject) => {
	    res = resolve;
	    rej = reject;
	  });
	  promise.resolve = res;
	  promise.reject = rej;
	  return promise;
	}
	function makeString(object) {
	  if (object == null) return '';
	  return '' + object;
	}
	function copy(a, s, t) {
	  a.forEach(m => {
	    if (s[m]) t[m] = s[m];
	  });
	}
	function getLastOfPath(object, path, Empty) {
	  function cleanKey(key) {
	    return key && key.indexOf('###') > -1 ? key.replace(/###/g, '.') : key;
	  }
	  function canNotTraverseDeeper() {
	    return !object || typeof object === 'string';
	  }
	  const stack = typeof path !== 'string' ? [].concat(path) : path.split('.');
	  while (stack.length > 1) {
	    if (canNotTraverseDeeper()) return {};
	    const key = cleanKey(stack.shift());
	    if (!object[key] && Empty) object[key] = new Empty();
	    if (Object.prototype.hasOwnProperty.call(object, key)) {
	      object = object[key];
	    } else {
	      object = {};
	    }
	  }
	  if (canNotTraverseDeeper()) return {};
	  return {
	    obj: object,
	    k: cleanKey(stack.shift())
	  };
	}
	function setPath(object, path, newValue) {
	  const {
	    obj,
	    k
	  } = getLastOfPath(object, path, Object);
	  obj[k] = newValue;
	}
	function pushPath(object, path, newValue, concat) {
	  const {
	    obj,
	    k
	  } = getLastOfPath(object, path, Object);
	  obj[k] = obj[k] || [];
	  obj[k].push(newValue);
	}
	function getPath(object, path) {
	  const {
	    obj,
	    k
	  } = getLastOfPath(object, path);
	  if (!obj) return undefined;
	  return obj[k];
	}
	function getPathWithDefaults(data, defaultData, key) {
	  const value = getPath(data, key);
	  if (value !== undefined) {
	    return value;
	  }
	  return getPath(defaultData, key);
	}
	function deepExtend(target, source, overwrite) {
	  for (const prop in source) {
	    if (prop !== '__proto__' && prop !== 'constructor') {
	      if (prop in target) {
	        if (typeof target[prop] === 'string' || target[prop] instanceof String || typeof source[prop] === 'string' || source[prop] instanceof String) {
	          if (overwrite) target[prop] = source[prop];
	        } else {
	          deepExtend(target[prop], source[prop], overwrite);
	        }
	      } else {
	        target[prop] = source[prop];
	      }
	    }
	  }
	  return target;
	}
	function regexEscape(str) {
	  return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
	}
	var _entityMap = {
	  '&': '&amp;',
	  '<': '&lt;',
	  '>': '&gt;',
	  '"': '&quot;',
	  "'": '&#39;',
	  '/': '&#x2F;'
	};
	function escape$1(data) {
	  if (typeof data === 'string') {
	    return data.replace(/[&<>"'\/]/g, s => _entityMap[s]);
	  }
	  return data;
	}
	const chars = [' ', ',', '?', '!', ';'];
	function looksLikeObjectPath(key, nsSeparator, keySeparator) {
	  nsSeparator = nsSeparator || '';
	  keySeparator = keySeparator || '';
	  const possibleChars = chars.filter(c => nsSeparator.indexOf(c) < 0 && keySeparator.indexOf(c) < 0);
	  if (possibleChars.length === 0) return true;
	  const r = new RegExp(`(${possibleChars.map(c => c === '?' ? '\\?' : c).join('|')})`);
	  let matched = !r.test(key);
	  if (!matched) {
	    const ki = key.indexOf(keySeparator);
	    if (ki > 0 && !r.test(key.substring(0, ki))) {
	      matched = true;
	    }
	  }
	  return matched;
	}
	function deepFind(obj, path) {
	  let keySeparator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '.';
	  if (!obj) return undefined;
	  if (obj[path]) return obj[path];
	  const paths = path.split(keySeparator);
	  let current = obj;
	  for (let i = 0; i < paths.length; ++i) {
	    if (!current) return undefined;
	    if (typeof current[paths[i]] === 'string' && i + 1 < paths.length) {
	      return undefined;
	    }
	    if (current[paths[i]] === undefined) {
	      let j = 2;
	      let p = paths.slice(i, i + j).join(keySeparator);
	      let mix = current[p];
	      while (mix === undefined && paths.length > i + j) {
	        j++;
	        p = paths.slice(i, i + j).join(keySeparator);
	        mix = current[p];
	      }
	      if (mix === undefined) return undefined;
	      if (mix === null) return null;
	      if (path.endsWith(p)) {
	        if (typeof mix === 'string') return mix;
	        if (p && typeof mix[p] === 'string') return mix[p];
	      }
	      const joinedPath = paths.slice(i + j).join(keySeparator);
	      if (joinedPath) return deepFind(mix, joinedPath, keySeparator);
	      return undefined;
	    }
	    current = current[paths[i]];
	  }
	  return current;
	}
	function getCleanedCode(code) {
	  if (code && code.indexOf('_') > 0) return code.replace('_', '-');
	  return code;
	}

	class ResourceStore extends EventEmitter {
	  constructor(data) {
	    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
	      ns: ['translation'],
	      defaultNS: 'translation'
	    };
	    super();
	    this.data = data || {};
	    this.options = options;
	    if (this.options.keySeparator === undefined) {
	      this.options.keySeparator = '.';
	    }
	    if (this.options.ignoreJSONStructure === undefined) {
	      this.options.ignoreJSONStructure = true;
	    }
	  }
	  addNamespaces(ns) {
	    if (this.options.ns.indexOf(ns) < 0) {
	      this.options.ns.push(ns);
	    }
	  }
	  removeNamespaces(ns) {
	    const index = this.options.ns.indexOf(ns);
	    if (index > -1) {
	      this.options.ns.splice(index, 1);
	    }
	  }
	  getResource(lng, ns, key) {
	    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
	    const keySeparator = options.keySeparator !== undefined ? options.keySeparator : this.options.keySeparator;
	    const ignoreJSONStructure = options.ignoreJSONStructure !== undefined ? options.ignoreJSONStructure : this.options.ignoreJSONStructure;
	    let path = [lng, ns];
	    if (key && typeof key !== 'string') path = path.concat(key);
	    if (key && typeof key === 'string') path = path.concat(keySeparator ? key.split(keySeparator) : key);
	    if (lng.indexOf('.') > -1) {
	      path = lng.split('.');
	    }
	    const result = getPath(this.data, path);
	    if (result || !ignoreJSONStructure || typeof key !== 'string') return result;
	    return deepFind(this.data && this.data[lng] && this.data[lng][ns], key, keySeparator);
	  }
	  addResource(lng, ns, key, value) {
	    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {
	      silent: false
	    };
	    const keySeparator = options.keySeparator !== undefined ? options.keySeparator : this.options.keySeparator;
	    let path = [lng, ns];
	    if (key) path = path.concat(keySeparator ? key.split(keySeparator) : key);
	    if (lng.indexOf('.') > -1) {
	      path = lng.split('.');
	      value = ns;
	      ns = path[1];
	    }
	    this.addNamespaces(ns);
	    setPath(this.data, path, value);
	    if (!options.silent) this.emit('added', lng, ns, key, value);
	  }
	  addResources(lng, ns, resources) {
	    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {
	      silent: false
	    };
	    for (const m in resources) {
	      if (typeof resources[m] === 'string' || Object.prototype.toString.apply(resources[m]) === '[object Array]') this.addResource(lng, ns, m, resources[m], {
	        silent: true
	      });
	    }
	    if (!options.silent) this.emit('added', lng, ns, resources);
	  }
	  addResourceBundle(lng, ns, resources, deep, overwrite) {
	    let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {
	      silent: false
	    };
	    let path = [lng, ns];
	    if (lng.indexOf('.') > -1) {
	      path = lng.split('.');
	      deep = resources;
	      resources = ns;
	      ns = path[1];
	    }
	    this.addNamespaces(ns);
	    let pack = getPath(this.data, path) || {};
	    if (deep) {
	      deepExtend(pack, resources, overwrite);
	    } else {
	      pack = {
	        ...pack,
	        ...resources
	      };
	    }
	    setPath(this.data, path, pack);
	    if (!options.silent) this.emit('added', lng, ns, resources);
	  }
	  removeResourceBundle(lng, ns) {
	    if (this.hasResourceBundle(lng, ns)) {
	      delete this.data[lng][ns];
	    }
	    this.removeNamespaces(ns);
	    this.emit('removed', lng, ns);
	  }
	  hasResourceBundle(lng, ns) {
	    return this.getResource(lng, ns) !== undefined;
	  }
	  getResourceBundle(lng, ns) {
	    if (!ns) ns = this.options.defaultNS;
	    if (this.options.compatibilityAPI === 'v1') return {
	      ...{},
	      ...this.getResource(lng, ns)
	    };
	    return this.getResource(lng, ns);
	  }
	  getDataByLanguage(lng) {
	    return this.data[lng];
	  }
	  hasLanguageSomeTranslations(lng) {
	    const data = this.getDataByLanguage(lng);
	    const n = data && Object.keys(data) || [];
	    return !!n.find(v => data[v] && Object.keys(data[v]).length > 0);
	  }
	  toJSON() {
	    return this.data;
	  }
	}

	var postProcessor = {
	  processors: {},
	  addPostProcessor(module) {
	    this.processors[module.name] = module;
	  },
	  handle(processors, value, key, options, translator) {
	    processors.forEach(processor => {
	      if (this.processors[processor]) value = this.processors[processor].process(value, key, options, translator);
	    });
	    return value;
	  }
	};

	const checkedLoadedFor = {};
	class Translator extends EventEmitter {
	  constructor(services) {
	    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	    super();
	    copy(['resourceStore', 'languageUtils', 'pluralResolver', 'interpolator', 'backendConnector', 'i18nFormat', 'utils'], services, this);
	    this.options = options;
	    if (this.options.keySeparator === undefined) {
	      this.options.keySeparator = '.';
	    }
	    this.logger = baseLogger.create('translator');
	  }
	  changeLanguage(lng) {
	    if (lng) this.language = lng;
	  }
	  exists(key) {
	    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
	      interpolation: {}
	    };
	    if (key === undefined || key === null) {
	      return false;
	    }
	    const resolved = this.resolve(key, options);
	    return resolved && resolved.res !== undefined;
	  }
	  extractFromKey(key, options) {
	    let nsSeparator = options.nsSeparator !== undefined ? options.nsSeparator : this.options.nsSeparator;
	    if (nsSeparator === undefined) nsSeparator = ':';
	    const keySeparator = options.keySeparator !== undefined ? options.keySeparator : this.options.keySeparator;
	    let namespaces = options.ns || this.options.defaultNS || [];
	    const wouldCheckForNsInKey = nsSeparator && key.indexOf(nsSeparator) > -1;
	    const seemsNaturalLanguage = !this.options.userDefinedKeySeparator && !options.keySeparator && !this.options.userDefinedNsSeparator && !options.nsSeparator && !looksLikeObjectPath(key, nsSeparator, keySeparator);
	    if (wouldCheckForNsInKey && !seemsNaturalLanguage) {
	      const m = key.match(this.interpolator.nestingRegexp);
	      if (m && m.length > 0) {
	        return {
	          key,
	          namespaces
	        };
	      }
	      const parts = key.split(nsSeparator);
	      if (nsSeparator !== keySeparator || nsSeparator === keySeparator && this.options.ns.indexOf(parts[0]) > -1) namespaces = parts.shift();
	      key = parts.join(keySeparator);
	    }
	    if (typeof namespaces === 'string') namespaces = [namespaces];
	    return {
	      key,
	      namespaces
	    };
	  }
	  translate(keys, options, lastKey) {
	    if (typeof options !== 'object' && this.options.overloadTranslationOptionHandler) {
	      options = this.options.overloadTranslationOptionHandler(arguments);
	    }
	    if (typeof options === 'object') options = {
	      ...options
	    };
	    if (!options) options = {};
	    if (keys === undefined || keys === null) return '';
	    if (!Array.isArray(keys)) keys = [String(keys)];
	    const returnDetails = options.returnDetails !== undefined ? options.returnDetails : this.options.returnDetails;
	    const keySeparator = options.keySeparator !== undefined ? options.keySeparator : this.options.keySeparator;
	    const {
	      key,
	      namespaces
	    } = this.extractFromKey(keys[keys.length - 1], options);
	    const namespace = namespaces[namespaces.length - 1];
	    const lng = options.lng || this.language;
	    const appendNamespaceToCIMode = options.appendNamespaceToCIMode || this.options.appendNamespaceToCIMode;
	    if (lng && lng.toLowerCase() === 'cimode') {
	      if (appendNamespaceToCIMode) {
	        const nsSeparator = options.nsSeparator || this.options.nsSeparator;
	        if (returnDetails) {
	          return {
	            res: `${namespace}${nsSeparator}${key}`,
	            usedKey: key,
	            exactUsedKey: key,
	            usedLng: lng,
	            usedNS: namespace
	          };
	        }
	        return `${namespace}${nsSeparator}${key}`;
	      }
	      if (returnDetails) {
	        return {
	          res: key,
	          usedKey: key,
	          exactUsedKey: key,
	          usedLng: lng,
	          usedNS: namespace
	        };
	      }
	      return key;
	    }
	    const resolved = this.resolve(keys, options);
	    let res = resolved && resolved.res;
	    const resUsedKey = resolved && resolved.usedKey || key;
	    const resExactUsedKey = resolved && resolved.exactUsedKey || key;
	    const resType = Object.prototype.toString.apply(res);
	    const noObject = ['[object Number]', '[object Function]', '[object RegExp]'];
	    const joinArrays = options.joinArrays !== undefined ? options.joinArrays : this.options.joinArrays;
	    const handleAsObjectInI18nFormat = !this.i18nFormat || this.i18nFormat.handleAsObject;
	    const handleAsObject = typeof res !== 'string' && typeof res !== 'boolean' && typeof res !== 'number';
	    if (handleAsObjectInI18nFormat && res && handleAsObject && noObject.indexOf(resType) < 0 && !(typeof joinArrays === 'string' && resType === '[object Array]')) {
	      if (!options.returnObjects && !this.options.returnObjects) {
	        if (!this.options.returnedObjectHandler) {
	          this.logger.warn('accessing an object - but returnObjects options is not enabled!');
	        }
	        const r = this.options.returnedObjectHandler ? this.options.returnedObjectHandler(resUsedKey, res, {
	          ...options,
	          ns: namespaces
	        }) : `key '${key} (${this.language})' returned an object instead of string.`;
	        if (returnDetails) {
	          resolved.res = r;
	          return resolved;
	        }
	        return r;
	      }
	      if (keySeparator) {
	        const resTypeIsArray = resType === '[object Array]';
	        const copy = resTypeIsArray ? [] : {};
	        const newKeyToUse = resTypeIsArray ? resExactUsedKey : resUsedKey;
	        for (const m in res) {
	          if (Object.prototype.hasOwnProperty.call(res, m)) {
	            const deepKey = `${newKeyToUse}${keySeparator}${m}`;
	            copy[m] = this.translate(deepKey, {
	              ...options,
	              ...{
	                joinArrays: false,
	                ns: namespaces
	              }
	            });
	            if (copy[m] === deepKey) copy[m] = res[m];
	          }
	        }
	        res = copy;
	      }
	    } else if (handleAsObjectInI18nFormat && typeof joinArrays === 'string' && resType === '[object Array]') {
	      res = res.join(joinArrays);
	      if (res) res = this.extendTranslation(res, keys, options, lastKey);
	    } else {
	      let usedDefault = false;
	      let usedKey = false;
	      const needsPluralHandling = options.count !== undefined && typeof options.count !== 'string';
	      const hasDefaultValue = Translator.hasDefaultValue(options);
	      const defaultValueSuffix = needsPluralHandling ? this.pluralResolver.getSuffix(lng, options.count, options) : '';
	      const defaultValueSuffixOrdinalFallback = options.ordinal && needsPluralHandling ? this.pluralResolver.getSuffix(lng, options.count, {
	        ordinal: false
	      }) : '';
	      const defaultValue = options[`defaultValue${defaultValueSuffix}`] || options[`defaultValue${defaultValueSuffixOrdinalFallback}`] || options.defaultValue;
	      if (!this.isValidLookup(res) && hasDefaultValue) {
	        usedDefault = true;
	        res = defaultValue;
	      }
	      if (!this.isValidLookup(res)) {
	        usedKey = true;
	        res = key;
	      }
	      const missingKeyNoValueFallbackToKey = options.missingKeyNoValueFallbackToKey || this.options.missingKeyNoValueFallbackToKey;
	      const resForMissing = missingKeyNoValueFallbackToKey && usedKey ? undefined : res;
	      const updateMissing = hasDefaultValue && defaultValue !== res && this.options.updateMissing;
	      if (usedKey || usedDefault || updateMissing) {
	        this.logger.log(updateMissing ? 'updateKey' : 'missingKey', lng, namespace, key, updateMissing ? defaultValue : res);
	        if (keySeparator) {
	          const fk = this.resolve(key, {
	            ...options,
	            keySeparator: false
	          });
	          if (fk && fk.res) this.logger.warn('Seems the loaded translations were in flat JSON format instead of nested. Either set keySeparator: false on init or make sure your translations are published in nested format.');
	        }
	        let lngs = [];
	        const fallbackLngs = this.languageUtils.getFallbackCodes(this.options.fallbackLng, options.lng || this.language);
	        if (this.options.saveMissingTo === 'fallback' && fallbackLngs && fallbackLngs[0]) {
	          for (let i = 0; i < fallbackLngs.length; i++) {
	            lngs.push(fallbackLngs[i]);
	          }
	        } else if (this.options.saveMissingTo === 'all') {
	          lngs = this.languageUtils.toResolveHierarchy(options.lng || this.language);
	        } else {
	          lngs.push(options.lng || this.language);
	        }
	        const send = (l, k, specificDefaultValue) => {
	          const defaultForMissing = hasDefaultValue && specificDefaultValue !== res ? specificDefaultValue : resForMissing;
	          if (this.options.missingKeyHandler) {
	            this.options.missingKeyHandler(l, namespace, k, defaultForMissing, updateMissing, options);
	          } else if (this.backendConnector && this.backendConnector.saveMissing) {
	            this.backendConnector.saveMissing(l, namespace, k, defaultForMissing, updateMissing, options);
	          }
	          this.emit('missingKey', l, namespace, k, res);
	        };
	        if (this.options.saveMissing) {
	          if (this.options.saveMissingPlurals && needsPluralHandling) {
	            lngs.forEach(language => {
	              this.pluralResolver.getSuffixes(language, options).forEach(suffix => {
	                send([language], key + suffix, options[`defaultValue${suffix}`] || defaultValue);
	              });
	            });
	          } else {
	            send(lngs, key, defaultValue);
	          }
	        }
	      }
	      res = this.extendTranslation(res, keys, options, resolved, lastKey);
	      if (usedKey && res === key && this.options.appendNamespaceToMissingKey) res = `${namespace}:${key}`;
	      if ((usedKey || usedDefault) && this.options.parseMissingKeyHandler) {
	        if (this.options.compatibilityAPI !== 'v1') {
	          res = this.options.parseMissingKeyHandler(this.options.appendNamespaceToMissingKey ? `${namespace}:${key}` : key, usedDefault ? res : undefined);
	        } else {
	          res = this.options.parseMissingKeyHandler(res);
	        }
	      }
	    }
	    if (returnDetails) {
	      resolved.res = res;
	      return resolved;
	    }
	    return res;
	  }
	  extendTranslation(res, key, options, resolved, lastKey) {
	    var _this = this;
	    if (this.i18nFormat && this.i18nFormat.parse) {
	      res = this.i18nFormat.parse(res, {
	        ...this.options.interpolation.defaultVariables,
	        ...options
	      }, options.lng || this.language || resolved.usedLng, resolved.usedNS, resolved.usedKey, {
	        resolved
	      });
	    } else if (!options.skipInterpolation) {
	      if (options.interpolation) this.interpolator.init({
	        ...options,
	        ...{
	          interpolation: {
	            ...this.options.interpolation,
	            ...options.interpolation
	          }
	        }
	      });
	      const skipOnVariables = typeof res === 'string' && (options && options.interpolation && options.interpolation.skipOnVariables !== undefined ? options.interpolation.skipOnVariables : this.options.interpolation.skipOnVariables);
	      let nestBef;
	      if (skipOnVariables) {
	        const nb = res.match(this.interpolator.nestingRegexp);
	        nestBef = nb && nb.length;
	      }
	      let data = options.replace && typeof options.replace !== 'string' ? options.replace : options;
	      if (this.options.interpolation.defaultVariables) data = {
	        ...this.options.interpolation.defaultVariables,
	        ...data
	      };
	      res = this.interpolator.interpolate(res, data, options.lng || this.language, options);
	      if (skipOnVariables) {
	        const na = res.match(this.interpolator.nestingRegexp);
	        const nestAft = na && na.length;
	        if (nestBef < nestAft) options.nest = false;
	      }
	      if (!options.lng && this.options.compatibilityAPI !== 'v1' && resolved && resolved.res) options.lng = resolved.usedLng;
	      if (options.nest !== false) res = this.interpolator.nest(res, function () {
	        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
	          args[_key] = arguments[_key];
	        }
	        if (lastKey && lastKey[0] === args[0] && !options.context) {
	          _this.logger.warn(`It seems you are nesting recursively key: ${args[0]} in key: ${key[0]}`);
	          return null;
	        }
	        return _this.translate(...args, key);
	      }, options);
	      if (options.interpolation) this.interpolator.reset();
	    }
	    const postProcess = options.postProcess || this.options.postProcess;
	    const postProcessorNames = typeof postProcess === 'string' ? [postProcess] : postProcess;
	    if (res !== undefined && res !== null && postProcessorNames && postProcessorNames.length && options.applyPostProcessor !== false) {
	      res = postProcessor.handle(postProcessorNames, res, key, this.options && this.options.postProcessPassResolved ? {
	        i18nResolved: resolved,
	        ...options
	      } : options, this);
	    }
	    return res;
	  }
	  resolve(keys) {
	    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	    let found;
	    let usedKey;
	    let exactUsedKey;
	    let usedLng;
	    let usedNS;
	    if (typeof keys === 'string') keys = [keys];
	    keys.forEach(k => {
	      if (this.isValidLookup(found)) return;
	      const extracted = this.extractFromKey(k, options);
	      const key = extracted.key;
	      usedKey = key;
	      let namespaces = extracted.namespaces;
	      if (this.options.fallbackNS) namespaces = namespaces.concat(this.options.fallbackNS);
	      const needsPluralHandling = options.count !== undefined && typeof options.count !== 'string';
	      const needsZeroSuffixLookup = needsPluralHandling && !options.ordinal && options.count === 0 && this.pluralResolver.shouldUseIntlApi();
	      const needsContextHandling = options.context !== undefined && (typeof options.context === 'string' || typeof options.context === 'number') && options.context !== '';
	      const codes = options.lngs ? options.lngs : this.languageUtils.toResolveHierarchy(options.lng || this.language, options.fallbackLng);
	      namespaces.forEach(ns => {
	        if (this.isValidLookup(found)) return;
	        usedNS = ns;
	        if (!checkedLoadedFor[`${codes[0]}-${ns}`] && this.utils && this.utils.hasLoadedNamespace && !this.utils.hasLoadedNamespace(usedNS)) {
	          checkedLoadedFor[`${codes[0]}-${ns}`] = true;
	          this.logger.warn(`key "${usedKey}" for languages "${codes.join(', ')}" won't get resolved as namespace "${usedNS}" was not yet loaded`, 'This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!');
	        }
	        codes.forEach(code => {
	          if (this.isValidLookup(found)) return;
	          usedLng = code;
	          const finalKeys = [key];
	          if (this.i18nFormat && this.i18nFormat.addLookupKeys) {
	            this.i18nFormat.addLookupKeys(finalKeys, key, code, ns, options);
	          } else {
	            let pluralSuffix;
	            if (needsPluralHandling) pluralSuffix = this.pluralResolver.getSuffix(code, options.count, options);
	            const zeroSuffix = `${this.options.pluralSeparator}zero`;
	            const ordinalPrefix = `${this.options.pluralSeparator}ordinal${this.options.pluralSeparator}`;
	            if (needsPluralHandling) {
	              finalKeys.push(key + pluralSuffix);
	              if (options.ordinal && pluralSuffix.indexOf(ordinalPrefix) === 0) {
	                finalKeys.push(key + pluralSuffix.replace(ordinalPrefix, this.options.pluralSeparator));
	              }
	              if (needsZeroSuffixLookup) {
	                finalKeys.push(key + zeroSuffix);
	              }
	            }
	            if (needsContextHandling) {
	              const contextKey = `${key}${this.options.contextSeparator}${options.context}`;
	              finalKeys.push(contextKey);
	              if (needsPluralHandling) {
	                finalKeys.push(contextKey + pluralSuffix);
	                if (options.ordinal && pluralSuffix.indexOf(ordinalPrefix) === 0) {
	                  finalKeys.push(contextKey + pluralSuffix.replace(ordinalPrefix, this.options.pluralSeparator));
	                }
	                if (needsZeroSuffixLookup) {
	                  finalKeys.push(contextKey + zeroSuffix);
	                }
	              }
	            }
	          }
	          let possibleKey;
	          while (possibleKey = finalKeys.pop()) {
	            if (!this.isValidLookup(found)) {
	              exactUsedKey = possibleKey;
	              found = this.getResource(code, ns, possibleKey, options);
	            }
	          }
	        });
	      });
	    });
	    return {
	      res: found,
	      usedKey,
	      exactUsedKey,
	      usedLng,
	      usedNS
	    };
	  }
	  isValidLookup(res) {
	    return res !== undefined && !(!this.options.returnNull && res === null) && !(!this.options.returnEmptyString && res === '');
	  }
	  getResource(code, ns, key) {
	    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
	    if (this.i18nFormat && this.i18nFormat.getResource) return this.i18nFormat.getResource(code, ns, key, options);
	    return this.resourceStore.getResource(code, ns, key, options);
	  }
	  static hasDefaultValue(options) {
	    const prefix = 'defaultValue';
	    for (const option in options) {
	      if (Object.prototype.hasOwnProperty.call(options, option) && prefix === option.substring(0, prefix.length) && undefined !== options[option]) {
	        return true;
	      }
	    }
	    return false;
	  }
	}

	function capitalize(string) {
	  return string.charAt(0).toUpperCase() + string.slice(1);
	}
	class LanguageUtil {
	  constructor(options) {
	    this.options = options;
	    this.supportedLngs = this.options.supportedLngs || false;
	    this.logger = baseLogger.create('languageUtils');
	  }
	  getScriptPartFromCode(code) {
	    code = getCleanedCode(code);
	    if (!code || code.indexOf('-') < 0) return null;
	    const p = code.split('-');
	    if (p.length === 2) return null;
	    p.pop();
	    if (p[p.length - 1].toLowerCase() === 'x') return null;
	    return this.formatLanguageCode(p.join('-'));
	  }
	  getLanguagePartFromCode(code) {
	    code = getCleanedCode(code);
	    if (!code || code.indexOf('-') < 0) return code;
	    const p = code.split('-');
	    return this.formatLanguageCode(p[0]);
	  }
	  formatLanguageCode(code) {
	    if (typeof code === 'string' && code.indexOf('-') > -1) {
	      const specialCases = ['hans', 'hant', 'latn', 'cyrl', 'cans', 'mong', 'arab'];
	      let p = code.split('-');
	      if (this.options.lowerCaseLng) {
	        p = p.map(part => part.toLowerCase());
	      } else if (p.length === 2) {
	        p[0] = p[0].toLowerCase();
	        p[1] = p[1].toUpperCase();
	        if (specialCases.indexOf(p[1].toLowerCase()) > -1) p[1] = capitalize(p[1].toLowerCase());
	      } else if (p.length === 3) {
	        p[0] = p[0].toLowerCase();
	        if (p[1].length === 2) p[1] = p[1].toUpperCase();
	        if (p[0] !== 'sgn' && p[2].length === 2) p[2] = p[2].toUpperCase();
	        if (specialCases.indexOf(p[1].toLowerCase()) > -1) p[1] = capitalize(p[1].toLowerCase());
	        if (specialCases.indexOf(p[2].toLowerCase()) > -1) p[2] = capitalize(p[2].toLowerCase());
	      }
	      return p.join('-');
	    }
	    return this.options.cleanCode || this.options.lowerCaseLng ? code.toLowerCase() : code;
	  }
	  isSupportedCode(code) {
	    if (this.options.load === 'languageOnly' || this.options.nonExplicitSupportedLngs) {
	      code = this.getLanguagePartFromCode(code);
	    }
	    return !this.supportedLngs || !this.supportedLngs.length || this.supportedLngs.indexOf(code) > -1;
	  }
	  getBestMatchFromCodes(codes) {
	    if (!codes) return null;
	    let found;
	    codes.forEach(code => {
	      if (found) return;
	      const cleanedLng = this.formatLanguageCode(code);
	      if (!this.options.supportedLngs || this.isSupportedCode(cleanedLng)) found = cleanedLng;
	    });
	    if (!found && this.options.supportedLngs) {
	      codes.forEach(code => {
	        if (found) return;
	        const lngOnly = this.getLanguagePartFromCode(code);
	        if (this.isSupportedCode(lngOnly)) return found = lngOnly;
	        found = this.options.supportedLngs.find(supportedLng => {
	          if (supportedLng === lngOnly) return supportedLng;
	          if (supportedLng.indexOf('-') < 0 && lngOnly.indexOf('-') < 0) return;
	          if (supportedLng.indexOf(lngOnly) === 0) return supportedLng;
	        });
	      });
	    }
	    if (!found) found = this.getFallbackCodes(this.options.fallbackLng)[0];
	    return found;
	  }
	  getFallbackCodes(fallbacks, code) {
	    if (!fallbacks) return [];
	    if (typeof fallbacks === 'function') fallbacks = fallbacks(code);
	    if (typeof fallbacks === 'string') fallbacks = [fallbacks];
	    if (Object.prototype.toString.apply(fallbacks) === '[object Array]') return fallbacks;
	    if (!code) return fallbacks.default || [];
	    let found = fallbacks[code];
	    if (!found) found = fallbacks[this.getScriptPartFromCode(code)];
	    if (!found) found = fallbacks[this.formatLanguageCode(code)];
	    if (!found) found = fallbacks[this.getLanguagePartFromCode(code)];
	    if (!found) found = fallbacks.default;
	    return found || [];
	  }
	  toResolveHierarchy(code, fallbackCode) {
	    const fallbackCodes = this.getFallbackCodes(fallbackCode || this.options.fallbackLng || [], code);
	    const codes = [];
	    const addCode = c => {
	      if (!c) return;
	      if (this.isSupportedCode(c)) {
	        codes.push(c);
	      } else {
	        this.logger.warn(`rejecting language code not found in supportedLngs: ${c}`);
	      }
	    };
	    if (typeof code === 'string' && (code.indexOf('-') > -1 || code.indexOf('_') > -1)) {
	      if (this.options.load !== 'languageOnly') addCode(this.formatLanguageCode(code));
	      if (this.options.load !== 'languageOnly' && this.options.load !== 'currentOnly') addCode(this.getScriptPartFromCode(code));
	      if (this.options.load !== 'currentOnly') addCode(this.getLanguagePartFromCode(code));
	    } else if (typeof code === 'string') {
	      addCode(this.formatLanguageCode(code));
	    }
	    fallbackCodes.forEach(fc => {
	      if (codes.indexOf(fc) < 0) addCode(this.formatLanguageCode(fc));
	    });
	    return codes;
	  }
	}

	let sets = [{
	  lngs: ['ach', 'ak', 'am', 'arn', 'br', 'fil', 'gun', 'ln', 'mfe', 'mg', 'mi', 'oc', 'pt', 'pt-BR', 'tg', 'tl', 'ti', 'tr', 'uz', 'wa'],
	  nr: [1, 2],
	  fc: 1
	}, {
	  lngs: ['af', 'an', 'ast', 'az', 'bg', 'bn', 'ca', 'da', 'de', 'dev', 'el', 'en', 'eo', 'es', 'et', 'eu', 'fi', 'fo', 'fur', 'fy', 'gl', 'gu', 'ha', 'hi', 'hu', 'hy', 'ia', 'it', 'kk', 'kn', 'ku', 'lb', 'mai', 'ml', 'mn', 'mr', 'nah', 'nap', 'nb', 'ne', 'nl', 'nn', 'no', 'nso', 'pa', 'pap', 'pms', 'ps', 'pt-PT', 'rm', 'sco', 'se', 'si', 'so', 'son', 'sq', 'sv', 'sw', 'ta', 'te', 'tk', 'ur', 'yo'],
	  nr: [1, 2],
	  fc: 2
	}, {
	  lngs: ['ay', 'bo', 'cgg', 'fa', 'ht', 'id', 'ja', 'jbo', 'ka', 'km', 'ko', 'ky', 'lo', 'ms', 'sah', 'su', 'th', 'tt', 'ug', 'vi', 'wo', 'zh'],
	  nr: [1],
	  fc: 3
	}, {
	  lngs: ['be', 'bs', 'cnr', 'dz', 'hr', 'ru', 'sr', 'uk'],
	  nr: [1, 2, 5],
	  fc: 4
	}, {
	  lngs: ['ar'],
	  nr: [0, 1, 2, 3, 11, 100],
	  fc: 5
	}, {
	  lngs: ['cs', 'sk'],
	  nr: [1, 2, 5],
	  fc: 6
	}, {
	  lngs: ['csb', 'pl'],
	  nr: [1, 2, 5],
	  fc: 7
	}, {
	  lngs: ['cy'],
	  nr: [1, 2, 3, 8],
	  fc: 8
	}, {
	  lngs: ['fr'],
	  nr: [1, 2],
	  fc: 9
	}, {
	  lngs: ['ga'],
	  nr: [1, 2, 3, 7, 11],
	  fc: 10
	}, {
	  lngs: ['gd'],
	  nr: [1, 2, 3, 20],
	  fc: 11
	}, {
	  lngs: ['is'],
	  nr: [1, 2],
	  fc: 12
	}, {
	  lngs: ['jv'],
	  nr: [0, 1],
	  fc: 13
	}, {
	  lngs: ['kw'],
	  nr: [1, 2, 3, 4],
	  fc: 14
	}, {
	  lngs: ['lt'],
	  nr: [1, 2, 10],
	  fc: 15
	}, {
	  lngs: ['lv'],
	  nr: [1, 2, 0],
	  fc: 16
	}, {
	  lngs: ['mk'],
	  nr: [1, 2],
	  fc: 17
	}, {
	  lngs: ['mnk'],
	  nr: [0, 1, 2],
	  fc: 18
	}, {
	  lngs: ['mt'],
	  nr: [1, 2, 11, 20],
	  fc: 19
	}, {
	  lngs: ['or'],
	  nr: [2, 1],
	  fc: 2
	}, {
	  lngs: ['ro'],
	  nr: [1, 2, 20],
	  fc: 20
	}, {
	  lngs: ['sl'],
	  nr: [5, 1, 2, 3],
	  fc: 21
	}, {
	  lngs: ['he', 'iw'],
	  nr: [1, 2, 20, 21],
	  fc: 22
	}];
	let _rulesPluralsTypes = {
	  1: function (n) {
	    return Number(n > 1);
	  },
	  2: function (n) {
	    return Number(n != 1);
	  },
	  3: function (n) {
	    return 0;
	  },
	  4: function (n) {
	    return Number(n % 10 == 1 && n % 100 != 11 ? 0 : n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 10 || n % 100 >= 20) ? 1 : 2);
	  },
	  5: function (n) {
	    return Number(n == 0 ? 0 : n == 1 ? 1 : n == 2 ? 2 : n % 100 >= 3 && n % 100 <= 10 ? 3 : n % 100 >= 11 ? 4 : 5);
	  },
	  6: function (n) {
	    return Number(n == 1 ? 0 : n >= 2 && n <= 4 ? 1 : 2);
	  },
	  7: function (n) {
	    return Number(n == 1 ? 0 : n % 10 >= 2 && n % 10 <= 4 && (n % 100 < 10 || n % 100 >= 20) ? 1 : 2);
	  },
	  8: function (n) {
	    return Number(n == 1 ? 0 : n == 2 ? 1 : n != 8 && n != 11 ? 2 : 3);
	  },
	  9: function (n) {
	    return Number(n >= 2);
	  },
	  10: function (n) {
	    return Number(n == 1 ? 0 : n == 2 ? 1 : n < 7 ? 2 : n < 11 ? 3 : 4);
	  },
	  11: function (n) {
	    return Number(n == 1 || n == 11 ? 0 : n == 2 || n == 12 ? 1 : n > 2 && n < 20 ? 2 : 3);
	  },
	  12: function (n) {
	    return Number(n % 10 != 1 || n % 100 == 11);
	  },
	  13: function (n) {
	    return Number(n !== 0);
	  },
	  14: function (n) {
	    return Number(n == 1 ? 0 : n == 2 ? 1 : n == 3 ? 2 : 3);
	  },
	  15: function (n) {
	    return Number(n % 10 == 1 && n % 100 != 11 ? 0 : n % 10 >= 2 && (n % 100 < 10 || n % 100 >= 20) ? 1 : 2);
	  },
	  16: function (n) {
	    return Number(n % 10 == 1 && n % 100 != 11 ? 0 : n !== 0 ? 1 : 2);
	  },
	  17: function (n) {
	    return Number(n == 1 || n % 10 == 1 && n % 100 != 11 ? 0 : 1);
	  },
	  18: function (n) {
	    return Number(n == 0 ? 0 : n == 1 ? 1 : 2);
	  },
	  19: function (n) {
	    return Number(n == 1 ? 0 : n == 0 || n % 100 > 1 && n % 100 < 11 ? 1 : n % 100 > 10 && n % 100 < 20 ? 2 : 3);
	  },
	  20: function (n) {
	    return Number(n == 1 ? 0 : n == 0 || n % 100 > 0 && n % 100 < 20 ? 1 : 2);
	  },
	  21: function (n) {
	    return Number(n % 100 == 1 ? 1 : n % 100 == 2 ? 2 : n % 100 == 3 || n % 100 == 4 ? 3 : 0);
	  },
	  22: function (n) {
	    return Number(n == 1 ? 0 : n == 2 ? 1 : (n < 0 || n > 10) && n % 10 == 0 ? 2 : 3);
	  }
	};
	const nonIntlVersions = ['v1', 'v2', 'v3'];
	const intlVersions = ['v4'];
	const suffixesOrder = {
	  zero: 0,
	  one: 1,
	  two: 2,
	  few: 3,
	  many: 4,
	  other: 5
	};
	function createRules() {
	  const rules = {};
	  sets.forEach(set => {
	    set.lngs.forEach(l => {
	      rules[l] = {
	        numbers: set.nr,
	        plurals: _rulesPluralsTypes[set.fc]
	      };
	    });
	  });
	  return rules;
	}
	class PluralResolver {
	  constructor(languageUtils) {
	    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	    this.languageUtils = languageUtils;
	    this.options = options;
	    this.logger = baseLogger.create('pluralResolver');
	    if ((!this.options.compatibilityJSON || intlVersions.includes(this.options.compatibilityJSON)) && (typeof Intl === 'undefined' || !Intl.PluralRules)) {
	      this.options.compatibilityJSON = 'v3';
	      this.logger.error('Your environment seems not to be Intl API compatible, use an Intl.PluralRules polyfill. Will fallback to the compatibilityJSON v3 format handling.');
	    }
	    this.rules = createRules();
	  }
	  addRule(lng, obj) {
	    this.rules[lng] = obj;
	  }
	  getRule(code) {
	    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	    if (this.shouldUseIntlApi()) {
	      try {
	        return new Intl.PluralRules(getCleanedCode(code), {
	          type: options.ordinal ? 'ordinal' : 'cardinal'
	        });
	      } catch {
	        return;
	      }
	    }
	    return this.rules[code] || this.rules[this.languageUtils.getLanguagePartFromCode(code)];
	  }
	  needsPlural(code) {
	    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	    const rule = this.getRule(code, options);
	    if (this.shouldUseIntlApi()) {
	      return rule && rule.resolvedOptions().pluralCategories.length > 1;
	    }
	    return rule && rule.numbers.length > 1;
	  }
	  getPluralFormsOfKey(code, key) {
	    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
	    return this.getSuffixes(code, options).map(suffix => `${key}${suffix}`);
	  }
	  getSuffixes(code) {
	    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	    const rule = this.getRule(code, options);
	    if (!rule) {
	      return [];
	    }
	    if (this.shouldUseIntlApi()) {
	      return rule.resolvedOptions().pluralCategories.sort((pluralCategory1, pluralCategory2) => suffixesOrder[pluralCategory1] - suffixesOrder[pluralCategory2]).map(pluralCategory => `${this.options.prepend}${options.ordinal ? `ordinal${this.options.prepend}` : ''}${pluralCategory}`);
	    }
	    return rule.numbers.map(number => this.getSuffix(code, number, options));
	  }
	  getSuffix(code, count) {
	    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
	    const rule = this.getRule(code, options);
	    if (rule) {
	      if (this.shouldUseIntlApi()) {
	        return `${this.options.prepend}${options.ordinal ? `ordinal${this.options.prepend}` : ''}${rule.select(count)}`;
	      }
	      return this.getSuffixRetroCompatible(rule, count);
	    }
	    this.logger.warn(`no plural rule found for: ${code}`);
	    return '';
	  }
	  getSuffixRetroCompatible(rule, count) {
	    const idx = rule.noAbs ? rule.plurals(count) : rule.plurals(Math.abs(count));
	    let suffix = rule.numbers[idx];
	    if (this.options.simplifyPluralSuffix && rule.numbers.length === 2 && rule.numbers[0] === 1) {
	      if (suffix === 2) {
	        suffix = 'plural';
	      } else if (suffix === 1) {
	        suffix = '';
	      }
	    }
	    const returnSuffix = () => this.options.prepend && suffix.toString() ? this.options.prepend + suffix.toString() : suffix.toString();
	    if (this.options.compatibilityJSON === 'v1') {
	      if (suffix === 1) return '';
	      if (typeof suffix === 'number') return `_plural_${suffix.toString()}`;
	      return returnSuffix();
	    } else if (this.options.compatibilityJSON === 'v2') {
	      return returnSuffix();
	    } else if (this.options.simplifyPluralSuffix && rule.numbers.length === 2 && rule.numbers[0] === 1) {
	      return returnSuffix();
	    }
	    return this.options.prepend && idx.toString() ? this.options.prepend + idx.toString() : idx.toString();
	  }
	  shouldUseIntlApi() {
	    return !nonIntlVersions.includes(this.options.compatibilityJSON);
	  }
	}

	function deepFindWithDefaults(data, defaultData, key) {
	  let keySeparator = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '.';
	  let ignoreJSONStructure = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
	  let path = getPathWithDefaults(data, defaultData, key);
	  if (!path && ignoreJSONStructure && typeof key === 'string') {
	    path = deepFind(data, key, keySeparator);
	    if (path === undefined) path = deepFind(defaultData, key, keySeparator);
	  }
	  return path;
	}
	class Interpolator {
	  constructor() {
	    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	    this.logger = baseLogger.create('interpolator');
	    this.options = options;
	    this.format = options.interpolation && options.interpolation.format || (value => value);
	    this.init(options);
	  }
	  init() {
	    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	    if (!options.interpolation) options.interpolation = {
	      escapeValue: true
	    };
	    const iOpts = options.interpolation;
	    this.escape = iOpts.escape !== undefined ? iOpts.escape : escape$1;
	    this.escapeValue = iOpts.escapeValue !== undefined ? iOpts.escapeValue : true;
	    this.useRawValueToEscape = iOpts.useRawValueToEscape !== undefined ? iOpts.useRawValueToEscape : false;
	    this.prefix = iOpts.prefix ? regexEscape(iOpts.prefix) : iOpts.prefixEscaped || '{{';
	    this.suffix = iOpts.suffix ? regexEscape(iOpts.suffix) : iOpts.suffixEscaped || '}}';
	    this.formatSeparator = iOpts.formatSeparator ? iOpts.formatSeparator : iOpts.formatSeparator || ',';
	    this.unescapePrefix = iOpts.unescapeSuffix ? '' : iOpts.unescapePrefix || '-';
	    this.unescapeSuffix = this.unescapePrefix ? '' : iOpts.unescapeSuffix || '';
	    this.nestingPrefix = iOpts.nestingPrefix ? regexEscape(iOpts.nestingPrefix) : iOpts.nestingPrefixEscaped || regexEscape('$t(');
	    this.nestingSuffix = iOpts.nestingSuffix ? regexEscape(iOpts.nestingSuffix) : iOpts.nestingSuffixEscaped || regexEscape(')');
	    this.nestingOptionsSeparator = iOpts.nestingOptionsSeparator ? iOpts.nestingOptionsSeparator : iOpts.nestingOptionsSeparator || ',';
	    this.maxReplaces = iOpts.maxReplaces ? iOpts.maxReplaces : 1000;
	    this.alwaysFormat = iOpts.alwaysFormat !== undefined ? iOpts.alwaysFormat : false;
	    this.resetRegExp();
	  }
	  reset() {
	    if (this.options) this.init(this.options);
	  }
	  resetRegExp() {
	    const regexpStr = `${this.prefix}(.+?)${this.suffix}`;
	    this.regexp = new RegExp(regexpStr, 'g');
	    const regexpUnescapeStr = `${this.prefix}${this.unescapePrefix}(.+?)${this.unescapeSuffix}${this.suffix}`;
	    this.regexpUnescape = new RegExp(regexpUnescapeStr, 'g');
	    const nestingRegexpStr = `${this.nestingPrefix}(.+?)${this.nestingSuffix}`;
	    this.nestingRegexp = new RegExp(nestingRegexpStr, 'g');
	  }
	  interpolate(str, data, lng, options) {
	    let match;
	    let value;
	    let replaces;
	    const defaultData = this.options && this.options.interpolation && this.options.interpolation.defaultVariables || {};
	    function regexSafe(val) {
	      return val.replace(/\$/g, '$$$$');
	    }
	    const handleFormat = key => {
	      if (key.indexOf(this.formatSeparator) < 0) {
	        const path = deepFindWithDefaults(data, defaultData, key, this.options.keySeparator, this.options.ignoreJSONStructure);
	        return this.alwaysFormat ? this.format(path, undefined, lng, {
	          ...options,
	          ...data,
	          interpolationkey: key
	        }) : path;
	      }
	      const p = key.split(this.formatSeparator);
	      const k = p.shift().trim();
	      const f = p.join(this.formatSeparator).trim();
	      return this.format(deepFindWithDefaults(data, defaultData, k, this.options.keySeparator, this.options.ignoreJSONStructure), f, lng, {
	        ...options,
	        ...data,
	        interpolationkey: k
	      });
	    };
	    this.resetRegExp();
	    const missingInterpolationHandler = options && options.missingInterpolationHandler || this.options.missingInterpolationHandler;
	    const skipOnVariables = options && options.interpolation && options.interpolation.skipOnVariables !== undefined ? options.interpolation.skipOnVariables : this.options.interpolation.skipOnVariables;
	    const todos = [{
	      regex: this.regexpUnescape,
	      safeValue: val => regexSafe(val)
	    }, {
	      regex: this.regexp,
	      safeValue: val => this.escapeValue ? regexSafe(this.escape(val)) : regexSafe(val)
	    }];
	    todos.forEach(todo => {
	      replaces = 0;
	      while (match = todo.regex.exec(str)) {
	        const matchedVar = match[1].trim();
	        value = handleFormat(matchedVar);
	        if (value === undefined) {
	          if (typeof missingInterpolationHandler === 'function') {
	            const temp = missingInterpolationHandler(str, match, options);
	            value = typeof temp === 'string' ? temp : '';
	          } else if (options && Object.prototype.hasOwnProperty.call(options, matchedVar)) {
	            value = '';
	          } else if (skipOnVariables) {
	            value = match[0];
	            continue;
	          } else {
	            this.logger.warn(`missed to pass in variable ${matchedVar} for interpolating ${str}`);
	            value = '';
	          }
	        } else if (typeof value !== 'string' && !this.useRawValueToEscape) {
	          value = makeString(value);
	        }
	        const safeValue = todo.safeValue(value);
	        str = str.replace(match[0], safeValue);
	        if (skipOnVariables) {
	          todo.regex.lastIndex += value.length;
	          todo.regex.lastIndex -= match[0].length;
	        } else {
	          todo.regex.lastIndex = 0;
	        }
	        replaces++;
	        if (replaces >= this.maxReplaces) {
	          break;
	        }
	      }
	    });
	    return str;
	  }
	  nest(str, fc) {
	    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
	    let match;
	    let value;
	    let clonedOptions;
	    function handleHasOptions(key, inheritedOptions) {
	      const sep = this.nestingOptionsSeparator;
	      if (key.indexOf(sep) < 0) return key;
	      const c = key.split(new RegExp(`${sep}[ ]*{`));
	      let optionsString = `{${c[1]}`;
	      key = c[0];
	      optionsString = this.interpolate(optionsString, clonedOptions);
	      const matchedSingleQuotes = optionsString.match(/'/g);
	      const matchedDoubleQuotes = optionsString.match(/"/g);
	      if (matchedSingleQuotes && matchedSingleQuotes.length % 2 === 0 && !matchedDoubleQuotes || matchedDoubleQuotes.length % 2 !== 0) {
	        optionsString = optionsString.replace(/'/g, '"');
	      }
	      try {
	        clonedOptions = JSON.parse(optionsString);
	        if (inheritedOptions) clonedOptions = {
	          ...inheritedOptions,
	          ...clonedOptions
	        };
	      } catch (e) {
	        this.logger.warn(`failed parsing options string in nesting for key ${key}`, e);
	        return `${key}${sep}${optionsString}`;
	      }
	      delete clonedOptions.defaultValue;
	      return key;
	    }
	    while (match = this.nestingRegexp.exec(str)) {
	      let formatters = [];
	      clonedOptions = {
	        ...options
	      };
	      clonedOptions = clonedOptions.replace && typeof clonedOptions.replace !== 'string' ? clonedOptions.replace : clonedOptions;
	      clonedOptions.applyPostProcessor = false;
	      delete clonedOptions.defaultValue;
	      let doReduce = false;
	      if (match[0].indexOf(this.formatSeparator) !== -1 && !/{.*}/.test(match[1])) {
	        const r = match[1].split(this.formatSeparator).map(elem => elem.trim());
	        match[1] = r.shift();
	        formatters = r;
	        doReduce = true;
	      }
	      value = fc(handleHasOptions.call(this, match[1].trim(), clonedOptions), clonedOptions);
	      if (value && match[0] === str && typeof value !== 'string') return value;
	      if (typeof value !== 'string') value = makeString(value);
	      if (!value) {
	        this.logger.warn(`missed to resolve ${match[1]} for nesting ${str}`);
	        value = '';
	      }
	      if (doReduce) {
	        value = formatters.reduce((v, f) => this.format(v, f, options.lng, {
	          ...options,
	          interpolationkey: match[1].trim()
	        }), value.trim());
	      }
	      str = str.replace(match[0], value);
	      this.regexp.lastIndex = 0;
	    }
	    return str;
	  }
	}

	function parseFormatStr(formatStr) {
	  let formatName = formatStr.toLowerCase().trim();
	  const formatOptions = {};
	  if (formatStr.indexOf('(') > -1) {
	    const p = formatStr.split('(');
	    formatName = p[0].toLowerCase().trim();
	    const optStr = p[1].substring(0, p[1].length - 1);
	    if (formatName === 'currency' && optStr.indexOf(':') < 0) {
	      if (!formatOptions.currency) formatOptions.currency = optStr.trim();
	    } else if (formatName === 'relativetime' && optStr.indexOf(':') < 0) {
	      if (!formatOptions.range) formatOptions.range = optStr.trim();
	    } else {
	      const opts = optStr.split(';');
	      opts.forEach(opt => {
	        if (!opt) return;
	        const [key, ...rest] = opt.split(':');
	        const val = rest.join(':').trim().replace(/^'+|'+$/g, '');
	        if (!formatOptions[key.trim()]) formatOptions[key.trim()] = val;
	        if (val === 'false') formatOptions[key.trim()] = false;
	        if (val === 'true') formatOptions[key.trim()] = true;
	        if (!isNaN(val)) formatOptions[key.trim()] = parseInt(val, 10);
	      });
	    }
	  }
	  return {
	    formatName,
	    formatOptions
	  };
	}
	function createCachedFormatter(fn) {
	  const cache = {};
	  return function invokeFormatter(val, lng, options) {
	    const key = lng + JSON.stringify(options);
	    let formatter = cache[key];
	    if (!formatter) {
	      formatter = fn(getCleanedCode(lng), options);
	      cache[key] = formatter;
	    }
	    return formatter(val);
	  };
	}
	class Formatter {
	  constructor() {
	    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	    this.logger = baseLogger.create('formatter');
	    this.options = options;
	    this.formats = {
	      number: createCachedFormatter((lng, opt) => {
	        const formatter = new Intl.NumberFormat(lng, {
	          ...opt
	        });
	        return val => formatter.format(val);
	      }),
	      currency: createCachedFormatter((lng, opt) => {
	        const formatter = new Intl.NumberFormat(lng, {
	          ...opt,
	          style: 'currency'
	        });
	        return val => formatter.format(val);
	      }),
	      datetime: createCachedFormatter((lng, opt) => {
	        const formatter = new Intl.DateTimeFormat(lng, {
	          ...opt
	        });
	        return val => formatter.format(val);
	      }),
	      relativetime: createCachedFormatter((lng, opt) => {
	        const formatter = new Intl.RelativeTimeFormat(lng, {
	          ...opt
	        });
	        return val => formatter.format(val, opt.range || 'day');
	      }),
	      list: createCachedFormatter((lng, opt) => {
	        const formatter = new Intl.ListFormat(lng, {
	          ...opt
	        });
	        return val => formatter.format(val);
	      })
	    };
	    this.init(options);
	  }
	  init(services) {
	    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
	      interpolation: {}
	    };
	    const iOpts = options.interpolation;
	    this.formatSeparator = iOpts.formatSeparator ? iOpts.formatSeparator : iOpts.formatSeparator || ',';
	  }
	  add(name, fc) {
	    this.formats[name.toLowerCase().trim()] = fc;
	  }
	  addCached(name, fc) {
	    this.formats[name.toLowerCase().trim()] = createCachedFormatter(fc);
	  }
	  format(value, format, lng) {
	    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
	    const formats = format.split(this.formatSeparator);
	    const result = formats.reduce((mem, f) => {
	      const {
	        formatName,
	        formatOptions
	      } = parseFormatStr(f);
	      if (this.formats[formatName]) {
	        let formatted = mem;
	        try {
	          const valOptions = options && options.formatParams && options.formatParams[options.interpolationkey] || {};
	          const l = valOptions.locale || valOptions.lng || options.locale || options.lng || lng;
	          formatted = this.formats[formatName](mem, l, {
	            ...formatOptions,
	            ...options,
	            ...valOptions
	          });
	        } catch (error) {
	          this.logger.warn(error);
	        }
	        return formatted;
	      } else {
	        this.logger.warn(`there was no format function for ${formatName}`);
	      }
	      return mem;
	    }, value);
	    return result;
	  }
	}

	function removePending(q, name) {
	  if (q.pending[name] !== undefined) {
	    delete q.pending[name];
	    q.pendingCount--;
	  }
	}
	class Connector extends EventEmitter {
	  constructor(backend, store, services) {
	    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
	    super();
	    this.backend = backend;
	    this.store = store;
	    this.services = services;
	    this.languageUtils = services.languageUtils;
	    this.options = options;
	    this.logger = baseLogger.create('backendConnector');
	    this.waitingReads = [];
	    this.maxParallelReads = options.maxParallelReads || 10;
	    this.readingCalls = 0;
	    this.maxRetries = options.maxRetries >= 0 ? options.maxRetries : 5;
	    this.retryTimeout = options.retryTimeout >= 1 ? options.retryTimeout : 350;
	    this.state = {};
	    this.queue = [];
	    if (this.backend && this.backend.init) {
	      this.backend.init(services, options.backend, options);
	    }
	  }
	  queueLoad(languages, namespaces, options, callback) {
	    const toLoad = {};
	    const pending = {};
	    const toLoadLanguages = {};
	    const toLoadNamespaces = {};
	    languages.forEach(lng => {
	      let hasAllNamespaces = true;
	      namespaces.forEach(ns => {
	        const name = `${lng}|${ns}`;
	        if (!options.reload && this.store.hasResourceBundle(lng, ns)) {
	          this.state[name] = 2;
	        } else if (this.state[name] < 0) ; else if (this.state[name] === 1) {
	          if (pending[name] === undefined) pending[name] = true;
	        } else {
	          this.state[name] = 1;
	          hasAllNamespaces = false;
	          if (pending[name] === undefined) pending[name] = true;
	          if (toLoad[name] === undefined) toLoad[name] = true;
	          if (toLoadNamespaces[ns] === undefined) toLoadNamespaces[ns] = true;
	        }
	      });
	      if (!hasAllNamespaces) toLoadLanguages[lng] = true;
	    });
	    if (Object.keys(toLoad).length || Object.keys(pending).length) {
	      this.queue.push({
	        pending,
	        pendingCount: Object.keys(pending).length,
	        loaded: {},
	        errors: [],
	        callback
	      });
	    }
	    return {
	      toLoad: Object.keys(toLoad),
	      pending: Object.keys(pending),
	      toLoadLanguages: Object.keys(toLoadLanguages),
	      toLoadNamespaces: Object.keys(toLoadNamespaces)
	    };
	  }
	  loaded(name, err, data) {
	    const s = name.split('|');
	    const lng = s[0];
	    const ns = s[1];
	    if (err) this.emit('failedLoading', lng, ns, err);
	    if (data) {
	      this.store.addResourceBundle(lng, ns, data);
	    }
	    this.state[name] = err ? -1 : 2;
	    const loaded = {};
	    this.queue.forEach(q => {
	      pushPath(q.loaded, [lng], ns);
	      removePending(q, name);
	      if (err) q.errors.push(err);
	      if (q.pendingCount === 0 && !q.done) {
	        Object.keys(q.loaded).forEach(l => {
	          if (!loaded[l]) loaded[l] = {};
	          const loadedKeys = q.loaded[l];
	          if (loadedKeys.length) {
	            loadedKeys.forEach(n => {
	              if (loaded[l][n] === undefined) loaded[l][n] = true;
	            });
	          }
	        });
	        q.done = true;
	        if (q.errors.length) {
	          q.callback(q.errors);
	        } else {
	          q.callback();
	        }
	      }
	    });
	    this.emit('loaded', loaded);
	    this.queue = this.queue.filter(q => !q.done);
	  }
	  read(lng, ns, fcName) {
	    let tried = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
	    let wait = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : this.retryTimeout;
	    let callback = arguments.length > 5 ? arguments[5] : undefined;
	    if (!lng.length) return callback(null, {});
	    if (this.readingCalls >= this.maxParallelReads) {
	      this.waitingReads.push({
	        lng,
	        ns,
	        fcName,
	        tried,
	        wait,
	        callback
	      });
	      return;
	    }
	    this.readingCalls++;
	    const resolver = (err, data) => {
	      this.readingCalls--;
	      if (this.waitingReads.length > 0) {
	        const next = this.waitingReads.shift();
	        this.read(next.lng, next.ns, next.fcName, next.tried, next.wait, next.callback);
	      }
	      if (err && data && tried < this.maxRetries) {
	        setTimeout(() => {
	          this.read.call(this, lng, ns, fcName, tried + 1, wait * 2, callback);
	        }, wait);
	        return;
	      }
	      callback(err, data);
	    };
	    const fc = this.backend[fcName].bind(this.backend);
	    if (fc.length === 2) {
	      try {
	        const r = fc(lng, ns);
	        if (r && typeof r.then === 'function') {
	          r.then(data => resolver(null, data)).catch(resolver);
	        } else {
	          resolver(null, r);
	        }
	      } catch (err) {
	        resolver(err);
	      }
	      return;
	    }
	    return fc(lng, ns, resolver);
	  }
	  prepareLoading(languages, namespaces) {
	    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
	    let callback = arguments.length > 3 ? arguments[3] : undefined;
	    if (!this.backend) {
	      this.logger.warn('No backend was added via i18next.use. Will not load resources.');
	      return callback && callback();
	    }
	    if (typeof languages === 'string') languages = this.languageUtils.toResolveHierarchy(languages);
	    if (typeof namespaces === 'string') namespaces = [namespaces];
	    const toLoad = this.queueLoad(languages, namespaces, options, callback);
	    if (!toLoad.toLoad.length) {
	      if (!toLoad.pending.length) callback();
	      return null;
	    }
	    toLoad.toLoad.forEach(name => {
	      this.loadOne(name);
	    });
	  }
	  load(languages, namespaces, callback) {
	    this.prepareLoading(languages, namespaces, {}, callback);
	  }
	  reload(languages, namespaces, callback) {
	    this.prepareLoading(languages, namespaces, {
	      reload: true
	    }, callback);
	  }
	  loadOne(name) {
	    let prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
	    const s = name.split('|');
	    const lng = s[0];
	    const ns = s[1];
	    this.read(lng, ns, 'read', undefined, undefined, (err, data) => {
	      if (err) this.logger.warn(`${prefix}loading namespace ${ns} for language ${lng} failed`, err);
	      if (!err && data) this.logger.log(`${prefix}loaded namespace ${ns} for language ${lng}`, data);
	      this.loaded(name, err, data);
	    });
	  }
	  saveMissing(languages, namespace, key, fallbackValue, isUpdate) {
	    let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
	    let clb = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : () => {};
	    if (this.services.utils && this.services.utils.hasLoadedNamespace && !this.services.utils.hasLoadedNamespace(namespace)) {
	      this.logger.warn(`did not save key "${key}" as the namespace "${namespace}" was not yet loaded`, 'This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!');
	      return;
	    }
	    if (key === undefined || key === null || key === '') return;
	    if (this.backend && this.backend.create) {
	      const opts = {
	        ...options,
	        isUpdate
	      };
	      const fc = this.backend.create.bind(this.backend);
	      if (fc.length < 6) {
	        try {
	          let r;
	          if (fc.length === 5) {
	            r = fc(languages, namespace, key, fallbackValue, opts);
	          } else {
	            r = fc(languages, namespace, key, fallbackValue);
	          }
	          if (r && typeof r.then === 'function') {
	            r.then(data => clb(null, data)).catch(clb);
	          } else {
	            clb(null, r);
	          }
	        } catch (err) {
	          clb(err);
	        }
	      } else {
	        fc(languages, namespace, key, fallbackValue, clb, opts);
	      }
	    }
	    if (!languages || !languages[0]) return;
	    this.store.addResource(languages[0], namespace, key, fallbackValue);
	  }
	}

	function get$5() {
	  return {
	    debug: false,
	    initImmediate: true,
	    ns: ['translation'],
	    defaultNS: ['translation'],
	    fallbackLng: ['dev'],
	    fallbackNS: false,
	    supportedLngs: false,
	    nonExplicitSupportedLngs: false,
	    load: 'all',
	    preload: false,
	    simplifyPluralSuffix: true,
	    keySeparator: '.',
	    nsSeparator: ':',
	    pluralSeparator: '_',
	    contextSeparator: '_',
	    partialBundledLanguages: false,
	    saveMissing: false,
	    updateMissing: false,
	    saveMissingTo: 'fallback',
	    saveMissingPlurals: true,
	    missingKeyHandler: false,
	    missingInterpolationHandler: false,
	    postProcess: false,
	    postProcessPassResolved: false,
	    returnNull: false,
	    returnEmptyString: true,
	    returnObjects: false,
	    joinArrays: false,
	    returnedObjectHandler: false,
	    parseMissingKeyHandler: false,
	    appendNamespaceToMissingKey: false,
	    appendNamespaceToCIMode: false,
	    overloadTranslationOptionHandler: function handle(args) {
	      let ret = {};
	      if (typeof args[1] === 'object') ret = args[1];
	      if (typeof args[1] === 'string') ret.defaultValue = args[1];
	      if (typeof args[2] === 'string') ret.tDescription = args[2];
	      if (typeof args[2] === 'object' || typeof args[3] === 'object') {
	        const options = args[3] || args[2];
	        Object.keys(options).forEach(key => {
	          ret[key] = options[key];
	        });
	      }
	      return ret;
	    },
	    interpolation: {
	      escapeValue: true,
	      format: (value, format, lng, options) => value,
	      prefix: '{{',
	      suffix: '}}',
	      formatSeparator: ',',
	      unescapePrefix: '-',
	      nestingPrefix: '$t(',
	      nestingSuffix: ')',
	      nestingOptionsSeparator: ',',
	      maxReplaces: 1000,
	      skipOnVariables: true
	    }
	  };
	}
	function transformOptions(options) {
	  if (typeof options.ns === 'string') options.ns = [options.ns];
	  if (typeof options.fallbackLng === 'string') options.fallbackLng = [options.fallbackLng];
	  if (typeof options.fallbackNS === 'string') options.fallbackNS = [options.fallbackNS];
	  if (options.supportedLngs && options.supportedLngs.indexOf('cimode') < 0) {
	    options.supportedLngs = options.supportedLngs.concat(['cimode']);
	  }
	  return options;
	}

	function noop$2() {}
	function bindMemberFunctions(inst) {
	  const mems = Object.getOwnPropertyNames(Object.getPrototypeOf(inst));
	  mems.forEach(mem => {
	    if (typeof inst[mem] === 'function') {
	      inst[mem] = inst[mem].bind(inst);
	    }
	  });
	}
	class I18n extends EventEmitter {
	  constructor() {
	    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	    let callback = arguments.length > 1 ? arguments[1] : undefined;
	    super();
	    this.options = transformOptions(options);
	    this.services = {};
	    this.logger = baseLogger;
	    this.modules = {
	      external: []
	    };
	    bindMemberFunctions(this);
	    if (callback && !this.isInitialized && !options.isClone) {
	      if (!this.options.initImmediate) {
	        this.init(options, callback);
	        return this;
	      }
	      setTimeout(() => {
	        this.init(options, callback);
	      }, 0);
	    }
	  }
	  init() {
	    var _this = this;
	    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	    let callback = arguments.length > 1 ? arguments[1] : undefined;
	    if (typeof options === 'function') {
	      callback = options;
	      options = {};
	    }
	    if (!options.defaultNS && options.defaultNS !== false && options.ns) {
	      if (typeof options.ns === 'string') {
	        options.defaultNS = options.ns;
	      } else if (options.ns.indexOf('translation') < 0) {
	        options.defaultNS = options.ns[0];
	      }
	    }
	    const defOpts = get$5();
	    this.options = {
	      ...defOpts,
	      ...this.options,
	      ...transformOptions(options)
	    };
	    if (this.options.compatibilityAPI !== 'v1') {
	      this.options.interpolation = {
	        ...defOpts.interpolation,
	        ...this.options.interpolation
	      };
	    }
	    if (options.keySeparator !== undefined) {
	      this.options.userDefinedKeySeparator = options.keySeparator;
	    }
	    if (options.nsSeparator !== undefined) {
	      this.options.userDefinedNsSeparator = options.nsSeparator;
	    }
	    function createClassOnDemand(ClassOrObject) {
	      if (!ClassOrObject) return null;
	      if (typeof ClassOrObject === 'function') return new ClassOrObject();
	      return ClassOrObject;
	    }
	    if (!this.options.isClone) {
	      if (this.modules.logger) {
	        baseLogger.init(createClassOnDemand(this.modules.logger), this.options);
	      } else {
	        baseLogger.init(null, this.options);
	      }
	      let formatter;
	      if (this.modules.formatter) {
	        formatter = this.modules.formatter;
	      } else if (typeof Intl !== 'undefined') {
	        formatter = Formatter;
	      }
	      const lu = new LanguageUtil(this.options);
	      this.store = new ResourceStore(this.options.resources, this.options);
	      const s = this.services;
	      s.logger = baseLogger;
	      s.resourceStore = this.store;
	      s.languageUtils = lu;
	      s.pluralResolver = new PluralResolver(lu, {
	        prepend: this.options.pluralSeparator,
	        compatibilityJSON: this.options.compatibilityJSON,
	        simplifyPluralSuffix: this.options.simplifyPluralSuffix
	      });
	      if (formatter && (!this.options.interpolation.format || this.options.interpolation.format === defOpts.interpolation.format)) {
	        s.formatter = createClassOnDemand(formatter);
	        s.formatter.init(s, this.options);
	        this.options.interpolation.format = s.formatter.format.bind(s.formatter);
	      }
	      s.interpolator = new Interpolator(this.options);
	      s.utils = {
	        hasLoadedNamespace: this.hasLoadedNamespace.bind(this)
	      };
	      s.backendConnector = new Connector(createClassOnDemand(this.modules.backend), s.resourceStore, s, this.options);
	      s.backendConnector.on('*', function (event) {
	        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
	          args[_key - 1] = arguments[_key];
	        }
	        _this.emit(event, ...args);
	      });
	      if (this.modules.languageDetector) {
	        s.languageDetector = createClassOnDemand(this.modules.languageDetector);
	        if (s.languageDetector.init) s.languageDetector.init(s, this.options.detection, this.options);
	      }
	      if (this.modules.i18nFormat) {
	        s.i18nFormat = createClassOnDemand(this.modules.i18nFormat);
	        if (s.i18nFormat.init) s.i18nFormat.init(this);
	      }
	      this.translator = new Translator(this.services, this.options);
	      this.translator.on('*', function (event) {
	        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
	          args[_key2 - 1] = arguments[_key2];
	        }
	        _this.emit(event, ...args);
	      });
	      this.modules.external.forEach(m => {
	        if (m.init) m.init(this);
	      });
	    }
	    this.format = this.options.interpolation.format;
	    if (!callback) callback = noop$2;
	    if (this.options.fallbackLng && !this.services.languageDetector && !this.options.lng) {
	      const codes = this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);
	      if (codes.length > 0 && codes[0] !== 'dev') this.options.lng = codes[0];
	    }
	    if (!this.services.languageDetector && !this.options.lng) {
	      this.logger.warn('init: no languageDetector is used and no lng is defined');
	    }
	    const storeApi = ['getResource', 'hasResourceBundle', 'getResourceBundle', 'getDataByLanguage'];
	    storeApi.forEach(fcName => {
	      this[fcName] = function () {
	        return _this.store[fcName](...arguments);
	      };
	    });
	    const storeApiChained = ['addResource', 'addResources', 'addResourceBundle', 'removeResourceBundle'];
	    storeApiChained.forEach(fcName => {
	      this[fcName] = function () {
	        _this.store[fcName](...arguments);
	        return _this;
	      };
	    });
	    const deferred = defer();
	    const load = () => {
	      const finish = (err, t) => {
	        if (this.isInitialized && !this.initializedStoreOnce) this.logger.warn('init: i18next is already initialized. You should call init just once!');
	        this.isInitialized = true;
	        if (!this.options.isClone) this.logger.log('initialized', this.options);
	        this.emit('initialized', this.options);
	        deferred.resolve(t);
	        callback(err, t);
	      };
	      if (this.languages && this.options.compatibilityAPI !== 'v1' && !this.isInitialized) return finish(null, this.t.bind(this));
	      this.changeLanguage(this.options.lng, finish);
	    };
	    if (this.options.resources || !this.options.initImmediate) {
	      load();
	    } else {
	      setTimeout(load, 0);
	    }
	    return deferred;
	  }
	  loadResources(language) {
	    let callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : noop$2;
	    let usedCallback = callback;
	    const usedLng = typeof language === 'string' ? language : this.language;
	    if (typeof language === 'function') usedCallback = language;
	    if (!this.options.resources || this.options.partialBundledLanguages) {
	      if (usedLng && usedLng.toLowerCase() === 'cimode' && (!this.options.preload || this.options.preload.length === 0)) return usedCallback();
	      const toLoad = [];
	      const append = lng => {
	        if (!lng) return;
	        if (lng === 'cimode') return;
	        const lngs = this.services.languageUtils.toResolveHierarchy(lng);
	        lngs.forEach(l => {
	          if (l === 'cimode') return;
	          if (toLoad.indexOf(l) < 0) toLoad.push(l);
	        });
	      };
	      if (!usedLng) {
	        const fallbacks = this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);
	        fallbacks.forEach(l => append(l));
	      } else {
	        append(usedLng);
	      }
	      if (this.options.preload) {
	        this.options.preload.forEach(l => append(l));
	      }
	      this.services.backendConnector.load(toLoad, this.options.ns, e => {
	        if (!e && !this.resolvedLanguage && this.language) this.setResolvedLanguage(this.language);
	        usedCallback(e);
	      });
	    } else {
	      usedCallback(null);
	    }
	  }
	  reloadResources(lngs, ns, callback) {
	    const deferred = defer();
	    if (!lngs) lngs = this.languages;
	    if (!ns) ns = this.options.ns;
	    if (!callback) callback = noop$2;
	    this.services.backendConnector.reload(lngs, ns, err => {
	      deferred.resolve();
	      callback(err);
	    });
	    return deferred;
	  }
	  use(module) {
	    if (!module) throw new Error('You are passing an undefined module! Please check the object you are passing to i18next.use()');
	    if (!module.type) throw new Error('You are passing a wrong module! Please check the object you are passing to i18next.use()');
	    if (module.type === 'backend') {
	      this.modules.backend = module;
	    }
	    if (module.type === 'logger' || module.log && module.warn && module.error) {
	      this.modules.logger = module;
	    }
	    if (module.type === 'languageDetector') {
	      this.modules.languageDetector = module;
	    }
	    if (module.type === 'i18nFormat') {
	      this.modules.i18nFormat = module;
	    }
	    if (module.type === 'postProcessor') {
	      postProcessor.addPostProcessor(module);
	    }
	    if (module.type === 'formatter') {
	      this.modules.formatter = module;
	    }
	    if (module.type === '3rdParty') {
	      this.modules.external.push(module);
	    }
	    return this;
	  }
	  setResolvedLanguage(l) {
	    if (!l || !this.languages) return;
	    if (['cimode', 'dev'].indexOf(l) > -1) return;
	    for (let li = 0; li < this.languages.length; li++) {
	      const lngInLngs = this.languages[li];
	      if (['cimode', 'dev'].indexOf(lngInLngs) > -1) continue;
	      if (this.store.hasLanguageSomeTranslations(lngInLngs)) {
	        this.resolvedLanguage = lngInLngs;
	        break;
	      }
	    }
	  }
	  changeLanguage(lng, callback) {
	    var _this2 = this;
	    this.isLanguageChangingTo = lng;
	    const deferred = defer();
	    this.emit('languageChanging', lng);
	    const setLngProps = l => {
	      this.language = l;
	      this.languages = this.services.languageUtils.toResolveHierarchy(l);
	      this.resolvedLanguage = undefined;
	      this.setResolvedLanguage(l);
	    };
	    const done = (err, l) => {
	      if (l) {
	        setLngProps(l);
	        this.translator.changeLanguage(l);
	        this.isLanguageChangingTo = undefined;
	        this.emit('languageChanged', l);
	        this.logger.log('languageChanged', l);
	      } else {
	        this.isLanguageChangingTo = undefined;
	      }
	      deferred.resolve(function () {
	        return _this2.t(...arguments);
	      });
	      if (callback) callback(err, function () {
	        return _this2.t(...arguments);
	      });
	    };
	    const setLng = lngs => {
	      if (!lng && !lngs && this.services.languageDetector) lngs = [];
	      const l = typeof lngs === 'string' ? lngs : this.services.languageUtils.getBestMatchFromCodes(lngs);
	      if (l) {
	        if (!this.language) {
	          setLngProps(l);
	        }
	        if (!this.translator.language) this.translator.changeLanguage(l);
	        if (this.services.languageDetector && this.services.languageDetector.cacheUserLanguage) this.services.languageDetector.cacheUserLanguage(l);
	      }
	      this.loadResources(l, err => {
	        done(err, l);
	      });
	    };
	    if (!lng && this.services.languageDetector && !this.services.languageDetector.async) {
	      setLng(this.services.languageDetector.detect());
	    } else if (!lng && this.services.languageDetector && this.services.languageDetector.async) {
	      if (this.services.languageDetector.detect.length === 0) {
	        this.services.languageDetector.detect().then(setLng);
	      } else {
	        this.services.languageDetector.detect(setLng);
	      }
	    } else {
	      setLng(lng);
	    }
	    return deferred;
	  }
	  getFixedT(lng, ns, keyPrefix) {
	    var _this3 = this;
	    const fixedT = function (key, opts) {
	      let options;
	      if (typeof opts !== 'object') {
	        for (var _len3 = arguments.length, rest = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
	          rest[_key3 - 2] = arguments[_key3];
	        }
	        options = _this3.options.overloadTranslationOptionHandler([key, opts].concat(rest));
	      } else {
	        options = {
	          ...opts
	        };
	      }
	      options.lng = options.lng || fixedT.lng;
	      options.lngs = options.lngs || fixedT.lngs;
	      options.ns = options.ns || fixedT.ns;
	      options.keyPrefix = options.keyPrefix || keyPrefix || fixedT.keyPrefix;
	      const keySeparator = _this3.options.keySeparator || '.';
	      let resultKey;
	      if (options.keyPrefix && Array.isArray(key)) {
	        resultKey = key.map(k => `${options.keyPrefix}${keySeparator}${k}`);
	      } else {
	        resultKey = options.keyPrefix ? `${options.keyPrefix}${keySeparator}${key}` : key;
	      }
	      return _this3.t(resultKey, options);
	    };
	    if (typeof lng === 'string') {
	      fixedT.lng = lng;
	    } else {
	      fixedT.lngs = lng;
	    }
	    fixedT.ns = ns;
	    fixedT.keyPrefix = keyPrefix;
	    return fixedT;
	  }
	  t() {
	    return this.translator && this.translator.translate(...arguments);
	  }
	  exists() {
	    return this.translator && this.translator.exists(...arguments);
	  }
	  setDefaultNamespace(ns) {
	    this.options.defaultNS = ns;
	  }
	  hasLoadedNamespace(ns) {
	    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	    if (!this.isInitialized) {
	      this.logger.warn('hasLoadedNamespace: i18next was not initialized', this.languages);
	      return false;
	    }
	    if (!this.languages || !this.languages.length) {
	      this.logger.warn('hasLoadedNamespace: i18n.languages were undefined or empty', this.languages);
	      return false;
	    }
	    const lng = options.lng || this.resolvedLanguage || this.languages[0];
	    const fallbackLng = this.options ? this.options.fallbackLng : false;
	    const lastLng = this.languages[this.languages.length - 1];
	    if (lng.toLowerCase() === 'cimode') return true;
	    const loadNotPending = (l, n) => {
	      const loadState = this.services.backendConnector.state[`${l}|${n}`];
	      return loadState === -1 || loadState === 2;
	    };
	    if (options.precheck) {
	      const preResult = options.precheck(this, loadNotPending);
	      if (preResult !== undefined) return preResult;
	    }
	    if (this.hasResourceBundle(lng, ns)) return true;
	    if (!this.services.backendConnector.backend || this.options.resources && !this.options.partialBundledLanguages) return true;
	    if (loadNotPending(lng, ns) && (!fallbackLng || loadNotPending(lastLng, ns))) return true;
	    return false;
	  }
	  loadNamespaces(ns, callback) {
	    const deferred = defer();
	    if (!this.options.ns) {
	      if (callback) callback();
	      return Promise.resolve();
	    }
	    if (typeof ns === 'string') ns = [ns];
	    ns.forEach(n => {
	      if (this.options.ns.indexOf(n) < 0) this.options.ns.push(n);
	    });
	    this.loadResources(err => {
	      deferred.resolve();
	      if (callback) callback(err);
	    });
	    return deferred;
	  }
	  loadLanguages(lngs, callback) {
	    const deferred = defer();
	    if (typeof lngs === 'string') lngs = [lngs];
	    const preloaded = this.options.preload || [];
	    const newLngs = lngs.filter(lng => preloaded.indexOf(lng) < 0);
	    if (!newLngs.length) {
	      if (callback) callback();
	      return Promise.resolve();
	    }
	    this.options.preload = preloaded.concat(newLngs);
	    this.loadResources(err => {
	      deferred.resolve();
	      if (callback) callback(err);
	    });
	    return deferred;
	  }
	  dir(lng) {
	    if (!lng) lng = this.resolvedLanguage || (this.languages && this.languages.length > 0 ? this.languages[0] : this.language);
	    if (!lng) return 'rtl';
	    const rtlLngs = ['ar', 'shu', 'sqr', 'ssh', 'xaa', 'yhd', 'yud', 'aao', 'abh', 'abv', 'acm', 'acq', 'acw', 'acx', 'acy', 'adf', 'ads', 'aeb', 'aec', 'afb', 'ajp', 'apc', 'apd', 'arb', 'arq', 'ars', 'ary', 'arz', 'auz', 'avl', 'ayh', 'ayl', 'ayn', 'ayp', 'bbz', 'pga', 'he', 'iw', 'ps', 'pbt', 'pbu', 'pst', 'prp', 'prd', 'ug', 'ur', 'ydd', 'yds', 'yih', 'ji', 'yi', 'hbo', 'men', 'xmn', 'fa', 'jpr', 'peo', 'pes', 'prs', 'dv', 'sam', 'ckb'];
	    const languageUtils = this.services && this.services.languageUtils || new LanguageUtil(get$5());
	    return rtlLngs.indexOf(languageUtils.getLanguagePartFromCode(lng)) > -1 || lng.toLowerCase().indexOf('-arab') > 1 ? 'rtl' : 'ltr';
	  }
	  static createInstance() {
	    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	    let callback = arguments.length > 1 ? arguments[1] : undefined;
	    return new I18n(options, callback);
	  }
	  cloneInstance() {
	    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	    let callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : noop$2;
	    const forkResourceStore = options.forkResourceStore;
	    if (forkResourceStore) delete options.forkResourceStore;
	    const mergedOptions = {
	      ...this.options,
	      ...options,
	      ...{
	        isClone: true
	      }
	    };
	    const clone = new I18n(mergedOptions);
	    if (options.debug !== undefined || options.prefix !== undefined) {
	      clone.logger = clone.logger.clone(options);
	    }
	    const membersToCopy = ['store', 'services', 'language'];
	    membersToCopy.forEach(m => {
	      clone[m] = this[m];
	    });
	    clone.services = {
	      ...this.services
	    };
	    clone.services.utils = {
	      hasLoadedNamespace: clone.hasLoadedNamespace.bind(clone)
	    };
	    if (forkResourceStore) {
	      clone.store = new ResourceStore(this.store.data, mergedOptions);
	      clone.services.resourceStore = clone.store;
	    }
	    clone.translator = new Translator(clone.services, mergedOptions);
	    clone.translator.on('*', function (event) {
	      for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
	        args[_key4 - 1] = arguments[_key4];
	      }
	      clone.emit(event, ...args);
	    });
	    clone.init(mergedOptions, callback);
	    clone.translator.options = mergedOptions;
	    clone.translator.backendConnector.services.utils = {
	      hasLoadedNamespace: clone.hasLoadedNamespace.bind(clone)
	    };
	    return clone;
	  }
	  toJSON() {
	    return {
	      options: this.options,
	      store: this.store,
	      language: this.language,
	      languages: this.languages,
	      resolvedLanguage: this.resolvedLanguage
	    };
	  }
	}
	const instance = I18n.createInstance();
	instance.createInstance = I18n.createInstance;

	instance.createInstance;
	instance.dir;
	instance.init;
	instance.loadResources;
	instance.reloadResources;
	instance.use;
	instance.changeLanguage;
	instance.getFixedT;
	const t$5 = instance.t;
	instance.exists;
	instance.setDefaultNamespace;
	instance.hasLoadedNamespace;
	instance.loadNamespaces;
	instance.loadLanguages;

	// separate regular expression for existing pages; fixes tRPC bugs with pages that are invalid DNS names but already exist
	const EXTANT_PAGE_LEGAL_REGEX = /^[a-zA-Z0-9-]{3,}/;

	// based on https://github.com/colinhacks/zod/issues/678#issuecomment-962387521

	function refinement$1() {
	    return function (val) {
	        return true;
	    };
	}

	const BigIntId = mod
	    .string()
	    .or(mod.number().transform((val) => val.toString()))
	    .refine((val) => {
	        try {
	            // BigInt throws on non-integer strings
	            const num = BigInt(val);
	            return num > BigInt(0);
	        } catch (e) {
	            return false;
	        }
	    });

	 
	const AttachmentId = mod
	    .string()
	    .uuid()
	    .refine(refinement$1());

	 
	mod.number().int().refine(refinement$1());

	 
	const ProjectId = mod
	    .number()
	    .int()
	    .refine(refinement$1());

	 
	const UserId = mod.number().int().refine(refinement$1());

	 
	const ProjectHandle = mod
	    .string()
	    // use the old legal regex to prevent tRPC errors with DNS-illegal usernames
	    .regex(EXTANT_PAGE_LEGAL_REGEX)
	    .refine(refinement$1());

	 
	mod
	    .string()
	    .uuid()
	    .refine(refinement$1());

	 
	BigIntId.refine(refinement$1());

	 
	mod
	    .string()
	    .uuid()
	    .refine(refinement$1());

	 
	mod
	    .string()
	    .uuid()
	    .refine(refinement$1());

	 
	mod
	    .string()
	    .uuid()
	    .refine(refinement$1());

	 
	mod
	    .string()
	    .uuid()
	    .refine(refinement$1());

	const ISODateString = mod
	    .string()
	    .refine((string) => DateTime_1.fromISO(string).isValid, {
	        message: "Not a valid ISO date!",
	    });

	 
	const AskId = BigIntId.refine(refinement$1());

	 
	BigIntId.refine(
	    refinement$1()
	);

	 
	mod
	    .string()
	    .refine(refinement$1());

	 
	mod
	    .string()
	    .refine(refinement$1());

	 
	BigIntId.refine(refinement$1());

	 
	mod
	    .string()
	    .refine(refinement$1());

	 
	mod
	    .string()
	    .refine(refinement$1());

	 
	mod
	    .string()
	    .uuid()
	    .refine(refinement$1());

	 
	const ArtistAlleyAdId = BigIntId.refine(
	    refinement$1()
	);

	 
	BigIntId.refine(
	    refinement$1()
	);

	 
	BigIntId.refine(
	    refinement$1()
	);

	exports.ProjectPrivacy = void 0; (function (ProjectPrivacy) {
	    const Public = "public"; ProjectPrivacy["Public"] = Public;
	    const Private = "private"; ProjectPrivacy["Private"] = Private;
	})(exports.ProjectPrivacy || (exports.ProjectPrivacy = {}));
	const ProjectPrivacyEnum = mod.nativeEnum(exports.ProjectPrivacy);
	 

	// shout out https://stackoverflow.com/a/61129291
	const ProjectFlag = mod.enum([
	    "staff",
	    "staffMember",
	    "friendOfTheSite",
	    "noTransparentAvatar",
	    "suspended",
	    "automated", // used for the bot badge
	    "parody", // used for the "un-verified" badge
	]);
	 

	// TODO: the DB also supports "all-ages", but this setting doesn't currently
	// work because of an NYI access checker upgrade.
	const LoggedOutPostVisibility = mod.enum(["public", "none"]);

	const AvatarShape = mod.enum([
	    "circle",
	    "roundrect",
	    "squircle",
	    "capsule-big",
	    "capsule-small",
	    "egg",
	]);
	 

	const ContactCardVisibility = mod.enum([
	    "public",
	    "logged-in",
	    "follows",
	    "following-you",
	]);
	 

	const ContactCardRow = mod.object({
	    service: mod.string(),
	    value: mod.string(),
	    visibility: ContactCardVisibility,
	});
	 

	const WireProjectModel = mod.object({
	    projectId: ProjectId,
	    handle: ProjectHandle,
	    displayName: mod.string(),
	    dek: mod.string(),
	    description: mod.string(),
	    avatarURL: mod.string().url(),
	    avatarPreviewURL: mod.string().url(),
	    headerURL: mod.string().url().nullable(),
	    headerPreviewURL: mod.string().url().nullable(),
	    privacy: ProjectPrivacyEnum,
	    url: mod.string().nullable(),
	    pronouns: mod.string().nullable(),
	    flags: ProjectFlag.array(),
	    avatarShape: AvatarShape,
	    loggedOutPostVisibility: LoggedOutPostVisibility,
	    frequentlyUsedTags: mod.string().array(),
	    askSettings: mod.object({
	        enabled: mod.boolean(),
	        allowAnon: mod.boolean(),
	        requireLoggedInAnon: mod.boolean(),
	    }),
	    contactCard: ContactCardRow.array(),
	    deleteAfter: ISODateString.nullable(),
	    isSelfProject: mod.boolean().nullable(),
	});
	 

	WireProjectModel.extend({
	    lastActivityTime: ISODateString.nullable(),
	    handleSuspicionResult: mod
	        .object({
	            match: mod.string(),
	            score: mod.number(),
	        })
	        .nullable(),
	});
	 



	mod
	    .object({
	        asks: mod
	            .object({
	                enabled: mod.boolean().default(false),
	                allowAnon: mod.boolean().default(false),
	                requireLoggedInAnon: mod.boolean().default(true),
	            })
	            .default({}),
	    })
	    .default({});

	// we don't use interpolation so that:
	// (a) classes don't get jit'd out
	// (b) we can have a default if there's no match
	function avatarMaskClass(avatarShape) {
	    switch (avatarShape) {
	        case "capsule-big":
	            return "mask-capsule-big";
	        case "capsule-small":
	            return "mask-capsule-small";
	        case "roundrect":
	            return "mask-roundrect";
	        case "squircle":
	            return "mask-squircle";
	        case "egg":
	            return "mask-egg";
	        default:
	        case "circle":
	            return "mask-circle";
	    }
	}

	WireProjectModel.pick({
	    avatarPreviewURL: true,
	    avatarURL: true,
	    avatarShape: true,
	    privacy: true,
	    handle: true,
	    flags: true,
	    projectId: true,
	});
	 



	const ProjectAvatar





	 = ({
	    project,
	    noLink = false,
	    className = "h-16 w-16 hidden lg:block cohost-shadow-light dark:cohost-shadow-dark",
	    hideLock = false,
	    forceAnimate = false,
	}) => {
	    const displayPrefs = useDisplayPrefs();
	    const animate = forceAnimate || !displayPrefs.pauseProfileGifs;
	    const noTransparentAvatar =
	        project.flags.indexOf("noTransparentAvatar") > -1;

	    const defaultAvatarBgStyle = {
	        backgroundImage: noTransparentAvatar
	            ? `url(${sitemap.public.project
                  .defaultAvatar({
                      projectId: project.projectId,
                  })
                  .toString()})`
	            : undefined,
	    };

	    const processedUrl = reactExports.useMemo(() => {
	        const src = animate ? project.avatarURL : project.avatarPreviewURL;
	 return src;
	    }, [animate, project.avatarPreviewURL, project.avatarURL]);

	    const image = (
	        React$2.createElement(React$2.Fragment, null
	            , React$2.createElement('img', {
	                src: processedUrl,
	                className: `mask ${avatarMaskClass(
                    project.avatarShape
                )} h-full w-full object-cover`,
	                alt: project.handle,
	                style: defaultAvatarBgStyle,}
	            )
	            , !hideLock && project.privacy === exports.ProjectPrivacy.Private ? (
	                React$2.createElement(IconEgg, {
	                    className: "cohost-shadow-light dark:cohost-shadow-dark absolute -bottom-1 -right-1 h-5 fill-foreground-500 text-notWhite"       ,
	                    scale: 0.6,}

	                    , React$2.createElement(ForwardRef$i, null )
	                )
	            ) : null
	        )
	    );
	    if (!noLink) {
	        return (
	            React$2.createElement('a', {
	                href: sitemap.public.project
	                    .mainAppProfile({ projectHandle: project.handle })
	                    .toString(),
	                className: `flex-0 mask relative aspect-square ${className}`,
	                title: `@${project.handle}`,}

	                , image
	            )
	        );
	    } else {
	        return (
	            React$2.createElement('div', { className: `flex-0 mask relative aspect-square ${className}`,}
	                , image
	            )
	        );
	    }
	};

	const ProjectSwitcherOption

	 = ({ project }) => {
	    const { enableNotificationCount } = useDisplayPrefs();
	    const notificationCount = useNotificationCount({
	        projectHandle: project.handle,
	    });
	    const followReqCount = useFollowRequestCount({
	        projectHandle: project.handle,
	    });
	    const unreadAskCount = useUnreadAskCount({
	        projectHandle: project.handle,
	    });

	    const totalCount =
	        notificationCount.count + followReqCount.count + unreadAskCount.count;

	    return (
	        React$2.createElement(Ht$1.Option, {
	            key: project.projectId,
	            value: project,
	            className: "flex h-10 cursor-pointer flex-row items-center gap-3 px-2 py-1 hover:bg-foreground-100 hover:text-foreground-800 lg:first-of-type:rounded-t-lg lg:last-of-type:rounded-b-lg"           ,}

	            , React$2.createElement(ProjectAvatar, {
	                project: project,
	                noLink: true,
	                className: "h-8 w-8" ,}
	            )
	            , React$2.createElement('span', null, "@", project.handle)
	            , totalCount ? (
	                React$2.createElement(TextEgg, { className: "ml-auto h-6 fill-sidebarAccent text-sidebarBg"   ,}
	                    , enableNotificationCount
	                        ? totalCount > 99
	                            ? "99+"
	                            : totalCount
	                        : ""
	                )
	            ) : null
	        )
	    );
	};

	const ProjectSwitcher = () => {
	    useTranslation();

	    const { projects } = useEditedProjects();
	    const currentProject = useCurrentProject();
	    const switchProject = trpc.projects.switchProject.useMutation();
	    const logout = trpc.login.logout.useMutation();

	    if (!currentProject) return null;

	    const onChange = async (val) => {
	        if (val.projectId === "new") {
	            // the "create a new project" option is handled special
	            location.assign(sitemap.public.createProject());
	        } else if (val.projectId === "sign_out") {
	            // sign out!
	            await logout.mutateAsync();
	            location.assign("/");
	        } else {
	            await switchProject.mutateAsync({ projectId: val.projectId });
	            location.reload();
	        }
	    };

	    return (
	        React$2.createElement(Ht$1, { value: currentProject, by: "projectId", onChange: onChange,}
	            , React$2.createElement('div', { className: "relative",}
	                , React$2.createElement(Ht$1.Button, { className: "group flex flex-row items-center gap-1"    ,}
	                    /* mobile */
	                    , React$2.createElement(ProjectAvatar, {
	                        project: currentProject,
	                        noLink: true,
	                        className: "h-8 w-8 lg:hidden"  ,}
	                    )
	                    /* desktop */
	                    , React$2.createElement('div', { className: "hidden flex-row items-center gap-3 rounded-l-lg px-2 py-1 group-hover:bg-foreground-600 ui-open:bg-foreground-700 lg:flex"         ,}
	                        , React$2.createElement(ProjectAvatar, {
	                            project: currentProject,
	                            noLink: true,
	                            className: "h-8 w-8" ,}
	                        )
	                        , React$2.createElement('span', null, "@", currentProject?.handle)
	                    )
	                    , React$2.createElement('div', { className: "hidden rounded-r-lg p-2 text-notWhite group-hover:bg-foreground-600 ui-open:bg-foreground-700 lg:block"      ,}
	                        , React$2.createElement(ForwardRef$t, { className: "h-6 w-6 text-notWhite transition-transform ui-open:rotate-180"    ,} )
	                    )
	                )
	                , React$2.createElement(tt$1, {
	                    as: reactExports.Fragment,
	                    leave: "lg:transition ease-in duration-100"  ,
	                    leaveFrom: "opacity-100",
	                    leaveTo: "opacity-0",}

	                    , React$2.createElement(Ht$1.Options, {
	                        className: `lg:cohost-shadow-light dark:lg:cohost-shadow-dark
                        fixed bottom-0 right-0 top-16 max-w-xs divide-y divide-foreground-500 !overflow-y-auto
                        truncate bg-foreground text-notWhite !outline-none lg:absolute
                        lg:bottom-auto lg:right-auto lg:top-auto lg:mt-6 lg:max-h-[calc(100vh_-_100px)]
                        lg:divide-none lg:rounded-lg lg:bg-notWhite lg:text-notBlack`,}

	                        , projects.map((project) => (
	                            React$2.createElement(ProjectSwitcherOption, {
	                                project: project,
	                                key: project.projectId,}
	                            )
	                        ))
	                        , React$2.createElement(Ht$1.Option, {
	                            key: "new",
	                            value: { projectId: "new" },
	                            className: "flex h-10 cursor-pointer flex-row items-center gap-3 px-2 py-1 hover:bg-foreground-100 hover:text-foreground-800 lg:first-of-type:rounded-t-lg lg:last-of-type:rounded-b-lg"           ,}

	                            , React$2.createElement(ForwardRef$W, { className: "h-6 w-8" ,} )
	                            , React$2.createElement('span', null, "create a new page"   )
	                        )
	                        , React$2.createElement(Ht$1.Option, {
	                            key: "sign_out",
	                            value: { projectId: "sign_out" },
	                            className: "flex h-10 cursor-pointer flex-row items-center gap-3 px-2 py-1 hover:bg-foreground-100 hover:text-foreground-800 lg:first-of-type:rounded-t-lg lg:last-of-type:rounded-b-lg"           ,}

	                            , React$2.createElement(ForwardRef$1f, { className: "h-6 w-8" ,} )
	                            , React$2.createElement('span', null, "sign out" )
	                        )
	                    )
	                )
	            )
	        )
	    );
	};

	const ModalPostComposerContext = React$2.createContext





	({
	    activate: lodashExports.noop,
	    isOpen: false,
	    close: lodashExports.noop,
	    setup: lodashExports.noop,
	    hasBeenSetup: false,
	});

	const useModalPostComposer = () => {
	    return React$2.useContext(ModalPostComposerContext);
	};

	var classnames = {exports: {}};

	/*!
	  Copyright (c) 2018 Jed Watson.
	  Licensed under the MIT License (MIT), see
	  http://jedwatson.github.io/classnames
	*/

	(function (module) {
		/* global define */

		(function () {

			var hasOwn = {}.hasOwnProperty;

			function classNames() {
				var classes = [];

				for (var i = 0; i < arguments.length; i++) {
					var arg = arguments[i];
					if (!arg) continue;

					var argType = typeof arg;

					if (argType === 'string' || argType === 'number') {
						classes.push(arg);
					} else if (Array.isArray(arg)) {
						if (arg.length) {
							var inner = classNames.apply(null, arg);
							if (inner) {
								classes.push(inner);
							}
						}
					} else if (argType === 'object') {
						if (arg.toString === Object.prototype.toString) {
							for (var key in arg) {
								if (hasOwn.call(arg, key) && arg[key]) {
									classes.push(key);
								}
							}
						} else {
							classes.push(arg.toString());
						}
					}
				}

				return classes.join(' ');
			}

			if (module.exports) {
				classNames.default = classNames;
				module.exports = classNames;
			} else {
				window.classNames = classNames;
			}
		}()); 
	} (classnames));

	var classnamesExports = classnames.exports;
	var classNames = /*@__PURE__*/getDefaultExportFromCjs(classnamesExports);

	const useSSR = () => {
	    const [isServer, setIsServer] = reactExports.useState(true);

	    reactExports.useEffect(() => {
	        setIsServer(false);
	    }, []);

	    return { isServer, isBrowser: !isServer };
	};

	const KikiOutline = (
	    props
	) => (
	    React$2.createElement('svg', {
	        fill: "none",
	        xmlns: "http://www.w3.org/2000/svg",
	        viewBox: "0 0 26 26"   ,
	        ...props,}

	        , React$2.createElement('path', {
	            d: "M11.3119 5.42651 6.14576 1.57637l1.85085 7.14697L1 10.8444l6.40678 1.9135L1.38644 25l9.15256-7.3545 3.2542 6.8473.1424-8.9222 8.7864 5.5331-6.9762-8.438L25 7.317 13.4678 8.40058 15.1356 1l-3.8237 4.42651Z"                 ,
	            stroke: "#E56B6F",
	            strokeWidth: "2",
	            strokeLinejoin: "round",}
	        )
	    )
	);

	const isDefined = (data) =>
	    data !== null && data !== undefined;

	const isTruthy = (data) => !!data;

	const NavItem = ({
	    label,
	    plainTextLabel,
	    Icon,
	    ActiveIcon,
	    href,
	    active,
	    eggCount,
	    narrowMode,
	    render,
	}) => {
	    const [isOpen, setIsOpen] = reactExports.useState(false);
	    const { enableNotificationCount } = useDisplayPrefs();

	    const onClick = reactExports.useCallback(
	        (e) => {
	            if (render) {
	                e.preventDefault();
	                setIsOpen((open) => !open);
	            }
	        },
	        [render]
	    );

	    // dumb hack for the rotating "saved tags" icon
	    let extraIconClasses = "";

	    if (render) {
	        extraIconClasses += "transition-transform ";

	        if (isOpen) {
	            extraIconClasses += "rotate-180";
	        }
	    }

	    return (
	        React$2.createElement(React$2.Fragment, null
	            , React$2.createElement('a', { href: href, onClick: onClick,}
	                , React$2.createElement('li', {
	                    className: classNames(
	                        `flex flex-row items-center
                        gap-2 rounded-lg border border-transparent px-1 py-3
                        hover:border-accent hover:text-accent
                        lg:hover:border-sidebarAccent lg:hover:text-sidebarAccent`,
	                        {
	                            "font-bold": active,
	                            "text-cherry-500 dark:text-mango-400":
	                                active && narrowMode,
	                        }
	                    ),
	                    title: plainTextLabel ?? label.toString(),}

	                    , React$2.createElement('div', { className: "relative",}
	                        , active && ActiveIcon ? (
	                            React$2.createElement(ActiveIcon, {
	                                className: classNames(
	                                    "inline-block h-6",
	                                    extraIconClasses
	                                ),}
	                            )
	                        ) : Icon ? (
	                            React$2.createElement(Icon, {
	                                className: classNames(
	                                    "inline-block h-6",
	                                    extraIconClasses
	                                ),}
	                            )
	                        ) : null
	                        /* narrow mode: superimpose the notification count egg on the icon */
	                        , narrowMode && eggCount ? (
	                            React$2.createElement(TextEgg, { className: "absolute -right-1 top-1 h-2 fill-sidebarAccent"    ,} )
	                        ) : null
	                    )
	                    , !narrowMode ? label : null
	                    /* wide mode: display the notification count egg on the right side of the menu */
	                    , !narrowMode && eggCount ? (
	                        React$2.createElement(TextEgg, { className: "ml-auto h-6 fill-sidebarAccent text-sidebarBg"   ,}
	                            , enableNotificationCount
	                                ? eggCount > 99
	                                    ? "99+"
	                                    : eggCount
	                                : ""
	                        )
	                    ) : null
	                )
	            )
	            , render ? render(isOpen) : null
	        )
	    );
	};

	const BookmarkedTags

	 = ({ bookmarkedTags }) => (
	    React$2.createElement('ul', { className: "my-1 ml-10" ,}
	        , bookmarkedTags.tags.map((tag) => (
	            React$2.createElement('li', {
	                key: tag,
	                className: "hover:text-accent lg:hover:text-sidebarAccent" ,}

	                , React$2.createElement('a', { href: sitemap.public.tags({ tagSlug: tag }).toString(),}, "#"
	                    , tag
	                )
	            )
	        ))
	    )
	);

	const InnerMenu





	 = ({
	    additionalNavItems = [],
	    defaultBookmarkedTags,
	    className,
	    narrowMode = false,
	    ...props
	}) => {
	    const userInfo = useUserInfo();
	    const displayPrefs = useDisplayPrefs();
	    const currentProject = useCurrentProject();
	    const reqMutableStore = useReqMutableStore();
	    const ssrUrl = reqMutableStore.get("ssrUrl");
	    const navItems = [
	        ...additionalNavItems,
	    ];
	    const { isBrowser } = useSSR();

	    const notificationCount = useNotificationCount();
	    const followReqCount = useFollowRequestCount();
	    const unreadAskCount = useUnreadAskCount();

	    const { data: bookmarkedTags } = useBookmarkedTags(defaultBookmarkedTags);
	    const savedTags = bookmarkedTags ?? { tags: defaultBookmarkedTags ?? [] };

	    const hasCohostPlus = useHasCohostPlus();

	    const artistAlleyListings = index_browserExports.useFlag(
	        FeatureFlag.Enum["artist-alley-listings"]
	    );
	    const shouldShowArtistAlley = artistAlleyListings;

	    if (userInfo.loggedIn && currentProject) {
	        navItems.push(
	            {
	                label: "dashboard",
	                Icon: ForwardRef$18,
	                ActiveIcon: ForwardRef$g,
	                href: sitemap.public.dashboard().toString(),
	                displayIf: displayPrefs.homeView === "following",
	            },
	            {
	                label: "notifications",
	                Icon: ForwardRef$1b,
	                ActiveIcon: ForwardRef$v,
	                href: sitemap.public.project.notifications().toString(),
	                eggCount: notificationCount?.count,
	            },
	            {
	                label: "bookmarked tags",
	                href: narrowMode
	                    ? sitemap.public.bookmarkedTagFeed().toString()
	                    : "#",
	                Icon: ForwardRef$O,
	                displayIf: savedTags.tags.length > 0,
	                render: narrowMode
	                    ? undefined
	                    : (isOpen) =>
	                          isOpen ? (
	                              React$2.createElement(BookmarkedTags, { bookmarkedTags: savedTags,} )
	                          ) : null,
	            },
	            {
	                label: "posts you've liked",
	                Icon: ForwardRef$F,
	                ActiveIcon: ForwardRef$m,
	                href: sitemap.public.likedPosts({}).toString(),
	            },
	            {
	                label: "artist alley",
	                Icon: ForwardRef$14,
	                ActiveIcon: ForwardRef$f,
	                href: sitemap.public.artistAlley.home().toString(),
	                displayIf: shouldShowArtistAlley,
	            },
	            {
	                label: "search",
	                href: sitemap.public.search().toString(),
	                Icon: ForwardRef$1a,
	                ActiveIcon: ForwardRef$h,
	            },
	            {
	                label: "profile",
	                Icon: ForwardRef$K,
	                ActiveIcon: ForwardRef$e,
	                href: sitemap.public.project
	                    .mainAppProfile({
	                        projectHandle: currentProject.handle,
	                    })
	                    .toString(),
	            },
	            {
	                label: "inbox",
	                Icon: ForwardRef$D,
	                ActiveIcon: ForwardRef$l,
	                href: sitemap.public.project.inbox().toString(),
	                displayIf: currentProject?.askSettings.enabled,
	                eggCount: unreadAskCount.count ?? 0,
	            },
	            {
	                label: "drafts",
	                Icon: ForwardRef$U,
	                ActiveIcon: ForwardRef$o,
	                href: sitemap.public.project.unpublishedPosts().toString(),
	            },
	            {
	                label: "following",
	                Icon: ForwardRef$E,
	                ActiveIcon: ForwardRef$a,
	                href: sitemap.public.project.following().toString(),
	                displayIf: displayPrefs.homeView === "dashboard",
	            },
	            {
	                label: "followers",
	                Icon: ForwardRef$I,
	                ActiveIcon: ForwardRef$d,
	                href: sitemap.public.project.followers().toString(),
	            },
	            {
	                label: "follow requests",
	                Icon: ForwardRef$G,
	                ActiveIcon: ForwardRef$b,
	                href: sitemap.public.project
	                    .followRequests({ projectHandle: currentProject.handle })
	                    .toString(),
	                eggCount: followReqCount?.count,
	                displayIf: currentProject?.privacy === exports.ProjectPrivacy.Private,
	            },
	            {
	                label: "settings",
	                Icon: ForwardRef$Y,
	                ActiveIcon: ForwardRef$p,
	                href: sitemap.public.userSettings().toString(),
	            },
	            {
	                label: "help / report a bug",
	                Icon: ForwardRef$1i,
	                ActiveIcon: ForwardRef$k,
	                href: "https://help.antisoftware.club/support/home",
	            },
	            {
	                label: (
	                    React$2.createElement(React$2.Fragment, null, "get cohost "
	                          , React$2.createElement('em', null, "Plus!")
	                    )
	                ),
	                plainTextLabel: "get cohost Plus!",
	                Icon: KikiOutline,
	                href: sitemap.public.subscriptions.manage().toString(),
	                displayIf: !hasCohostPlus,
	            }
	        );
	    }

	    return (
	        React$2.createElement(ot.Items, { static: props.static, as: "ul", className: className,}
	            , props.children
	            , navItems
	                .filter(isTruthy)
	                // note: if item.displayIf is undefined, we display it
	                .filter((item) => item.displayIf !== false)
	                .map((props) => (
	                    React$2.createElement(reactExports.Suspense, { key: `${props.href}-${props.label.toString()}`,}
	                        , React$2.createElement(ot.Item, {
	                            as: NavItem,
	                            key: `${props.href}-${props.label.toString()}`,
	                            ...props,
	                            narrowMode: narrowMode,
	                            active: 
	                                isBrowser
	                                    ? props.href === window.location.toString()
	                                    : props.href === ssrUrl
	                            ,}
	                        )
	                    )
	                ))
	        )
	    );
	};

	const SidebarMenu = (props) => {
	    const userInfo = useUserInfo();
	    return (
	        React$2.createElement(ot, null
	            , React$2.createElement(InnerMenu, {
	                static: true,
	                className: classNames(
	                    "hidden h-fit flex-col rounded-lg bg-sidebarBg p-6 text-sidebarText lg:flex",
	                    {
	                        "cohost-shadow-light dark:cohost-shadow-dark dark:border dark:border-gray-700":
	                            !(props.narrowMode ?? false),
	                    }
	                ),
	                ...props,}

	                , !userInfo.loggedIn ? (
	                    React$2.createElement(React$2.Fragment, null
	                        , React$2.createElement(ot.Item, { as: "li",}
	                            , React$2.createElement('a', {
	                                href: sitemap.public.login().toString(),
	                                className: "cohost-shadow-dark my-3 flex h-10 flex-row items-center justify-center gap-2 rounded-lg bg-accent px-10 py-2 text-notBlack"            ,}

	                                , React$2.createElement(ForwardRef$1j, { className: "h-6 w-6" ,} )
	                                , React$2.createElement('span', { className: "font-bold leading-none" ,}, "log in"

	                                )
	                            )
	                        )
	                        , React$2.createElement(ot.Item, { as: "li",}
	                            , React$2.createElement('a', {
	                                href: sitemap.public.signup().toString(),
	                                className: "cohost-shadow-dark my-3 flex h-10 flex-row items-center justify-center gap-2 rounded-lg bg-notWhite px-10 py-2 text-notBlack"            ,}

	                                , React$2.createElement(ForwardRef$G, { className: "h-6 w-6" ,} )
	                                , React$2.createElement('span', { className: "font-bold leading-none" ,}, "sign up"

	                                )
	                            )
	                        )
	                    )
	                ) : null
	            )
	        )
	    );
	};

	const NavBarMenu = (props) => {
	    const notificationCount = useNotificationCount();
	    const followReqCount = useFollowRequestCount();
	    const totalCount = notificationCount.count + followReqCount.count;
	    const currentProject = useCurrentProject();

	    return (
	        React$2.createElement(ot, { as: "div", className: "lg:hidden",}
	            , React$2.createElement(ot.Button, { className: "relative text-notWhite transition-transform ui-open:rotate-90 lg:hidden"    ,}
	                , totalCount ? (
	                    React$2.createElement(TextEgg, { className: "cohost-shadow-dark absolute -right-1 top-1 h-2 fill-accent"     ,} )
	                ) : null
	                , React$2.createElement(ForwardRef$w, { className: "h-6 w-6" ,} )
	            )
	            , React$2.createElement(InnerMenu, {
	                static: false,
	                className: "fixed bottom-0 left-0 top-16 flex w-[61.8%] min-w-fit flex-col divide-y divide-foreground-500 overflow-y-auto bg-foreground p-2 text-notWhite !outline-none lg:hidden"               ,
	                ...props,}

	                , currentProject?.handle ? (
	                    React$2.createElement(ot.Item, { as: "li",}
	                        , React$2.createElement('a', {
	                            href: sitemap.public.project
	                                .composePost({
	                                    projectHandle: currentProject.handle,
	                                })
	                                .toString(),
	                            className: "cohost-shadow-dark my-3 flex h-10 flex-row items-center justify-center gap-2 rounded-lg bg-accent px-10 py-2 text-notBlack"            ,}

	                            , React$2.createElement(ForwardRef$10, { className: "h-6 w-6" ,} )
	                            , React$2.createElement('span', { className: "font-bold leading-none" ,}, "post!"

	                            )
	                        )
	                    )
	                ) : (
	                    React$2.createElement(React$2.Fragment, null
	                        , React$2.createElement(ot.Item, { as: "li",}
	                            , React$2.createElement('a', {
	                                href: sitemap.public.login().toString(),
	                                className: "cohost-shadow-dark my-3 flex h-10 flex-row items-center justify-center gap-2 rounded-lg bg-accent px-10 py-2 text-notBlack"            ,}

	                                , React$2.createElement(ForwardRef$1j, { className: "h-6 w-6" ,} )
	                                , React$2.createElement('span', { className: "font-bold leading-none" ,}, "log in"

	                                )
	                            )
	                        )
	                        , React$2.createElement(ot.Item, { as: "li",}
	                            , React$2.createElement('a', {
	                                href: sitemap.public.signup().toString(),
	                                className: "cohost-shadow-dark my-3 flex h-10 flex-row items-center justify-center gap-2 rounded-lg bg-notWhite px-10 py-2 text-notBlack"            ,}

	                                , React$2.createElement(ForwardRef$G, { className: "h-6 w-6" ,} )
	                                , React$2.createElement('span', { className: "font-bold leading-none" ,}, "sign up"

	                                )
	                            )
	                        )
	                    )
	                )
	            )
	        )
	    );
	};

	const BEAT_LENGTH = 86.4;

	function fromDateTime(date, centibeats = false) {
	    const bmtDate = date.setZone("UTC+1");
	    let beats =
	        (bmtDate.second + bmtDate.minute * 60 + bmtDate.hour * 3600) /
	        BEAT_LENGTH;

	    beats = centibeats ? beats % 1000 : Math.floor(beats % 1000);

	    return `@${beats
        .toFixed(centibeats ? 2 : 0)
        .padStart(centibeats ? 6 : 3, "0")}`;
	}

	function now(centibeats = false) {
	    return fromDateTime(DateTime_1.now(), centibeats);
	}

	const BeatClock = React$2.memo(
	    ({ className }) => {
	        const [displayTime, setDisplayTime] = reactExports.useState(now());

	        const updateClock = reactExports.useCallback(() => {
	            const newTime = now();
	            if (newTime !== displayTime) {
	                setDisplayTime(newTime);
	            }
	        }, [displayTime]);

	        reactExports.useEffect(() => {
	            const intervalId = setInterval(updateClock, 1000);
	            return () => clearInterval(intervalId);
	        }, [updateClock]);

	        return (
	            React$2.createElement('a', {
	                href: "https://internet-ti.me/",
	                className: `tabular-nums ${className ?? ""}`,
	                target: "_blank",
	                rel: "noopener noreferrer" ,}

	                , displayTime
	            )
	        );
	    }
	);

	BeatClock.displayName = "BeatClock";

	const Bounce = (
	    props
	) => {
	    return React$2.createElement('span', { className: "animate-bounce",}, props.children);
	};

	const BUTTON_TYPE$2 = "button" ;

	const RectButton = ({
	    as: Component = BUTTON_TYPE$2,
	    children,
	    ...props
	}) => {
	    const className = props.className ?? "";
	    return (
	        React$2.createElement(Component, {
	            ...props,
	            className: `flex h-10 w-fit flex-row items-center rounded-lg px-3 ${className}`,}

	            , children
	        )
	    );
	};

	const LoginStateButtons = () => {
	    const userInfo = useUserInfo();
	    const currentProject = useCurrentProject();
	    const { beatsTimestamps } = useDisplayPrefs();
	    const modalPostComposer = useModalPostComposer();
	    const displayPrefs = useDisplayPrefs();

	    const onClickPost = reactExports.useCallback(
	        (e) => {
	            if (displayPrefs.disableModalPostComposer) {
	                // user wants this to be a link
	                return;
	            }

	            if (e.ctrlKey || e.metaKey || e.button === 3) {
	                // ctrl/cmd/middle click: user wants this to open in a new
	                // tab, treat it as a link.
	                return;
	            }
	            if (modalPostComposer.hasBeenSetup) {
	                // don't process as a link, check if we can pop a modal and if
	                // so Do It.
	                e.preventDefault();
	                modalPostComposer.activate({});
	            }
	        },
	        [displayPrefs.disableModalPostComposer, modalPostComposer]
	    );

	    return (
	        React$2.createElement('nav', { className: `flex flex-row items-center justify-end gap-4`,}
	            , beatsTimestamps ? React$2.createElement(BeatClock, null ) : null
	            , userInfo.loggedIn && currentProject?.handle ? (
	                React$2.createElement(React$2.Fragment, null
	                    , userInfo.modMode ? (
	                        React$2.createElement(Bounce, null
	                            , React$2.createElement('a', {
	                                href: `${sitemap.public
                                    .userSettings()
                                    .toString()}#staff-only`,}
	, "mod mode active"

	                            )
	                        )
	                    ) : null
	                    , React$2.createElement(ProjectSwitcher, null )
	                    , React$2.createElement('div', { className: "hidden flex-row items-center gap-4 lg:flex"    ,}
	                        , React$2.createElement(RectButton, {
	                            as: "a",
	                            className: "active:text-foreground-900 gap-1 bg-notWhite text-notBlack hover:bg-foreground-100 hover:text-foreground-800 active:bg-foreground-200"      ,
	                            href: sitemap.public.project
	                                .composePost({
	                                    projectHandle: currentProject.handle,
	                                })
	                                .toString(),
	                            onClick: onClickPost,}

	                            , React$2.createElement(ForwardRef$10, { className: "h-5 w-5" ,} )
	                            , React$2.createElement('span', { className: "leading-none",}, "post")
	                        )
	                    )
	                )
	            ) : (
	                React$2.createElement('div', { className: "hidden flex-row items-center gap-4 lg:flex"    ,}
	                    , React$2.createElement(RectButton, {
	                        as: "a",
	                        className: "active:text-foreground-900 gap-1 bg-notWhite text-notBlack hover:bg-foreground-100 hover:text-foreground-800 active:bg-foreground-200"      ,
	                        href: sitemap.public.login().toString(),}

	                        , React$2.createElement(ForwardRef$1j, { className: "h-5 w-5" ,} )
	                        , React$2.createElement('span', { className: "leading-none",}, "log in" )
	                    )
	                    , React$2.createElement(RectButton, {
	                        as: "a",
	                        className: "active:text-foreground-900 gap-1 bg-notWhite text-notBlack hover:bg-foreground-100 hover:text-foreground-800 active:bg-foreground-200"      ,
	                        href: sitemap.public.signup().toString(),}

	                        , React$2.createElement(ForwardRef$G, { className: "h-5 w-5" ,} )
	                        , React$2.createElement('span', { className: "leading-none",}, "sign up" )
	                    )
	                )
	            )
	        )
	    );
	};

	const TopNav = () => {
	    const chaosDay22 = index_browserExports.useFlag(FeatureFlag.Enum["chaos-day-2022"]);

	    const { t } = useTranslation();
	    return (
	        React$2.createElement(React$2.Fragment, null
	            , React$2.createElement(Helmet, null
	                , React$2.createElement('style', null
	                    , `body {
                        margin-top: 4rem;
                    }`
	                )
	            )
	            , React$2.createElement('header', { className: "fixed left-0 right-0 top-0 z-10 h-16 bg-foreground text-text"       ,}
	                , React$2.createElement('div', { className: "container mx-auto grid h-full grid-cols-3 grid-rows-1 items-center justify-between px-2 lg:grid-cols-2 lg:p-0"          ,}
	                    , React$2.createElement(NavBarMenu, null )
	                    , React$2.createElement('div', null
	                        , React$2.createElement('a', {
	                            href: 'https://cohost.org/'.toString(),
	                            className: "text-text hover:text-accent" ,}

	                            , chaosDay22 ? (
	                                React$2.createElement(React$2.Fragment, null
	                                    , React$2.createElement(CohostLogoBookman, {
	                                        className: "hidden h-8 lg:block"  ,
	                                        role: "img",
	                                        'aria-label': t("common:brand-name"),}
	                                    )
	                                    , React$2.createElement(CohostEggBookman, {
	                                        className: "mx-auto block h-8 lg:hidden"   ,
	                                        role: "img",
	                                        'aria-label': t("common:brand-name"),}
	                                    )
	                                )
	                            ) : (
	                                React$2.createElement(React$2.Fragment, null
	                                    , React$2.createElement(CohostLogo, {
	                                        className: "hidden h-8 lg:block"  ,
	                                        role: "img",
	                                        'aria-label': t("common:brand-name"),}
	                                    )
	                                    , React$2.createElement(CohostEgg, {
	                                        className: "mx-auto block h-8 lg:hidden"   ,
	                                        role: "img",
	                                        'aria-label': t("common:brand-name"),}
	                                    )
	                                )
	                            )
	                        )
	                    )
	                    , React$2.createElement(LoginStateButtons, null )
	                )
	            )
	        )
	    );
	};

	const Footer = React$2.memo(() => {
	    return (
	        React$2.createElement('footer', { className: "-mb-20 w-full bg-notBlack pb-20 pt-8 text-notWhite"     ,}
	            , React$2.createElement('div', { className: "container mx-auto grid px-6 lg:grid-cols-12 lg:px-0"     ,}
	                , React$2.createElement('div', { className: "flex flex-col gap-3 py-3 lg:col-span-3 lg:py-0"     ,}
	                    , React$2.createElement(CohostLogo, { className: "w-52 text-notWhite" ,} )
	                    , React$2.createElement('ul', { className: "list-none text-sm" ,}
	                        , React$2.createElement('li', null, "© "
	                             , DateTime_1.now().year, " "
	                            , React$2.createElement('a', {
	                                href: "https://antisoftware.club/",
	                                className: "underline",}
	, "anti software software club llc"

	                            )
	                        )
	                        , React$2.createElement('li', null, "thanks for using cohost"   )
	                    )
	                )
	                , React$2.createElement('div', { className: "flex flex-col gap-3 py-3 lg:col-span-2 lg:py-0"     ,}
	                    , React$2.createElement('h4', { className: "font-atkinson text-sm font-bold leading-none -tracking-tight lg:py-3"     ,}, "Legal"

	                    )
	                    , React$2.createElement('ul', { className: "flex list-none flex-col gap-3 font-league text-xs font-normal text-notWhite"       ,}
	                        , React$2.createElement('li', null
	                            , React$2.createElement('a', {
	                                href: sitemap.public
	                                    .staticContent({ slug: "tos" })
	                                    .toString(),
	                                className: "hover:underline",}
	, "Terms of Use"

	                            )
	                        )
	                        , React$2.createElement('li', null
	                            , React$2.createElement('a', {
	                                href: sitemap.public
	                                    .staticContent({ slug: "privacy" })
	                                    .toString(),
	                                className: "hover:underline",}
	, "Privacy Notice"

	                            )
	                        )
	                        , React$2.createElement('li', null
	                            , React$2.createElement('a', {
	                                href: sitemap.public
	                                    .staticContent({
	                                        slug: "community-guidelines",
	                                    })
	                                    .toString(),
	                                className: "hover:underline",}
	, "Community Guidelines"

	                            )
	                        )
	                    )
	                )
	                , React$2.createElement('div', { className: "flex flex-col gap-3 py-3 lg:col-span-2 lg:py-0"     ,}
	                    , React$2.createElement('h4', { className: "font-atkinson text-sm font-bold leading-none -tracking-tight lg:py-3"     ,}, "About"

	                    )
	                    , React$2.createElement('ul', { className: "flex list-none flex-col gap-3 font-league text-xs font-normal text-notWhite"       ,}
	                        , React$2.createElement('li', null
	                            , React$2.createElement('a', {
	                                href: "https://help.antisoftware.club/support/solutions/articles/62000227811-how-to-install-the-cohost-app",
	                                className: "hover:underline",}
	, "install cohost on your phone"

	                            )
	                        )
	                        , React$2.createElement('li', null
	                            , React$2.createElement('a', {
	                                href: sitemap.public.project
	                                    .mainAppProfile({
	                                        projectHandle: "staff" ,
	                                    })
	                                    .toString(),
	                                className: "hover:underline",}
	, "@staff"

	                            )
	                        )
	                        , React$2.createElement('li', null
	                            , React$2.createElement('a', {
	                                href: "https://help.antisoftware.club/",
	                                className: "hover:underline",}
	, "Support"

	                            )
	                        )
	                    )
	                )
	                , React$2.createElement('div', { className: "-mt-3 flex flex-col gap-3 py-3 lg:col-span-2 lg:mt-0 lg:py-0"       ,}
	                    , React$2.createElement('ul', { className: "flex list-none flex-col gap-3 font-league text-xs font-normal text-notWhite lg:mt-[50px]"        ,}
	                        , React$2.createElement('li', null
	                            , React$2.createElement('a', {
	                                href: sitemap.public
	                                    .staticContent({ slug: "credits" })
	                                    .toString(),
	                                className: "hover:underline",}
	, "Credits"

	                            )
	                        )
	                        , React$2.createElement('li', null
	                            , React$2.createElement('a', {
	                                href: "https://status.cohost.org",
	                                className: "hover:underline",}
	, "cohost status"

	                            )
	                        )
	                        , React$2.createElement('li', null
	                            , React$2.createElement('a', {
	                                href: "https://jobs.gusto.com/boards/anti-software-software-club-844d514c-4e9d-43e2-9b9c-12088dd3d526",
	                                className: "hover:underline",}
	, "Careers"

	                            )
	                        )
	                    )
	                )
	            )
	        )
	    );
	});
	Footer.displayName = "Footer";

	var reactSwipeable_umd = {exports: {}};

	(function (module, exports) {
		(function (global, factory) {
		  factory(exports, reactExports) ;
		}(commonjsGlobal, (function (exports, React) {
		  function _interopNamespace(e) {
		    if (e && e.__esModule) return e;
		    var n = Object.create(null);
		    if (e) {
		      Object.keys(e).forEach(function (k) {
		        if (k !== 'default') {
		          var d = Object.getOwnPropertyDescriptor(e, k);
		          Object.defineProperty(n, k, d.get ? d : {
		            enumerable: true,
		            get: function () {
		              return e[k];
		            }
		          });
		        }
		      });
		    }
		    n['default'] = e;
		    return n;
		  }

		  var React__namespace = /*#__PURE__*/_interopNamespace(React);

		  function _extends() {
		    _extends = Object.assign || function (target) {
		      for (var i = 1; i < arguments.length; i++) {
		        var source = arguments[i];

		        for (var key in source) {
		          if (Object.prototype.hasOwnProperty.call(source, key)) {
		            target[key] = source[key];
		          }
		        }
		      }

		      return target;
		    };

		    return _extends.apply(this, arguments);
		  }

		  var LEFT = "Left";
		  var RIGHT = "Right";
		  var UP = "Up";
		  var DOWN = "Down";

		  var defaultProps = {
		    delta: 10,
		    preventDefaultTouchmoveEvent: false,
		    rotationAngle: 0,
		    trackMouse: false,
		    trackTouch: true
		  };
		  var initialState = {
		    first: true,
		    initial: [0, 0],
		    start: 0,
		    swiping: false,
		    xy: [0, 0]
		  };
		  var mouseMove = "mousemove";
		  var mouseUp = "mouseup";
		  var touchEnd = "touchend";
		  var touchMove = "touchmove";
		  var touchStart = "touchstart";

		  function getDirection(absX, absY, deltaX, deltaY) {
		    if (absX > absY) {
		      if (deltaX > 0) {
		        return RIGHT;
		      }

		      return LEFT;
		    } else if (deltaY > 0) {
		      return DOWN;
		    }

		    return UP;
		  }

		  function rotateXYByAngle(pos, angle) {
		    if (angle === 0) return pos;
		    var angleInRadians = Math.PI / 180 * angle;
		    var x = pos[0] * Math.cos(angleInRadians) + pos[1] * Math.sin(angleInRadians);
		    var y = pos[1] * Math.cos(angleInRadians) - pos[0] * Math.sin(angleInRadians);
		    return [x, y];
		  }

		  function getHandlers(set, handlerProps) {
		    var onStart = function onStart(event) {
		      if (event && "touches" in event && event.touches.length > 1) return;
		      set(function (state, props) {
		        if (props.trackMouse) {
		          document.addEventListener(mouseMove, onMove);
		          document.addEventListener(mouseUp, onUp);
		        }

		        var _ref = "touches" in event ? event.touches[0] : event,
		            clientX = _ref.clientX,
		            clientY = _ref.clientY;

		        var xy = rotateXYByAngle([clientX, clientY], props.rotationAngle);
		        return _extends({}, state, initialState, {
		          initial: [].concat(xy),
		          xy: xy,
		          start: event.timeStamp || 0
		        });
		      });
		    };

		    var onMove = function onMove(event) {
		      set(function (state, props) {
		        if ("touches" in event && event.touches.length > 1) {
		          return state;
		        }

		        var _ref2 = "touches" in event ? event.touches[0] : event,
		            clientX = _ref2.clientX,
		            clientY = _ref2.clientY;

		        var _rotateXYByAngle = rotateXYByAngle([clientX, clientY], props.rotationAngle),
		            x = _rotateXYByAngle[0],
		            y = _rotateXYByAngle[1];

		        var deltaX = x - state.xy[0];
		        var deltaY = y - state.xy[1];
		        var absX = Math.abs(deltaX);
		        var absY = Math.abs(deltaY);
		        var time = (event.timeStamp || 0) - state.start;
		        var velocity = Math.sqrt(absX * absX + absY * absY) / (time || 1);
		        var vxvy = [deltaX / (time || 1), deltaY / (time || 1)];
		        var dir = getDirection(absX, absY, deltaX, deltaY);
		        var delta = typeof props.delta === "number" ? props.delta : props.delta[dir.toLowerCase()] || defaultProps.delta;
		        if (absX < delta && absY < delta && !state.swiping) return state;
		        var eventData = {
		          absX: absX,
		          absY: absY,
		          deltaX: deltaX,
		          deltaY: deltaY,
		          dir: dir,
		          event: event,
		          first: state.first,
		          initial: state.initial,
		          velocity: velocity,
		          vxvy: vxvy
		        };
		        eventData.first && props.onSwipeStart && props.onSwipeStart(eventData);
		        props.onSwiping && props.onSwiping(eventData);
		        var cancelablePageSwipe = false;

		        if (props.onSwiping || props.onSwiped || "onSwiped" + dir in props) {
		          cancelablePageSwipe = true;
		        }

		        if (cancelablePageSwipe && props.preventDefaultTouchmoveEvent && props.trackTouch && event.cancelable) event.preventDefault();
		        return _extends({}, state, {
		          first: false,
		          eventData: eventData,
		          swiping: true
		        });
		      });
		    };

		    var onEnd = function onEnd(event) {
		      set(function (state, props) {
		        var eventData;

		        if (state.swiping && state.eventData) {
		          eventData = _extends({}, state.eventData, {
		            event: event
		          });
		          props.onSwiped && props.onSwiped(eventData);
		          var onSwipedDir = props["onSwiped" + eventData.dir];
		          onSwipedDir && onSwipedDir(eventData);
		        } else {
		          props.onTap && props.onTap({
		            event: event
		          });
		        }

		        return _extends({}, state, initialState, {
		          eventData: eventData
		        });
		      });
		    };

		    var cleanUpMouse = function cleanUpMouse() {
		      document.removeEventListener(mouseMove, onMove);
		      document.removeEventListener(mouseUp, onUp);
		    };

		    var onUp = function onUp(e) {
		      cleanUpMouse();
		      onEnd(e);
		    };

		    var attachTouch = function attachTouch(el, passive) {
		      var cleanup = function cleanup() {};

		      if (el && el.addEventListener) {
		        var tls = [[touchStart, onStart], [touchMove, onMove], [touchEnd, onEnd]];
		        tls.forEach(function (_ref3) {
		          var e = _ref3[0],
		              h = _ref3[1];
		          return el.addEventListener(e, h, {
		            passive: passive
		          });
		        });

		        cleanup = function cleanup() {
		          return tls.forEach(function (_ref4) {
		            var e = _ref4[0],
		                h = _ref4[1];
		            return el.removeEventListener(e, h);
		          });
		        };
		      }

		      return cleanup;
		    };

		    var onRef = function onRef(el) {
		      if (el === null) return;
		      set(function (state, props) {
		        if (state.el === el) return state;
		        var addState = {};

		        if (state.el && state.el !== el && state.cleanUpTouch) {
		          state.cleanUpTouch();
		          addState.cleanUpTouch = undefined;
		        }

		        if (props.trackTouch && el) {
		          addState.cleanUpTouch = attachTouch(el, !props.preventDefaultTouchmoveEvent);
		        }

		        return _extends({}, state, {
		          el: el
		        }, addState);
		      });
		    };

		    var output = {
		      ref: onRef
		    };

		    if (handlerProps.trackMouse) {
		      output.onMouseDown = onStart;
		    }

		    return [output, attachTouch];
		  }

		  function updateTransientState(state, props, attachTouch) {
		    var addState = {};

		    if (!props.trackTouch && state.cleanUpTouch) {
		      state.cleanUpTouch();
		      addState.cleanUpTouch = undefined;
		    } else if (props.trackTouch && !state.cleanUpTouch) {
		      if (state.el) {
		        addState.cleanUpTouch = attachTouch(state.el, !props.preventDefaultTouchmoveEvent);
		      }
		    }

		    return _extends({}, state, addState);
		  }

		  function useSwipeable(options) {
		    var trackMouse = options.trackMouse;
		    var transientState = React__namespace.useRef(_extends({}, initialState));
		    var transientProps = React__namespace.useRef(_extends({}, defaultProps));
		    transientProps.current = _extends({}, defaultProps, options);

		    var _React$useMemo = React__namespace.useMemo(function () {
		      return getHandlers(function (stateSetter) {
		        return transientState.current = stateSetter(transientState.current, transientProps.current);
		      }, {
		        trackMouse: trackMouse
		      });
		    }, [trackMouse]),
		        handlers = _React$useMemo[0],
		        attachTouch = _React$useMemo[1];

		    transientState.current = updateTransientState(transientState.current, transientProps.current, attachTouch);
		    return handlers;
		  }

		  exports.DOWN = DOWN;
		  exports.LEFT = LEFT;
		  exports.RIGHT = RIGHT;
		  exports.UP = UP;
		  exports.useSwipeable = useSwipeable;

		})));
		
	} (reactSwipeable_umd, reactSwipeable_umd.exports));

	var reactSwipeable_umdExports = reactSwipeable_umd.exports;

	const ModalOverlay


	 = ({ className = "bg-notBlack/90", zIndex = 10 }) => (
	    React$2.createElement('div', {
	        className: `fixed inset-0 ${className}`,
	        style: {
	            zIndex,
	        },
	        'aria-hidden': true,}
	    )
	);

	const Lightbox = reactExports.createContext






	({
	    openLightbox: lodashExports.noop,
	    closeLightbox: lodashExports.noop,
	    setLightboxContentForPost: lodashExports.noop,
	});

	const paginationEggStyles = classNames(
	    "h-8",
	    "fill-cherry",
	    "dark:fill-mango",
	    "text-notWhite",
	    "dark:text-notBlack",
	    "cohost-shadow-dark",
	    "flex-none",
	    "cursor-pointer"
	);

	const LightboxCarousel




	 = ({ content, onClick, carouselIndex, setCarouselIndex }) => {
	    const handlers = reactSwipeable_umdExports.useSwipeable({
	        onSwipedRight: () => {
	            if (carouselIndex > 0) {
	                setCarouselIndex(carouselIndex - 1);
	            }
	        },
	        onSwipedLeft: () => {
	            if (carouselIndex < content.length - 1) {
	                setCarouselIndex(carouselIndex + 1);
	            }
	        },
	    });

	    const container = reactExports.useRef(null);
	    reactExports.useEffect(() => {
	        container.current?.focus();
	    }, [container]);

	    const onKeyDown = (e) => {
	        switch (e.key) {
	            case "ArrowLeft":
	            case "H":
	            case "h":
	                if (carouselIndex > 0) {
	                    setCarouselIndex(carouselIndex - 1);
	                }
	                break;
	            case "ArrowRight":
	            case "L":
	            case "l":
	                if (carouselIndex < content.length - 1) {
	                    setCarouselIndex(carouselIndex + 1);
	                }
	                break;
	        }
	    };

	    // pre-load images
	    reactExports.useEffect(() => {
	        content.forEach(({ attachment }) => {
	            const img = new Image();
	            img.src = attachment.fileURL;
	        });
	    });

	    const setIndexFactory

	 = (idx) => (e) => {
	        setCarouselIndex(idx);
	        e.stopPropagation();
	    };

	    const singleImage = content.length === 1;

	    const imgMaxHeightClassName = singleImage
	        ? "max-h-[calc(100vh_-_4rem)]"
	        : // little extra room for the eggs and thumbnails
	          "max-h-[calc(100vh_-_14rem)]";

	    return (
	        React$2.createElement('div', {
	            ...handlers,
	            ref: container,
	            onClick: onClick,
	            onKeyDown: onKeyDown,
	            tabIndex: 0,
	            className: "container absolute inset-0 z-30 mx-auto my-0 overflow-hidden overflow-y-auto py-8 outline-none"         ,}

	            , React$2.createElement('div', { className: "flex h-auto w-full flex-col items-center justify-between gap-6 overflow-auto"       ,}
	                , React$2.createElement('div', {
	                    className: `flex h-full min-h-0 w-full flex-1 flex-col items-center gap-2`,}

	                    , React$2.createElement('img', {
	                        src: 
	                            content[carouselIndex]?.attachment.fileURL ??
	                            missingAttachment
	                        ,
	                        className: `block ${imgMaxHeightClassName} mx-auto min-h-0 max-w-full object-scale-down`,
	                        alt: "",}
	                    )
	                    , singleImage ? null : (
	                        React$2.createElement('div', { className: "flex w-full max-w-prose flex-row items-center justify-between p-2"      ,}
	                            , React$2.createElement(IconEgg, {
	                                className: `${paginationEggStyles} scale-x-[-1] ${
                                    carouselIndex > 0 ? "visible" : "invisible"
                                }`,
	                                onClick: setIndexFactory(carouselIndex - 1),}

	                                , React$2.createElement(ForwardRef$r, null )
	                            )
	                            , React$2.createElement(IconEgg, {
	                                className: `${paginationEggStyles} ${
                                    carouselIndex < content.length - 1
                                        ? "visible"
                                        : "invisible"
                                }`,
	                                onClick: setIndexFactory(carouselIndex + 1),}

	                                , React$2.createElement(ForwardRef$r, null )
	                            )
	                        )
	                    )
	                    , content[carouselIndex]?.attachment.altText ? (
	                        React$2.createElement('p', { className: "mx-auto max-w-prose p-3 text-center italic text-notWhite"     ,}
	                            , content[carouselIndex]?.attachment.altText
	                        )
	                    ) : null
	                )
	                , singleImage ? null : (
	                    React$2.createElement('div', { className: "flex flex-none flex-row items-center gap-4"    ,}
	                        , content.map(({ attachment }, idx) => (
	                            React$2.createElement('button', {
	                                key: attachment.attachmentId,
	                                onClick: setIndexFactory(idx),
	                                type: "button",}

	                                , React$2.createElement('img', {
	                                    src: attachment.fileURL,
	                                    className: `cohost-shadow-dark box-content aspect-square h-16 cursor-pointer rounded-lg object-cover ${
                                        idx === carouselIndex
                                            ? "border-2 border-cherry"
                                            : ""
                                    }`,
	                                    alt: attachment.altText,}
	                                )
	                            )
	                        ))
	                    )
	                )
	            )
	        )
	    );
	};

	const LightboxHost = ({
	    children,
	    ...props
	}) => {
	    const [isOpen, setIsOpen] = reactExports.useState(false);
	    const [visiblePostId, setVisiblePostId] = reactExports.useState(0 );
	    const [lightboxContent, setLightboxContent] = reactExports.useState

	({});
	    const [carouselIndex, setCarouselIndex] = reactExports.useState(0);

	    const openLightbox = (postId, attachmentId) => {
	        setVisiblePostId(postId);

	        const index =
	            lightboxContent[postId]?.findIndex(
	                (block) => block.attachment.attachmentId === attachmentId
	            ) ?? 0;

	        setCarouselIndex(index);
	        setIsOpen(true);
	    };

	    const closeLightbox = () => {
	        setIsOpen(false);
	    };

	    const setLightboxContentForPost = (
	        postId,
	        content
	    ) => {
	        if (lightboxContent[postId]) return;
	        lightboxContent[postId] = content;
	        setLightboxContent(lightboxContent);
	    };

	    return (
	        React$2.createElement(React$2.Fragment, null
	            , React$2.createElement(Lightbox.Provider, {
	                value: {
	                    openLightbox,
	                    closeLightbox,
	                    setLightboxContentForPost,
	                },}

	                , children
	            )
	            , React$2.createElement(St$1, { onClose: closeLightbox, open: isOpen,}
	                , React$2.createElement(ModalOverlay, { className: "bg-notBlack",} )
	                , React$2.createElement('div', { className: "fixed inset-0 z-10 overflow-y-auto"   ,}
	                    , React$2.createElement('div', { className: "flex min-h-full items-center justify-center py-20"    ,}
	                        , React$2.createElement(LightboxCarousel, {
	                            content: lightboxContent[visiblePostId] ?? [],
	                            onClick: closeLightbox,
	                            carouselIndex: carouselIndex,
	                            setCarouselIndex: setCarouselIndex,}
	                        )
	                    )
	                )
	            )
	        )
	    );
	};

	const useLightbox = () => reactExports.useContext(Lightbox);

	/******************************************************************************
	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.
	***************************************************************************** */
	/* global Reflect, Promise */


	var __assign$5 = function() {
	    __assign$5 = Object.assign || function __assign(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$5.apply(this, arguments);
	};

	function useMountedState() {
	    var mountedRef = reactExports.useRef(false);
	    var get = reactExports.useCallback(function () { return mountedRef.current; }, []);
	    reactExports.useEffect(function () {
	        mountedRef.current = true;
	        return function () {
	            mountedRef.current = false;
	        };
	    }, []);
	    return get;
	}

	function useAsyncFn(fn, deps, initialState) {
	    if (deps === void 0) { deps = []; }
	    if (initialState === void 0) { initialState = { loading: false }; }
	    var lastCallId = reactExports.useRef(0);
	    var isMounted = useMountedState();
	    var _a = reactExports.useState(initialState), state = _a[0], set = _a[1];
	    var callback = reactExports.useCallback(function () {
	        var args = [];
	        for (var _i = 0; _i < arguments.length; _i++) {
	            args[_i] = arguments[_i];
	        }
	        var callId = ++lastCallId.current;
	        if (!state.loading) {
	            set(function (prevState) { return (__assign$5(__assign$5({}, prevState), { loading: true })); });
	        }
	        return fn.apply(void 0, args).then(function (value) {
	            isMounted() && callId === lastCallId.current && set({ value: value, loading: false });
	            return value;
	        }, function (error) {
	            isMounted() && callId === lastCallId.current && set({ error: error, loading: false });
	            return error;
	        });
	    }, deps);
	    return [state, callback];
	}

	function useAsync(fn, deps) {
	    if (deps === void 0) { deps = []; }
	    var _a = useAsyncFn(fn, deps, {
	        loading: true,
	    }), state = _a[0], callback = _a[1];
	    reactExports.useEffect(function () {
	        callback();
	    }, [callback]);
	    return state;
	}

	var isBrowser = typeof window !== 'undefined';

	var getInitialState$3 = function (query, defaultState) {
	    // Prevent a React hydration mismatch when a default value is provided by not defaulting to window.matchMedia(query).matches.
	    if (defaultState !== undefined) {
	        return defaultState;
	    }
	    if (isBrowser) {
	        return window.matchMedia(query).matches;
	    }
	    return false;
	};
	var useMedia = function (query, defaultState) {
	    var _a = reactExports.useState(getInitialState$3(query, defaultState)), state = _a[0], setState = _a[1];
	    reactExports.useEffect(function () {
	        var mounted = true;
	        var mql = window.matchMedia(query);
	        var onChange = function () {
	            if (!mounted) {
	                return;
	            }
	            setState(!!mql.matches);
	        };
	        mql.addListener(onChange);
	        setState(mql.matches);
	        return function () {
	            mounted = false;
	            mql.removeListener(onChange);
	        };
	    }, [query]);
	    return state;
	};

	const usePrefersDark = () =>
	    useMedia("(prefers-color-scheme: dark)", false);

	function useDynamicTheme()


	 {
	    const defaultPostBoxThemeSetting = useDisplayPrefs().defaultPostBoxTheme;
	    const [forcedTheme, forceTheme] = reactExports.useState(null);

	    if (forcedTheme) {
	        return { current: forcedTheme, forceTheme };
	    } else if (defaultPostBoxThemeSetting === "prefers-color-scheme") {
	        return { current: "both", forceTheme };
	    } else {
	        return { current: defaultPostBoxThemeSetting, forceTheme };
	    }
	}

	const StandardHeader = ({
	    children,
	}) => {
	    const dynamicTheme = useDynamicTheme();

	    return (
	        React$2.createElement('div', {
	            className: `co-themed-box co-header-alert cohost-shadow-light dark:cohost-shadow-dark flex flex-row items-start self-stretch p-3`,
	            'data-theme': dynamicTheme.current,}

	            , children
	        )
	    );
	};

	const EmailVerifyCanceledHeader = () => {
	    const { loggedIn, email, emailVerifyCanceled } = useUserInfo();

	    return loggedIn && emailVerifyCanceled ? (
	        React$2.createElement(StandardHeader, null
	            , React$2.createElement(Trans, {
	                parent: "div",
	                className: "prose mx-auto" ,
	                i18nKey: "client:header-notice.email-verify-canceled",}

	                , React$2.createElement('p', null
	                    , React$2.createElement('strong', null, "Warning!"), " The owner of the email address"      , " "
	                    , React$2.createElement('em', null, { email }), " told us that they didn't sign up for cohost. Please verify that your email is set correctly and"
	                             , " "
	                    , React$2.createElement('a', { href: patterns.public.settingsMain.toString(),}, "change it"

	                    ), " ", "if it's incorrect."

	                )
	            )
	        )
	    ) : null;
	};

	const ReadOnlyHeader = () => {
	    const { loggedIn, readOnly } = useUserInfo();

	    return loggedIn && readOnly ? (
	        React$2.createElement(StandardHeader, null
	            , React$2.createElement(Trans, {
	                parent: "div",
	                className: "prose mx-auto" ,
	                i18nKey: "client:header-notice.read-only",}

	                , React$2.createElement('p', null
	                    , React$2.createElement('strong', null, "cohost is read-only as of October 1, 2024."       ), " ", "The site will be fully shut down at the end of the year. Until then, you can use the site but can’t do anything that isn’t reading (following, liking posts, making or editing posts, sending asks, updating your profile, etc)."




	                )
	                , React$2.createElement('p', null, "thank you for having used cohost. we’ll see you around."

	                    , " "
	                    /* not using the custom emoji component because getting the emoji URLs was causing weird load issues. it's fine for this imo. */
	                    , React$2.createElement('img', {
	                        src: "https://cohost.org/static/17aa2d48956926005de9.png",
	                        alt: ":eggbug:",
	                        title: ":eggbug:",
	                        className: "m-0 inline-block aspect-square object-contain align-middle"    ,
	                        style: { height: "var(--emoji-scale, 1em)" },}
	)
	                )
	            )
	        )
	    ) : null;
	};

	/**
	 * a simple tagged template literal that we can use to activate tailwind
	 * intellisense; also introduce a tagged string type here so that methods which take
	 * class names can enforce using the tagged template.
	 */

	// based on https://github.com/colinhacks/zod/issues/678#issuecomment-962387521

	function refinement() {
	    return function (val) {
	        return true;
	    };
	}

	 
	mod
	    .string()
	    .refine(refinement());

	const tw = (
	    strings,
	    ...values
	) =>
	    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
	    String.raw({ raw: strings }, ...values) ;

	mod.enum([
	    "info",
	    "warning",
	    "done",
	    "post-box-info",
	    "post-box-warning",
	]);
	 







	const InfoBox

	 = ({ level, className: moreClasses, textSize = "sm", children }) => {
	    let bgClasses;
	    let iconElement;
	    let textSizeClasses;

	    switch (level) {
	        case "info":
	            bgClasses = "bg-mango-100";
	            iconElement = (
	                React$2.createElement(ForwardRef$B, { className: "w-6 self-start text-cherry"  ,} )
	            );
	            break;
	        case "warning":
	            bgClasses = "bg-strawberry-100";
	            iconElement = (
	                React$2.createElement(ForwardRef$P, { className: "w-6 self-start text-strawberry"  ,} )
	            );
	            break;
	        case "done":
	            bgClasses = "bg-green-100";
	            iconElement = (
	                React$2.createElement(ForwardRef$17, { className: "w-6 self-start text-green-800"  ,} )
	            );
	            break;
	        case "post-box-info":
	            bgClasses = tw`co-info-box co-info`;
	            iconElement = React$2.createElement(ForwardRef$B, { className: "w-6 self-start" ,} );
	            break;
	        case "post-box-warning":
	            bgClasses = tw`co-info-box co-warning`;
	            iconElement = (
	                React$2.createElement(ForwardRef$P, { className: "w-6 self-start" ,} )
	            );
	            break;
	    }

	    switch (textSize) {
	        case "base":
	            textSizeClasses = "text-base";
	            break;
	        case "sm":
	        default:
	            textSizeClasses = "text-sm";
	            break;
	    }

	    return (
	        React$2.createElement('div', {
	            className: classNames(
	                bgClasses,
	                textSizeClasses,
	                "mx-auto flex w-full flex-row gap-4 rounded-lg p-3",
	                moreClasses
	            ),}

	            , iconElement
	            , React$2.createElement('div', { className: "flex-1 self-center" ,}, children)
	        )
	    );
	};

	const UnactivatedHeader = () => {
	    const { loggedIn, activated, emailVerified } = useUserInfo();

	    return loggedIn && !activated ? (
	        React$2.createElement(StandardHeader, null
	            , React$2.createElement(React$2.Fragment, null
	                , React$2.createElement(Trans, {
	                    parent: "div",
	                    className: "prose mx-auto" ,
	                    i18nKey: "client:header-notice.unactivated",}

	                    , React$2.createElement('p', null
	                        , React$2.createElement('strong', null, "Heads up!" ), " You're still in the waiting period before you can post! While you're free to follow, like, and share other users' posts, you can't comment or make any new posts yet."



	                    )
	                    , React$2.createElement('p', null, "This waiting period lasts a day or two, so just hold tight. We'll email you when you can post. You can find more information on"


	                          , " "
	                        , React$2.createElement('a', {
	                            href: "https://help.antisoftware.club/support/solutions/articles/62000224749-details-on-invites-and-the-restrictions-on-un-activated-accounts/",
	                            target: "_blank",
	                            rel: "noreferrer",}
	, "our support site!"

	                        )
	                    )
	                )
	                , !emailVerified ? (
	                    React$2.createElement(Trans, {
	                        parent: InfoBox,
	                        level: "info",
	                        className: "mx-auto mt-6 max-w-prose"  ,
	                        i18nKey: "client:header-notice.unverified-unactivated",}

	                        , React$2.createElement('div', { className: "prose prose-sm" ,}
	                            , React$2.createElement('p', null, "You won't be activated until you've verified your email address. Check for an email from no-reply@no-reply.cohost.org. If you can't find it, you can resend it from the"



	                                      , " "
	                                , React$2.createElement('a', {
	                                    href: sitemap.public
	                                        .userSettings()
	                                        .toString(),}
	, "settings page"

	                                ), "."

	                            )
	                        )
	                    )
	                ) : null
	            )
	        )
	    ) : null;
	};

	var index$2 =  reactExports.useLayoutEffect ;

	function useConstant(fn) {
	    var ref = reactExports.useRef();
	    if (!ref.current) {
	        ref.current = { v: fn() };
	    }
	    return ref.current.v;
	}

	function isActorWithState(actorRef) {
	    return 'state' in actorRef;
	}

	/*! *****************************************************************************
	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.
	***************************************************************************** */

	var __assign$4 = function() {
	    __assign$4 = Object.assign || function __assign(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$4.apply(this, arguments);
	};

	function __rest$1(s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	}

	function __values(o) {
	    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
	    if (m) return m.call(o);
	    if (o && typeof o.length === "number") return {
	        next: function () {
	            if (o && i >= o.length) o = void 0;
	            return { value: o && o[i++], done: !o };
	        }
	    };
	    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
	}

	function __read$2(o, n) {
	    var m = typeof Symbol === "function" && o[Symbol.iterator];
	    if (!m) return o;
	    var i = m.call(o), r, ar = [], e;
	    try {
	        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
	    }
	    catch (error) { e = { error: error }; }
	    finally {
	        try {
	            if (r && !r.done && (m = i["return"])) m.call(i);
	        }
	        finally { if (e) throw e.error; }
	    }
	    return ar;
	}

	function __spreadArray(to, from, pack) {
	    if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
	        if (ar || !(i in from)) {
	            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
	            ar[i] = from[i];
	        }
	    }
	    return to.concat(ar || Array.prototype.slice.call(from));
	}

	var ActionTypes$1;

	(function (ActionTypes) {
	  ActionTypes["Start"] = "xstate.start";
	  ActionTypes["Stop"] = "xstate.stop";
	  ActionTypes["Raise"] = "xstate.raise";
	  ActionTypes["Send"] = "xstate.send";
	  ActionTypes["Cancel"] = "xstate.cancel";
	  ActionTypes["NullEvent"] = "";
	  ActionTypes["Assign"] = "xstate.assign";
	  ActionTypes["After"] = "xstate.after";
	  ActionTypes["DoneState"] = "done.state";
	  ActionTypes["DoneInvoke"] = "done.invoke";
	  ActionTypes["Log"] = "xstate.log";
	  ActionTypes["Init"] = "xstate.init";
	  ActionTypes["Invoke"] = "xstate.invoke";
	  ActionTypes["ErrorExecution"] = "error.execution";
	  ActionTypes["ErrorCommunication"] = "error.communication";
	  ActionTypes["ErrorPlatform"] = "error.platform";
	  ActionTypes["ErrorCustom"] = "xstate.error";
	  ActionTypes["Update"] = "xstate.update";
	  ActionTypes["Pure"] = "xstate.pure";
	  ActionTypes["Choose"] = "xstate.choose";
	})(ActionTypes$1 || (ActionTypes$1 = {}));

	var SpecialTargets;

	(function (SpecialTargets) {
	  SpecialTargets["Parent"] = "#_parent";
	  SpecialTargets["Internal"] = "#_internal";
	})(SpecialTargets || (SpecialTargets = {}));

	var start$2 = ActionTypes$1.Start;
	var stop$1 = ActionTypes$1.Stop;
	var raise$1 = ActionTypes$1.Raise;
	var send$1 = ActionTypes$1.Send;
	var cancel$1 = ActionTypes$1.Cancel;
	var nullEvent = ActionTypes$1.NullEvent;
	var assign$3 = ActionTypes$1.Assign;
	ActionTypes$1.After;
	ActionTypes$1.DoneState;
	var log = ActionTypes$1.Log;
	var init = ActionTypes$1.Init;
	var invoke = ActionTypes$1.Invoke;
	ActionTypes$1.ErrorExecution;
	var errorPlatform = ActionTypes$1.ErrorPlatform;
	var error$1 = ActionTypes$1.ErrorCustom;
	var update = ActionTypes$1.Update;
	var choose = ActionTypes$1.Choose;
	var pure = ActionTypes$1.Pure;

	var STATE_DELIMITER = '.';
	var EMPTY_ACTIVITY_MAP = {};
	var DEFAULT_GUARD_TYPE = 'xstate.guard';
	var TARGETLESS_KEY = '';

	var _a$1;
	function matchesState(parentStateId, childStateId, delimiter) {
	  if (delimiter === void 0) {
	    delimiter = STATE_DELIMITER;
	  }

	  var parentStateValue = toStateValue(parentStateId, delimiter);
	  var childStateValue = toStateValue(childStateId, delimiter);

	  if (isString$1(childStateValue)) {
	    if (isString$1(parentStateValue)) {
	      return childStateValue === parentStateValue;
	    } // Parent more specific than child


	    return false;
	  }

	  if (isString$1(parentStateValue)) {
	    return parentStateValue in childStateValue;
	  }

	  return Object.keys(parentStateValue).every(function (key) {
	    if (!(key in childStateValue)) {
	      return false;
	    }

	    return matchesState(parentStateValue[key], childStateValue[key]);
	  });
	}
	function getEventType(event) {
	  try {
	    return isString$1(event) || typeof event === 'number' ? "".concat(event) : event.type;
	  } catch (e) {
	    throw new Error('Events must be strings or objects with a string event.type property.');
	  }
	}
	function toStatePath(stateId, delimiter) {
	  try {
	    if (isArray$1(stateId)) {
	      return stateId;
	    }

	    return stateId.toString().split(delimiter);
	  } catch (e) {
	    throw new Error("'".concat(stateId, "' is not a valid state path."));
	  }
	}
	function isStateLike(state) {
	  return typeof state === 'object' && 'value' in state && 'context' in state && 'event' in state && '_event' in state;
	}
	function toStateValue(stateValue, delimiter) {
	  if (isStateLike(stateValue)) {
	    return stateValue.value;
	  }

	  if (isArray$1(stateValue)) {
	    return pathToStateValue(stateValue);
	  }

	  if (typeof stateValue !== 'string') {
	    return stateValue;
	  }

	  var statePath = toStatePath(stateValue, delimiter);
	  return pathToStateValue(statePath);
	}
	function pathToStateValue(statePath) {
	  if (statePath.length === 1) {
	    return statePath[0];
	  }

	  var value = {};
	  var marker = value;

	  for (var i = 0; i < statePath.length - 1; i++) {
	    if (i === statePath.length - 2) {
	      marker[statePath[i]] = statePath[i + 1];
	    } else {
	      marker[statePath[i]] = {};
	      marker = marker[statePath[i]];
	    }
	  }

	  return value;
	}
	function mapValues(collection, iteratee) {
	  var result = {};
	  var collectionKeys = Object.keys(collection);

	  for (var i = 0; i < collectionKeys.length; i++) {
	    var key = collectionKeys[i];
	    result[key] = iteratee(collection[key], key, collection, i);
	  }

	  return result;
	}
	function mapFilterValues(collection, iteratee, predicate) {
	  var e_1, _a;

	  var result = {};

	  try {
	    for (var _b = __values(Object.keys(collection)), _c = _b.next(); !_c.done; _c = _b.next()) {
	      var key = _c.value;
	      var item = collection[key];

	      if (!predicate(item)) {
	        continue;
	      }

	      result[key] = iteratee(item, key, collection);
	    }
	  } catch (e_1_1) {
	    e_1 = {
	      error: e_1_1
	    };
	  } finally {
	    try {
	      if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
	    } finally {
	      if (e_1) throw e_1.error;
	    }
	  }

	  return result;
	}
	/**
	 * Retrieves a value at the given path.
	 * @param props The deep path to the prop of the desired value
	 */

	var path$2 = function (props) {
	  return function (object) {
	    var e_2, _a;

	    var result = object;

	    try {
	      for (var props_1 = __values(props), props_1_1 = props_1.next(); !props_1_1.done; props_1_1 = props_1.next()) {
	        var prop = props_1_1.value;
	        result = result[prop];
	      }
	    } catch (e_2_1) {
	      e_2 = {
	        error: e_2_1
	      };
	    } finally {
	      try {
	        if (props_1_1 && !props_1_1.done && (_a = props_1.return)) _a.call(props_1);
	      } finally {
	        if (e_2) throw e_2.error;
	      }
	    }

	    return result;
	  };
	};
	/**
	 * Retrieves a value at the given path via the nested accessor prop.
	 * @param props The deep path to the prop of the desired value
	 */

	function nestedPath(props, accessorProp) {
	  return function (object) {
	    var e_3, _a;

	    var result = object;

	    try {
	      for (var props_2 = __values(props), props_2_1 = props_2.next(); !props_2_1.done; props_2_1 = props_2.next()) {
	        var prop = props_2_1.value;
	        result = result[accessorProp][prop];
	      }
	    } catch (e_3_1) {
	      e_3 = {
	        error: e_3_1
	      };
	    } finally {
	      try {
	        if (props_2_1 && !props_2_1.done && (_a = props_2.return)) _a.call(props_2);
	      } finally {
	        if (e_3) throw e_3.error;
	      }
	    }

	    return result;
	  };
	}
	function toStatePaths(stateValue) {
	  if (!stateValue) {
	    return [[]];
	  }

	  if (isString$1(stateValue)) {
	    return [[stateValue]];
	  }

	  var result = flatten(Object.keys(stateValue).map(function (key) {
	    var subStateValue = stateValue[key];

	    if (typeof subStateValue !== 'string' && (!subStateValue || !Object.keys(subStateValue).length)) {
	      return [[key]];
	    }

	    return toStatePaths(stateValue[key]).map(function (subPath) {
	      return [key].concat(subPath);
	    });
	  }));
	  return result;
	}
	function flatten(array) {
	  var _a;

	  return (_a = []).concat.apply(_a, __spreadArray([], __read$2(array), false));
	}
	function toArrayStrict(value) {
	  if (isArray$1(value)) {
	    return value;
	  }

	  return [value];
	}
	function toArray(value) {
	  if (value === undefined) {
	    return [];
	  }

	  return toArrayStrict(value);
	}
	function mapContext(mapper, context, _event) {
	  var e_5, _a;

	  if (isFunction$1(mapper)) {
	    return mapper(context, _event.data);
	  }

	  var result = {};

	  try {
	    for (var _b = __values(Object.keys(mapper)), _c = _b.next(); !_c.done; _c = _b.next()) {
	      var key = _c.value;
	      var subMapper = mapper[key];

	      if (isFunction$1(subMapper)) {
	        result[key] = subMapper(context, _event.data);
	      } else {
	        result[key] = subMapper;
	      }
	    }
	  } catch (e_5_1) {
	    e_5 = {
	      error: e_5_1
	    };
	  } finally {
	    try {
	      if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
	    } finally {
	      if (e_5) throw e_5.error;
	    }
	  }

	  return result;
	}
	function isBuiltInEvent(eventType) {
	  return /^(done|error)\./.test(eventType);
	}
	function isPromiseLike(value) {
	  if (value instanceof Promise) {
	    return true;
	  } // Check if shape matches the Promise/A+ specification for a "thenable".


	  if (value !== null && (isFunction$1(value) || typeof value === 'object') && isFunction$1(value.then)) {
	    return true;
	  }

	  return false;
	}
	function isBehavior(value) {
	  return value !== null && typeof value === 'object' && 'transition' in value && typeof value.transition === 'function';
	}
	function partition$1(items, predicate) {
	  var e_6, _a;

	  var _b = __read$2([[], []], 2),
	      truthy = _b[0],
	      falsy = _b[1];

	  try {
	    for (var items_1 = __values(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
	      var item = items_1_1.value;

	      if (predicate(item)) {
	        truthy.push(item);
	      } else {
	        falsy.push(item);
	      }
	    }
	  } catch (e_6_1) {
	    e_6 = {
	      error: e_6_1
	    };
	  } finally {
	    try {
	      if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
	    } finally {
	      if (e_6) throw e_6.error;
	    }
	  }

	  return [truthy, falsy];
	}
	function updateHistoryStates(hist, stateValue) {
	  return mapValues(hist.states, function (subHist, key) {
	    if (!subHist) {
	      return undefined;
	    }

	    var subStateValue = (isString$1(stateValue) ? undefined : stateValue[key]) || (subHist ? subHist.current : undefined);

	    if (!subStateValue) {
	      return undefined;
	    }

	    return {
	      current: subStateValue,
	      states: updateHistoryStates(subHist, subStateValue)
	    };
	  });
	}
	function updateHistoryValue(hist, stateValue) {
	  return {
	    current: stateValue,
	    states: updateHistoryStates(hist, stateValue)
	  };
	}
	function updateContext(context, _event, assignActions, state) {

	  var updatedContext = context ? assignActions.reduce(function (acc, assignAction) {
	    var e_7, _a;

	    var assignment = assignAction.assignment;
	    var meta = {
	      state: state,
	      action: assignAction,
	      _event: _event
	    };
	    var partialUpdate = {};

	    if (isFunction$1(assignment)) {
	      partialUpdate = assignment(acc, _event.data, meta);
	    } else {
	      try {
	        for (var _b = __values(Object.keys(assignment)), _c = _b.next(); !_c.done; _c = _b.next()) {
	          var key = _c.value;
	          var propAssignment = assignment[key];
	          partialUpdate[key] = isFunction$1(propAssignment) ? propAssignment(acc, _event.data, meta) : propAssignment;
	        }
	      } catch (e_7_1) {
	        e_7 = {
	          error: e_7_1
	        };
	      } finally {
	        try {
	          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
	        } finally {
	          if (e_7) throw e_7.error;
	        }
	      }
	    }

	    return Object.assign({}, acc, partialUpdate);
	  }, context) : context;
	  return updatedContext;
	} // tslint:disable-next-line:no-empty

	var warn = function () {};
	function isArray$1(value) {
	  return Array.isArray(value);
	} // tslint:disable-next-line:ban-types

	function isFunction$1(value) {
	  return typeof value === 'function';
	}
	function isString$1(value) {
	  return typeof value === 'string';
	}
	function toGuard(condition, guardMap) {
	  if (!condition) {
	    return undefined;
	  }

	  if (isString$1(condition)) {
	    return {
	      type: DEFAULT_GUARD_TYPE,
	      name: condition,
	      predicate: guardMap ? guardMap[condition] : undefined
	    };
	  }

	  if (isFunction$1(condition)) {
	    return {
	      type: DEFAULT_GUARD_TYPE,
	      name: condition.name,
	      predicate: condition
	    };
	  }

	  return condition;
	}
	function isObservable(value) {
	  try {
	    return 'subscribe' in value && isFunction$1(value.subscribe);
	  } catch (e) {
	    return false;
	  }
	}
	var symbolObservable = /*#__PURE__*/function () {
	  return typeof Symbol === 'function' && Symbol.observable || '@@observable';
	}(); // TODO: to be removed in v5, left it out just to minimize the scope of the change and maintain compatibility with older versions of integration paackages

	(_a$1 = {}, _a$1[symbolObservable] = function () {
	  return this;
	}, _a$1[Symbol.observable] = function () {
	  return this;
	}, _a$1);
	function isMachine(value) {
	  return !!value && '__xstatenode' in value;
	}
	function isActor$1(value) {
	  return !!value && typeof value.send === 'function';
	}
	function toEventObject(event, payload // id?: TEvent['type']
	) {
	  if (isString$1(event) || typeof event === 'number') {
	    return __assign$4({
	      type: event
	    }, payload);
	  }

	  return event;
	}
	function toSCXMLEvent(event, scxmlEvent) {
	  if (!isString$1(event) && '$$type' in event && event.$$type === 'scxml') {
	    return event;
	  }

	  var eventObject = toEventObject(event);
	  return __assign$4({
	    name: eventObject.type,
	    data: eventObject,
	    $$type: 'scxml',
	    type: 'external'
	  }, scxmlEvent);
	}
	function toTransitionConfigArray(event, configLike) {
	  var transitions = toArrayStrict(configLike).map(function (transitionLike) {
	    if (typeof transitionLike === 'undefined' || typeof transitionLike === 'string' || isMachine(transitionLike)) {
	      return {
	        target: transitionLike,
	        event: event
	      };
	    }

	    return __assign$4(__assign$4({}, transitionLike), {
	      event: event
	    });
	  });
	  return transitions;
	}
	function normalizeTarget(target) {
	  if (target === undefined || target === TARGETLESS_KEY) {
	    return undefined;
	  }

	  return toArray(target);
	}
	function evaluateGuard(machine, guard, context, _event, state) {
	  var guards = machine.options.guards;
	  var guardMeta = {
	    state: state,
	    cond: guard,
	    _event: _event
	  }; // TODO: do not hardcode!

	  if (guard.type === DEFAULT_GUARD_TYPE) {
	    return ((guards === null || guards === void 0 ? void 0 : guards[guard.name]) || guard.predicate)(context, _event.data, guardMeta);
	  }

	  var condFn = guards === null || guards === void 0 ? void 0 : guards[guard.type];

	  if (!condFn) {
	    throw new Error("Guard '".concat(guard.type, "' is not implemented on machine '").concat(machine.id, "'."));
	  }

	  return condFn(context, _event.data, guardMeta);
	}
	function toInvokeSource$1(src) {
	  if (typeof src === 'string') {
	    return {
	      type: src
	    };
	  }

	  return src;
	}
	function toObserver(nextHandler, errorHandler, completionHandler) {
	  if (typeof nextHandler === 'object') {
	    return nextHandler;
	  }

	  var noop = function () {
	    return void 0;
	  };

	  return {
	    next: nextHandler,
	    error: errorHandler || noop,
	    complete: completionHandler || noop
	  };
	}
	function createInvokeId(stateNodeId, index) {
	  return "".concat(stateNodeId, ":invocation[").concat(index, "]");
	}

	var initEvent = /*#__PURE__*/toSCXMLEvent({
	  type: init
	});
	function getActionFunction(actionType, actionFunctionMap) {
	  return actionFunctionMap ? actionFunctionMap[actionType] || undefined : undefined;
	}
	function toActionObject(action, actionFunctionMap) {
	  var actionObject;

	  if (isString$1(action) || typeof action === 'number') {
	    var exec = getActionFunction(action, actionFunctionMap);

	    if (isFunction$1(exec)) {
	      actionObject = {
	        type: action,
	        exec: exec
	      };
	    } else if (exec) {
	      actionObject = exec;
	    } else {
	      actionObject = {
	        type: action,
	        exec: undefined
	      };
	    }
	  } else if (isFunction$1(action)) {
	    actionObject = {
	      // Convert action to string if unnamed
	      type: action.name || action.toString(),
	      exec: action
	    };
	  } else {
	    var exec = getActionFunction(action.type, actionFunctionMap);

	    if (isFunction$1(exec)) {
	      actionObject = __assign$4(__assign$4({}, action), {
	        exec: exec
	      });
	    } else if (exec) {
	      var actionType = exec.type || action.type;
	      actionObject = __assign$4(__assign$4(__assign$4({}, exec), action), {
	        type: actionType
	      });
	    } else {
	      actionObject = action;
	    }
	  }

	  return actionObject;
	}
	var toActionObjects = function (action, actionFunctionMap) {
	  if (!action) {
	    return [];
	  }

	  var actions = isArray$1(action) ? action : [action];
	  return actions.map(function (subAction) {
	    return toActionObject(subAction, actionFunctionMap);
	  });
	};
	function toActivityDefinition(action) {
	  var actionObject = toActionObject(action);
	  return __assign$4(__assign$4({
	    id: isString$1(action) ? action : actionObject.id
	  }, actionObject), {
	    type: actionObject.type
	  });
	}
	/**
	 * Raises an event. This places the event in the internal event queue, so that
	 * the event is immediately consumed by the machine in the current step.
	 *
	 * @param eventType The event to raise.
	 */

	function raise(event) {
	  if (!isString$1(event)) {
	    return send(event, {
	      to: SpecialTargets.Internal
	    });
	  }

	  return {
	    type: raise$1,
	    event: event
	  };
	}
	function resolveRaise(action) {
	  return {
	    type: raise$1,
	    _event: toSCXMLEvent(action.event)
	  };
	}
	/**
	 * Sends an event. This returns an action that will be read by an interpreter to
	 * send the event in the next step, after the current step is finished executing.
	 *
	 * @param event The event to send.
	 * @param options Options to pass into the send event:
	 *  - `id` - The unique send event identifier (used with `cancel()`).
	 *  - `delay` - The number of milliseconds to delay the sending of the event.
	 *  - `to` - The target of this event (by default, the machine the event was sent from).
	 */

	function send(event, options) {
	  return {
	    to: options ? options.to : undefined,
	    type: send$1,
	    event: isFunction$1(event) ? event : toEventObject(event),
	    delay: options ? options.delay : undefined,
	    id: options && options.id !== undefined ? options.id : isFunction$1(event) ? event.name : getEventType(event)
	  };
	}
	function resolveSend(action, ctx, _event, delaysMap) {
	  var meta = {
	    _event: _event
	  }; // TODO: helper function for resolving Expr

	  var resolvedEvent = toSCXMLEvent(isFunction$1(action.event) ? action.event(ctx, _event.data, meta) : action.event);
	  var resolvedDelay;

	  if (isString$1(action.delay)) {
	    var configDelay = delaysMap && delaysMap[action.delay];
	    resolvedDelay = isFunction$1(configDelay) ? configDelay(ctx, _event.data, meta) : configDelay;
	  } else {
	    resolvedDelay = isFunction$1(action.delay) ? action.delay(ctx, _event.data, meta) : action.delay;
	  }

	  var resolvedTarget = isFunction$1(action.to) ? action.to(ctx, _event.data, meta) : action.to;
	  return __assign$4(__assign$4({}, action), {
	    to: resolvedTarget,
	    _event: resolvedEvent,
	    event: resolvedEvent.data,
	    delay: resolvedDelay
	  });
	}
	var resolveLog = function (action, ctx, _event) {
	  return __assign$4(__assign$4({}, action), {
	    value: isString$1(action.expr) ? action.expr : action.expr(ctx, _event.data, {
	      _event: _event
	    })
	  });
	};
	/**
	 * Cancels an in-flight `send(...)` action. A canceled sent action will not
	 * be executed, nor will its event be sent, unless it has already been sent
	 * (e.g., if `cancel(...)` is called after the `send(...)` action's `delay`).
	 *
	 * @param sendId The `id` of the `send(...)` action to cancel.
	 */

	var cancel = function (sendId) {
	  return {
	    type: cancel$1,
	    sendId: sendId
	  };
	};
	/**
	 * Starts an activity.
	 *
	 * @param activity The activity to start.
	 */

	function start$1(activity) {
	  var activityDef = toActivityDefinition(activity);
	  return {
	    type: ActionTypes$1.Start,
	    activity: activityDef,
	    exec: undefined
	  };
	}
	/**
	 * Stops an activity.
	 *
	 * @param actorRef The activity to stop.
	 */

	function stop(actorRef) {
	  var activity = isFunction$1(actorRef) ? actorRef : toActivityDefinition(actorRef);
	  return {
	    type: ActionTypes$1.Stop,
	    activity: activity,
	    exec: undefined
	  };
	}
	function resolveStop(action, context, _event) {
	  var actorRefOrString = isFunction$1(action.activity) ? action.activity(context, _event.data) : action.activity;
	  var resolvedActorRef = typeof actorRefOrString === 'string' ? {
	    id: actorRefOrString
	  } : actorRefOrString;
	  var actionObject = {
	    type: ActionTypes$1.Stop,
	    activity: resolvedActorRef
	  };
	  return actionObject;
	}
	/**
	 * Updates the current context of the machine.
	 *
	 * @param assignment An object that represents the partial context to update.
	 */

	var assign$2 = function (assignment) {
	  return {
	    type: assign$3,
	    assignment: assignment
	  };
	};
	/**
	 * Returns an event type that represents an implicit event that
	 * is sent after the specified `delay`.
	 *
	 * @param delayRef The delay in milliseconds
	 * @param id The state node ID where this event is handled
	 */

	function after(delayRef, id) {
	  var idSuffix = id ? "#".concat(id) : '';
	  return "".concat(ActionTypes$1.After, "(").concat(delayRef, ")").concat(idSuffix);
	}
	/**
	 * Returns an event that represents that a final state node
	 * has been reached in the parent state node.
	 *
	 * @param id The final state node's parent state node `id`
	 * @param data The data to pass into the event
	 */

	function done(id, data) {
	  var type = "".concat(ActionTypes$1.DoneState, ".").concat(id);
	  var eventObject = {
	    type: type,
	    data: data
	  };

	  eventObject.toString = function () {
	    return type;
	  };

	  return eventObject;
	}
	/**
	 * Returns an event that represents that an invoked service has terminated.
	 *
	 * An invoked service is terminated when it has reached a top-level final state node,
	 * but not when it is canceled.
	 *
	 * @param id The final state node ID
	 * @param data The data to pass into the event
	 */

	function doneInvoke(id, data) {
	  var type = "".concat(ActionTypes$1.DoneInvoke, ".").concat(id);
	  var eventObject = {
	    type: type,
	    data: data
	  };

	  eventObject.toString = function () {
	    return type;
	  };

	  return eventObject;
	}
	function error(id, data) {
	  var type = "".concat(ActionTypes$1.ErrorPlatform, ".").concat(id);
	  var eventObject = {
	    type: type,
	    data: data
	  };

	  eventObject.toString = function () {
	    return type;
	  };

	  return eventObject;
	}
	function resolveActions(machine, currentState, currentContext, _event, actions, preserveActionOrder) {
	  if (preserveActionOrder === void 0) {
	    preserveActionOrder = false;
	  }

	  var _a = __read$2(preserveActionOrder ? [[], actions] : partition$1(actions, function (action) {
	    return action.type === assign$3;
	  }), 2),
	      assignActions = _a[0],
	      otherActions = _a[1];

	  var updatedContext = assignActions.length ? updateContext(currentContext, _event, assignActions, currentState) : currentContext;
	  var preservedContexts = preserveActionOrder ? [currentContext] : undefined;
	  var resolvedActions = flatten(otherActions.map(function (actionObject) {
	    var _a;

	    switch (actionObject.type) {
	      case raise$1:
	        return resolveRaise(actionObject);

	      case send$1:
	        var sendAction = resolveSend(actionObject, updatedContext, _event, machine.options.delays); // TODO: fix ActionTypes.Init

	        return sendAction;

	      case log:
	        return resolveLog(actionObject, updatedContext, _event);

	      case choose:
	        {
	          var chooseAction = actionObject;
	          var matchedActions = (_a = chooseAction.conds.find(function (condition) {
	            var guard = toGuard(condition.cond, machine.options.guards);
	            return !guard || evaluateGuard(machine, guard, updatedContext, _event, currentState);
	          })) === null || _a === void 0 ? void 0 : _a.actions;

	          if (!matchedActions) {
	            return [];
	          }

	          var _b = __read$2(resolveActions(machine, currentState, updatedContext, _event, toActionObjects(toArray(matchedActions), machine.options.actions), preserveActionOrder), 2),
	              resolvedActionsFromChoose = _b[0],
	              resolvedContextFromChoose = _b[1];

	          updatedContext = resolvedContextFromChoose;
	          preservedContexts === null || preservedContexts === void 0 ? void 0 : preservedContexts.push(updatedContext);
	          return resolvedActionsFromChoose;
	        }

	      case pure:
	        {
	          var matchedActions = actionObject.get(updatedContext, _event.data);

	          if (!matchedActions) {
	            return [];
	          }

	          var _c = __read$2(resolveActions(machine, currentState, updatedContext, _event, toActionObjects(toArray(matchedActions), machine.options.actions), preserveActionOrder), 2),
	              resolvedActionsFromPure = _c[0],
	              resolvedContext = _c[1];

	          updatedContext = resolvedContext;
	          preservedContexts === null || preservedContexts === void 0 ? void 0 : preservedContexts.push(updatedContext);
	          return resolvedActionsFromPure;
	        }

	      case stop$1:
	        {
	          return resolveStop(actionObject, updatedContext, _event);
	        }

	      case assign$3:
	        {
	          updatedContext = updateContext(updatedContext, _event, [actionObject], currentState);
	          preservedContexts === null || preservedContexts === void 0 ? void 0 : preservedContexts.push(updatedContext);
	          break;
	        }

	      default:
	        var resolvedActionObject = toActionObject(actionObject, machine.options.actions);
	        var exec_1 = resolvedActionObject.exec;

	        if (exec_1 && preservedContexts) {
	          var contextIndex_1 = preservedContexts.length - 1;
	          resolvedActionObject = __assign$4(__assign$4({}, resolvedActionObject), {
	            exec: function (_ctx) {
	              var args = [];

	              for (var _i = 1; _i < arguments.length; _i++) {
	                args[_i - 1] = arguments[_i];
	              }

	              exec_1.apply(void 0, __spreadArray([preservedContexts[contextIndex_1]], __read$2(args), false));
	            }
	          });
	        }

	        return resolvedActionObject;
	    }
	  }).filter(function (a) {
	    return !!a;
	  }));
	  return [resolvedActions, updatedContext];
	}

	/**
	 * Maintains a stack of the current service in scope.
	 * This is used to provide the correct service to spawn().
	 */
	var provide = function (service, fn) {
	  var result = fn(service);
	  return result;
	};

	function createNullActor(id) {
	  var _a;

	  return _a = {
	    id: id,
	    send: function () {
	      return void 0;
	    },
	    subscribe: function () {
	      return {
	        unsubscribe: function () {
	          return void 0;
	        }
	      };
	    },
	    getSnapshot: function () {
	      return undefined;
	    },
	    toJSON: function () {
	      return {
	        id: id
	      };
	    }
	  }, _a[symbolObservable] = function () {
	    return this;
	  }, _a;
	}
	/**
	 * Creates a deferred actor that is able to be invoked given the provided
	 * invocation information in its `.meta` value.
	 *
	 * @param invokeDefinition The meta information needed to invoke the actor.
	 */

	function createInvocableActor(invokeDefinition, machine, context, _event) {
	  var _a;

	  var invokeSrc = toInvokeSource$1(invokeDefinition.src);
	  var serviceCreator = (_a = machine === null || machine === void 0 ? void 0 : machine.options.services) === null || _a === void 0 ? void 0 : _a[invokeSrc.type];
	  var resolvedData = invokeDefinition.data ? mapContext(invokeDefinition.data, context, _event) : undefined;
	  var tempActor = serviceCreator ? createDeferredActor(serviceCreator, invokeDefinition.id, resolvedData) : createNullActor(invokeDefinition.id); // @ts-ignore

	  tempActor.meta = invokeDefinition;
	  return tempActor;
	}
	function createDeferredActor(entity, id, data) {
	  var tempActor = createNullActor(id); // @ts-ignore

	  tempActor.deferred = true;

	  if (isMachine(entity)) {
	    // "mute" the existing service scope so potential spawned actors within the `.initialState` stay deferred here
	    var initialState_1 = tempActor.state = provide(undefined, function () {
	      return (data ? entity.withContext(data) : entity).initialState;
	    });

	    tempActor.getSnapshot = function () {
	      return initialState_1;
	    };
	  }

	  return tempActor;
	}
	function isActor(item) {
	  try {
	    return typeof item.send === 'function';
	  } catch (e) {
	    return false;
	  }
	}
	function isSpawnedActor(item) {
	  return isActor(item) && 'id' in item;
	} // TODO: refactor the return type, this could be written in a better way but it's best to avoid unneccessary breaking changes now

	function toActorRef(actorRefLike) {
	  var _a;

	  return __assign$4((_a = {
	    subscribe: function () {
	      return {
	        unsubscribe: function () {
	          return void 0;
	        }
	      };
	    },
	    id: 'anonymous',
	    getSnapshot: function () {
	      return undefined;
	    }
	  }, _a[symbolObservable] = function () {
	    return this;
	  }, _a), actorRefLike);
	}

	var isLeafNode = function (stateNode) {
	  return stateNode.type === 'atomic' || stateNode.type === 'final';
	};
	function getChildren$1(stateNode) {
	  return Object.keys(stateNode.states).map(function (key) {
	    return stateNode.states[key];
	  }).filter(function (sn) {
	    return sn.type !== 'history';
	  });
	}
	function getAllStateNodes(stateNode) {
	  var stateNodes = [stateNode];

	  if (isLeafNode(stateNode)) {
	    return stateNodes;
	  }

	  return stateNodes.concat(flatten(getChildren$1(stateNode).map(getAllStateNodes)));
	}
	function getConfiguration(prevStateNodes, stateNodes) {
	  var e_1, _a, e_2, _b, e_3, _c, e_4, _d;

	  var prevConfiguration = new Set(prevStateNodes);
	  var prevAdjList = getAdjList(prevConfiguration);
	  var configuration = new Set(stateNodes);

	  try {
	    // add all ancestors
	    for (var configuration_1 = __values(configuration), configuration_1_1 = configuration_1.next(); !configuration_1_1.done; configuration_1_1 = configuration_1.next()) {
	      var s = configuration_1_1.value;
	      var m = s.parent;

	      while (m && !configuration.has(m)) {
	        configuration.add(m);
	        m = m.parent;
	      }
	    }
	  } catch (e_1_1) {
	    e_1 = {
	      error: e_1_1
	    };
	  } finally {
	    try {
	      if (configuration_1_1 && !configuration_1_1.done && (_a = configuration_1.return)) _a.call(configuration_1);
	    } finally {
	      if (e_1) throw e_1.error;
	    }
	  }

	  var adjList = getAdjList(configuration);

	  try {
	    // add descendants
	    for (var configuration_2 = __values(configuration), configuration_2_1 = configuration_2.next(); !configuration_2_1.done; configuration_2_1 = configuration_2.next()) {
	      var s = configuration_2_1.value; // if previously active, add existing child nodes

	      if (s.type === 'compound' && (!adjList.get(s) || !adjList.get(s).length)) {
	        if (prevAdjList.get(s)) {
	          prevAdjList.get(s).forEach(function (sn) {
	            return configuration.add(sn);
	          });
	        } else {
	          s.initialStateNodes.forEach(function (sn) {
	            return configuration.add(sn);
	          });
	        }
	      } else {
	        if (s.type === 'parallel') {
	          try {
	            for (var _e = (e_3 = void 0, __values(getChildren$1(s))), _f = _e.next(); !_f.done; _f = _e.next()) {
	              var child = _f.value;

	              if (!configuration.has(child)) {
	                configuration.add(child);

	                if (prevAdjList.get(child)) {
	                  prevAdjList.get(child).forEach(function (sn) {
	                    return configuration.add(sn);
	                  });
	                } else {
	                  child.initialStateNodes.forEach(function (sn) {
	                    return configuration.add(sn);
	                  });
	                }
	              }
	            }
	          } catch (e_3_1) {
	            e_3 = {
	              error: e_3_1
	            };
	          } finally {
	            try {
	              if (_f && !_f.done && (_c = _e.return)) _c.call(_e);
	            } finally {
	              if (e_3) throw e_3.error;
	            }
	          }
	        }
	      }
	    }
	  } catch (e_2_1) {
	    e_2 = {
	      error: e_2_1
	    };
	  } finally {
	    try {
	      if (configuration_2_1 && !configuration_2_1.done && (_b = configuration_2.return)) _b.call(configuration_2);
	    } finally {
	      if (e_2) throw e_2.error;
	    }
	  }

	  try {
	    // add all ancestors
	    for (var configuration_3 = __values(configuration), configuration_3_1 = configuration_3.next(); !configuration_3_1.done; configuration_3_1 = configuration_3.next()) {
	      var s = configuration_3_1.value;
	      var m = s.parent;

	      while (m && !configuration.has(m)) {
	        configuration.add(m);
	        m = m.parent;
	      }
	    }
	  } catch (e_4_1) {
	    e_4 = {
	      error: e_4_1
	    };
	  } finally {
	    try {
	      if (configuration_3_1 && !configuration_3_1.done && (_d = configuration_3.return)) _d.call(configuration_3);
	    } finally {
	      if (e_4) throw e_4.error;
	    }
	  }

	  return configuration;
	}

	function getValueFromAdj(baseNode, adjList) {
	  var childStateNodes = adjList.get(baseNode);

	  if (!childStateNodes) {
	    return {}; // todo: fix?
	  }

	  if (baseNode.type === 'compound') {
	    var childStateNode = childStateNodes[0];

	    if (childStateNode) {
	      if (isLeafNode(childStateNode)) {
	        return childStateNode.key;
	      }
	    } else {
	      return {};
	    }
	  }

	  var stateValue = {};
	  childStateNodes.forEach(function (csn) {
	    stateValue[csn.key] = getValueFromAdj(csn, adjList);
	  });
	  return stateValue;
	}

	function getAdjList(configuration) {
	  var e_5, _a;

	  var adjList = new Map();

	  try {
	    for (var configuration_4 = __values(configuration), configuration_4_1 = configuration_4.next(); !configuration_4_1.done; configuration_4_1 = configuration_4.next()) {
	      var s = configuration_4_1.value;

	      if (!adjList.has(s)) {
	        adjList.set(s, []);
	      }

	      if (s.parent) {
	        if (!adjList.has(s.parent)) {
	          adjList.set(s.parent, []);
	        }

	        adjList.get(s.parent).push(s);
	      }
	    }
	  } catch (e_5_1) {
	    e_5 = {
	      error: e_5_1
	    };
	  } finally {
	    try {
	      if (configuration_4_1 && !configuration_4_1.done && (_a = configuration_4.return)) _a.call(configuration_4);
	    } finally {
	      if (e_5) throw e_5.error;
	    }
	  }

	  return adjList;
	}
	function getValue(rootNode, configuration) {
	  var config = getConfiguration([rootNode], configuration);
	  return getValueFromAdj(rootNode, getAdjList(config));
	}
	function has$1(iterable, item) {
	  if (Array.isArray(iterable)) {
	    return iterable.some(function (member) {
	      return member === item;
	    });
	  }

	  if (iterable instanceof Set) {
	    return iterable.has(item);
	  }

	  return false; // TODO: fix
	}
	function nextEvents(configuration) {
	  return __spreadArray([], __read$2(new Set(flatten(__spreadArray([], __read$2(configuration.map(function (sn) {
	    return sn.ownEvents;
	  })), false)))), false);
	}
	function isInFinalState(configuration, stateNode) {
	  if (stateNode.type === 'compound') {
	    return getChildren$1(stateNode).some(function (s) {
	      return s.type === 'final' && has$1(configuration, s);
	    });
	  }

	  if (stateNode.type === 'parallel') {
	    return getChildren$1(stateNode).every(function (sn) {
	      return isInFinalState(configuration, sn);
	    });
	  }

	  return false;
	}
	function getMeta(configuration) {
	  if (configuration === void 0) {
	    configuration = [];
	  }

	  return configuration.reduce(function (acc, stateNode) {
	    if (stateNode.meta !== undefined) {
	      acc[stateNode.id] = stateNode.meta;
	    }

	    return acc;
	  }, {});
	}
	function getTagsFromConfiguration(configuration) {
	  return new Set(flatten(configuration.map(function (sn) {
	    return sn.tags;
	  })));
	}

	function stateValuesEqual(a, b) {
	  if (a === b) {
	    return true;
	  }

	  if (a === undefined || b === undefined) {
	    return false;
	  }

	  if (isString$1(a) || isString$1(b)) {
	    return a === b;
	  }

	  var aKeys = Object.keys(a);
	  var bKeys = Object.keys(b);
	  return aKeys.length === bKeys.length && aKeys.every(function (key) {
	    return stateValuesEqual(a[key], b[key]);
	  });
	}
	function isStateConfig(state) {
	  if (typeof state !== 'object' || state === null) {
	    return false;
	  }

	  return 'value' in state && '_event' in state;
	}
	function bindActionToState(action, state) {
	  var exec = action.exec;

	  var boundAction = __assign$4(__assign$4({}, action), {
	    exec: exec !== undefined ? function () {
	      return exec(state.context, state.event, {
	        action: action,
	        state: state,
	        _event: state._event
	      });
	    } : undefined
	  });

	  return boundAction;
	}

	var State =
	/*#__PURE__*/

	/** @class */
	function () {
	  /**
	   * Creates a new State instance.
	   * @param value The state value
	   * @param context The extended state
	   * @param historyValue The tree representing historical values of the state nodes
	   * @param history The previous state
	   * @param actions An array of action objects to execute as side-effects
	   * @param activities A mapping of activities and whether they are started (`true`) or stopped (`false`).
	   * @param meta
	   * @param events Internal event queue. Should be empty with run-to-completion semantics.
	   * @param configuration
	   */
	  function State(config) {
	    var _this = this;

	    var _a;

	    this.actions = [];
	    this.activities = EMPTY_ACTIVITY_MAP;
	    this.meta = {};
	    this.events = [];
	    this.value = config.value;
	    this.context = config.context;
	    this._event = config._event;
	    this._sessionid = config._sessionid;
	    this.event = this._event.data;
	    this.historyValue = config.historyValue;
	    this.history = config.history;
	    this.actions = config.actions || [];
	    this.activities = config.activities || EMPTY_ACTIVITY_MAP;
	    this.meta = getMeta(config.configuration);
	    this.events = config.events || [];
	    this.matches = this.matches.bind(this);
	    this.toStrings = this.toStrings.bind(this);
	    this.configuration = config.configuration;
	    this.transitions = config.transitions;
	    this.children = config.children;
	    this.done = !!config.done;
	    this.tags = (_a = Array.isArray(config.tags) ? new Set(config.tags) : config.tags) !== null && _a !== void 0 ? _a : new Set();
	    this.machine = config.machine;
	    Object.defineProperty(this, 'nextEvents', {
	      get: function () {
	        return nextEvents(_this.configuration);
	      }
	    });
	  }
	  /**
	   * Creates a new State instance for the given `stateValue` and `context`.
	   * @param stateValue
	   * @param context
	   */


	  State.from = function (stateValue, context) {
	    if (stateValue instanceof State) {
	      if (stateValue.context !== context) {
	        return new State({
	          value: stateValue.value,
	          context: context,
	          _event: stateValue._event,
	          _sessionid: null,
	          historyValue: stateValue.historyValue,
	          history: stateValue.history,
	          actions: [],
	          activities: stateValue.activities,
	          meta: {},
	          events: [],
	          configuration: [],
	          transitions: [],
	          children: {}
	        });
	      }

	      return stateValue;
	    }

	    var _event = initEvent;
	    return new State({
	      value: stateValue,
	      context: context,
	      _event: _event,
	      _sessionid: null,
	      historyValue: undefined,
	      history: undefined,
	      actions: [],
	      activities: undefined,
	      meta: undefined,
	      events: [],
	      configuration: [],
	      transitions: [],
	      children: {}
	    });
	  };
	  /**
	   * Creates a new State instance for the given `config`.
	   * @param config The state config
	   */


	  State.create = function (config) {
	    return new State(config);
	  };
	  /**
	   * Creates a new `State` instance for the given `stateValue` and `context` with no actions (side-effects).
	   * @param stateValue
	   * @param context
	   */


	  State.inert = function (stateValue, context) {
	    if (stateValue instanceof State) {
	      if (!stateValue.actions.length) {
	        return stateValue;
	      }

	      var _event = initEvent;
	      return new State({
	        value: stateValue.value,
	        context: context,
	        _event: _event,
	        _sessionid: null,
	        historyValue: stateValue.historyValue,
	        history: stateValue.history,
	        activities: stateValue.activities,
	        configuration: stateValue.configuration,
	        transitions: [],
	        children: {}
	      });
	    }

	    return State.from(stateValue, context);
	  };
	  /**
	   * Returns an array of all the string leaf state node paths.
	   * @param stateValue
	   * @param delimiter The character(s) that separate each subpath in the string state node path.
	   */


	  State.prototype.toStrings = function (stateValue, delimiter) {
	    var _this = this;

	    if (stateValue === void 0) {
	      stateValue = this.value;
	    }

	    if (delimiter === void 0) {
	      delimiter = '.';
	    }

	    if (isString$1(stateValue)) {
	      return [stateValue];
	    }

	    var valueKeys = Object.keys(stateValue);
	    return valueKeys.concat.apply(valueKeys, __spreadArray([], __read$2(valueKeys.map(function (key) {
	      return _this.toStrings(stateValue[key], delimiter).map(function (s) {
	        return key + delimiter + s;
	      });
	    })), false));
	  };

	  State.prototype.toJSON = function () {
	    var _a = this;
	        _a.configuration;
	        _a.transitions;
	        var tags = _a.tags;
	        _a.machine;
	        var jsonValues = __rest$1(_a, ["configuration", "transitions", "tags", "machine"]);

	    return __assign$4(__assign$4({}, jsonValues), {
	      tags: Array.from(tags)
	    });
	  };

	  State.prototype.matches = function (parentStateValue) {
	    return matchesState(parentStateValue, this.value);
	  };
	  /**
	   * Whether the current state configuration has a state node with the specified `tag`.
	   * @param tag
	   */


	  State.prototype.hasTag = function (tag) {
	    return this.tags.has(tag);
	  };
	  /**
	   * Determines whether sending the `event` will cause a non-forbidden transition
	   * to be selected, even if the transitions have no actions nor
	   * change the state value.
	   *
	   * @param event The event to test
	   * @returns Whether the event will cause a transition
	   */


	  State.prototype.can = function (event) {
	    var _a;

	    {
	      warn(!!this.machine);
	    }

	    var transitionData = (_a = this.machine) === null || _a === void 0 ? void 0 : _a.getTransitionData(this, event);
	    return !!(transitionData === null || transitionData === void 0 ? void 0 : transitionData.transitions.length) && // Check that at least one transition is not forbidden
	    transitionData.transitions.some(function (t) {
	      return t.target !== undefined || t.actions.length;
	    });
	  };

	  return State;
	}();

	var defaultOptions$1 = {
	  deferEvents: false
	};

	var Scheduler =
	/*#__PURE__*/

	/** @class */
	function () {
	  function Scheduler(options) {
	    this.processingEvent = false;
	    this.queue = [];
	    this.initialized = false;
	    this.options = __assign$4(__assign$4({}, defaultOptions$1), options);
	  }

	  Scheduler.prototype.initialize = function (callback) {
	    this.initialized = true;

	    if (callback) {
	      if (!this.options.deferEvents) {
	        this.schedule(callback);
	        return;
	      }

	      this.process(callback);
	    }

	    this.flushEvents();
	  };

	  Scheduler.prototype.schedule = function (task) {
	    if (!this.initialized || this.processingEvent) {
	      this.queue.push(task);
	      return;
	    }

	    if (this.queue.length !== 0) {
	      throw new Error('Event queue should be empty when it is not processing events');
	    }

	    this.process(task);
	    this.flushEvents();
	  };

	  Scheduler.prototype.clear = function () {
	    this.queue = [];
	  };

	  Scheduler.prototype.flushEvents = function () {
	    var nextCallback = this.queue.shift();

	    while (nextCallback) {
	      this.process(nextCallback);
	      nextCallback = this.queue.shift();
	    }
	  };

	  Scheduler.prototype.process = function (callback) {
	    this.processingEvent = true;

	    try {
	      callback();
	    } catch (e) {
	      // there is no use to keep the future events
	      // as the situation is not anymore the same
	      this.clear();
	      throw e;
	    } finally {
	      this.processingEvent = false;
	    }
	  };

	  return Scheduler;
	}();

	var children = /*#__PURE__*/new Map();
	var sessionIdIndex = 0;
	var registry = {
	  bookId: function () {
	    return "x:".concat(sessionIdIndex++);
	  },
	  register: function (id, actor) {
	    children.set(id, actor);
	    return id;
	  },
	  get: function (id) {
	    return children.get(id);
	  },
	  free: function (id) {
	    children.delete(id);
	  }
	};

	function getGlobal() {
	  if (typeof globalThis !== 'undefined') {
	    return globalThis;
	  }

	  if (typeof self !== 'undefined') {
	    return self;
	  }

	  if (typeof window !== 'undefined') {
	    return window;
	  }

	  if (typeof global !== 'undefined') {
	    return global;
	  }
	}

	function getDevTools() {
	  var global = getGlobal();

	  if (global && '__xstate__' in global) {
	    return global.__xstate__;
	  }

	  return undefined;
	}

	function registerService(service) {
	  if (!getGlobal()) {
	    return;
	  }

	  var devTools = getDevTools();

	  if (devTools) {
	    devTools.register(service);
	  }
	}

	function spawnBehavior(behavior, options) {
	  if (options === void 0) {
	    options = {};
	  }

	  var state = behavior.initialState;
	  var observers = new Set();
	  var mailbox = [];
	  var flushing = false;

	  var flush = function () {
	    if (flushing) {
	      return;
	    }

	    flushing = true;

	    while (mailbox.length > 0) {
	      var event_1 = mailbox.shift();
	      state = behavior.transition(state, event_1, actorCtx);
	      observers.forEach(function (observer) {
	        return observer.next(state);
	      });
	    }

	    flushing = false;
	  };

	  var actor = toActorRef({
	    id: options.id,
	    send: function (event) {
	      mailbox.push(event);
	      flush();
	    },
	    getSnapshot: function () {
	      return state;
	    },
	    subscribe: function (next, handleError, complete) {
	      var observer = toObserver(next, handleError, complete);
	      observers.add(observer);
	      observer.next(state);
	      return {
	        unsubscribe: function () {
	          observers.delete(observer);
	        }
	      };
	    }
	  });
	  var actorCtx = {
	    parent: options.parent,
	    self: actor,
	    id: options.id || 'anonymous',
	    observers: observers
	  };
	  state = behavior.start ? behavior.start(actorCtx) : state;
	  return actor;
	}

	var DEFAULT_SPAWN_OPTIONS = {
	  sync: false,
	  autoForward: false
	};
	var InterpreterStatus;

	(function (InterpreterStatus) {
	  InterpreterStatus[InterpreterStatus["NotStarted"] = 0] = "NotStarted";
	  InterpreterStatus[InterpreterStatus["Running"] = 1] = "Running";
	  InterpreterStatus[InterpreterStatus["Stopped"] = 2] = "Stopped";
	})(InterpreterStatus || (InterpreterStatus = {}));

	var Interpreter =
	/*#__PURE__*/

	/** @class */
	function () {
	  /**
	   * Creates a new Interpreter instance (i.e., service) for the given machine with the provided options, if any.
	   *
	   * @param machine The machine to be interpreted
	   * @param options Interpreter options
	   */
	  function Interpreter(machine, options) {
	    var _this = this;

	    if (options === void 0) {
	      options = Interpreter.defaultOptions;
	    }

	    this.machine = machine;
	    this.delayedEventsMap = {};
	    this.listeners = new Set();
	    this.contextListeners = new Set();
	    this.stopListeners = new Set();
	    this.doneListeners = new Set();
	    this.eventListeners = new Set();
	    this.sendListeners = new Set();
	    /**
	     * Whether the service is started.
	     */

	    this.initialized = false;
	    this.status = InterpreterStatus.NotStarted;
	    this.children = new Map();
	    this.forwardTo = new Set();
	    /**
	     * Alias for Interpreter.prototype.start
	     */

	    this.init = this.start;
	    /**
	     * Sends an event to the running interpreter to trigger a transition.
	     *
	     * An array of events (batched) can be sent as well, which will send all
	     * batched events to the running interpreter. The listeners will be
	     * notified only **once** when all events are processed.
	     *
	     * @param event The event(s) to send
	     */

	    this.send = function (event, payload) {
	      if (isArray$1(event)) {
	        _this.batch(event);

	        return _this.state;
	      }

	      var _event = toSCXMLEvent(toEventObject(event, payload));

	      if (_this.status === InterpreterStatus.Stopped) {

	        return _this.state;
	      }

	      if (_this.status !== InterpreterStatus.Running && !_this.options.deferEvents) {
	        throw new Error("Event \"".concat(_event.name, "\" was sent to uninitialized service \"").concat(_this.machine.id // tslint:disable-next-line:max-line-length
	        , "\". Make sure .start() is called for this service, or set { deferEvents: true } in the service options.\nEvent: ").concat(JSON.stringify(_event.data)));
	      }

	      _this.scheduler.schedule(function () {
	        // Forward copy of event to child actors
	        _this.forward(_event);

	        var nextState = _this.nextState(_event);

	        _this.update(nextState, _event);
	      });

	      return _this._state; // TODO: deprecate (should return void)
	      // tslint:disable-next-line:semicolon
	    };

	    this.sendTo = function (event, to) {
	      var isParent = _this.parent && (to === SpecialTargets.Parent || _this.parent.id === to);
	      var target = isParent ? _this.parent : isString$1(to) ? _this.children.get(to) || registry.get(to) : isActor$1(to) ? to : undefined;

	      if (!target) {
	        if (!isParent) {
	          throw new Error("Unable to send event to child '".concat(to, "' from service '").concat(_this.id, "'."));
	        } // tslint:disable-next-line:no-console

	        return;
	      }

	      if ('machine' in target) {
	        // Send SCXML events to machines
	        target.send(__assign$4(__assign$4({}, event), {
	          name: event.name === error$1 ? "".concat(error(_this.id)) : event.name,
	          origin: _this.sessionId
	        }));
	      } else {
	        // Send normal events to other targets
	        target.send(event.data);
	      }
	    };

	    var resolvedOptions = __assign$4(__assign$4({}, Interpreter.defaultOptions), options);

	    var clock = resolvedOptions.clock,
	        logger = resolvedOptions.logger,
	        parent = resolvedOptions.parent,
	        id = resolvedOptions.id;
	    var resolvedId = id !== undefined ? id : machine.id;
	    this.id = resolvedId;
	    this.logger = logger;
	    this.clock = clock;
	    this.parent = parent;
	    this.options = resolvedOptions;
	    this.scheduler = new Scheduler({
	      deferEvents: this.options.deferEvents
	    });
	    this.sessionId = registry.bookId();
	  }

	  Object.defineProperty(Interpreter.prototype, "initialState", {
	    get: function () {
	      var _this = this;

	      if (this._initialState) {
	        return this._initialState;
	      }

	      return provide(this, function () {
	        _this._initialState = _this.machine.initialState;
	        return _this._initialState;
	      });
	    },
	    enumerable: false,
	    configurable: true
	  });
	  Object.defineProperty(Interpreter.prototype, "state", {
	    get: function () {

	      return this._state;
	    },
	    enumerable: false,
	    configurable: true
	  });
	  /**
	   * Executes the actions of the given state, with that state's `context` and `event`.
	   *
	   * @param state The state whose actions will be executed
	   * @param actionsConfig The action implementations to use
	   */

	  Interpreter.prototype.execute = function (state, actionsConfig) {
	    var e_1, _a;

	    try {
	      for (var _b = __values(state.actions), _c = _b.next(); !_c.done; _c = _b.next()) {
	        var action = _c.value;
	        this.exec(action, state, actionsConfig);
	      }
	    } catch (e_1_1) {
	      e_1 = {
	        error: e_1_1
	      };
	    } finally {
	      try {
	        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
	      } finally {
	        if (e_1) throw e_1.error;
	      }
	    }
	  };

	  Interpreter.prototype.update = function (state, _event) {
	    var e_2, _a, e_3, _b, e_4, _c, e_5, _d;

	    var _this = this; // Attach session ID to state


	    state._sessionid = this.sessionId; // Update state

	    this._state = state; // Execute actions

	    if (this.options.execute) {
	      this.execute(this.state);
	    } // Update children


	    this.children.forEach(function (child) {
	      _this.state.children[child.id] = child;
	    }); // Dev tools

	    if (this.devTools) {
	      this.devTools.send(_event.data, state);
	    } // Execute listeners


	    if (state.event) {
	      try {
	        for (var _e = __values(this.eventListeners), _f = _e.next(); !_f.done; _f = _e.next()) {
	          var listener = _f.value;
	          listener(state.event);
	        }
	      } catch (e_2_1) {
	        e_2 = {
	          error: e_2_1
	        };
	      } finally {
	        try {
	          if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
	        } finally {
	          if (e_2) throw e_2.error;
	        }
	      }
	    }

	    try {
	      for (var _g = __values(this.listeners), _h = _g.next(); !_h.done; _h = _g.next()) {
	        var listener = _h.value;
	        listener(state, state.event);
	      }
	    } catch (e_3_1) {
	      e_3 = {
	        error: e_3_1
	      };
	    } finally {
	      try {
	        if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
	      } finally {
	        if (e_3) throw e_3.error;
	      }
	    }

	    try {
	      for (var _j = __values(this.contextListeners), _k = _j.next(); !_k.done; _k = _j.next()) {
	        var contextListener = _k.value;
	        contextListener(this.state.context, this.state.history ? this.state.history.context : undefined);
	      }
	    } catch (e_4_1) {
	      e_4 = {
	        error: e_4_1
	      };
	    } finally {
	      try {
	        if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
	      } finally {
	        if (e_4) throw e_4.error;
	      }
	    }

	    var isDone = isInFinalState(state.configuration || [], this.machine);

	    if (this.state.configuration && isDone) {
	      // get final child state node
	      var finalChildStateNode = state.configuration.find(function (sn) {
	        return sn.type === 'final' && sn.parent === _this.machine;
	      });
	      var doneData = finalChildStateNode && finalChildStateNode.doneData ? mapContext(finalChildStateNode.doneData, state.context, _event) : undefined;

	      try {
	        for (var _l = __values(this.doneListeners), _m = _l.next(); !_m.done; _m = _l.next()) {
	          var listener = _m.value;
	          listener(doneInvoke(this.id, doneData));
	        }
	      } catch (e_5_1) {
	        e_5 = {
	          error: e_5_1
	        };
	      } finally {
	        try {
	          if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
	        } finally {
	          if (e_5) throw e_5.error;
	        }
	      }

	      this.stop();
	    }
	  };
	  /*
	   * Adds a listener that is notified whenever a state transition happens. The listener is called with
	   * the next state and the event object that caused the state transition.
	   *
	   * @param listener The state listener
	   */


	  Interpreter.prototype.onTransition = function (listener) {
	    this.listeners.add(listener); // Send current state to listener

	    if (this.status === InterpreterStatus.Running) {
	      listener(this.state, this.state.event);
	    }

	    return this;
	  };

	  Interpreter.prototype.subscribe = function (nextListenerOrObserver, _, // TODO: error listener
	  completeListener) {
	    var _this = this;

	    if (!nextListenerOrObserver) {
	      return {
	        unsubscribe: function () {
	          return void 0;
	        }
	      };
	    }

	    var listener;
	    var resolvedCompleteListener = completeListener;

	    if (typeof nextListenerOrObserver === 'function') {
	      listener = nextListenerOrObserver;
	    } else {
	      listener = nextListenerOrObserver.next.bind(nextListenerOrObserver);
	      resolvedCompleteListener = nextListenerOrObserver.complete.bind(nextListenerOrObserver);
	    }

	    this.listeners.add(listener); // Send current state to listener

	    if (this.status !== InterpreterStatus.NotStarted) {
	      listener(this.state);
	    }

	    if (resolvedCompleteListener) {
	      if (this.status === InterpreterStatus.Stopped) {
	        resolvedCompleteListener();
	      } else {
	        this.onDone(resolvedCompleteListener);
	      }
	    }

	    return {
	      unsubscribe: function () {
	        listener && _this.listeners.delete(listener);
	        resolvedCompleteListener && _this.doneListeners.delete(resolvedCompleteListener);
	      }
	    };
	  };
	  /**
	   * Adds an event listener that is notified whenever an event is sent to the running interpreter.
	   * @param listener The event listener
	   */


	  Interpreter.prototype.onEvent = function (listener) {
	    this.eventListeners.add(listener);
	    return this;
	  };
	  /**
	   * Adds an event listener that is notified whenever a `send` event occurs.
	   * @param listener The event listener
	   */


	  Interpreter.prototype.onSend = function (listener) {
	    this.sendListeners.add(listener);
	    return this;
	  };
	  /**
	   * Adds a context listener that is notified whenever the state context changes.
	   * @param listener The context listener
	   */


	  Interpreter.prototype.onChange = function (listener) {
	    this.contextListeners.add(listener);
	    return this;
	  };
	  /**
	   * Adds a listener that is notified when the machine is stopped.
	   * @param listener The listener
	   */


	  Interpreter.prototype.onStop = function (listener) {
	    this.stopListeners.add(listener);
	    return this;
	  };
	  /**
	   * Adds a state listener that is notified when the statechart has reached its final state.
	   * @param listener The state listener
	   */


	  Interpreter.prototype.onDone = function (listener) {
	    this.doneListeners.add(listener);
	    return this;
	  };
	  /**
	   * Removes a listener.
	   * @param listener The listener to remove
	   */


	  Interpreter.prototype.off = function (listener) {
	    this.listeners.delete(listener);
	    this.eventListeners.delete(listener);
	    this.sendListeners.delete(listener);
	    this.stopListeners.delete(listener);
	    this.doneListeners.delete(listener);
	    this.contextListeners.delete(listener);
	    return this;
	  };
	  /**
	   * Starts the interpreter from the given state, or the initial state.
	   * @param initialState The state to start the statechart from
	   */


	  Interpreter.prototype.start = function (initialState) {
	    var _this = this;

	    if (this.status === InterpreterStatus.Running) {
	      // Do not restart the service if it is already started
	      return this;
	    } // yes, it's a hack but we need the related cache to be populated for some things to work (like delayed transitions)
	    // this is usually called by `machine.getInitialState` but if we rehydrate from a state we might bypass this call
	    // we also don't want to call this method here as it resolves the full initial state which might involve calling assign actions
	    // and that could potentially lead to some unwanted side-effects (even such as creating some rogue actors)


	    this.machine._init();

	    registry.register(this.sessionId, this);
	    this.initialized = true;
	    this.status = InterpreterStatus.Running;
	    var resolvedState = initialState === undefined ? this.initialState : provide(this, function () {
	      return isStateConfig(initialState) ? _this.machine.resolveState(initialState) : _this.machine.resolveState(State.from(initialState, _this.machine.context));
	    });

	    if (this.options.devTools) {
	      this.attachDev();
	    }

	    this.scheduler.initialize(function () {
	      _this.update(resolvedState, initEvent);
	    });
	    return this;
	  };
	  /**
	   * Stops the interpreter and unsubscribe all listeners.
	   *
	   * This will also notify the `onStop` listeners.
	   */


	  Interpreter.prototype.stop = function () {
	    var e_6, _a, e_7, _b, e_8, _c, e_9, _d, e_10, _e;

	    var _this = this;

	    try {
	      for (var _f = __values(this.listeners), _g = _f.next(); !_g.done; _g = _f.next()) {
	        var listener = _g.value;
	        this.listeners.delete(listener);
	      }
	    } catch (e_6_1) {
	      e_6 = {
	        error: e_6_1
	      };
	    } finally {
	      try {
	        if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
	      } finally {
	        if (e_6) throw e_6.error;
	      }
	    }

	    try {
	      for (var _h = __values(this.stopListeners), _j = _h.next(); !_j.done; _j = _h.next()) {
	        var listener = _j.value; // call listener, then remove

	        listener();
	        this.stopListeners.delete(listener);
	      }
	    } catch (e_7_1) {
	      e_7 = {
	        error: e_7_1
	      };
	    } finally {
	      try {
	        if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
	      } finally {
	        if (e_7) throw e_7.error;
	      }
	    }

	    try {
	      for (var _k = __values(this.contextListeners), _l = _k.next(); !_l.done; _l = _k.next()) {
	        var listener = _l.value;
	        this.contextListeners.delete(listener);
	      }
	    } catch (e_8_1) {
	      e_8 = {
	        error: e_8_1
	      };
	    } finally {
	      try {
	        if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
	      } finally {
	        if (e_8) throw e_8.error;
	      }
	    }

	    try {
	      for (var _m = __values(this.doneListeners), _o = _m.next(); !_o.done; _o = _m.next()) {
	        var listener = _o.value;
	        this.doneListeners.delete(listener);
	      }
	    } catch (e_9_1) {
	      e_9 = {
	        error: e_9_1
	      };
	    } finally {
	      try {
	        if (_o && !_o.done && (_d = _m.return)) _d.call(_m);
	      } finally {
	        if (e_9) throw e_9.error;
	      }
	    }

	    if (!this.initialized) {
	      // Interpreter already stopped; do nothing
	      return this;
	    }

	    __spreadArray([], __read$2(this.state.configuration), false).sort(function (a, b) {
	      return b.order - a.order;
	    }).forEach(function (stateNode) {
	      var e_11, _a;

	      try {
	        for (var _b = __values(stateNode.definition.exit), _c = _b.next(); !_c.done; _c = _b.next()) {
	          var action = _c.value;

	          _this.exec(action, _this.state);
	        }
	      } catch (e_11_1) {
	        e_11 = {
	          error: e_11_1
	        };
	      } finally {
	        try {
	          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
	        } finally {
	          if (e_11) throw e_11.error;
	        }
	      }
	    }); // Stop all children


	    this.children.forEach(function (child) {
	      if (isFunction$1(child.stop)) {
	        child.stop();
	      }
	    });
	    this.children.clear();

	    try {
	      // Cancel all delayed events
	      for (var _p = __values(Object.keys(this.delayedEventsMap)), _q = _p.next(); !_q.done; _q = _p.next()) {
	        var key = _q.value;
	        this.clock.clearTimeout(this.delayedEventsMap[key]);
	      }
	    } catch (e_10_1) {
	      e_10 = {
	        error: e_10_1
	      };
	    } finally {
	      try {
	        if (_q && !_q.done && (_e = _p.return)) _e.call(_p);
	      } finally {
	        if (e_10) throw e_10.error;
	      }
	    }

	    this.scheduler.clear();
	    this.scheduler = new Scheduler({
	      deferEvents: this.options.deferEvents
	    });
	    this.initialized = false;
	    this.status = InterpreterStatus.Stopped;
	    this._initialState = undefined;
	    registry.free(this.sessionId);
	    return this;
	  };

	  Interpreter.prototype.batch = function (events) {
	    var _this = this;

	    if (this.status === InterpreterStatus.NotStarted && this.options.deferEvents) ; else if (this.status !== InterpreterStatus.Running) {
	      throw new Error( // tslint:disable-next-line:max-line-length
	      "".concat(events.length, " event(s) were sent to uninitialized service \"").concat(this.machine.id, "\". Make sure .start() is called for this service, or set { deferEvents: true } in the service options."));
	    }

	    this.scheduler.schedule(function () {
	      var e_12, _a;

	      var nextState = _this.state;
	      var batchChanged = false;
	      var batchedActions = [];

	      var _loop_1 = function (event_1) {
	        var _event = toSCXMLEvent(event_1);

	        _this.forward(_event);

	        nextState = provide(_this, function () {
	          return _this.machine.transition(nextState, _event);
	        });
	        batchedActions.push.apply(batchedActions, __spreadArray([], __read$2(nextState.actions.map(function (a) {
	          return bindActionToState(a, nextState);
	        })), false));
	        batchChanged = batchChanged || !!nextState.changed;
	      };

	      try {
	        for (var events_1 = __values(events), events_1_1 = events_1.next(); !events_1_1.done; events_1_1 = events_1.next()) {
	          var event_1 = events_1_1.value;

	          _loop_1(event_1);
	        }
	      } catch (e_12_1) {
	        e_12 = {
	          error: e_12_1
	        };
	      } finally {
	        try {
	          if (events_1_1 && !events_1_1.done && (_a = events_1.return)) _a.call(events_1);
	        } finally {
	          if (e_12) throw e_12.error;
	        }
	      }

	      nextState.changed = batchChanged;
	      nextState.actions = batchedActions;

	      _this.update(nextState, toSCXMLEvent(events[events.length - 1]));
	    });
	  };
	  /**
	   * Returns a send function bound to this interpreter instance.
	   *
	   * @param event The event to be sent by the sender.
	   */


	  Interpreter.prototype.sender = function (event) {
	    return this.send.bind(this, event);
	  };
	  /**
	   * Returns the next state given the interpreter's current state and the event.
	   *
	   * This is a pure method that does _not_ update the interpreter's state.
	   *
	   * @param event The event to determine the next state
	   */


	  Interpreter.prototype.nextState = function (event) {
	    var _this = this;

	    var _event = toSCXMLEvent(event);

	    if (_event.name.indexOf(errorPlatform) === 0 && !this.state.nextEvents.some(function (nextEvent) {
	      return nextEvent.indexOf(errorPlatform) === 0;
	    })) {
	      throw _event.data.data;
	    }

	    var nextState = provide(this, function () {
	      return _this.machine.transition(_this.state, _event);
	    });
	    return nextState;
	  };

	  Interpreter.prototype.forward = function (event) {
	    var e_13, _a;

	    try {
	      for (var _b = __values(this.forwardTo), _c = _b.next(); !_c.done; _c = _b.next()) {
	        var id = _c.value;
	        var child = this.children.get(id);

	        if (!child) {
	          throw new Error("Unable to forward event '".concat(event, "' from interpreter '").concat(this.id, "' to nonexistant child '").concat(id, "'."));
	        }

	        child.send(event);
	      }
	    } catch (e_13_1) {
	      e_13 = {
	        error: e_13_1
	      };
	    } finally {
	      try {
	        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
	      } finally {
	        if (e_13) throw e_13.error;
	      }
	    }
	  };

	  Interpreter.prototype.defer = function (sendAction) {
	    var _this = this;

	    this.delayedEventsMap[sendAction.id] = this.clock.setTimeout(function () {
	      if (sendAction.to) {
	        _this.sendTo(sendAction._event, sendAction.to);
	      } else {
	        _this.send(sendAction._event);
	      }
	    }, sendAction.delay);
	  };

	  Interpreter.prototype.cancel = function (sendId) {
	    this.clock.clearTimeout(this.delayedEventsMap[sendId]);
	    delete this.delayedEventsMap[sendId];
	  };

	  Interpreter.prototype.exec = function (action, state, actionFunctionMap) {
	    if (actionFunctionMap === void 0) {
	      actionFunctionMap = this.machine.options.actions;
	    }

	    var context = state.context,
	        _event = state._event;
	    var actionOrExec = action.exec || getActionFunction(action.type, actionFunctionMap);
	    var exec = isFunction$1(actionOrExec) ? actionOrExec : actionOrExec ? actionOrExec.exec : action.exec;

	    if (exec) {
	      try {
	        return exec(context, _event.data, {
	          action: action,
	          state: this.state,
	          _event: _event
	        });
	      } catch (err) {
	        if (this.parent) {
	          this.parent.send({
	            type: 'xstate.error',
	            data: err
	          });
	        }

	        throw err;
	      }
	    }

	    switch (action.type) {
	      case send$1:
	        var sendAction = action;

	        if (typeof sendAction.delay === 'number') {
	          this.defer(sendAction);
	          return;
	        } else {
	          if (sendAction.to) {
	            this.sendTo(sendAction._event, sendAction.to);
	          } else {
	            this.send(sendAction._event);
	          }
	        }

	        break;

	      case cancel$1:
	        this.cancel(action.sendId);
	        break;

	      case start$2:
	        {
	          if (this.status !== InterpreterStatus.Running) {
	            return;
	          }

	          var activity = action.activity; // If the activity will be stopped right after it's started
	          // (such as in transient states)
	          // don't bother starting the activity.

	          if (!this.state.activities[activity.id || activity.type]) {
	            break;
	          } // Invoked services


	          if (activity.type === ActionTypes$1.Invoke) {
	            var invokeSource = toInvokeSource$1(activity.src);
	            var serviceCreator = this.machine.options.services ? this.machine.options.services[invokeSource.type] : undefined;
	            var id = activity.id,
	                data = activity.data;

	            var autoForward = 'autoForward' in activity ? activity.autoForward : !!activity.forward;

	            if (!serviceCreator) {

	              return;
	            }

	            var resolvedData = data ? mapContext(data, context, _event) : undefined;

	            if (typeof serviceCreator === 'string') {
	              // TODO: warn
	              return;
	            }

	            var source = isFunction$1(serviceCreator) ? serviceCreator(context, _event.data, {
	              data: resolvedData,
	              src: invokeSource,
	              meta: activity.meta
	            }) : serviceCreator;

	            if (!source) {
	              // TODO: warn?
	              return;
	            }

	            var options = void 0;

	            if (isMachine(source)) {
	              source = resolvedData ? source.withContext(resolvedData) : source;
	              options = {
	                autoForward: autoForward
	              };
	            }

	            this.spawn(source, id, options);
	          } else {
	            this.spawnActivity(activity);
	          }

	          break;
	        }

	      case stop$1:
	        {
	          this.stopChild(action.activity.id);
	          break;
	        }

	      case log:
	        var label = action.label,
	            value = action.value;

	        if (label) {
	          this.logger(label, value);
	        } else {
	          this.logger(value);
	        }

	        break;
	    }

	    return undefined;
	  };

	  Interpreter.prototype.removeChild = function (childId) {
	    var _a;

	    this.children.delete(childId);
	    this.forwardTo.delete(childId); // this.state might not exist at the time this is called,
	    // such as when a child is added then removed while initializing the state

	    (_a = this.state) === null || _a === void 0 ? true : delete _a.children[childId];
	  };

	  Interpreter.prototype.stopChild = function (childId) {
	    var child = this.children.get(childId);

	    if (!child) {
	      return;
	    }

	    this.removeChild(childId);

	    if (isFunction$1(child.stop)) {
	      child.stop();
	    }
	  };

	  Interpreter.prototype.spawn = function (entity, name, options) {
	    if (isPromiseLike(entity)) {
	      return this.spawnPromise(Promise.resolve(entity), name);
	    } else if (isFunction$1(entity)) {
	      return this.spawnCallback(entity, name);
	    } else if (isSpawnedActor(entity)) {
	      return this.spawnActor(entity, name);
	    } else if (isObservable(entity)) {
	      return this.spawnObservable(entity, name);
	    } else if (isMachine(entity)) {
	      return this.spawnMachine(entity, __assign$4(__assign$4({}, options), {
	        id: name
	      }));
	    } else if (isBehavior(entity)) {
	      return this.spawnBehavior(entity, name);
	    } else {
	      throw new Error("Unable to spawn entity \"".concat(name, "\" of type \"").concat(typeof entity, "\"."));
	    }
	  };

	  Interpreter.prototype.spawnMachine = function (machine, options) {
	    var _this = this;

	    if (options === void 0) {
	      options = {};
	    }

	    var childService = new Interpreter(machine, __assign$4(__assign$4({}, this.options), {
	      parent: this,
	      id: options.id || machine.id
	    }));

	    var resolvedOptions = __assign$4(__assign$4({}, DEFAULT_SPAWN_OPTIONS), options);

	    if (resolvedOptions.sync) {
	      childService.onTransition(function (state) {
	        _this.send(update, {
	          state: state,
	          id: childService.id
	        });
	      });
	    }

	    var actor = childService;
	    this.children.set(childService.id, actor);

	    if (resolvedOptions.autoForward) {
	      this.forwardTo.add(childService.id);
	    }

	    childService.onDone(function (doneEvent) {
	      _this.removeChild(childService.id);

	      _this.send(toSCXMLEvent(doneEvent, {
	        origin: childService.id
	      }));
	    }).start();
	    return actor;
	  };

	  Interpreter.prototype.spawnBehavior = function (behavior, id) {
	    var actorRef = spawnBehavior(behavior, {
	      id: id,
	      parent: this
	    });
	    this.children.set(id, actorRef);
	    return actorRef;
	  };

	  Interpreter.prototype.spawnPromise = function (promise, id) {
	    var _a;

	    var _this = this;

	    var canceled = false;
	    var resolvedData;
	    promise.then(function (response) {
	      if (!canceled) {
	        resolvedData = response;

	        _this.removeChild(id);

	        _this.send(toSCXMLEvent(doneInvoke(id, response), {
	          origin: id
	        }));
	      }
	    }, function (errorData) {
	      if (!canceled) {
	        _this.removeChild(id);

	        var errorEvent = error(id, errorData);

	        try {
	          // Send "error.platform.id" to this (parent).
	          _this.send(toSCXMLEvent(errorEvent, {
	            origin: id
	          }));
	        } catch (error) {

	          if (_this.devTools) {
	            _this.devTools.send(errorEvent, _this.state);
	          }

	          if (_this.machine.strict) {
	            // it would be better to always stop the state machine if unhandled
	            // exception/promise rejection happens but because we don't want to
	            // break existing code so enforce it on strict mode only especially so
	            // because documentation says that onError is optional
	            _this.stop();
	          }
	        }
	      }
	    });
	    var actor = (_a = {
	      id: id,
	      send: function () {
	        return void 0;
	      },
	      subscribe: function (next, handleError, complete) {
	        var observer = toObserver(next, handleError, complete);
	        var unsubscribed = false;
	        promise.then(function (response) {
	          if (unsubscribed) {
	            return;
	          }

	          observer.next(response);

	          if (unsubscribed) {
	            return;
	          }

	          observer.complete();
	        }, function (err) {
	          if (unsubscribed) {
	            return;
	          }

	          observer.error(err);
	        });
	        return {
	          unsubscribe: function () {
	            return unsubscribed = true;
	          }
	        };
	      },
	      stop: function () {
	        canceled = true;
	      },
	      toJSON: function () {
	        return {
	          id: id
	        };
	      },
	      getSnapshot: function () {
	        return resolvedData;
	      }
	    }, _a[symbolObservable] = function () {
	      return this;
	    }, _a);
	    this.children.set(id, actor);
	    return actor;
	  };

	  Interpreter.prototype.spawnCallback = function (callback, id) {
	    var _a;

	    var _this = this;

	    var canceled = false;
	    var receivers = new Set();
	    var listeners = new Set();
	    var emitted;

	    var receive = function (e) {
	      emitted = e;
	      listeners.forEach(function (listener) {
	        return listener(e);
	      });

	      if (canceled) {
	        return;
	      }

	      _this.send(toSCXMLEvent(e, {
	        origin: id
	      }));
	    };

	    var callbackStop;

	    try {
	      callbackStop = callback(receive, function (newListener) {
	        receivers.add(newListener);
	      });
	    } catch (err) {
	      this.send(error(id, err));
	    }

	    if (isPromiseLike(callbackStop)) {
	      // it turned out to be an async function, can't reliably check this before calling `callback`
	      // because transpiled async functions are not recognizable
	      return this.spawnPromise(callbackStop, id);
	    }

	    var actor = (_a = {
	      id: id,
	      send: function (event) {
	        return receivers.forEach(function (receiver) {
	          return receiver(event);
	        });
	      },
	      subscribe: function (next) {
	        var observer = toObserver(next);
	        listeners.add(observer.next);
	        return {
	          unsubscribe: function () {
	            listeners.delete(observer.next);
	          }
	        };
	      },
	      stop: function () {
	        canceled = true;

	        if (isFunction$1(callbackStop)) {
	          callbackStop();
	        }
	      },
	      toJSON: function () {
	        return {
	          id: id
	        };
	      },
	      getSnapshot: function () {
	        return emitted;
	      }
	    }, _a[symbolObservable] = function () {
	      return this;
	    }, _a);
	    this.children.set(id, actor);
	    return actor;
	  };

	  Interpreter.prototype.spawnObservable = function (source, id) {
	    var _a;

	    var _this = this;

	    var emitted;
	    var subscription = source.subscribe(function (value) {
	      emitted = value;

	      _this.send(toSCXMLEvent(value, {
	        origin: id
	      }));
	    }, function (err) {
	      _this.removeChild(id);

	      _this.send(toSCXMLEvent(error(id, err), {
	        origin: id
	      }));
	    }, function () {
	      _this.removeChild(id);

	      _this.send(toSCXMLEvent(doneInvoke(id), {
	        origin: id
	      }));
	    });
	    var actor = (_a = {
	      id: id,
	      send: function () {
	        return void 0;
	      },
	      subscribe: function (next, handleError, complete) {
	        return source.subscribe(next, handleError, complete);
	      },
	      stop: function () {
	        return subscription.unsubscribe();
	      },
	      getSnapshot: function () {
	        return emitted;
	      },
	      toJSON: function () {
	        return {
	          id: id
	        };
	      }
	    }, _a[symbolObservable] = function () {
	      return this;
	    }, _a);
	    this.children.set(id, actor);
	    return actor;
	  };

	  Interpreter.prototype.spawnActor = function (actor, name) {
	    this.children.set(name, actor);
	    return actor;
	  };

	  Interpreter.prototype.spawnActivity = function (activity) {
	    var implementation = this.machine.options && this.machine.options.activities ? this.machine.options.activities[activity.type] : undefined;

	    if (!implementation) {


	      return;
	    } // Start implementation


	    var dispose = implementation(this.state.context, activity);
	    this.spawnEffect(activity.id, dispose);
	  };

	  Interpreter.prototype.spawnEffect = function (id, dispose) {
	    var _a;

	    this.children.set(id, (_a = {
	      id: id,
	      send: function () {
	        return void 0;
	      },
	      subscribe: function () {
	        return {
	          unsubscribe: function () {
	            return void 0;
	          }
	        };
	      },
	      stop: dispose || undefined,
	      getSnapshot: function () {
	        return undefined;
	      },
	      toJSON: function () {
	        return {
	          id: id
	        };
	      }
	    }, _a[symbolObservable] = function () {
	      return this;
	    }, _a));
	  };

	  Interpreter.prototype.attachDev = function () {
	    var global = getGlobal();

	    if (this.options.devTools && global) {
	      if (global.__REDUX_DEVTOOLS_EXTENSION__) {
	        var devToolsOptions = typeof this.options.devTools === 'object' ? this.options.devTools : undefined;
	        this.devTools = global.__REDUX_DEVTOOLS_EXTENSION__.connect(__assign$4(__assign$4({
	          name: this.id,
	          autoPause: true,
	          stateSanitizer: function (state) {
	            return {
	              value: state.value,
	              context: state.context,
	              actions: state.actions
	            };
	          }
	        }, devToolsOptions), {
	          features: __assign$4({
	            jump: false,
	            skip: false
	          }, devToolsOptions ? devToolsOptions.features : undefined)
	        }), this.machine);
	        this.devTools.init(this.state);
	      } // add XState-specific dev tooling hook


	      registerService(this);
	    }
	  };

	  Interpreter.prototype.toJSON = function () {
	    return {
	      id: this.id
	    };
	  };

	  Interpreter.prototype[symbolObservable] = function () {
	    return this;
	  };

	  Interpreter.prototype.getSnapshot = function () {
	    if (this.status === InterpreterStatus.NotStarted) {
	      return this.initialState;
	    }

	    return this._state;
	  };
	  /**
	   * The default interpreter options:
	   *
	   * - `clock` uses the global `setTimeout` and `clearTimeout` functions
	   * - `logger` uses the global `console.log()` method
	   */


	  Interpreter.defaultOptions = {
	    execute: true,
	    deferEvents: true,
	    clock: {
	      setTimeout: function (fn, ms) {
	        return setTimeout(fn, ms);
	      },
	      clearTimeout: function (id) {
	        return clearTimeout(id);
	      }
	    },
	    logger: /*#__PURE__*/console.log.bind(console),
	    devTools: false
	  };
	  Interpreter.interpret = interpret;
	  return Interpreter;
	}();
	/**
	 * Creates a new Interpreter instance for the given machine with the provided options, if any.
	 *
	 * @param machine The machine to interpret
	 * @param options Interpreter options
	 */

	function interpret(machine, options) {
	  var interpreter = new Interpreter(machine, options);
	  return interpreter;
	}

	function toInvokeSource(src) {
	  if (typeof src === 'string') {
	    var simpleSrc = {
	      type: src
	    };

	    simpleSrc.toString = function () {
	      return src;
	    }; // v4 compat - TODO: remove in v5


	    return simpleSrc;
	  }

	  return src;
	}
	function toInvokeDefinition(invokeConfig) {
	  return __assign$4(__assign$4({
	    type: invoke
	  }, invokeConfig), {
	    toJSON: function () {
	      invokeConfig.onDone;
	          invokeConfig.onError;
	          var invokeDef = __rest$1(invokeConfig, ["onDone", "onError"]);

	      return __assign$4(__assign$4({}, invokeDef), {
	        type: invoke,
	        src: toInvokeSource(invokeConfig.src)
	      });
	    }
	  });
	}

	var NULL_EVENT = '';
	var STATE_IDENTIFIER = '#';
	var WILDCARD = '*';
	var EMPTY_OBJECT = {};

	var isStateId = function (str) {
	  return str[0] === STATE_IDENTIFIER;
	};

	var createDefaultOptions = function () {
	  return {
	    actions: {},
	    guards: {},
	    services: {},
	    activities: {},
	    delays: {}
	  };
	};

	var StateNode =
	/*#__PURE__*/

	/** @class */
	function () {
	  function StateNode(
	  /**
	   * The raw config used to create the machine.
	   */
	  config, options,
	  /**
	   * The initial extended state
	   */
	  _context, // TODO: this is unsafe, but we're removing it in v5 anyway
	  _stateInfo) {
	    var _this = this;

	    if (_context === void 0) {
	      _context = 'context' in config ? config.context : undefined;
	    }

	    var _a;

	    this.config = config;
	    this._context = _context;
	    /**
	     * The order this state node appears. Corresponds to the implicit SCXML document order.
	     */

	    this.order = -1;
	    this.__xstatenode = true;
	    this.__cache = {
	      events: undefined,
	      relativeValue: new Map(),
	      initialStateValue: undefined,
	      initialState: undefined,
	      on: undefined,
	      transitions: undefined,
	      candidates: {},
	      delayedTransitions: undefined
	    };
	    this.idMap = {};
	    this.tags = [];
	    this.options = Object.assign(createDefaultOptions(), options);
	    this.parent = _stateInfo === null || _stateInfo === void 0 ? void 0 : _stateInfo.parent;
	    this.key = this.config.key || (_stateInfo === null || _stateInfo === void 0 ? void 0 : _stateInfo.key) || this.config.id || '(machine)';
	    this.machine = this.parent ? this.parent.machine : this;
	    this.path = this.parent ? this.parent.path.concat(this.key) : [];
	    this.delimiter = this.config.delimiter || (this.parent ? this.parent.delimiter : STATE_DELIMITER);
	    this.id = this.config.id || __spreadArray([this.machine.key], __read$2(this.path), false).join(this.delimiter);
	    this.version = this.parent ? this.parent.version : this.config.version;
	    this.type = this.config.type || (this.config.parallel ? 'parallel' : this.config.states && Object.keys(this.config.states).length ? 'compound' : this.config.history ? 'history' : 'atomic');
	    this.schema = this.parent ? this.machine.schema : (_a = this.config.schema) !== null && _a !== void 0 ? _a : {};
	    this.description = this.config.description;

	    this.initial = this.config.initial;
	    this.states = this.config.states ? mapValues(this.config.states, function (stateConfig, key) {
	      var _a;

	      var stateNode = new StateNode(stateConfig, {}, undefined, {
	        parent: _this,
	        key: key
	      });
	      Object.assign(_this.idMap, __assign$4((_a = {}, _a[stateNode.id] = stateNode, _a), stateNode.idMap));
	      return stateNode;
	    }) : EMPTY_OBJECT; // Document order

	    var order = 0;

	    function dfs(stateNode) {
	      var e_1, _a;

	      stateNode.order = order++;

	      try {
	        for (var _b = __values(getChildren$1(stateNode)), _c = _b.next(); !_c.done; _c = _b.next()) {
	          var child = _c.value;
	          dfs(child);
	        }
	      } catch (e_1_1) {
	        e_1 = {
	          error: e_1_1
	        };
	      } finally {
	        try {
	          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
	        } finally {
	          if (e_1) throw e_1.error;
	        }
	      }
	    }

	    dfs(this); // History config

	    this.history = this.config.history === true ? 'shallow' : this.config.history || false;
	    this._transient = !!this.config.always || (!this.config.on ? false : Array.isArray(this.config.on) ? this.config.on.some(function (_a) {
	      var event = _a.event;
	      return event === NULL_EVENT;
	    }) : NULL_EVENT in this.config.on);
	    this.strict = !!this.config.strict; // TODO: deprecate (entry)

	    this.onEntry = toArray(this.config.entry || this.config.onEntry).map(function (action) {
	      return toActionObject(action);
	    }); // TODO: deprecate (exit)

	    this.onExit = toArray(this.config.exit || this.config.onExit).map(function (action) {
	      return toActionObject(action);
	    });
	    this.meta = this.config.meta;
	    this.doneData = this.type === 'final' ? this.config.data : undefined;
	    this.invoke = toArray(this.config.invoke).map(function (invokeConfig, i) {
	      var _a, _b;

	      if (isMachine(invokeConfig)) {
	        var invokeId = createInvokeId(_this.id, i);
	        _this.machine.options.services = __assign$4((_a = {}, _a[invokeId] = invokeConfig, _a), _this.machine.options.services);
	        return toInvokeDefinition({
	          src: invokeId,
	          id: invokeId
	        });
	      } else if (isString$1(invokeConfig.src)) {
	        var invokeId = invokeConfig.id || createInvokeId(_this.id, i);
	        return toInvokeDefinition(__assign$4(__assign$4({}, invokeConfig), {
	          id: invokeId,
	          src: invokeConfig.src
	        }));
	      } else if (isMachine(invokeConfig.src) || isFunction$1(invokeConfig.src)) {
	        var invokeId = invokeConfig.id || createInvokeId(_this.id, i);
	        _this.machine.options.services = __assign$4((_b = {}, _b[invokeId] = invokeConfig.src, _b), _this.machine.options.services);
	        return toInvokeDefinition(__assign$4(__assign$4({
	          id: invokeId
	        }, invokeConfig), {
	          src: invokeId
	        }));
	      } else {
	        var invokeSource = invokeConfig.src;
	        return toInvokeDefinition(__assign$4(__assign$4({
	          id: createInvokeId(_this.id, i)
	        }, invokeConfig), {
	          src: invokeSource
	        }));
	      }
	    });
	    this.activities = toArray(this.config.activities).concat(this.invoke).map(function (activity) {
	      return toActivityDefinition(activity);
	    });
	    this.transition = this.transition.bind(this);
	    this.tags = toArray(this.config.tags); // TODO: this is the real fix for initialization once
	    // state node getters are deprecated
	    // if (!this.parent) {
	    //   this._init();
	    // }
	  }

	  StateNode.prototype._init = function () {
	    if (this.__cache.transitions) {
	      return;
	    }

	    getAllStateNodes(this).forEach(function (stateNode) {
	      return stateNode.on;
	    });
	  };
	  /**
	   * Clones this state machine with custom options and context.
	   *
	   * @param options Options (actions, guards, activities, services) to recursively merge with the existing options.
	   * @param context Custom context (will override predefined context)
	   */


	  StateNode.prototype.withConfig = function (options, context) {
	    var _a = this.options,
	        actions = _a.actions,
	        activities = _a.activities,
	        guards = _a.guards,
	        services = _a.services,
	        delays = _a.delays;
	    return new StateNode(this.config, {
	      actions: __assign$4(__assign$4({}, actions), options.actions),
	      activities: __assign$4(__assign$4({}, activities), options.activities),
	      guards: __assign$4(__assign$4({}, guards), options.guards),
	      services: __assign$4(__assign$4({}, services), options.services),
	      delays: __assign$4(__assign$4({}, delays), options.delays)
	    }, context !== null && context !== void 0 ? context : this.context);
	  };
	  /**
	   * Clones this state machine with custom context.
	   *
	   * @param context Custom context (will override predefined context, not recursive)
	   */


	  StateNode.prototype.withContext = function (context) {
	    return new StateNode(this.config, this.options, context);
	  };

	  Object.defineProperty(StateNode.prototype, "context", {
	    get: function () {
	      return isFunction$1(this._context) ? this._context() : this._context;
	    },
	    enumerable: false,
	    configurable: true
	  });
	  Object.defineProperty(StateNode.prototype, "definition", {
	    /**
	     * The well-structured state node definition.
	     */
	    get: function () {
	      return {
	        id: this.id,
	        key: this.key,
	        version: this.version,
	        context: this.context,
	        type: this.type,
	        initial: this.initial,
	        history: this.history,
	        states: mapValues(this.states, function (state) {
	          return state.definition;
	        }),
	        on: this.on,
	        transitions: this.transitions,
	        entry: this.onEntry,
	        exit: this.onExit,
	        activities: this.activities || [],
	        meta: this.meta,
	        order: this.order || -1,
	        data: this.doneData,
	        invoke: this.invoke,
	        description: this.description,
	        tags: this.tags
	      };
	    },
	    enumerable: false,
	    configurable: true
	  });

	  StateNode.prototype.toJSON = function () {
	    return this.definition;
	  };

	  Object.defineProperty(StateNode.prototype, "on", {
	    /**
	     * The mapping of events to transitions.
	     */
	    get: function () {
	      if (this.__cache.on) {
	        return this.__cache.on;
	      }

	      var transitions = this.transitions;
	      return this.__cache.on = transitions.reduce(function (map, transition) {
	        map[transition.eventType] = map[transition.eventType] || [];
	        map[transition.eventType].push(transition);
	        return map;
	      }, {});
	    },
	    enumerable: false,
	    configurable: true
	  });
	  Object.defineProperty(StateNode.prototype, "after", {
	    get: function () {
	      return this.__cache.delayedTransitions || (this.__cache.delayedTransitions = this.getDelayedTransitions(), this.__cache.delayedTransitions);
	    },
	    enumerable: false,
	    configurable: true
	  });
	  Object.defineProperty(StateNode.prototype, "transitions", {
	    /**
	     * All the transitions that can be taken from this state node.
	     */
	    get: function () {
	      return this.__cache.transitions || (this.__cache.transitions = this.formatTransitions(), this.__cache.transitions);
	    },
	    enumerable: false,
	    configurable: true
	  });

	  StateNode.prototype.getCandidates = function (eventName) {
	    if (this.__cache.candidates[eventName]) {
	      return this.__cache.candidates[eventName];
	    }

	    var transient = eventName === NULL_EVENT;
	    var candidates = this.transitions.filter(function (transition) {
	      var sameEventType = transition.eventType === eventName; // null events should only match against eventless transitions

	      return transient ? sameEventType : sameEventType || transition.eventType === WILDCARD;
	    });
	    this.__cache.candidates[eventName] = candidates;
	    return candidates;
	  };
	  /**
	   * All delayed transitions from the config.
	   */


	  StateNode.prototype.getDelayedTransitions = function () {
	    var _this = this;

	    var afterConfig = this.config.after;

	    if (!afterConfig) {
	      return [];
	    }

	    var mutateEntryExit = function (delay, i) {
	      var delayRef = isFunction$1(delay) ? "".concat(_this.id, ":delay[").concat(i, "]") : delay;
	      var eventType = after(delayRef, _this.id);

	      _this.onEntry.push(send(eventType, {
	        delay: delay
	      }));

	      _this.onExit.push(cancel(eventType));

	      return eventType;
	    };

	    var delayedTransitions = isArray$1(afterConfig) ? afterConfig.map(function (transition, i) {
	      var eventType = mutateEntryExit(transition.delay, i);
	      return __assign$4(__assign$4({}, transition), {
	        event: eventType
	      });
	    }) : flatten(Object.keys(afterConfig).map(function (delay, i) {
	      var configTransition = afterConfig[delay];
	      var resolvedTransition = isString$1(configTransition) ? {
	        target: configTransition
	      } : configTransition;
	      var resolvedDelay = !isNaN(+delay) ? +delay : delay;
	      var eventType = mutateEntryExit(resolvedDelay, i);
	      return toArray(resolvedTransition).map(function (transition) {
	        return __assign$4(__assign$4({}, transition), {
	          event: eventType,
	          delay: resolvedDelay
	        });
	      });
	    }));
	    return delayedTransitions.map(function (delayedTransition) {
	      var delay = delayedTransition.delay;
	      return __assign$4(__assign$4({}, _this.formatTransition(delayedTransition)), {
	        delay: delay
	      });
	    });
	  };
	  /**
	   * Returns the state nodes represented by the current state value.
	   *
	   * @param state The state value or State instance
	   */


	  StateNode.prototype.getStateNodes = function (state) {
	    var _a;

	    var _this = this;

	    if (!state) {
	      return [];
	    }

	    var stateValue = state instanceof State ? state.value : toStateValue(state, this.delimiter);

	    if (isString$1(stateValue)) {
	      var initialStateValue = this.getStateNode(stateValue).initial;
	      return initialStateValue !== undefined ? this.getStateNodes((_a = {}, _a[stateValue] = initialStateValue, _a)) : [this, this.states[stateValue]];
	    }

	    var subStateKeys = Object.keys(stateValue);
	    var subStateNodes = [this];
	    subStateNodes.push.apply(subStateNodes, __spreadArray([], __read$2(flatten(subStateKeys.map(function (subStateKey) {
	      return _this.getStateNode(subStateKey).getStateNodes(stateValue[subStateKey]);
	    }))), false));
	    return subStateNodes;
	  };
	  /**
	   * Returns `true` if this state node explicitly handles the given event.
	   *
	   * @param event The event in question
	   */


	  StateNode.prototype.handles = function (event) {
	    var eventType = getEventType(event);
	    return this.events.includes(eventType);
	  };
	  /**
	   * Resolves the given `state` to a new `State` instance relative to this machine.
	   *
	   * This ensures that `.events` and `.nextEvents` represent the correct values.
	   *
	   * @param state The state to resolve
	   */


	  StateNode.prototype.resolveState = function (state) {
	    var stateFromConfig = state instanceof State ? state : State.create(state);
	    var configuration = Array.from(getConfiguration([], this.getStateNodes(stateFromConfig.value)));
	    return new State(__assign$4(__assign$4({}, stateFromConfig), {
	      value: this.resolve(stateFromConfig.value),
	      configuration: configuration,
	      done: isInFinalState(configuration, this),
	      tags: getTagsFromConfiguration(configuration),
	      machine: this.machine
	    }));
	  };

	  StateNode.prototype.transitionLeafNode = function (stateValue, state, _event) {
	    var stateNode = this.getStateNode(stateValue);
	    var next = stateNode.next(state, _event);

	    if (!next || !next.transitions.length) {
	      return this.next(state, _event);
	    }

	    return next;
	  };

	  StateNode.prototype.transitionCompoundNode = function (stateValue, state, _event) {
	    var subStateKeys = Object.keys(stateValue);
	    var stateNode = this.getStateNode(subStateKeys[0]);

	    var next = stateNode._transition(stateValue[subStateKeys[0]], state, _event);

	    if (!next || !next.transitions.length) {
	      return this.next(state, _event);
	    }

	    return next;
	  };

	  StateNode.prototype.transitionParallelNode = function (stateValue, state, _event) {
	    var e_2, _a;

	    var transitionMap = {};

	    try {
	      for (var _b = __values(Object.keys(stateValue)), _c = _b.next(); !_c.done; _c = _b.next()) {
	        var subStateKey = _c.value;
	        var subStateValue = stateValue[subStateKey];

	        if (!subStateValue) {
	          continue;
	        }

	        var subStateNode = this.getStateNode(subStateKey);

	        var next = subStateNode._transition(subStateValue, state, _event);

	        if (next) {
	          transitionMap[subStateKey] = next;
	        }
	      }
	    } catch (e_2_1) {
	      e_2 = {
	        error: e_2_1
	      };
	    } finally {
	      try {
	        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
	      } finally {
	        if (e_2) throw e_2.error;
	      }
	    }

	    var stateTransitions = Object.keys(transitionMap).map(function (key) {
	      return transitionMap[key];
	    });
	    var enabledTransitions = flatten(stateTransitions.map(function (st) {
	      return st.transitions;
	    }));
	    var willTransition = stateTransitions.some(function (st) {
	      return st.transitions.length > 0;
	    });

	    if (!willTransition) {
	      return this.next(state, _event);
	    }

	    var entryNodes = flatten(stateTransitions.map(function (t) {
	      return t.entrySet;
	    }));
	    var configuration = flatten(Object.keys(transitionMap).map(function (key) {
	      return transitionMap[key].configuration;
	    }));
	    return {
	      transitions: enabledTransitions,
	      entrySet: entryNodes,
	      exitSet: flatten(stateTransitions.map(function (t) {
	        return t.exitSet;
	      })),
	      configuration: configuration,
	      source: state,
	      actions: flatten(Object.keys(transitionMap).map(function (key) {
	        return transitionMap[key].actions;
	      }))
	    };
	  };

	  StateNode.prototype._transition = function (stateValue, state, _event) {
	    // leaf node
	    if (isString$1(stateValue)) {
	      return this.transitionLeafNode(stateValue, state, _event);
	    } // hierarchical node


	    if (Object.keys(stateValue).length === 1) {
	      return this.transitionCompoundNode(stateValue, state, _event);
	    } // orthogonal node


	    return this.transitionParallelNode(stateValue, state, _event);
	  };

	  StateNode.prototype.getTransitionData = function (state, event) {
	    return this._transition(state.value, state, toSCXMLEvent(event));
	  };

	  StateNode.prototype.next = function (state, _event) {
	    var e_3, _a;

	    var _this = this;

	    var eventName = _event.name;
	    var actions = [];
	    var nextStateNodes = [];
	    var selectedTransition;

	    try {
	      for (var _b = __values(this.getCandidates(eventName)), _c = _b.next(); !_c.done; _c = _b.next()) {
	        var candidate = _c.value;
	        var cond = candidate.cond,
	            stateIn = candidate.in;
	        var resolvedContext = state.context;
	        var isInState = stateIn ? isString$1(stateIn) && isStateId(stateIn) ? // Check if in state by ID
	        state.matches(toStateValue(this.getStateNodeById(stateIn).path, this.delimiter)) : // Check if in state by relative grandparent
	        matchesState(toStateValue(stateIn, this.delimiter), path$2(this.path.slice(0, -2))(state.value)) : true;
	        var guardPassed = false;

	        try {
	          guardPassed = !cond || evaluateGuard(this.machine, cond, resolvedContext, _event, state);
	        } catch (err) {
	          throw new Error("Unable to evaluate guard '".concat(cond.name || cond.type, "' in transition for event '").concat(eventName, "' in state node '").concat(this.id, "':\n").concat(err.message));
	        }

	        if (guardPassed && isInState) {
	          if (candidate.target !== undefined) {
	            nextStateNodes = candidate.target;
	          }

	          actions.push.apply(actions, __spreadArray([], __read$2(candidate.actions), false));
	          selectedTransition = candidate;
	          break;
	        }
	      }
	    } catch (e_3_1) {
	      e_3 = {
	        error: e_3_1
	      };
	    } finally {
	      try {
	        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
	      } finally {
	        if (e_3) throw e_3.error;
	      }
	    }

	    if (!selectedTransition) {
	      return undefined;
	    }

	    if (!nextStateNodes.length) {
	      return {
	        transitions: [selectedTransition],
	        entrySet: [],
	        exitSet: [],
	        configuration: state.value ? [this] : [],
	        source: state,
	        actions: actions
	      };
	    }

	    var allNextStateNodes = flatten(nextStateNodes.map(function (stateNode) {
	      return _this.getRelativeStateNodes(stateNode, state.historyValue);
	    }));
	    var isInternal = !!selectedTransition.internal;
	    var reentryNodes = isInternal ? [] : flatten(allNextStateNodes.map(function (n) {
	      return _this.nodesFromChild(n);
	    }));
	    return {
	      transitions: [selectedTransition],
	      entrySet: reentryNodes,
	      exitSet: isInternal ? [] : [this],
	      configuration: allNextStateNodes,
	      source: state,
	      actions: actions
	    };
	  };

	  StateNode.prototype.nodesFromChild = function (childStateNode) {
	    if (childStateNode.escapes(this)) {
	      return [];
	    }

	    var nodes = [];
	    var marker = childStateNode;

	    while (marker && marker !== this) {
	      nodes.push(marker);
	      marker = marker.parent;
	    }

	    nodes.push(this); // inclusive

	    return nodes;
	  };
	  /**
	   * Whether the given state node "escapes" this state node. If the `stateNode` is equal to or the parent of
	   * this state node, it does not escape.
	   */


	  StateNode.prototype.escapes = function (stateNode) {
	    if (this === stateNode) {
	      return false;
	    }

	    var parent = this.parent;

	    while (parent) {
	      if (parent === stateNode) {
	        return false;
	      }

	      parent = parent.parent;
	    }

	    return true;
	  };

	  StateNode.prototype.getActions = function (transition, currentContext, _event, prevState) {
	    var e_4, _a, e_5, _b;

	    var prevConfig = getConfiguration([], prevState ? this.getStateNodes(prevState.value) : [this]);
	    var resolvedConfig = transition.configuration.length ? getConfiguration(prevConfig, transition.configuration) : prevConfig;

	    try {
	      for (var resolvedConfig_1 = __values(resolvedConfig), resolvedConfig_1_1 = resolvedConfig_1.next(); !resolvedConfig_1_1.done; resolvedConfig_1_1 = resolvedConfig_1.next()) {
	        var sn = resolvedConfig_1_1.value;

	        if (!has$1(prevConfig, sn)) {
	          transition.entrySet.push(sn);
	        }
	      }
	    } catch (e_4_1) {
	      e_4 = {
	        error: e_4_1
	      };
	    } finally {
	      try {
	        if (resolvedConfig_1_1 && !resolvedConfig_1_1.done && (_a = resolvedConfig_1.return)) _a.call(resolvedConfig_1);
	      } finally {
	        if (e_4) throw e_4.error;
	      }
	    }

	    try {
	      for (var prevConfig_1 = __values(prevConfig), prevConfig_1_1 = prevConfig_1.next(); !prevConfig_1_1.done; prevConfig_1_1 = prevConfig_1.next()) {
	        var sn = prevConfig_1_1.value;

	        if (!has$1(resolvedConfig, sn) || has$1(transition.exitSet, sn.parent)) {
	          transition.exitSet.push(sn);
	        }
	      }
	    } catch (e_5_1) {
	      e_5 = {
	        error: e_5_1
	      };
	    } finally {
	      try {
	        if (prevConfig_1_1 && !prevConfig_1_1.done && (_b = prevConfig_1.return)) _b.call(prevConfig_1);
	      } finally {
	        if (e_5) throw e_5.error;
	      }
	    }

	    var doneEvents = flatten(transition.entrySet.map(function (sn) {
	      var events = [];

	      if (sn.type !== 'final') {
	        return events;
	      }

	      var parent = sn.parent;

	      if (!parent.parent) {
	        return events;
	      }

	      events.push(done(sn.id, sn.doneData), // TODO: deprecate - final states should not emit done events for their own state.
	      done(parent.id, sn.doneData ? mapContext(sn.doneData, currentContext, _event) : undefined));
	      var grandparent = parent.parent;

	      if (grandparent.type === 'parallel') {
	        if (getChildren$1(grandparent).every(function (parentNode) {
	          return isInFinalState(transition.configuration, parentNode);
	        })) {
	          events.push(done(grandparent.id));
	        }
	      }

	      return events;
	    }));
	    transition.exitSet.sort(function (a, b) {
	      return b.order - a.order;
	    });
	    transition.entrySet.sort(function (a, b) {
	      return a.order - b.order;
	    });
	    var entryStates = new Set(transition.entrySet);
	    var exitStates = new Set(transition.exitSet);

	    var _c = __read$2([flatten(Array.from(entryStates).map(function (stateNode) {
	      return __spreadArray(__spreadArray([], __read$2(stateNode.activities.map(function (activity) {
	        return start$1(activity);
	      })), false), __read$2(stateNode.onEntry), false);
	    })).concat(doneEvents.map(raise)), flatten(Array.from(exitStates).map(function (stateNode) {
	      return __spreadArray(__spreadArray([], __read$2(stateNode.onExit), false), __read$2(stateNode.activities.map(function (activity) {
	        return stop(activity);
	      })), false);
	    }))], 2),
	        entryActions = _c[0],
	        exitActions = _c[1];

	    var actions = toActionObjects(exitActions.concat(transition.actions).concat(entryActions), this.machine.options.actions);
	    return actions;
	  };
	  /**
	   * Determines the next state given the current `state` and sent `event`.
	   *
	   * @param state The current State instance or state value
	   * @param event The event that was sent at the current state
	   * @param context The current context (extended state) of the current state
	   */


	  StateNode.prototype.transition = function (state, event, context) {
	    if (state === void 0) {
	      state = this.initialState;
	    }

	    var _event = toSCXMLEvent(event);

	    var currentState;

	    if (state instanceof State) {
	      currentState = context === undefined ? state : this.resolveState(State.from(state, context));
	    } else {
	      var resolvedStateValue = isString$1(state) ? this.resolve(pathToStateValue(this.getResolvedPath(state))) : this.resolve(state);
	      var resolvedContext = context !== null && context !== void 0 ? context : this.machine.context;
	      currentState = this.resolveState(State.from(resolvedStateValue, resolvedContext));
	    }

	    if (this.strict) {
	      if (!this.events.includes(_event.name) && !isBuiltInEvent(_event.name)) {
	        throw new Error("Machine '".concat(this.id, "' does not accept event '").concat(_event.name, "'"));
	      }
	    }

	    var stateTransition = this._transition(currentState.value, currentState, _event) || {
	      transitions: [],
	      configuration: [],
	      entrySet: [],
	      exitSet: [],
	      source: currentState,
	      actions: []
	    };
	    var prevConfig = getConfiguration([], this.getStateNodes(currentState.value));
	    var resolvedConfig = stateTransition.configuration.length ? getConfiguration(prevConfig, stateTransition.configuration) : prevConfig;
	    stateTransition.configuration = __spreadArray([], __read$2(resolvedConfig), false);
	    return this.resolveTransition(stateTransition, currentState, currentState.context, _event);
	  };

	  StateNode.prototype.resolveRaisedTransition = function (state, _event, originalEvent) {
	    var _a;

	    var currentActions = state.actions;
	    state = this.transition(state, _event); // Save original event to state
	    // TODO: this should be the raised event! Delete in V5 (breaking)

	    state._event = originalEvent;
	    state.event = originalEvent.data;

	    (_a = state.actions).unshift.apply(_a, __spreadArray([], __read$2(currentActions), false));

	    return state;
	  };

	  StateNode.prototype.resolveTransition = function (stateTransition, currentState, context, _event) {
	    var e_6, _a;

	    var _this = this;

	    if (_event === void 0) {
	      _event = initEvent;
	    }

	    var configuration = stateTransition.configuration; // Transition will "apply" if:
	    // - this is the initial state (there is no current state)
	    // - OR there are transitions

	    var willTransition = !currentState || stateTransition.transitions.length > 0;
	    var resolvedStateValue = willTransition ? getValue(this.machine, configuration) : undefined;
	    var historyValue = currentState ? currentState.historyValue ? currentState.historyValue : stateTransition.source ? this.machine.historyValue(currentState.value) : undefined : undefined;
	    var actions = this.getActions(stateTransition, context, _event, currentState);
	    var activities = currentState ? __assign$4({}, currentState.activities) : {};

	    try {
	      for (var actions_1 = __values(actions), actions_1_1 = actions_1.next(); !actions_1_1.done; actions_1_1 = actions_1.next()) {
	        var action = actions_1_1.value;

	        if (action.type === start$2) {
	          activities[action.activity.id || action.activity.type] = action;
	        } else if (action.type === stop$1) {
	          activities[action.activity.id || action.activity.type] = false;
	        }
	      }
	    } catch (e_6_1) {
	      e_6 = {
	        error: e_6_1
	      };
	    } finally {
	      try {
	        if (actions_1_1 && !actions_1_1.done && (_a = actions_1.return)) _a.call(actions_1);
	      } finally {
	        if (e_6) throw e_6.error;
	      }
	    }

	    var _b = __read$2(resolveActions(this, currentState, context, _event, actions, this.machine.config.preserveActionOrder), 2),
	        resolvedActions = _b[0],
	        updatedContext = _b[1];

	    var _c = __read$2(partition$1(resolvedActions, function (action) {
	      return action.type === raise$1 || action.type === send$1 && action.to === SpecialTargets.Internal;
	    }), 2),
	        raisedEvents = _c[0],
	        nonRaisedActions = _c[1];

	    var invokeActions = resolvedActions.filter(function (action) {
	      var _a;

	      return action.type === start$2 && ((_a = action.activity) === null || _a === void 0 ? void 0 : _a.type) === invoke;
	    });
	    var children = invokeActions.reduce(function (acc, action) {
	      acc[action.activity.id] = createInvocableActor(action.activity, _this.machine, updatedContext, _event);
	      return acc;
	    }, currentState ? __assign$4({}, currentState.children) : {});
	    var resolvedConfiguration = willTransition ? stateTransition.configuration : currentState ? currentState.configuration : [];
	    var isDone = isInFinalState(resolvedConfiguration, this);
	    var nextState = new State({
	      value: resolvedStateValue || currentState.value,
	      context: updatedContext,
	      _event: _event,
	      // Persist _sessionid between states
	      _sessionid: currentState ? currentState._sessionid : null,
	      historyValue: resolvedStateValue ? historyValue ? updateHistoryValue(historyValue, resolvedStateValue) : undefined : currentState ? currentState.historyValue : undefined,
	      history: !resolvedStateValue || stateTransition.source ? currentState : undefined,
	      actions: resolvedStateValue ? nonRaisedActions : [],
	      activities: resolvedStateValue ? activities : currentState ? currentState.activities : {},
	      events: [],
	      configuration: resolvedConfiguration,
	      transitions: stateTransition.transitions,
	      children: children,
	      done: isDone,
	      tags: getTagsFromConfiguration(resolvedConfiguration),
	      machine: this
	    });
	    var didUpdateContext = context !== updatedContext;
	    nextState.changed = _event.name === update || didUpdateContext; // Dispose of penultimate histories to prevent memory leaks

	    var history = nextState.history;

	    if (history) {
	      delete history.history;
	    } // There are transient transitions if the machine is not in a final state
	    // and if some of the state nodes have transient ("always") transitions.


	    var isTransient = !isDone && (this._transient || configuration.some(function (stateNode) {
	      return stateNode._transient;
	    })); // If there are no enabled transitions, check if there are transient transitions.
	    // If there are transient transitions, continue checking for more transitions
	    // because an transient transition should be triggered even if there are no
	    // enabled transitions.
	    //
	    // If we're already working on an transient transition (by checking
	    // if the event is a NULL_EVENT), then stop to prevent an infinite loop.
	    //
	    // Otherwise, if there are no enabled nor transient transitions, we are done.

	    if (!willTransition && (!isTransient || _event.name === NULL_EVENT)) {
	      return nextState;
	    }

	    var maybeNextState = nextState;

	    if (!isDone) {
	      if (isTransient) {
	        maybeNextState = this.resolveRaisedTransition(maybeNextState, {
	          type: nullEvent
	        }, _event);
	      }

	      while (raisedEvents.length) {
	        var raisedEvent = raisedEvents.shift();
	        maybeNextState = this.resolveRaisedTransition(maybeNextState, raisedEvent._event, _event);
	      }
	    } // Detect if state changed


	    var changed = maybeNextState.changed || (history ? !!maybeNextState.actions.length || didUpdateContext || typeof history.value !== typeof maybeNextState.value || !stateValuesEqual(maybeNextState.value, history.value) : undefined);
	    maybeNextState.changed = changed; // Preserve original history after raised events

	    maybeNextState.history = history;
	    return maybeNextState;
	  };
	  /**
	   * Returns the child state node from its relative `stateKey`, or throws.
	   */


	  StateNode.prototype.getStateNode = function (stateKey) {
	    if (isStateId(stateKey)) {
	      return this.machine.getStateNodeById(stateKey);
	    }

	    if (!this.states) {
	      throw new Error("Unable to retrieve child state '".concat(stateKey, "' from '").concat(this.id, "'; no child states exist."));
	    }

	    var result = this.states[stateKey];

	    if (!result) {
	      throw new Error("Child state '".concat(stateKey, "' does not exist on '").concat(this.id, "'"));
	    }

	    return result;
	  };
	  /**
	   * Returns the state node with the given `stateId`, or throws.
	   *
	   * @param stateId The state ID. The prefix "#" is removed.
	   */


	  StateNode.prototype.getStateNodeById = function (stateId) {
	    var resolvedStateId = isStateId(stateId) ? stateId.slice(STATE_IDENTIFIER.length) : stateId;

	    if (resolvedStateId === this.id) {
	      return this;
	    }

	    var stateNode = this.machine.idMap[resolvedStateId];

	    if (!stateNode) {
	      throw new Error("Child state node '#".concat(resolvedStateId, "' does not exist on machine '").concat(this.id, "'"));
	    }

	    return stateNode;
	  };
	  /**
	   * Returns the relative state node from the given `statePath`, or throws.
	   *
	   * @param statePath The string or string array relative path to the state node.
	   */


	  StateNode.prototype.getStateNodeByPath = function (statePath) {
	    if (typeof statePath === 'string' && isStateId(statePath)) {
	      try {
	        return this.getStateNodeById(statePath.slice(1));
	      } catch (e) {// try individual paths
	        // throw e;
	      }
	    }

	    var arrayStatePath = toStatePath(statePath, this.delimiter).slice();
	    var currentStateNode = this;

	    while (arrayStatePath.length) {
	      var key = arrayStatePath.shift();

	      if (!key.length) {
	        break;
	      }

	      currentStateNode = currentStateNode.getStateNode(key);
	    }

	    return currentStateNode;
	  };
	  /**
	   * Resolves a partial state value with its full representation in this machine.
	   *
	   * @param stateValue The partial state value to resolve.
	   */


	  StateNode.prototype.resolve = function (stateValue) {
	    var _a;

	    var _this = this;

	    if (!stateValue) {
	      return this.initialStateValue || EMPTY_OBJECT; // TODO: type-specific properties
	    }

	    switch (this.type) {
	      case 'parallel':
	        return mapValues(this.initialStateValue, function (subStateValue, subStateKey) {
	          return subStateValue ? _this.getStateNode(subStateKey).resolve(stateValue[subStateKey] || subStateValue) : EMPTY_OBJECT;
	        });

	      case 'compound':
	        if (isString$1(stateValue)) {
	          var subStateNode = this.getStateNode(stateValue);

	          if (subStateNode.type === 'parallel' || subStateNode.type === 'compound') {
	            return _a = {}, _a[stateValue] = subStateNode.initialStateValue, _a;
	          }

	          return stateValue;
	        }

	        if (!Object.keys(stateValue).length) {
	          return this.initialStateValue || {};
	        }

	        return mapValues(stateValue, function (subStateValue, subStateKey) {
	          return subStateValue ? _this.getStateNode(subStateKey).resolve(subStateValue) : EMPTY_OBJECT;
	        });

	      default:
	        return stateValue || EMPTY_OBJECT;
	    }
	  };

	  StateNode.prototype.getResolvedPath = function (stateIdentifier) {
	    if (isStateId(stateIdentifier)) {
	      var stateNode = this.machine.idMap[stateIdentifier.slice(STATE_IDENTIFIER.length)];

	      if (!stateNode) {
	        throw new Error("Unable to find state node '".concat(stateIdentifier, "'"));
	      }

	      return stateNode.path;
	    }

	    return toStatePath(stateIdentifier, this.delimiter);
	  };

	  Object.defineProperty(StateNode.prototype, "initialStateValue", {
	    get: function () {
	      var _a;

	      if (this.__cache.initialStateValue) {
	        return this.__cache.initialStateValue;
	      }

	      var initialStateValue;

	      if (this.type === 'parallel') {
	        initialStateValue = mapFilterValues(this.states, function (state) {
	          return state.initialStateValue || EMPTY_OBJECT;
	        }, function (stateNode) {
	          return !(stateNode.type === 'history');
	        });
	      } else if (this.initial !== undefined) {
	        if (!this.states[this.initial]) {
	          throw new Error("Initial state '".concat(this.initial, "' not found on '").concat(this.key, "'"));
	        }

	        initialStateValue = isLeafNode(this.states[this.initial]) ? this.initial : (_a = {}, _a[this.initial] = this.states[this.initial].initialStateValue, _a);
	      } else {
	        // The finite state value of a machine without child states is just an empty object
	        initialStateValue = {};
	      }

	      this.__cache.initialStateValue = initialStateValue;
	      return this.__cache.initialStateValue;
	    },
	    enumerable: false,
	    configurable: true
	  });

	  StateNode.prototype.getInitialState = function (stateValue, context) {
	    this._init(); // TODO: this should be in the constructor (see note in constructor)


	    var configuration = this.getStateNodes(stateValue);
	    return this.resolveTransition({
	      configuration: configuration,
	      entrySet: configuration,
	      exitSet: [],
	      transitions: [],
	      source: undefined,
	      actions: []
	    }, undefined, context !== null && context !== void 0 ? context : this.machine.context, undefined);
	  };

	  Object.defineProperty(StateNode.prototype, "initialState", {
	    /**
	     * The initial State instance, which includes all actions to be executed from
	     * entering the initial state.
	     */
	    get: function () {
	      var initialStateValue = this.initialStateValue;

	      if (!initialStateValue) {
	        throw new Error("Cannot retrieve initial state from simple state '".concat(this.id, "'."));
	      }

	      return this.getInitialState(initialStateValue);
	    },
	    enumerable: false,
	    configurable: true
	  });
	  Object.defineProperty(StateNode.prototype, "target", {
	    /**
	     * The target state value of the history state node, if it exists. This represents the
	     * default state value to transition to if no history value exists yet.
	     */
	    get: function () {
	      var target;

	      if (this.type === 'history') {
	        var historyConfig = this.config;

	        if (isString$1(historyConfig.target)) {
	          target = isStateId(historyConfig.target) ? pathToStateValue(this.machine.getStateNodeById(historyConfig.target).path.slice(this.path.length - 1)) : historyConfig.target;
	        } else {
	          target = historyConfig.target;
	        }
	      }

	      return target;
	    },
	    enumerable: false,
	    configurable: true
	  });
	  /**
	   * Returns the leaf nodes from a state path relative to this state node.
	   *
	   * @param relativeStateId The relative state path to retrieve the state nodes
	   * @param history The previous state to retrieve history
	   * @param resolve Whether state nodes should resolve to initial child state nodes
	   */

	  StateNode.prototype.getRelativeStateNodes = function (relativeStateId, historyValue, resolve) {
	    if (resolve === void 0) {
	      resolve = true;
	    }

	    return resolve ? relativeStateId.type === 'history' ? relativeStateId.resolveHistory(historyValue) : relativeStateId.initialStateNodes : [relativeStateId];
	  };

	  Object.defineProperty(StateNode.prototype, "initialStateNodes", {
	    get: function () {
	      var _this = this;

	      if (isLeafNode(this)) {
	        return [this];
	      } // Case when state node is compound but no initial state is defined


	      if (this.type === 'compound' && !this.initial) {

	        return [this];
	      }

	      var initialStateNodePaths = toStatePaths(this.initialStateValue);
	      return flatten(initialStateNodePaths.map(function (initialPath) {
	        return _this.getFromRelativePath(initialPath);
	      }));
	    },
	    enumerable: false,
	    configurable: true
	  });
	  /**
	   * Retrieves state nodes from a relative path to this state node.
	   *
	   * @param relativePath The relative path from this state node
	   * @param historyValue
	   */

	  StateNode.prototype.getFromRelativePath = function (relativePath) {
	    if (!relativePath.length) {
	      return [this];
	    }

	    var _a = __read$2(relativePath),
	        stateKey = _a[0],
	        childStatePath = _a.slice(1);

	    if (!this.states) {
	      throw new Error("Cannot retrieve subPath '".concat(stateKey, "' from node with no states"));
	    }

	    var childStateNode = this.getStateNode(stateKey);

	    if (childStateNode.type === 'history') {
	      return childStateNode.resolveHistory();
	    }

	    if (!this.states[stateKey]) {
	      throw new Error("Child state '".concat(stateKey, "' does not exist on '").concat(this.id, "'"));
	    }

	    return this.states[stateKey].getFromRelativePath(childStatePath);
	  };

	  StateNode.prototype.historyValue = function (relativeStateValue) {
	    if (!Object.keys(this.states).length) {
	      return undefined;
	    }

	    return {
	      current: relativeStateValue || this.initialStateValue,
	      states: mapFilterValues(this.states, function (stateNode, key) {
	        if (!relativeStateValue) {
	          return stateNode.historyValue();
	        }

	        var subStateValue = isString$1(relativeStateValue) ? undefined : relativeStateValue[key];
	        return stateNode.historyValue(subStateValue || stateNode.initialStateValue);
	      }, function (stateNode) {
	        return !stateNode.history;
	      })
	    };
	  };
	  /**
	   * Resolves to the historical value(s) of the parent state node,
	   * represented by state nodes.
	   *
	   * @param historyValue
	   */


	  StateNode.prototype.resolveHistory = function (historyValue) {
	    var _this = this;

	    if (this.type !== 'history') {
	      return [this];
	    }

	    var parent = this.parent;

	    if (!historyValue) {
	      var historyTarget = this.target;
	      return historyTarget ? flatten(toStatePaths(historyTarget).map(function (relativeChildPath) {
	        return parent.getFromRelativePath(relativeChildPath);
	      })) : parent.initialStateNodes;
	    }

	    var subHistoryValue = nestedPath(parent.path, 'states')(historyValue).current;

	    if (isString$1(subHistoryValue)) {
	      return [parent.getStateNode(subHistoryValue)];
	    }

	    return flatten(toStatePaths(subHistoryValue).map(function (subStatePath) {
	      return _this.history === 'deep' ? parent.getFromRelativePath(subStatePath) : [parent.states[subStatePath[0]]];
	    }));
	  };

	  Object.defineProperty(StateNode.prototype, "stateIds", {
	    /**
	     * All the state node IDs of this state node and its descendant state nodes.
	     */
	    get: function () {
	      var _this = this;

	      var childStateIds = flatten(Object.keys(this.states).map(function (stateKey) {
	        return _this.states[stateKey].stateIds;
	      }));
	      return [this.id].concat(childStateIds);
	    },
	    enumerable: false,
	    configurable: true
	  });
	  Object.defineProperty(StateNode.prototype, "events", {
	    /**
	     * All the event types accepted by this state node and its descendants.
	     */
	    get: function () {
	      var e_7, _a, e_8, _b;

	      if (this.__cache.events) {
	        return this.__cache.events;
	      }

	      var states = this.states;
	      var events = new Set(this.ownEvents);

	      if (states) {
	        try {
	          for (var _c = __values(Object.keys(states)), _d = _c.next(); !_d.done; _d = _c.next()) {
	            var stateId = _d.value;
	            var state = states[stateId];

	            if (state.states) {
	              try {
	                for (var _e = (e_8 = void 0, __values(state.events)), _f = _e.next(); !_f.done; _f = _e.next()) {
	                  var event_1 = _f.value;
	                  events.add("".concat(event_1));
	                }
	              } catch (e_8_1) {
	                e_8 = {
	                  error: e_8_1
	                };
	              } finally {
	                try {
	                  if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
	                } finally {
	                  if (e_8) throw e_8.error;
	                }
	              }
	            }
	          }
	        } catch (e_7_1) {
	          e_7 = {
	            error: e_7_1
	          };
	        } finally {
	          try {
	            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
	          } finally {
	            if (e_7) throw e_7.error;
	          }
	        }
	      }

	      return this.__cache.events = Array.from(events);
	    },
	    enumerable: false,
	    configurable: true
	  });
	  Object.defineProperty(StateNode.prototype, "ownEvents", {
	    /**
	     * All the events that have transitions directly from this state node.
	     *
	     * Excludes any inert events.
	     */
	    get: function () {
	      var events = new Set(this.transitions.filter(function (transition) {
	        return !(!transition.target && !transition.actions.length && transition.internal);
	      }).map(function (transition) {
	        return transition.eventType;
	      }));
	      return Array.from(events);
	    },
	    enumerable: false,
	    configurable: true
	  });

	  StateNode.prototype.resolveTarget = function (_target) {
	    var _this = this;

	    if (_target === undefined) {
	      // an undefined target signals that the state node should not transition from that state when receiving that event
	      return undefined;
	    }

	    return _target.map(function (target) {
	      if (!isString$1(target)) {
	        return target;
	      }

	      var isInternalTarget = target[0] === _this.delimiter; // If internal target is defined on machine,
	      // do not include machine key on target

	      if (isInternalTarget && !_this.parent) {
	        return _this.getStateNodeByPath(target.slice(1));
	      }

	      var resolvedTarget = isInternalTarget ? _this.key + target : target;

	      if (_this.parent) {
	        try {
	          var targetStateNode = _this.parent.getStateNodeByPath(resolvedTarget);

	          return targetStateNode;
	        } catch (err) {
	          throw new Error("Invalid transition definition for state node '".concat(_this.id, "':\n").concat(err.message));
	        }
	      } else {
	        return _this.getStateNodeByPath(resolvedTarget);
	      }
	    });
	  };

	  StateNode.prototype.formatTransition = function (transitionConfig) {
	    var _this = this;

	    var normalizedTarget = normalizeTarget(transitionConfig.target);
	    var internal = 'internal' in transitionConfig ? transitionConfig.internal : normalizedTarget ? normalizedTarget.some(function (_target) {
	      return isString$1(_target) && _target[0] === _this.delimiter;
	    }) : true;
	    var guards = this.machine.options.guards;
	    var target = this.resolveTarget(normalizedTarget);

	    var transition = __assign$4(__assign$4({}, transitionConfig), {
	      actions: toActionObjects(toArray(transitionConfig.actions)),
	      cond: toGuard(transitionConfig.cond, guards),
	      target: target,
	      source: this,
	      internal: internal,
	      eventType: transitionConfig.event,
	      toJSON: function () {
	        return __assign$4(__assign$4({}, transition), {
	          target: transition.target ? transition.target.map(function (t) {
	            return "#".concat(t.id);
	          }) : undefined,
	          source: "#".concat(_this.id)
	        });
	      }
	    });

	    return transition;
	  };

	  StateNode.prototype.formatTransitions = function () {
	    var e_9, _a;

	    var _this = this;

	    var onConfig;

	    if (!this.config.on) {
	      onConfig = [];
	    } else if (Array.isArray(this.config.on)) {
	      onConfig = this.config.on;
	    } else {
	      var _b = this.config.on,
	          _c = WILDCARD,
	          _d = _b[_c],
	          wildcardConfigs = _d === void 0 ? [] : _d,
	          strictTransitionConfigs_1 = __rest$1(_b, [typeof _c === "symbol" ? _c : _c + ""]);

	      onConfig = flatten(Object.keys(strictTransitionConfigs_1).map(function (key) {

	        var transitionConfigArray = toTransitionConfigArray(key, strictTransitionConfigs_1[key]);

	        return transitionConfigArray;
	      }).concat(toTransitionConfigArray(WILDCARD, wildcardConfigs)));
	    }

	    var eventlessConfig = this.config.always ? toTransitionConfigArray('', this.config.always) : [];
	    var doneConfig = this.config.onDone ? toTransitionConfigArray(String(done(this.id)), this.config.onDone) : [];

	    var invokeConfig = flatten(this.invoke.map(function (invokeDef) {
	      var settleTransitions = [];

	      if (invokeDef.onDone) {
	        settleTransitions.push.apply(settleTransitions, __spreadArray([], __read$2(toTransitionConfigArray(String(doneInvoke(invokeDef.id)), invokeDef.onDone)), false));
	      }

	      if (invokeDef.onError) {
	        settleTransitions.push.apply(settleTransitions, __spreadArray([], __read$2(toTransitionConfigArray(String(error(invokeDef.id)), invokeDef.onError)), false));
	      }

	      return settleTransitions;
	    }));
	    var delayedTransitions = this.after;
	    var formattedTransitions = flatten(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read$2(doneConfig), false), __read$2(invokeConfig), false), __read$2(onConfig), false), __read$2(eventlessConfig), false).map(function (transitionConfig) {
	      return toArray(transitionConfig).map(function (transition) {
	        return _this.formatTransition(transition);
	      });
	    }));

	    try {
	      for (var delayedTransitions_1 = __values(delayedTransitions), delayedTransitions_1_1 = delayedTransitions_1.next(); !delayedTransitions_1_1.done; delayedTransitions_1_1 = delayedTransitions_1.next()) {
	        var delayedTransition = delayedTransitions_1_1.value;
	        formattedTransitions.push(delayedTransition);
	      }
	    } catch (e_9_1) {
	      e_9 = {
	        error: e_9_1
	      };
	    } finally {
	      try {
	        if (delayedTransitions_1_1 && !delayedTransitions_1_1.done && (_a = delayedTransitions_1.return)) _a.call(delayedTransitions_1);
	      } finally {
	        if (e_9) throw e_9.error;
	      }
	    }

	    return formattedTransitions;
	  };

	  return StateNode;
	}();

	function createMachine(config, options) {
	  return new StateNode(config, options);
	}

	var assign$1 = assign$2;

	var __assign$3 = (this && this.__assign) || function () {
	    __assign$3 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$3.apply(this, arguments);
	};
	var __rest = (this && this.__rest) || function (s, e) {
	    var t = {};
	    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
	        t[p] = s[p];
	    if (s != null && typeof Object.getOwnPropertySymbols === "function")
	        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
	                t[p[i]] = s[p[i]];
	        }
	    return t;
	};
	var __read$1 = (this && this.__read) || function (o, n) {
	    var m = typeof Symbol === "function" && o[Symbol.iterator];
	    if (!m) return o;
	    var i = m.call(o), r, ar = [], e;
	    try {
	        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
	    }
	    catch (error) { e = { error: error }; }
	    finally {
	        try {
	            if (r && !r.done && (m = i["return"])) m.call(i);
	        }
	        finally { if (e) throw e.error; }
	    }
	    return ar;
	};
	function useIdleInterpreter(getMachine, options) {
	    var machine = useConstant(function () {
	        return typeof getMachine === 'function' ? getMachine() : getMachine;
	    });
	    var context = options.context, guards = options.guards, actions = options.actions, activities = options.activities, services = options.services, delays = options.delays; options.state; var interpreterOptions = __rest(options, ["context", "guards", "actions", "activities", "services", "delays", "state"]);
	    var service = useConstant(function () {
	        var machineConfig = {
	            context: context,
	            guards: guards,
	            actions: actions,
	            activities: activities,
	            services: services,
	            delays: delays
	        };
	        var machineWithConfig = machine.withConfig(machineConfig, function () { return (__assign$3(__assign$3({}, machine.context), context)); });
	        return interpret(machineWithConfig, interpreterOptions);
	    });
	    // Make sure options are kept updated when they change.
	    // This mutation assignment is safe because the service instance is only used
	    // in one place -- this hook's caller.
	    index$2(function () {
	        Object.assign(service.machine.options.actions, actions);
	        Object.assign(service.machine.options.guards, guards);
	        Object.assign(service.machine.options.activities, activities);
	        Object.assign(service.machine.options.services, services);
	        Object.assign(service.machine.options.delays, delays);
	    }, [actions, guards, activities, services, delays]);
	    return service;
	}
	function useInterpret(getMachine) {
	    var _a = [];
	    for (var _i = 1; _i < arguments.length; _i++) {
	        _a[_i - 1] = arguments[_i];
	    }
	    var _b = __read$1(_a, 2), _c = _b[0], options = _c === void 0 ? {} : _c, observerOrListener = _b[1];
	    var service = useIdleInterpreter(getMachine, options);
	    reactExports.useEffect(function () {
	        if (!observerOrListener) {
	            return;
	        }
	        var sub = service.subscribe(toObserver(observerOrListener));
	        return function () {
	            sub.unsubscribe();
	        };
	    }, [observerOrListener]);
	    reactExports.useEffect(function () {
	        var rehydratedState = options.state;
	        service.start(rehydratedState ? State.create(rehydratedState) : undefined);
	        return function () {
	            service.stop();
	            service.status = InterpreterStatus.NotStarted;
	        };
	    }, []);
	    return service;
	}

	var withSelector = {exports: {}};

	var useSyncExternalStoreWithSelector_production_min = {};

	var g$2=reactExports;function n$5(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var p$4="function"===typeof Object.is?Object.is:n$5,q$3=g$2.useSyncExternalStore,r$3=g$2.useRef,t$4=g$2.useEffect,u$5=g$2.useMemo,v$4=g$2.useDebugValue;
	useSyncExternalStoreWithSelector_production_min.useSyncExternalStoreWithSelector=function(a,b,e,l,h){var c=r$3(null);if(null===c.current){var f={hasValue:!1,value:null};c.current=f;}else f=c.current;c=u$5(function(){function a(a){if(!c){c=!0;d=a;a=l(a);if(void 0!==h&&f.hasValue){var b=f.value;if(h(b,a))return k=b}return k=a}b=k;if(p$4(d,a))return b;var e=l(a);if(void 0!==h&&h(b,e))return b;d=a;return k=e}var c=!1,d,k,m=void 0===e?null:e;return [function(){return a(b())},null===m?void 0:function(){return a(m())}]},[b,e,l,h]);var d=q$3(a,c[0],c[1]);
	t$4(function(){f.hasValue=!0;f.value=d;},[d]);v$4(d);return d};

	{
	  withSelector.exports = useSyncExternalStoreWithSelector_production_min;
	}

	var withSelectorExports = withSelector.exports;

	var __read = (this && this.__read) || function (o, n) {
	    var m = typeof Symbol === "function" && o[Symbol.iterator];
	    if (!m) return o;
	    var i = m.call(o), r, ar = [], e;
	    try {
	        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
	    }
	    catch (error) { e = { error: error }; }
	    finally {
	        try {
	            if (r && !r.done && (m = i["return"])) m.call(i);
	        }
	        finally { if (e) throw e.error; }
	    }
	    return ar;
	};
	function identity(a) {
	    return a;
	}
	function useMachine(getMachine) {
	    var _a = [];
	    for (var _i = 1; _i < arguments.length; _i++) {
	        _a[_i - 1] = arguments[_i];
	    }
	    var _b = __read(_a, 1), _c = _b[0], options = _c === void 0 ? {} : _c;
	    // using `useIdleInterpreter` allows us to subscribe to the service *before* we start it
	    // so we don't miss any notifications
	    var service = useIdleInterpreter(getMachine, options);
	    var getSnapshot = reactExports.useCallback(function () {
	        if (service.status === InterpreterStatus.NotStarted) {
	            return (options.state
	                ? State.create(options.state)
	                : service.machine.initialState);
	        }
	        return service.state;
	    }, [service]);
	    var isEqual = reactExports.useCallback(function (prevState, nextState) {
	        if (service.status === InterpreterStatus.NotStarted) {
	            return true;
	        }
	        // Only change the current state if:
	        // - the incoming state is the "live" initial state (since it might have new actors)
	        // - OR the incoming state actually changed.
	        //
	        // The "live" initial state will have .changed === undefined.
	        var initialStateChanged = nextState.changed === undefined &&
	            (Object.keys(nextState.children).length > 0 ||
	                typeof prevState.changed === 'boolean');
	        return !(nextState.changed || initialStateChanged);
	    }, [service]);
	    var subscribe = reactExports.useCallback(function (handleStoreChange) {
	        var unsubscribe = service.subscribe(handleStoreChange).unsubscribe;
	        return unsubscribe;
	    }, [service]);
	    var storeSnapshot = withSelectorExports.useSyncExternalStoreWithSelector(subscribe, getSnapshot, getSnapshot, identity, isEqual);
	    reactExports.useEffect(function () {
	        var rehydratedState = options.state;
	        service.start(rehydratedState ? State.create(rehydratedState) : undefined);
	        return function () {
	            service.stop();
	            service.status = InterpreterStatus.NotStarted;
	        };
	    }, []);
	    return [storeSnapshot, service.send, service];
	}

	(this && this.__read) || function (o, n) {
	    var m = typeof Symbol === "function" && o[Symbol.iterator];
	    if (!m) return o;
	    var i = m.call(o), r, ar = [], e;
	    try {
	        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
	    }
	    catch (error) { e = { error: error }; }
	    finally {
	        try {
	            if (r && !r.done && (m = i["return"])) m.call(i);
	        }
	        finally { if (e) throw e.error; }
	    }
	    return ar;
	};
	(this && this.__values) || function(o) {
	    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
	    if (m) return m.call(o);
	    if (o && typeof o.length === "number") return {
	        next: function () {
	            if (o && i >= o.length) o = void 0;
	            return { value: o && o[i++], done: !o };
	        }
	    };
	    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
	};
	function getServiceSnapshot(service) {
	    return service.status !== 0 ? service.state : service.machine.initialState;
	}

	function isService(actor) {
	    return 'state' in actor && 'machine' in actor;
	}
	var defaultCompare = function (a, b) { return a === b; };
	var defaultGetSnapshot = function (a) {
	    return isService(a)
	        ? getServiceSnapshot(a)
	        : isActorWithState(a)
	            ? a.state
	            : undefined;
	};
	function useSelector$1(actor, selector, compare, getSnapshot) {
	    if (compare === void 0) { compare = defaultCompare; }
	    if (getSnapshot === void 0) { getSnapshot = defaultGetSnapshot; }
	    var subscribe = reactExports.useCallback(function (handleStoreChange) {
	        var unsubscribe = actor.subscribe(handleStoreChange).unsubscribe;
	        return unsubscribe;
	    }, [actor]);
	    var boundGetSnapshot = reactExports.useCallback(function () { return getSnapshot(actor); }, [
	        actor,
	        getSnapshot
	    ]);
	    var selectedSnapshot = withSelectorExports.useSyncExternalStoreWithSelector(subscribe, boundGetSnapshot, boundGetSnapshot, selector, compare);
	    return selectedSnapshot;
	}

	class ErrorBoundary extends React$2.Component


	 {
	    constructor(props) {
	        super(props);
	        this.state = { hasError: false };
	    }

	    static getDerivedStateFromError(error) {
	        return { hasError: true };
	    }

	    componentDidCatch(error, errorInfo) {
	        console.error(error, errorInfo);
	    }

	    render() {
	        if (this.state.hasError) {
	            return React$2.createElement('h1', null, "Something went wrong."  );
	        }

	        return this.props.children;
	    }
	}

	let vanillaClient;

	function getVanillaClient() {
	    if (!vanillaClient) {
	        const url = sitemap.public.apiV1.trpc().toString();

	        vanillaClient = createTRPCProxyClient({
	            links: [
	                httpBatchLink({
	                    url,
	                    fetch(url, options) {
	                        return fetch(url, {
	                            ...options,
	                            credentials: "include",
	                        });
	                    },
	                    maxURLLength: 2083,
	                }),
	            ],
	        });
	    }

	    return vanillaClient;
	}

	async function submitPostReport(context) {
	    const response = await axios$1.post(
	        sitemap.public.apiV1.reporting.reportPost().toString(),
	        {
	            postId: context.postId ,
	            // TODO: actually make sure this is filled in
	            reportingReason: context.reportingReason ,
	            additionalDetails: context.additionalDetails,
	        }
	    );

	    if (response.status >= 200 && response.status <= 400) {
	        return Promise.resolve();
	    } else {
	        throw new Error(response.statusText);
	    }
	}

	async function submitProjectReport(context) {
	    if (!context.projectId) {
	        throw new Error("project id not set");
	    }

	    if (!context.reportingReason) {
	        throw new Error("reporting reason not set");
	    }

	    const vanillaClient = getVanillaClient();

	    await vanillaClient.reporting.reportProject.mutate({
	        additionalDetails: context.additionalDetails,
	        projectId: context.projectId,
	        reportingReason: context.reportingReason,
	    });
	}

	async function submitCommentReport(context) {
	    if (!context.commentId) {
	        throw new Error("comment id not set");
	    }

	    if (!context.reportingReason) {
	        throw new Error("reporting reason not set");
	    }

	    const vanillaClient = getVanillaClient();

	    await vanillaClient.reporting.reportComment.mutate({
	        additionalDetails: context.additionalDetails,
	        commentId: context.commentId,
	        reportingReason: context.reportingReason,
	    });
	}

	async function submitAskReport(context) {
	    if (!context.askId) {
	        throw new Error("ask id not set");
	    }

	    if (!context.reportingReason) {
	        throw new Error("reporting reason not set");
	    }

	    const vanillaClient = getVanillaClient();

	    await vanillaClient.reporting.reportAsk.mutate({
	        additionalDetails: context.additionalDetails,
	        askId: context.askId,
	        reportingReason: context.reportingReason,
	    });
	}

	async function submitArtistAlleyReport(context) {
	    if (!context.artistAlleyListingId) {
	        throw new Error("listing id not set");
	    }

	    if (!context.reportingReason) {
	        throw new Error("reporting reason not set");
	    }

	    const vanillaClient = getVanillaClient();

	    await vanillaClient.reporting.reportArtistAlleyListing.mutate({
	        additionalDetails: context.additionalDetails,
	        artistAlleyListingId: context.artistAlleyListingId,
	        reportingReason: context.reportingReason,
	    });
	}

	const reportingUIMachine = createMachine



	(
	    {
	        initial: "closed",
	        strict: true,
	        context: {},
	        states: {
	            closed: {
	                entry: assign$1(() => {
	                    return {};
	                }),
	                on: {
	                    START_REPORT: {
	                        target: "editingReport",
	                        actions: assign$1((_context, event) => {
	                            return {
	                                postId: event.postId,
	                                projectId: event.projectId,
	                                commentId: event.commentId,
	                                askId: event.askId,
	                                artistAlleyListingId:
	                                    event.artistAlleyListingId,
	                            };
	                        }),
	                    },
	                },
	            },
	            editingReport: {
	                on: {
	                    CLOSE: { target: "closed" },
	                    SUBMIT: {
	                        target: "submitting",
	                        actions: assign$1((context, event) => {
	                            return {
	                                ...context,
	                                reportingReason: event.reportingReason,
	                                additionalDetails: event.additionalDetails,
	                            };
	                        }),
	                    },
	                },
	            },
	            submitting: {
	                invoke: {
	                    src: "submit",
	                    onDone: {
	                        target: "acknowledging",
	                    },
	                    onError: {
	                        target: "displayingError",
	                    },
	                },
	            },
	            acknowledging: {
	                on: {
	                    ACKNOWLEDGE: {
	                        target: "closed",
	                    },
	                    CLOSE: {
	                        target: "closed",
	                    },
	                },
	            },
	            displayingError: {
	                on: {
	                    CLOSE: {
	                        target: "closed",
	                    },
	                },
	            },
	        },
	    },
	    {
	        services: {
	            submit: async (context) => {
	                if (context.postId) {
	                    return submitPostReport(context);
	                } else if (context.projectId) {
	                    return submitProjectReport(context);
	                } else if (context.commentId) {
	                    return submitCommentReport(context);
	                } else if (context.askId) {
	                    return submitAskReport(context);
	                } else if (context.artistAlleyListingId) {
	                    return submitArtistAlleyReport(context);
	                } else {
	                    // todo: rollbar
	                    throw new Error("submit with invalid state shape");
	                }
	            },
	        },
	    }
	);

	const ReportingUIContext = reactExports.createContext(
	    {} 
	);

	var isCheckBoxInput = (element) => element.type === 'checkbox';

	var isDateObject = (value) => value instanceof Date;

	var isNullOrUndefined = (value) => value == null;

	const isObjectType = (value) => typeof value === 'object';
	var isObject$1 = (value) => !isNullOrUndefined(value) &&
	    !Array.isArray(value) &&
	    isObjectType(value) &&
	    !isDateObject(value);

	var getEventValue = (event) => isObject$1(event) && event.target
	    ? isCheckBoxInput(event.target)
	        ? event.target.checked
	        : event.target.value
	    : event;

	var getNodeParentName = (name) => name.substring(0, name.search(/.\d/)) || name;

	var isNameInFieldArray = (names, name) => [...names].some((current) => getNodeParentName(name) === current);

	var compact = (value) => value.filter(Boolean);

	var isUndefined = (val) => val === undefined;

	var get$4 = (obj, path, defaultValue) => {
	    if (!path || !isObject$1(obj)) {
	        return defaultValue;
	    }
	    const result = compact(path.split(/[,[\].]+?/)).reduce((result, key) => isNullOrUndefined(result) ? result : result[key], obj);
	    return isUndefined(result) || result === obj
	        ? isUndefined(obj[path])
	            ? defaultValue
	            : obj[path]
	        : result;
	};

	const EVENTS = {
	    BLUR: 'blur',
	    FOCUS_OUT: 'focusout',
	    CHANGE: 'change',
	};
	const VALIDATION_MODE = {
	    onBlur: 'onBlur',
	    onChange: 'onChange',
	    onSubmit: 'onSubmit',
	    onTouched: 'onTouched',
	    all: 'all',
	};
	const INPUT_VALIDATION_RULES = {
	    max: 'max',
	    min: 'min',
	    maxLength: 'maxLength',
	    minLength: 'minLength',
	    pattern: 'pattern',
	    required: 'required',
	    validate: 'validate',
	};

	var omit = (source, key) => {
	    const copy = Object.assign({}, source);
	    delete copy[key];
	    return copy;
	};

	const HookFormContext = React$2.createContext(null);
	const useFormContext = () => React$2.useContext(HookFormContext);

	var getProxyFormState = (formState, _proxyFormState, localProxyFormState, isRoot = true) => {
	    const result = {};
	    for (const key in formState) {
	        Object.defineProperty(result, key, {
	            get: () => {
	                const _key = key;
	                if (_proxyFormState[_key] !== VALIDATION_MODE.all) {
	                    _proxyFormState[_key] = !isRoot || VALIDATION_MODE.all;
	                }
	                localProxyFormState && (localProxyFormState[_key] = true);
	                return formState[_key];
	            },
	        });
	    }
	    return result;
	};

	var isEmptyObject = (value) => isObject$1(value) && !Object.keys(value).length;

	var shouldRenderFormState = (formStateData, _proxyFormState, isRoot) => {
	    const formState = omit(formStateData, 'name');
	    return (isEmptyObject(formState) ||
	        Object.keys(formState).length >= Object.keys(_proxyFormState).length ||
	        Object.keys(formState).find((key) => _proxyFormState[key] ===
	            (!isRoot || VALIDATION_MODE.all)));
	};

	var convertToArrayPayload = (value) => (Array.isArray(value) ? value : [value]);

	var shouldSubscribeByName = (name, signalName, exact) => exact && signalName
	    ? name === signalName
	    : !name ||
	        !signalName ||
	        name === signalName ||
	        convertToArrayPayload(name).some((currentName) => currentName &&
	            (currentName.startsWith(signalName) ||
	                signalName.startsWith(currentName)));

	function useSubscribe(props) {
	    const _props = React$2.useRef(props);
	    _props.current = props;
	    React$2.useEffect(() => {
	        const tearDown = (subscription) => {
	            if (subscription) {
	                subscription.unsubscribe();
	            }
	        };
	        const subscription = !props.disabled &&
	            _props.current.subject.subscribe({
	                next: _props.current.callback,
	            });
	        return () => tearDown(subscription);
	    }, [props.disabled]);
	}

	function useFormState(props) {
	    const methods = useFormContext();
	    const { control = methods.control, disabled, name, exact } = props || {};
	    const [formState, updateFormState] = React$2.useState(control._formState);
	    const _localProxyFormState = React$2.useRef({
	        isDirty: false,
	        dirtyFields: false,
	        touchedFields: false,
	        isValidating: false,
	        isValid: false,
	        errors: false,
	    });
	    const _name = React$2.useRef(name);
	    const _mounted = React$2.useRef(true);
	    _name.current = name;
	    const callback = React$2.useCallback((value) => _mounted.current &&
	        shouldSubscribeByName(_name.current, value.name, exact) &&
	        shouldRenderFormState(value, _localProxyFormState.current) &&
	        updateFormState(Object.assign(Object.assign({}, control._formState), value)), [control, exact]);
	    useSubscribe({
	        disabled,
	        callback,
	        subject: control._subjects.state,
	    });
	    React$2.useEffect(() => () => {
	        _mounted.current = false;
	    }, []);
	    return getProxyFormState(formState, control._proxyFormState, _localProxyFormState.current, false);
	}

	var isString = (value) => typeof value === 'string';

	var generateWatchOutput = (names, _names, formValues, isGlobal) => {
	    const isArray = Array.isArray(names);
	    if (isString(names)) {
	        isGlobal && _names.watch.add(names);
	        return get$4(formValues, names);
	    }
	    if (isArray) {
	        return names.map((fieldName) => (isGlobal && _names.watch.add(fieldName),
	            get$4(formValues, fieldName)));
	    }
	    isGlobal && (_names.watchAll = true);
	    return formValues;
	};

	var isFunction = (value) => typeof value === 'function';

	var objectHasFunction = (data) => {
	    for (const key in data) {
	        if (isFunction(data[key])) {
	            return true;
	        }
	    }
	    return false;
	};

	function useWatch(props) {
	    const methods = useFormContext();
	    const { control = methods.control, name, defaultValue, disabled, exact, } = props || {};
	    const _name = React$2.useRef(name);
	    _name.current = name;
	    const callback = React$2.useCallback((formState) => {
	        if (shouldSubscribeByName(_name.current, formState.name, exact)) {
	            const fieldValues = generateWatchOutput(_name.current, control._names, formState.values || control._formValues);
	            updateValue(isUndefined(_name.current) ||
	                (isObject$1(fieldValues) && !objectHasFunction(fieldValues))
	                ? Object.assign({}, fieldValues) : Array.isArray(fieldValues)
	                ? [...fieldValues]
	                : isUndefined(fieldValues)
	                    ? defaultValue
	                    : fieldValues);
	        }
	    }, [control, exact, defaultValue]);
	    useSubscribe({
	        disabled,
	        subject: control._subjects.watch,
	        callback,
	    });
	    const [value, updateValue] = React$2.useState(isUndefined(defaultValue)
	        ? control._getWatch(name)
	        : defaultValue);
	    React$2.useEffect(() => {
	        control._removeUnmounted();
	    });
	    return value;
	}

	function useController(props) {
	    const methods = useFormContext();
	    const { name, control = methods.control, shouldUnregister } = props;
	    const isArrayField = isNameInFieldArray(control._names.array, name);
	    const value = useWatch({
	        control,
	        name,
	        defaultValue: get$4(control._formValues, name, get$4(control._defaultValues, name, props.defaultValue)),
	        exact: !isArrayField,
	    });
	    const formState = useFormState({
	        control,
	        name,
	    });
	    const _registerProps = React$2.useRef(control.register(name, Object.assign(Object.assign({}, props.rules), { value })));
	    React$2.useEffect(() => {
	        const updateMounted = (name, value) => {
	            const field = get$4(control._fields, name);
	            if (field) {
	                field._f.mount = value;
	            }
	        };
	        updateMounted(name, true);
	        return () => {
	            const _shouldUnregisterField = control._options.shouldUnregister || shouldUnregister;
	            (isArrayField
	                ? _shouldUnregisterField && !control._stateFlags.action
	                : _shouldUnregisterField)
	                ? control.unregister(name)
	                : updateMounted(name, false);
	        };
	    }, [name, control, isArrayField, shouldUnregister]);
	    return {
	        field: {
	            name,
	            value,
	            onChange: React$2.useCallback((event) => {
	                _registerProps.current.onChange({
	                    target: {
	                        value: getEventValue(event),
	                        name: name,
	                    },
	                    type: EVENTS.CHANGE,
	                });
	            }, [name]),
	            onBlur: React$2.useCallback(() => {
	                _registerProps.current.onBlur({
	                    target: {
	                        value: get$4(control._formValues, name),
	                        name: name,
	                    },
	                    type: EVENTS.BLUR,
	                });
	            }, [name, control]),
	            ref: React$2.useCallback((elm) => {
	                const field = get$4(control._fields, name);
	                if (elm && field && elm.focus) {
	                    field._f.ref = {
	                        focus: () => elm.focus(),
	                        setCustomValidity: (message) => elm.setCustomValidity(message),
	                        reportValidity: () => elm.reportValidity(),
	                    };
	                }
	            }, [name, control._fields]),
	        },
	        formState,
	        fieldState: control.getFieldState(name, formState),
	    };
	}

	const Controller = (props) => props.render(useController(props));

	var appendErrors = (name, validateAllFieldCriteria, errors, type, message) => validateAllFieldCriteria
	    ? Object.assign(Object.assign({}, errors[name]), { types: Object.assign(Object.assign({}, (errors[name] && errors[name].types ? errors[name].types : {})), { [type]: message || true }) }) : {};

	var isKey = (value) => /^\w*$/.test(value);

	var stringToPath = (input) => compact(input.replace(/["|']|\]/g, '').split(/\.|\[/));

	function set$1(object, path, value) {
	    let index = -1;
	    const tempPath = isKey(path) ? [path] : stringToPath(path);
	    const length = tempPath.length;
	    const lastIndex = length - 1;
	    while (++index < length) {
	        const key = tempPath[index];
	        let newValue = value;
	        if (index !== lastIndex) {
	            const objValue = object[key];
	            newValue =
	                isObject$1(objValue) || Array.isArray(objValue)
	                    ? objValue
	                    : !isNaN(+tempPath[index + 1])
	                        ? []
	                        : {};
	        }
	        object[key] = newValue;
	        object = object[key];
	    }
	    return object;
	}

	const focusFieldBy = (fields, callback, fieldsNames) => {
	    for (const key of fieldsNames || Object.keys(fields)) {
	        const field = get$4(fields, key);
	        if (field) {
	            const _f = field._f;
	            const current = omit(field, '_f');
	            if (_f && callback(_f.name)) {
	                if (_f.ref.focus && isUndefined(_f.ref.focus())) {
	                    break;
	                }
	                else if (_f.refs) {
	                    _f.refs[0].focus();
	                    break;
	                }
	            }
	            else if (isObject$1(current)) {
	                focusFieldBy(current, callback);
	            }
	        }
	    }
	};

	var isWatched = (name, _names, isBlurEvent) => !isBlurEvent &&
	    (_names.watchAll ||
	        _names.watch.has(name) ||
	        [..._names.watch].some((watchName) => name.startsWith(watchName) &&
	            /^\.\w+/.test(name.slice(watchName.length))));

	function cloneObject(data) {
	    let copy;
	    const isArray = Array.isArray(data);
	    if (data instanceof Date) {
	        copy = new Date(data);
	    }
	    else if (data instanceof Set) {
	        copy = new Set(data);
	    }
	    else if (isArray || isObject$1(data)) {
	        copy = isArray ? [] : {};
	        for (const key in data) {
	            if (isFunction(data[key])) {
	                copy = data;
	                break;
	            }
	            copy[key] = cloneObject(data[key]);
	        }
	    }
	    else {
	        return data;
	    }
	    return copy;
	}

	function createSubject() {
	    let _observers = [];
	    const next = (value) => {
	        for (const observer of _observers) {
	            observer.next(value);
	        }
	    };
	    const subscribe = (observer) => {
	        _observers.push(observer);
	        return {
	            unsubscribe: () => {
	                _observers = _observers.filter((o) => o !== observer);
	            },
	        };
	    };
	    const unsubscribe = () => {
	        _observers = [];
	    };
	    return {
	        get observers() {
	            return _observers;
	        },
	        next,
	        subscribe,
	        unsubscribe,
	    };
	}

	var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);

	function deepEqual$1(object1, object2) {
	    if (isPrimitive(object1) || isPrimitive(object2)) {
	        return object1 === object2;
	    }
	    if (isDateObject(object1) && isDateObject(object2)) {
	        return object1.getTime() === object2.getTime();
	    }
	    const keys1 = Object.keys(object1);
	    const keys2 = Object.keys(object2);
	    if (keys1.length !== keys2.length) {
	        return false;
	    }
	    for (const key of keys1) {
	        const val1 = object1[key];
	        if (!keys2.includes(key)) {
	            return false;
	        }
	        if (key !== 'ref') {
	            const val2 = object2[key];
	            if ((isDateObject(val1) && isDateObject(val2)) ||
	                (isObject$1(val1) && isObject$1(val2)) ||
	                (Array.isArray(val1) && Array.isArray(val2))
	                ? !deepEqual$1(val1, val2)
	                : val1 !== val2) {
	                return false;
	            }
	        }
	    }
	    return true;
	}

	var getValidationModes = (mode) => ({
	    isOnSubmit: !mode || mode === VALIDATION_MODE.onSubmit,
	    isOnBlur: mode === VALIDATION_MODE.onBlur,
	    isOnChange: mode === VALIDATION_MODE.onChange,
	    isOnAll: mode === VALIDATION_MODE.all,
	    isOnTouch: mode === VALIDATION_MODE.onTouched,
	});

	var isBoolean$1 = (value) => typeof value === 'boolean';

	var isFileInput = (element) => element.type === 'file';

	var isHTMLElement = (value) => value instanceof HTMLElement;

	var isMultipleSelect = (element) => element.type === `select-multiple`;

	var isRadioInput = (element) => element.type === 'radio';

	var isRadioOrCheckbox = (ref) => isRadioInput(ref) || isCheckBoxInput(ref);

	var isWeb = typeof window !== 'undefined' &&
	    typeof window.HTMLElement !== 'undefined' &&
	    typeof document !== 'undefined';

	var live = (ref) => isHTMLElement(ref) && ref.isConnected;

	function baseGet(object, updatePath) {
	    const length = updatePath.slice(0, -1).length;
	    let index = 0;
	    while (index < length) {
	        object = isUndefined(object) ? index++ : object[updatePath[index++]];
	    }
	    return object;
	}
	function unset(object, path) {
	    const updatePath = isKey(path) ? [path] : stringToPath(path);
	    const childObject = updatePath.length == 1 ? object : baseGet(object, updatePath);
	    const key = updatePath[updatePath.length - 1];
	    let previousObjRef;
	    if (childObject) {
	        delete childObject[key];
	    }
	    for (let k = 0; k < updatePath.slice(0, -1).length; k++) {
	        let index = -1;
	        let objectRef;
	        const currentPaths = updatePath.slice(0, -(k + 1));
	        const currentPathsLength = currentPaths.length - 1;
	        if (k > 0) {
	            previousObjRef = object;
	        }
	        while (++index < currentPaths.length) {
	            const item = currentPaths[index];
	            objectRef = objectRef ? objectRef[item] : object[item];
	            if (currentPathsLength === index &&
	                ((isObject$1(objectRef) && isEmptyObject(objectRef)) ||
	                    (Array.isArray(objectRef) &&
	                        !objectRef.filter((data) => (isObject$1(data) && !isEmptyObject(data)) || isBoolean$1(data)).length))) {
	                previousObjRef ? delete previousObjRef[item] : delete object[item];
	            }
	            previousObjRef = objectRef;
	        }
	    }
	    return object;
	}

	function markFieldsDirty(data, fields = {}) {
	    const isParentNodeArray = Array.isArray(data);
	    if (isObject$1(data) || isParentNodeArray) {
	        for (const key in data) {
	            if (Array.isArray(data[key]) ||
	                (isObject$1(data[key]) && !objectHasFunction(data[key]))) {
	                fields[key] = Array.isArray(data[key]) ? [] : {};
	                markFieldsDirty(data[key], fields[key]);
	            }
	            else if (!isNullOrUndefined(data[key])) {
	                fields[key] = true;
	            }
	        }
	    }
	    return fields;
	}
	function getDirtyFieldsFromDefaultValues(data, formValues, dirtyFieldsFromValues) {
	    const isParentNodeArray = Array.isArray(data);
	    if (isObject$1(data) || isParentNodeArray) {
	        for (const key in data) {
	            if (Array.isArray(data[key]) ||
	                (isObject$1(data[key]) && !objectHasFunction(data[key]))) {
	                if (isUndefined(formValues) ||
	                    isPrimitive(dirtyFieldsFromValues[key])) {
	                    dirtyFieldsFromValues[key] = Array.isArray(data[key])
	                        ? markFieldsDirty(data[key], [])
	                        : Object.assign({}, markFieldsDirty(data[key]));
	                }
	                else {
	                    getDirtyFieldsFromDefaultValues(data[key], isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key]);
	                }
	            }
	            else {
	                dirtyFieldsFromValues[key] = !deepEqual$1(data[key], formValues[key]);
	            }
	        }
	    }
	    return dirtyFieldsFromValues;
	}
	var getDirtyFields = (defaultValues, formValues) => getDirtyFieldsFromDefaultValues(defaultValues, formValues, markFieldsDirty(formValues));

	const defaultResult = {
	    value: false,
	    isValid: false,
	};
	const validResult = { value: true, isValid: true };
	var getCheckboxValue = (options) => {
	    if (Array.isArray(options)) {
	        if (options.length > 1) {
	            const values = options
	                .filter((option) => option && option.checked && !option.disabled)
	                .map((option) => option.value);
	            return { value: values, isValid: !!values.length };
	        }
	        return options[0].checked && !options[0].disabled
	            ? // @ts-expect-error expected to work in the browser
	                options[0].attributes && !isUndefined(options[0].attributes.value)
	                    ? isUndefined(options[0].value) || options[0].value === ''
	                        ? validResult
	                        : { value: options[0].value, isValid: true }
	                    : validResult
	            : defaultResult;
	    }
	    return defaultResult;
	};

	var getFieldValueAs = (value, { valueAsNumber, valueAsDate, setValueAs }) => isUndefined(value)
	    ? value
	    : valueAsNumber
	        ? value === ''
	            ? NaN
	            : +value
	        : valueAsDate && isString(value)
	            ? new Date(value)
	            : setValueAs
	                ? setValueAs(value)
	                : value;

	const defaultReturn = {
	    isValid: false,
	    value: null,
	};
	var getRadioValue = (options) => Array.isArray(options)
	    ? options.reduce((previous, option) => option && option.checked && !option.disabled
	        ? {
	            isValid: true,
	            value: option.value,
	        }
	        : previous, defaultReturn)
	    : defaultReturn;

	function getFieldValue(_f) {
	    const ref = _f.ref;
	    if (_f.refs ? _f.refs.every((ref) => ref.disabled) : ref.disabled) {
	        return;
	    }
	    if (isFileInput(ref)) {
	        return ref.files;
	    }
	    if (isRadioInput(ref)) {
	        return getRadioValue(_f.refs).value;
	    }
	    if (isMultipleSelect(ref)) {
	        return [...ref.selectedOptions].map(({ value }) => value);
	    }
	    if (isCheckBoxInput(ref)) {
	        return getCheckboxValue(_f.refs).value;
	    }
	    return getFieldValueAs(isUndefined(ref.value) ? _f.ref.value : ref.value, _f);
	}

	var getResolverOptions = (fieldsNames, _fields, criteriaMode, shouldUseNativeValidation) => {
	    const fields = {};
	    for (const name of fieldsNames) {
	        const field = get$4(_fields, name);
	        field && set$1(fields, name, field._f);
	    }
	    return {
	        criteriaMode,
	        names: [...fieldsNames],
	        fields,
	        shouldUseNativeValidation,
	    };
	};

	var isRegex = (value) => value instanceof RegExp;

	var getRuleValue = (rule) => isUndefined(rule)
	    ? undefined
	    : isRegex(rule)
	        ? rule.source
	        : isObject$1(rule)
	            ? isRegex(rule.value)
	                ? rule.value.source
	                : rule.value
	            : rule;

	var hasValidation = (options) => options.mount &&
	    (options.required ||
	        options.min ||
	        options.max ||
	        options.maxLength ||
	        options.minLength ||
	        options.pattern ||
	        options.validate);

	function schemaErrorLookup(errors, _fields, name) {
	    const error = get$4(errors, name);
	    if (error || isKey(name)) {
	        return {
	            error,
	            name,
	        };
	    }
	    const names = name.split('.');
	    while (names.length) {
	        const fieldName = names.join('.');
	        const field = get$4(_fields, fieldName);
	        const foundError = get$4(errors, fieldName);
	        if (field && !Array.isArray(field) && name !== fieldName) {
	            return { name };
	        }
	        if (foundError && foundError.type) {
	            return {
	                name: fieldName,
	                error: foundError,
	            };
	        }
	        names.pop();
	    }
	    return {
	        name,
	    };
	}

	var skipValidation = (isBlurEvent, isTouched, isSubmitted, reValidateMode, mode) => {
	    if (mode.isOnAll) {
	        return false;
	    }
	    else if (!isSubmitted && mode.isOnTouch) {
	        return !(isTouched || isBlurEvent);
	    }
	    else if (isSubmitted ? reValidateMode.isOnBlur : mode.isOnBlur) {
	        return !isBlurEvent;
	    }
	    else if (isSubmitted ? reValidateMode.isOnChange : mode.isOnChange) {
	        return isBlurEvent;
	    }
	    return true;
	};

	var unsetEmptyArray = (ref, name) => !compact(get$4(ref, name)).length && unset(ref, name);

	var isMessage = (value) => isString(value) || React$2.isValidElement(value);

	function getValidateError(result, ref, type = 'validate') {
	    if (isMessage(result) ||
	        (Array.isArray(result) && result.every(isMessage)) ||
	        (isBoolean$1(result) && !result)) {
	        return {
	            type,
	            message: isMessage(result) ? result : '',
	            ref,
	        };
	    }
	}

	var getValueAndMessage = (validationData) => isObject$1(validationData) && !isRegex(validationData)
	    ? validationData
	    : {
	        value: validationData,
	        message: '',
	    };

	var validateField = async (field, inputValue, validateAllFieldCriteria, shouldUseNativeValidation) => {
	    const { ref, refs, required, maxLength, minLength, min, max, pattern, validate, name, valueAsNumber, mount, disabled, } = field._f;
	    if (!mount || disabled) {
	        return {};
	    }
	    const inputRef = refs ? refs[0] : ref;
	    const setCustomValidity = (message) => {
	        if (shouldUseNativeValidation && inputRef.reportValidity) {
	            inputRef.setCustomValidity(isBoolean$1(message) ? '' : message || ' ');
	            inputRef.reportValidity();
	        }
	    };
	    const error = {};
	    const isRadio = isRadioInput(ref);
	    const isCheckBox = isCheckBoxInput(ref);
	    const isRadioOrCheckbox = isRadio || isCheckBox;
	    const isEmpty = ((valueAsNumber || isFileInput(ref)) && !ref.value) ||
	        inputValue === '' ||
	        (Array.isArray(inputValue) && !inputValue.length);
	    const appendErrorsCurry = appendErrors.bind(null, name, validateAllFieldCriteria, error);
	    const getMinMaxMessage = (exceedMax, maxLengthMessage, minLengthMessage, maxType = INPUT_VALIDATION_RULES.maxLength, minType = INPUT_VALIDATION_RULES.minLength) => {
	        const message = exceedMax ? maxLengthMessage : minLengthMessage;
	        error[name] = Object.assign({ type: exceedMax ? maxType : minType, message,
	            ref }, appendErrorsCurry(exceedMax ? maxType : minType, message));
	    };
	    if (required &&
	        ((!isRadioOrCheckbox && (isEmpty || isNullOrUndefined(inputValue))) ||
	            (isBoolean$1(inputValue) && !inputValue) ||
	            (isCheckBox && !getCheckboxValue(refs).isValid) ||
	            (isRadio && !getRadioValue(refs).isValid))) {
	        const { value, message } = isMessage(required)
	            ? { value: !!required, message: required }
	            : getValueAndMessage(required);
	        if (value) {
	            error[name] = Object.assign({ type: INPUT_VALIDATION_RULES.required, message, ref: inputRef }, appendErrorsCurry(INPUT_VALIDATION_RULES.required, message));
	            if (!validateAllFieldCriteria) {
	                setCustomValidity(message);
	                return error;
	            }
	        }
	    }
	    if (!isEmpty && (!isNullOrUndefined(min) || !isNullOrUndefined(max))) {
	        let exceedMax;
	        let exceedMin;
	        const maxOutput = getValueAndMessage(max);
	        const minOutput = getValueAndMessage(min);
	        if (!isNaN(inputValue)) {
	            const valueNumber = ref.valueAsNumber ||
	                parseFloat(inputValue);
	            if (!isNullOrUndefined(maxOutput.value)) {
	                exceedMax = valueNumber > maxOutput.value;
	            }
	            if (!isNullOrUndefined(minOutput.value)) {
	                exceedMin = valueNumber < minOutput.value;
	            }
	        }
	        else {
	            const valueDate = ref.valueAsDate || new Date(inputValue);
	            if (isString(maxOutput.value)) {
	                exceedMax = valueDate > new Date(maxOutput.value);
	            }
	            if (isString(minOutput.value)) {
	                exceedMin = valueDate < new Date(minOutput.value);
	            }
	        }
	        if (exceedMax || exceedMin) {
	            getMinMaxMessage(!!exceedMax, maxOutput.message, minOutput.message, INPUT_VALIDATION_RULES.max, INPUT_VALIDATION_RULES.min);
	            if (!validateAllFieldCriteria) {
	                setCustomValidity(error[name].message);
	                return error;
	            }
	        }
	    }
	    if ((maxLength || minLength) && !isEmpty && isString(inputValue)) {
	        const maxLengthOutput = getValueAndMessage(maxLength);
	        const minLengthOutput = getValueAndMessage(minLength);
	        const exceedMax = !isNullOrUndefined(maxLengthOutput.value) &&
	            inputValue.length > maxLengthOutput.value;
	        const exceedMin = !isNullOrUndefined(minLengthOutput.value) &&
	            inputValue.length < minLengthOutput.value;
	        if (exceedMax || exceedMin) {
	            getMinMaxMessage(exceedMax, maxLengthOutput.message, minLengthOutput.message);
	            if (!validateAllFieldCriteria) {
	                setCustomValidity(error[name].message);
	                return error;
	            }
	        }
	    }
	    if (pattern && !isEmpty && isString(inputValue)) {
	        const { value: patternValue, message } = getValueAndMessage(pattern);
	        if (isRegex(patternValue) && !inputValue.match(patternValue)) {
	            error[name] = Object.assign({ type: INPUT_VALIDATION_RULES.pattern, message,
	                ref }, appendErrorsCurry(INPUT_VALIDATION_RULES.pattern, message));
	            if (!validateAllFieldCriteria) {
	                setCustomValidity(message);
	                return error;
	            }
	        }
	    }
	    if (validate) {
	        if (isFunction(validate)) {
	            const result = await validate(inputValue);
	            const validateError = getValidateError(result, inputRef);
	            if (validateError) {
	                error[name] = Object.assign(Object.assign({}, validateError), appendErrorsCurry(INPUT_VALIDATION_RULES.validate, validateError.message));
	                if (!validateAllFieldCriteria) {
	                    setCustomValidity(validateError.message);
	                    return error;
	                }
	            }
	        }
	        else if (isObject$1(validate)) {
	            let validationResult = {};
	            for (const key in validate) {
	                if (!isEmptyObject(validationResult) && !validateAllFieldCriteria) {
	                    break;
	                }
	                const validateError = getValidateError(await validate[key](inputValue), inputRef, key);
	                if (validateError) {
	                    validationResult = Object.assign(Object.assign({}, validateError), appendErrorsCurry(key, validateError.message));
	                    setCustomValidity(validateError.message);
	                    if (validateAllFieldCriteria) {
	                        error[name] = validationResult;
	                    }
	                }
	            }
	            if (!isEmptyObject(validationResult)) {
	                error[name] = Object.assign({ ref: inputRef }, validationResult);
	                if (!validateAllFieldCriteria) {
	                    return error;
	                }
	            }
	        }
	    }
	    setCustomValidity(true);
	    return error;
	};

	const defaultOptions = {
	    mode: VALIDATION_MODE.onSubmit,
	    reValidateMode: VALIDATION_MODE.onChange,
	    shouldFocusError: true,
	};
	function createFormControl(props = {}) {
	    let _options = Object.assign(Object.assign({}, defaultOptions), props);
	    let _formState = {
	        isDirty: false,
	        isValidating: false,
	        dirtyFields: {},
	        isSubmitted: false,
	        submitCount: 0,
	        touchedFields: {},
	        isSubmitting: false,
	        isSubmitSuccessful: false,
	        isValid: false,
	        errors: {},
	    };
	    let _fields = {};
	    let _defaultValues = _options.defaultValues || {};
	    let _formValues = _options.shouldUnregister
	        ? {}
	        : cloneObject(_defaultValues);
	    let _stateFlags = {
	        action: false,
	        mount: false,
	        watch: false,
	    };
	    let _names = {
	        mount: new Set(),
	        unMount: new Set(),
	        array: new Set(),
	        watch: new Set(),
	    };
	    let delayErrorCallback;
	    let timer = 0;
	    let validateFields = {};
	    const _proxyFormState = {
	        isDirty: false,
	        dirtyFields: false,
	        touchedFields: false,
	        isValidating: false,
	        isValid: false,
	        errors: false,
	    };
	    const _subjects = {
	        watch: createSubject(),
	        array: createSubject(),
	        state: createSubject(),
	    };
	    const validationModeBeforeSubmit = getValidationModes(_options.mode);
	    const validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
	    const shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all;
	    const debounce = (callback, wait) => (...args) => {
	        clearTimeout(timer);
	        timer = window.setTimeout(() => callback(...args), wait);
	    };
	    const _updateValid = async (shouldSkipRender) => {
	        let isValid = false;
	        if (_proxyFormState.isValid) {
	            isValid = _options.resolver
	                ? isEmptyObject((await _executeSchema()).errors)
	                : await executeBuildInValidation(_fields, true);
	            if (!shouldSkipRender && isValid !== _formState.isValid) {
	                _formState.isValid = isValid;
	                _subjects.state.next({
	                    isValid,
	                });
	            }
	        }
	        return isValid;
	    };
	    const _updateFieldArray = (name, values = [], method, args, shouldSetValues = true, shouldUpdateFieldsAndErrors = true) => {
	        if (args && method) {
	            _stateFlags.action = true;
	            if (shouldUpdateFieldsAndErrors && Array.isArray(get$4(_fields, name))) {
	                const fieldValues = method(get$4(_fields, name), args.argA, args.argB);
	                shouldSetValues && set$1(_fields, name, fieldValues);
	            }
	            if (_proxyFormState.errors &&
	                shouldUpdateFieldsAndErrors &&
	                Array.isArray(get$4(_formState.errors, name))) {
	                const errors = method(get$4(_formState.errors, name), args.argA, args.argB);
	                shouldSetValues && set$1(_formState.errors, name, errors);
	                unsetEmptyArray(_formState.errors, name);
	            }
	            if (_proxyFormState.touchedFields &&
	                Array.isArray(get$4(_formState.touchedFields, name))) {
	                const touchedFields = method(get$4(_formState.touchedFields, name), args.argA, args.argB);
	                shouldSetValues && set$1(_formState.touchedFields, name, touchedFields);
	            }
	            if (_proxyFormState.dirtyFields) {
	                _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
	            }
	            _subjects.state.next({
	                isDirty: _getDirty(name, values),
	                dirtyFields: _formState.dirtyFields,
	                errors: _formState.errors,
	                isValid: _formState.isValid,
	            });
	        }
	        else {
	            set$1(_formValues, name, values);
	        }
	    };
	    const updateErrors = (name, error) => (set$1(_formState.errors, name, error),
	        _subjects.state.next({
	            errors: _formState.errors,
	        }));
	    const updateValidAndValue = (name, shouldSkipSetValueAs, value, ref) => {
	        const field = get$4(_fields, name);
	        if (field) {
	            const defaultValue = get$4(_formValues, name, isUndefined(value) ? get$4(_defaultValues, name) : value);
	            isUndefined(defaultValue) ||
	                (ref && ref.defaultChecked) ||
	                shouldSkipSetValueAs
	                ? set$1(_formValues, name, shouldSkipSetValueAs ? defaultValue : getFieldValue(field._f))
	                : setFieldValue(name, defaultValue);
	            _stateFlags.mount && _updateValid();
	        }
	    };
	    const updateTouchAndDirty = (name, fieldValue, isBlurEvent, shouldDirty, shouldRender) => {
	        let isFieldDirty = false;
	        const output = {
	            name,
	        };
	        const isPreviousFieldTouched = get$4(_formState.touchedFields, name);
	        if (_proxyFormState.isDirty) {
	            const isPreviousFormDirty = _formState.isDirty;
	            _formState.isDirty = output.isDirty = _getDirty();
	            isFieldDirty = isPreviousFormDirty !== output.isDirty;
	        }
	        if (_proxyFormState.dirtyFields && (!isBlurEvent || shouldDirty)) {
	            const isPreviousFieldDirty = get$4(_formState.dirtyFields, name);
	            const isCurrentFieldPristine = deepEqual$1(get$4(_defaultValues, name), fieldValue);
	            isCurrentFieldPristine
	                ? unset(_formState.dirtyFields, name)
	                : set$1(_formState.dirtyFields, name, true);
	            output.dirtyFields = _formState.dirtyFields;
	            isFieldDirty =
	                isFieldDirty ||
	                    isPreviousFieldDirty !== get$4(_formState.dirtyFields, name);
	        }
	        if (isBlurEvent && !isPreviousFieldTouched) {
	            set$1(_formState.touchedFields, name, isBlurEvent);
	            output.touchedFields = _formState.touchedFields;
	            isFieldDirty =
	                isFieldDirty ||
	                    (_proxyFormState.touchedFields &&
	                        isPreviousFieldTouched !== isBlurEvent);
	        }
	        isFieldDirty && shouldRender && _subjects.state.next(output);
	        return isFieldDirty ? output : {};
	    };
	    const shouldRenderByError = async (shouldSkipRender, name, isValid, error, fieldState) => {
	        const previousFieldError = get$4(_formState.errors, name);
	        const shouldUpdateValid = _proxyFormState.isValid && _formState.isValid !== isValid;
	        if (props.delayError && error) {
	            delayErrorCallback =
	                delayErrorCallback || debounce(updateErrors, props.delayError);
	            delayErrorCallback(name, error);
	        }
	        else {
	            clearTimeout(timer);
	            error
	                ? set$1(_formState.errors, name, error)
	                : unset(_formState.errors, name);
	        }
	        if (((error ? !deepEqual$1(previousFieldError, error) : previousFieldError) ||
	            !isEmptyObject(fieldState) ||
	            shouldUpdateValid) &&
	            !shouldSkipRender) {
	            const updatedFormState = Object.assign(Object.assign(Object.assign({}, fieldState), (shouldUpdateValid ? { isValid } : {})), { errors: _formState.errors, name });
	            _formState = Object.assign(Object.assign({}, _formState), updatedFormState);
	            _subjects.state.next(updatedFormState);
	        }
	        validateFields[name]--;
	        if (_proxyFormState.isValidating && !validateFields[name]) {
	            _subjects.state.next({
	                isValidating: false,
	            });
	            validateFields = {};
	        }
	    };
	    const _executeSchema = async (name) => _options.resolver
	        ? await _options.resolver(Object.assign({}, _formValues), _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation))
	        : {};
	    const executeSchemaAndUpdateState = async (names) => {
	        const { errors } = await _executeSchema();
	        if (names) {
	            for (const name of names) {
	                const error = get$4(errors, name);
	                error
	                    ? set$1(_formState.errors, name, error)
	                    : unset(_formState.errors, name);
	            }
	        }
	        else {
	            _formState.errors = errors;
	        }
	        return errors;
	    };
	    const executeBuildInValidation = async (fields, shouldOnlyCheckValid, context = {
	        valid: true,
	    }) => {
	        for (const name in fields) {
	            const field = fields[name];
	            if (field) {
	                const fieldReference = field._f;
	                const fieldValue = omit(field, '_f');
	                if (fieldReference) {
	                    const fieldError = await validateField(field, get$4(_formValues, fieldReference.name), shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation);
	                    if (fieldError[fieldReference.name]) {
	                        context.valid = false;
	                        if (shouldOnlyCheckValid) {
	                            break;
	                        }
	                    }
	                    if (!shouldOnlyCheckValid) {
	                        fieldError[fieldReference.name]
	                            ? set$1(_formState.errors, fieldReference.name, fieldError[fieldReference.name])
	                            : unset(_formState.errors, fieldReference.name);
	                    }
	                }
	                fieldValue &&
	                    (await executeBuildInValidation(fieldValue, shouldOnlyCheckValid, context));
	            }
	        }
	        return context.valid;
	    };
	    const _removeUnmounted = () => {
	        for (const name of _names.unMount) {
	            const field = get$4(_fields, name);
	            field &&
	                (field._f.refs
	                    ? field._f.refs.every((ref) => !live(ref))
	                    : !live(field._f.ref)) &&
	                unregister(name);
	        }
	        _names.unMount = new Set();
	    };
	    const _getDirty = (name, data) => (name && data && set$1(_formValues, name, data),
	        !deepEqual$1(getValues(), _defaultValues));
	    const _getWatch = (names, defaultValue, isGlobal) => {
	        const fieldValues = Object.assign({}, (_stateFlags.mount
	            ? _formValues
	            : isUndefined(defaultValue)
	                ? _defaultValues
	                : isString(names)
	                    ? { [names]: defaultValue }
	                    : defaultValue));
	        return generateWatchOutput(names, _names, fieldValues, isGlobal);
	    };
	    const _getFieldArray = (name) => compact(get$4(_stateFlags.mount ? _formValues : _defaultValues, name, props.shouldUnregister ? get$4(_defaultValues, name, []) : []));
	    const setFieldValue = (name, value, options = {}) => {
	        const field = get$4(_fields, name);
	        let fieldValue = value;
	        if (field) {
	            const fieldReference = field._f;
	            if (fieldReference) {
	                !fieldReference.disabled &&
	                    set$1(_formValues, name, getFieldValueAs(value, fieldReference));
	                fieldValue =
	                    isWeb && isHTMLElement(fieldReference.ref) && isNullOrUndefined(value)
	                        ? ''
	                        : value;
	                if (isMultipleSelect(fieldReference.ref)) {
	                    [...fieldReference.ref.options].forEach((selectRef) => (selectRef.selected = fieldValue.includes(selectRef.value)));
	                }
	                else if (fieldReference.refs) {
	                    if (isCheckBoxInput(fieldReference.ref)) {
	                        fieldReference.refs.length > 1
	                            ? fieldReference.refs.forEach((checkboxRef) => (checkboxRef.checked = Array.isArray(fieldValue)
	                                ? !!fieldValue.find((data) => data === checkboxRef.value)
	                                : fieldValue === checkboxRef.value))
	                            : fieldReference.refs[0] &&
	                                (fieldReference.refs[0].checked = !!fieldValue);
	                    }
	                    else {
	                        fieldReference.refs.forEach((radioRef) => (radioRef.checked = radioRef.value === fieldValue));
	                    }
	                }
	                else if (isFileInput(fieldReference.ref)) {
	                    fieldReference.ref.value = '';
	                }
	                else {
	                    fieldReference.ref.value = fieldValue;
	                    if (!fieldReference.ref.type) {
	                        _subjects.watch.next({
	                            name,
	                        });
	                    }
	                }
	            }
	        }
	        (options.shouldDirty || options.shouldTouch) &&
	            updateTouchAndDirty(name, fieldValue, options.shouldTouch, options.shouldDirty, true);
	        options.shouldValidate && trigger(name);
	    };
	    const setValues = (name, value, options) => {
	        for (const fieldKey in value) {
	            const fieldValue = value[fieldKey];
	            const fieldName = `${name}.${fieldKey}`;
	            const field = get$4(_fields, fieldName);
	            (_names.array.has(name) ||
	                !isPrimitive(fieldValue) ||
	                (field && !field._f)) &&
	                !isDateObject(fieldValue)
	                ? setValues(fieldName, fieldValue, options)
	                : setFieldValue(fieldName, fieldValue, options);
	        }
	    };
	    const setValue = (name, value, options = {}) => {
	        const field = get$4(_fields, name);
	        const isFieldArray = _names.array.has(name);
	        const cloneValue = cloneObject(value);
	        set$1(_formValues, name, cloneValue);
	        if (isFieldArray) {
	            _subjects.array.next({
	                name,
	                values: _formValues,
	            });
	            if ((_proxyFormState.isDirty || _proxyFormState.dirtyFields) &&
	                options.shouldDirty) {
	                _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
	                _subjects.state.next({
	                    name,
	                    dirtyFields: _formState.dirtyFields,
	                    isDirty: _getDirty(name, cloneValue),
	                });
	            }
	        }
	        else {
	            field && !field._f && !isNullOrUndefined(cloneValue)
	                ? setValues(name, cloneValue, options)
	                : setFieldValue(name, cloneValue, options);
	        }
	        isWatched(name, _names) && _subjects.state.next({});
	        _subjects.watch.next({
	            name,
	        });
	    };
	    const onChange = async (event) => {
	        const target = event.target;
	        let name = target.name;
	        const field = get$4(_fields, name);
	        if (field) {
	            let error;
	            let isValid;
	            const fieldValue = target.type
	                ? getFieldValue(field._f)
	                : getEventValue(event);
	            const isBlurEvent = event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT;
	            const shouldSkipValidation = (!hasValidation(field._f) &&
	                !_options.resolver &&
	                !get$4(_formState.errors, name) &&
	                !field._f.deps) ||
	                skipValidation(isBlurEvent, get$4(_formState.touchedFields, name), _formState.isSubmitted, validationModeAfterSubmit, validationModeBeforeSubmit);
	            const watched = isWatched(name, _names, isBlurEvent);
	            set$1(_formValues, name, fieldValue);
	            if (isBlurEvent) {
	                field._f.onBlur && field._f.onBlur(event);
	            }
	            else if (field._f.onChange) {
	                field._f.onChange(event);
	            }
	            const fieldState = updateTouchAndDirty(name, fieldValue, isBlurEvent, false);
	            const shouldRender = !isEmptyObject(fieldState) || watched;
	            !isBlurEvent &&
	                _subjects.watch.next({
	                    name,
	                    type: event.type,
	                });
	            if (shouldSkipValidation) {
	                return (shouldRender &&
	                    _subjects.state.next(Object.assign({ name }, (watched ? {} : fieldState))));
	            }
	            !isBlurEvent && watched && _subjects.state.next({});
	            validateFields[name] = validateFields[name] ? +1 : 1;
	            _subjects.state.next({
	                isValidating: true,
	            });
	            if (_options.resolver) {
	                const { errors } = await _executeSchema([name]);
	                const previousErrorLookupResult = schemaErrorLookup(_formState.errors, _fields, name);
	                const errorLookupResult = schemaErrorLookup(errors, _fields, previousErrorLookupResult.name || name);
	                error = errorLookupResult.error;
	                name = errorLookupResult.name;
	                isValid = isEmptyObject(errors);
	            }
	            else {
	                error = (await validateField(field, get$4(_formValues, name), shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation))[name];
	                isValid = await _updateValid(true);
	            }
	            field._f.deps && trigger(field._f.deps);
	            shouldRenderByError(false, name, isValid, error, fieldState);
	        }
	    };
	    const trigger = async (name, options = {}) => {
	        let isValid;
	        let validationResult;
	        const fieldNames = convertToArrayPayload(name);
	        _subjects.state.next({
	            isValidating: true,
	        });
	        if (_options.resolver) {
	            const errors = await executeSchemaAndUpdateState(isUndefined(name) ? name : fieldNames);
	            isValid = isEmptyObject(errors);
	            validationResult = name
	                ? !fieldNames.some((name) => get$4(errors, name))
	                : isValid;
	        }
	        else if (name) {
	            validationResult = (await Promise.all(fieldNames.map(async (fieldName) => {
	                const field = get$4(_fields, fieldName);
	                return await executeBuildInValidation(field && field._f ? { [fieldName]: field } : field);
	            }))).every(Boolean);
	            !(!validationResult && !_formState.isValid) && _updateValid();
	        }
	        else {
	            validationResult = isValid = await executeBuildInValidation(_fields);
	        }
	        _subjects.state.next(Object.assign(Object.assign(Object.assign({}, (!isString(name) ||
	            (_proxyFormState.isValid && isValid !== _formState.isValid)
	            ? {}
	            : { name })), (_options.resolver ? { isValid } : {})), { errors: _formState.errors, isValidating: false }));
	        options.shouldFocus &&
	            !validationResult &&
	            focusFieldBy(_fields, (key) => get$4(_formState.errors, key), name ? fieldNames : _names.mount);
	        return validationResult;
	    };
	    const getValues = (fieldNames) => {
	        const values = Object.assign(Object.assign({}, _defaultValues), (_stateFlags.mount ? _formValues : {}));
	        return isUndefined(fieldNames)
	            ? values
	            : isString(fieldNames)
	                ? get$4(values, fieldNames)
	                : fieldNames.map((name) => get$4(values, name));
	    };
	    const getFieldState = (name, formState) => ({
	        invalid: !!get$4((formState || _formState).errors, name),
	        isDirty: !!get$4((formState || _formState).dirtyFields, name),
	        isTouched: !!get$4((formState || _formState).touchedFields, name),
	        error: get$4((formState || _formState).errors, name),
	    });
	    const clearErrors = (name) => {
	        name
	            ? convertToArrayPayload(name).forEach((inputName) => unset(_formState.errors, inputName))
	            : (_formState.errors = {});
	        _subjects.state.next({
	            errors: _formState.errors,
	        });
	    };
	    const setError = (name, error, options) => {
	        const ref = (get$4(_fields, name, { _f: {} })._f || {}).ref;
	        set$1(_formState.errors, name, Object.assign(Object.assign({}, error), { ref }));
	        _subjects.state.next({
	            name,
	            errors: _formState.errors,
	            isValid: false,
	        });
	        options && options.shouldFocus && ref && ref.focus && ref.focus();
	    };
	    const watch = (name, defaultValue) => isFunction(name)
	        ? _subjects.watch.subscribe({
	            next: (info) => name(_getWatch(undefined, defaultValue), info),
	        })
	        : _getWatch(name, defaultValue, true);
	    const unregister = (name, options = {}) => {
	        for (const fieldName of name ? convertToArrayPayload(name) : _names.mount) {
	            _names.mount.delete(fieldName);
	            _names.array.delete(fieldName);
	            if (get$4(_fields, fieldName)) {
	                if (!options.keepValue) {
	                    unset(_fields, fieldName);
	                    unset(_formValues, fieldName);
	                }
	                !options.keepError && unset(_formState.errors, fieldName);
	                !options.keepDirty && unset(_formState.dirtyFields, fieldName);
	                !options.keepTouched && unset(_formState.touchedFields, fieldName);
	                !_options.shouldUnregister &&
	                    !options.keepDefaultValue &&
	                    unset(_defaultValues, fieldName);
	            }
	        }
	        _subjects.watch.next({});
	        _subjects.state.next(Object.assign(Object.assign({}, _formState), (!options.keepDirty ? {} : { isDirty: _getDirty() })));
	        !options.keepIsValid && _updateValid();
	    };
	    const register = (name, options = {}) => {
	        let field = get$4(_fields, name);
	        const disabledIsDefined = isBoolean$1(options.disabled);
	        set$1(_fields, name, {
	            _f: Object.assign(Object.assign(Object.assign({}, (field && field._f ? field._f : { ref: { name } })), { name, mount: true }), options),
	        });
	        _names.mount.add(name);
	        field
	            ? disabledIsDefined &&
	                set$1(_formValues, name, options.disabled
	                    ? undefined
	                    : get$4(_formValues, name, getFieldValue(field._f)))
	            : updateValidAndValue(name, true, options.value);
	        return Object.assign(Object.assign(Object.assign({}, (disabledIsDefined ? { disabled: options.disabled } : {})), (_options.shouldUseNativeValidation
	            ? {
	                required: !!options.required,
	                min: getRuleValue(options.min),
	                max: getRuleValue(options.max),
	                minLength: getRuleValue(options.minLength),
	                maxLength: getRuleValue(options.maxLength),
	                pattern: getRuleValue(options.pattern),
	            }
	            : {})), { name,
	            onChange, onBlur: onChange, ref: (ref) => {
	                if (ref) {
	                    register(name, options);
	                    field = get$4(_fields, name);
	                    const fieldRef = isUndefined(ref.value)
	                        ? ref.querySelectorAll
	                            ? ref.querySelectorAll('input,select,textarea')[0] || ref
	                            : ref
	                        : ref;
	                    const radioOrCheckbox = isRadioOrCheckbox(fieldRef);
	                    const refs = field._f.refs || [];
	                    if (radioOrCheckbox
	                        ? refs.find((option) => option === fieldRef)
	                        : fieldRef === field._f.ref) {
	                        return;
	                    }
	                    set$1(_fields, name, {
	                        _f: Object.assign(Object.assign({}, field._f), (radioOrCheckbox
	                            ? {
	                                refs: refs.concat(fieldRef).filter(live),
	                                ref: { type: fieldRef.type, name },
	                            }
	                            : { ref: fieldRef })),
	                    });
	                    updateValidAndValue(name, false, undefined, fieldRef);
	                }
	                else {
	                    field = get$4(_fields, name, {});
	                    if (field._f) {
	                        field._f.mount = false;
	                    }
	                    (_options.shouldUnregister || options.shouldUnregister) &&
	                        !(isNameInFieldArray(_names.array, name) && _stateFlags.action) &&
	                        _names.unMount.add(name);
	                }
	            } });
	    };
	    const handleSubmit = (onValid, onInvalid) => async (e) => {
	        if (e) {
	            e.preventDefault && e.preventDefault();
	            e.persist && e.persist();
	        }
	        let hasNoPromiseError = true;
	        let fieldValues = _options.shouldUnregister
	            ? cloneObject(_formValues)
	            : Object.assign({}, _formValues);
	        _subjects.state.next({
	            isSubmitting: true,
	        });
	        try {
	            if (_options.resolver) {
	                const { errors, values } = await _executeSchema();
	                _formState.errors = errors;
	                fieldValues = values;
	            }
	            else {
	                await executeBuildInValidation(_fields);
	            }
	            if (isEmptyObject(_formState.errors) &&
	                Object.keys(_formState.errors).every((name) => get$4(fieldValues, name))) {
	                _subjects.state.next({
	                    errors: {},
	                    isSubmitting: true,
	                });
	                await onValid(fieldValues, e);
	            }
	            else {
	                onInvalid && (await onInvalid(_formState.errors, e));
	                _options.shouldFocusError &&
	                    focusFieldBy(_fields, (key) => get$4(_formState.errors, key), _names.mount);
	            }
	        }
	        catch (err) {
	            hasNoPromiseError = false;
	            throw err;
	        }
	        finally {
	            _formState.isSubmitted = true;
	            _subjects.state.next({
	                isSubmitted: true,
	                isSubmitting: false,
	                isSubmitSuccessful: isEmptyObject(_formState.errors) && hasNoPromiseError,
	                submitCount: _formState.submitCount + 1,
	                errors: _formState.errors,
	            });
	        }
	    };
	    const resetField = (name, options = {}) => {
	        if (get$4(_fields, name)) {
	            if (isUndefined(options.defaultValue)) {
	                setValue(name, get$4(_defaultValues, name));
	            }
	            else {
	                setValue(name, options.defaultValue);
	                set$1(_defaultValues, name, options.defaultValue);
	            }
	            if (!options.keepTouched) {
	                unset(_formState.touchedFields, name);
	            }
	            if (!options.keepDirty) {
	                unset(_formState.dirtyFields, name);
	                _formState.isDirty = options.defaultValue
	                    ? _getDirty(name, get$4(_defaultValues, name))
	                    : _getDirty();
	            }
	            if (!options.keepError) {
	                unset(_formState.errors, name);
	                _proxyFormState.isValid && _updateValid();
	            }
	            _subjects.state.next(Object.assign({}, _formState));
	        }
	    };
	    const reset = (formValues, keepStateOptions = {}) => {
	        const updatedValues = formValues || _defaultValues;
	        const cloneUpdatedValues = cloneObject(updatedValues);
	        const values = formValues && !isEmptyObject(formValues)
	            ? cloneUpdatedValues
	            : _defaultValues;
	        if (!keepStateOptions.keepDefaultValues) {
	            _defaultValues = updatedValues;
	        }
	        if (!keepStateOptions.keepValues) {
	            if (isWeb && isUndefined(formValues)) {
	                for (const name of _names.mount) {
	                    const field = get$4(_fields, name);
	                    if (field && field._f) {
	                        const fieldReference = Array.isArray(field._f.refs)
	                            ? field._f.refs[0]
	                            : field._f.ref;
	                        try {
	                            isHTMLElement(fieldReference) &&
	                                fieldReference.closest('form').reset();
	                            break;
	                        }
	                        catch (_a) { }
	                    }
	                }
	            }
	            _formValues = props.shouldUnregister
	                ? keepStateOptions.keepDefaultValues
	                    ? cloneObject(_defaultValues)
	                    : {}
	                : cloneUpdatedValues;
	            _fields = {};
	            _subjects.array.next({
	                values,
	            });
	            _subjects.watch.next({
	                values,
	            });
	        }
	        _names = {
	            mount: new Set(),
	            unMount: new Set(),
	            array: new Set(),
	            watch: new Set(),
	            watchAll: false,
	            focus: '',
	        };
	        _stateFlags.mount =
	            !_proxyFormState.isValid || !!keepStateOptions.keepIsValid;
	        _stateFlags.watch = !!props.shouldUnregister;
	        _subjects.state.next({
	            submitCount: keepStateOptions.keepSubmitCount
	                ? _formState.submitCount
	                : 0,
	            isDirty: keepStateOptions.keepDirty
	                ? _formState.isDirty
	                : keepStateOptions.keepDefaultValues
	                    ? !deepEqual$1(formValues, _defaultValues)
	                    : false,
	            isSubmitted: keepStateOptions.keepIsSubmitted
	                ? _formState.isSubmitted
	                : false,
	            dirtyFields: keepStateOptions.keepDirty
	                ? _formState.dirtyFields
	                : (keepStateOptions.keepDefaultValues && formValues
	                    ? Object.entries(formValues).reduce((previous, [key, value]) => (Object.assign(Object.assign({}, previous), { [key]: value !== get$4(_defaultValues, key) })), {})
	                    : {}),
	            touchedFields: keepStateOptions.keepTouched
	                ? _formState.touchedFields
	                : {},
	            errors: keepStateOptions.keepErrors
	                ? _formState.errors
	                : {},
	            isSubmitting: false,
	            isSubmitSuccessful: false,
	        });
	    };
	    const setFocus = (name) => {
	        const field = get$4(_fields, name)._f;
	        (field.ref.focus ? field.ref : field.refs[0]).focus();
	    };
	    return {
	        control: {
	            register,
	            unregister,
	            getFieldState,
	            _executeSchema,
	            _getWatch,
	            _getDirty,
	            _updateValid,
	            _removeUnmounted,
	            _updateFieldArray,
	            _getFieldArray,
	            _subjects,
	            _proxyFormState,
	            get _fields() {
	                return _fields;
	            },
	            get _formValues() {
	                return _formValues;
	            },
	            get _stateFlags() {
	                return _stateFlags;
	            },
	            set _stateFlags(value) {
	                _stateFlags = value;
	            },
	            get _defaultValues() {
	                return _defaultValues;
	            },
	            get _names() {
	                return _names;
	            },
	            set _names(value) {
	                _names = value;
	            },
	            get _formState() {
	                return _formState;
	            },
	            set _formState(value) {
	                _formState = value;
	            },
	            get _options() {
	                return _options;
	            },
	            set _options(value) {
	                _options = Object.assign(Object.assign({}, _options), value);
	            },
	        },
	        trigger,
	        register,
	        handleSubmit,
	        watch,
	        setValue,
	        getValues,
	        reset,
	        resetField,
	        clearErrors,
	        unregister,
	        setError,
	        setFocus,
	        getFieldState,
	    };
	}

	function useForm(props = {}) {
	    const _formControl = React$2.useRef();
	    const [formState, updateFormState] = React$2.useState({
	        isDirty: false,
	        isValidating: false,
	        dirtyFields: {},
	        isSubmitted: false,
	        submitCount: 0,
	        touchedFields: {},
	        isSubmitting: false,
	        isSubmitSuccessful: false,
	        isValid: false,
	        errors: {},
	    });
	    if (_formControl.current) {
	        _formControl.current.control._options = props;
	    }
	    else {
	        _formControl.current = Object.assign(Object.assign({}, createFormControl(props)), { formState });
	    }
	    const control = _formControl.current.control;
	    const callback = React$2.useCallback((value) => {
	        if (shouldRenderFormState(value, control._proxyFormState, true)) {
	            control._formState = Object.assign(Object.assign({}, control._formState), value);
	            updateFormState(Object.assign({}, control._formState));
	        }
	    }, [control]);
	    useSubscribe({
	        subject: control._subjects.state,
	        callback,
	    });
	    React$2.useEffect(() => {
	        if (!control._stateFlags.mount) {
	            control._proxyFormState.isValid && control._updateValid();
	            control._stateFlags.mount = true;
	        }
	        if (control._stateFlags.watch) {
	            control._stateFlags.watch = false;
	            control._subjects.state.next({});
	        }
	        control._removeUnmounted();
	    });
	    _formControl.current.formState = getProxyFormState(formState, control._proxyFormState);
	    return _formControl.current;
	}

	const useReportingReasons = (onError) =>
	    useDataLoader(
	        sitemap.public.apiV1.reporting.listReasons().toString(),
	        onError
	    );










	const ReportForm = ({
	    whatsWrong,
	}) => {
	    const service = reactExports.useContext(ReportingUIContext);
	    const { t } = useTranslation();

	    const { register, handleSubmit, setError, formState } = useForm({
	        mode: "all",
	    });

	    const onLoadError = reactExports.useCallback(() => {
	        setError("reportingReason", {
	            message: t(
	                "common:report.loading-failed",
	                "Loading report form failed.  Please e-mail support@cohost.org about your concerns."
	            ),
	        });
	    }, [setError, t]);

	    const reportingReasons = useReportingReasons(onLoadError);

	    const onSubmit = (data) => {
	        service.send({
	            type: "SUBMIT",
	            reportingReason: data.reportingReason,
	            additionalDetails: data.additionalDetails,
	        });
	    };

	    return (
	        React$2.createElement('div', { className: "cohost-shadow-light dark:cohost-shadow-dark relative mx-auto flex max-w-md flex-col rounded-lg"       ,}
	            , React$2.createElement('div', { className: "flex flex-row rounded-t-lg bg-longan p-3 text-notBlack"     ,}
	                , React$2.createElement('button', {
	                    className: "h-6 w-6" ,
	                    onClick: () => service.send({ type: "CLOSE" }),}

	                    , React$2.createElement(ForwardRef$s, { className: "h-6 w-6" ,} )
	                )

	                , React$2.createElement(St$1.Title, { as: "div", className: "text-xl font-bold leading-6"  ,}
	                    , t("common:report.title", "Report an issue")
	                )
	            )

	            , React$2.createElement('form', {
	                className: "flex flex-col rounded-b-lg bg-notWhite text-notBlack"    ,
	                onSubmit: handleSubmit(onSubmit),}

	                , React$2.createElement('p', { className: "px-3 pt-3 text-xl font-bold text-foreground"    ,}
	                    , whatsWrong
	                )

	                , React$2.createElement('p', { className: "px-3 pb-3" ,}
	                    , React$2.createElement(Trans, { i18nKey: "common:report.moderation-guide",}, "If you're not sure, check out"
	                             , " "
	                        , React$2.createElement('a', {
	                            href: sitemap.public
	                                .staticContent({ slug: "community-guidelines" })
	                                .toString(),
	                            target: "_new",
	                            className: "text-secondary",}
	, "our community guidelines"

	                        ), " ", "for help."

	                    )
	                )

	                , React$2.createElement('hr', { className: "border-gray-300",} )

	                , reportingReasons.data?.map((reason) => (
	                    React$2.createElement(React$2.Fragment, null
	                        , React$2.createElement('div', {
	                            key: reason.id,
	                            className: "flex flex-row items-center gap-3 p-3"    ,}

	                            , React$2.createElement('input', {
	                                type: "radio",
	                                id: `reason-${reason.id}`,
	                                value: reason.text,
	                                ...register("reportingReason", {
	                                    required: true,
	                                }),}
	                            )
	                            , React$2.createElement('label', { htmlFor: `reason-${reason.id}`,}
	                                , reason.text
	                            )
	                        )
	                        , React$2.createElement('hr', { className: "border-gray-300",} )
	                    )
	                ))

	                , React$2.createElement('p', { className: "m-3",}
	                    , t(
	                        "common:report.additional-details",
	                        "Use the form below to provide any context you think is helpful:"
	                    )
	                )

	                , React$2.createElement('div', { className: "m-3",}
	                    , React$2.createElement('textarea', {
	                        className: "w-full",
	                        rows: 4,
	                        ...register("additionalDetails"),}
	)
	                )

	                , React$2.createElement('div', { className: "flex flex-row" ,}
	                    , React$2.createElement('p', { className: "mr-3 flex-1 text-right align-top text-red"    ,}
	                        , formState.errors.reportingReason &&
	                            (formState.errors.reportingReason.message ?? (
	                                React$2.createElement('span', null
	                                    , t(
	                                        "common:report.must-select-reason",
	                                        "You must select a reporting reason."
	                                    )
	                                )
	                            ))
	                    )

	                    , React$2.createElement('button', {
	                        type: "submit",
	                        className: `mb-3 mr-3 min-w-0
    rounded-lg bg-foreground px-4 py-1 
    text-lg font-bold text-notWhite hover:bg-foreground-600 active:bg-foreground-700 disabled:bg-foreground-200`,
	                        disabled: !formState.isValid,}

	                        , t("common:report.report-button", "report")
	                    )
	                )
	            )
	        )
	    );
	};
	ReportForm.displayName = "ReportForm";

	const AckForm = () => {
	    const service = reactExports.useContext(ReportingUIContext);
	    const { t } = useTranslation();

	    return (
	        React$2.createElement('div', { className: "cohost-shadow-light dark:cohost-shadow-dark relative mx-auto flex max-w-md flex-col rounded-lg bg-notWhite p-3 text-notBlack"          ,}
	            , t(
	                "common:report-post.thanks",
	                "Thanks for letting us know.  We'll look into your report as soon as possible."
	            )

	            , React$2.createElement('button', {
	                type: "submit",
	                className: `max-w-10 align-self-center mt-3 rounded-lg bg-foreground py-1 px-4 
    text-lg font-bold text-notWhite hover:bg-foreground-600 active:bg-foreground-700`,
	                onClick: () => service.send({ type: "ACKNOWLEDGE" }),}

	                , t("common:ok", "ok")
	            )
	        )
	    );
	};

	const ErrorForm = () => {
	    const service = reactExports.useContext(ReportingUIContext);
	    const { t } = useTranslation();

	    return (
	        React$2.createElement('div', { className: "cohost-shadow-light dark:cohost-shadow-dark relative mx-auto flex max-w-md flex-col rounded-lg bg-notWhite p-3 text-notBlack"          ,}
	            , React$2.createElement(Trans, { i18nKey: "common:report.report-failed",}
	                , React$2.createElement('p', null, "Submitting your report failed. Please email support@cohost.org about your concerns, and include the following information:"



	                )
	            )

	            , React$2.createElement('hr', null )

	            , service.state.context.postId ? (
	                React$2.createElement('p', null
	                    , React$2.createElement(React$2.Fragment, null, "post id: "  , service.state.context.postId)
	                )
	            ) : null

	            , service.state.context.projectId ? (
	                React$2.createElement('p', null
	                    , React$2.createElement(React$2.Fragment, null, "page id: "  , service.state.context.projectId)
	                )
	            ) : null

	            , service.state.context.commentId ? (
	                React$2.createElement('p', null
	                    , React$2.createElement(React$2.Fragment, null, "comment id: "  , service.state.context.commentId)
	                )
	            ) : null

	            , React$2.createElement('p', null
	                , React$2.createElement(React$2.Fragment, null, "reporting reason: "  , service.state.context.reportingReason)
	            )
	            , React$2.createElement('p', null
	                , React$2.createElement(React$2.Fragment, null, "additional details:"
	                     , " "
	                    , service.state.context.additionalDetails
	                )
	            )

	            , React$2.createElement('button', {
	                type: "submit",
	                className: `max-w-10 align-self-center mt-3 rounded-lg bg-foreground py-1 px-4 
    text-lg font-bold text-notWhite hover:bg-foreground-600 active:bg-foreground-700`,
	                onClick: () => service.send({ type: "CLOSE" }),}

	                , t("common:ok", "ok")
	            )
	        )
	    );
	};

	const ReportingUIHost = ({
	    children,
	}) => {
	    const reportDialogService = useInterpret(reportingUIMachine, {
	        context: {},
	    });

	    return (
	        React$2.createElement(React$2.Fragment, null
	            , React$2.createElement(ReportingUIContext.Provider, { value: reportDialogService,}
	                , React$2.createElement(ErrorBoundary, null
	                    , React$2.createElement(ReportingUI, null )
	                )
	                , children
	            )
	        )
	    );
	};

	const ReportingUI = (props) => {
	    const { t } = useTranslation();
	    const service = reactExports.useContext(ReportingUIContext);
	    const isOpen = useSelector$1(service, (state) => !state.matches("closed"));
	    const isReportingPost = useSelector$1(
	        service,
	        (state) => state.matches("editingReport") && state.context.postId
	    );
	    const isReportingProject = useSelector$1(
	        service,
	        (state) => state.matches("editingReport") && state.context.projectId
	    );
	    const isReportingComment = useSelector$1(
	        service,
	        (state) => state.matches("editingReport") && state.context.commentId
	    );
	    const isReportingAsk = useSelector$1(
	        service,
	        (state) => state.matches("editingReport") && state.context.askId
	    );
	    const isReportingArtistAlleyListing = useSelector$1(
	        service,
	        (state) =>
	            state.matches("editingReport") && state.context.artistAlleyListingId
	    );
	    const isAcknowledging = useSelector$1(service, (state) =>
	        state.matches("acknowledging")
	    );
	    const isDisplayingError = useSelector$1(service, (state) =>
	        state.matches("displayingError")
	    );

	    const whatsWrong = reactExports.useMemo(() => {
	        if (isReportingPost) {
	            return t(
	                "common:report.whats-wrong.post",
	                "Help us understand the problem. What's wrong with this post?"
	            );
	        } else if (isReportingProject) {
	            return t(
	                "common:report.whats-wrong.project",
	                "Help us understand the problem. What's wrong with this project?"
	            );
	        } else if (isReportingComment) {
	            return t(
	                "common:report.whats-wrong.comment",
	                "Help us understand the problem. What's wrong with this comment?"
	            );
	        } else if (isReportingAsk) {
	            return t(
	                "common:report.whats-wrong.ask",
	                "Help us understand the problem. What's wrong with this ask?"
	            );
	        } else if (isReportingArtistAlleyListing) {
	            return t(
	                "common:report.whats-wrong.artist-alley-listing",
	                "Help us understand the problem. What's wrong with this listing?"
	            );
	        } else {
	            return "";
	        }
	    }, [
	        isReportingAsk,
	        isReportingComment,
	        isReportingPost,
	        isReportingProject,
	        isReportingArtistAlleyListing,
	        t,
	    ]);

	    return (
	        React$2.createElement(St$1, { open: isOpen, onClose: () => service.send({ type: "CLOSE" }),}
	            , React$2.createElement(ModalOverlay, null )
	            , React$2.createElement('div', { className: "fixed inset-0 z-10 overflow-y-auto"   ,}
	                , React$2.createElement('div', { className: "flex min-h-full items-center justify-center py-20"    ,}
	                    , whatsWrong.length ? (
	                        React$2.createElement(St$1.Panel, { as: ReportForm, whatsWrong: whatsWrong,} )
	                    ) : null
	                    , isAcknowledging ? React$2.createElement(St$1.Panel, { as: AckForm,} ) : null
	                    , isDisplayingError ? React$2.createElement(St$1.Panel, { as: ErrorForm,} ) : null
	                )
	            )
	        )
	    );
	};

	// src/index.ts
	var React$1 = (
	  // prettier-ignore
	  // @ts-ignore
	  "default" in ReactOriginal ? React$2 : ReactOriginal
	);

	// src/components/Context.ts
	var ContextKey = Symbol.for(`react-redux-context`);
	var gT = typeof globalThis !== "undefined" ? globalThis : (
	  /* fall back to a per-module scope (pre-8.1 behaviour) if `globalThis` is not available */
	  {}
	);
	function getContext() {
	  if (!React$1.createContext)
	    return {};
	  const contextMap = gT[ContextKey] ?? (gT[ContextKey] = /* @__PURE__ */ new Map());
	  let realContext = contextMap.get(React$1.createContext);
	  if (!realContext) {
	    realContext = React$1.createContext(
	      null
	    );
	    contextMap.set(React$1.createContext, realContext);
	  }
	  return realContext;
	}
	var ReactReduxContext = /* @__PURE__ */ getContext();

	// src/utils/useSyncExternalStore.ts
	var notInitialized = () => {
	  throw new Error("uSES not initialized!");
	};

	// src/hooks/useReduxContext.ts
	function createReduxContextHook(context = ReactReduxContext) {
	  return function useReduxContext2() {
	    const contextValue = React$1.useContext(context);
	    return contextValue;
	  };
	}
	var useReduxContext = /* @__PURE__ */ createReduxContextHook();

	// src/hooks/useSelector.ts
	var useSyncExternalStoreWithSelector = notInitialized;
	var initializeUseSelector = (fn) => {
	  useSyncExternalStoreWithSelector = fn;
	};
	var refEquality = (a, b) => a === b;
	function createSelectorHook(context = ReactReduxContext) {
	  const useReduxContext2 = context === ReactReduxContext ? useReduxContext : createReduxContextHook(context);
	  const useSelector2 = (selector, equalityFnOrOptions = {}) => {
	    const { equalityFn = refEquality, devModeChecks = {} } = typeof equalityFnOrOptions === "function" ? { equalityFn: equalityFnOrOptions } : equalityFnOrOptions;
	    const {
	      store,
	      subscription,
	      getServerState,
	      stabilityCheck,
	      identityFunctionCheck
	    } = useReduxContext2();
	    React$1.useRef(true);
	    const wrappedSelector = React$1.useCallback(
	      {
	        [selector.name](state) {
	          const selected = selector(state);
	          return selected;
	        }
	      }[selector.name],
	      [selector, stabilityCheck, devModeChecks.stabilityCheck]
	    );
	    const selectedState = useSyncExternalStoreWithSelector(
	      subscription.addNestedSub,
	      store.getState,
	      getServerState || store.getState,
	      wrappedSelector,
	      equalityFn
	    );
	    React$1.useDebugValue(selectedState);
	    return selectedState;
	  };
	  Object.assign(useSelector2, {
	    withTypes: () => useSelector2
	  });
	  return useSelector2;
	}
	var useSelector = /* @__PURE__ */ createSelectorHook();

	// src/utils/batch.ts
	function defaultNoopBatch(callback) {
	  callback();
	}

	// src/utils/Subscription.ts
	function createListenerCollection() {
	  let first = null;
	  let last = null;
	  return {
	    clear() {
	      first = null;
	      last = null;
	    },
	    notify() {
	      defaultNoopBatch(() => {
	        let listener = first;
	        while (listener) {
	          listener.callback();
	          listener = listener.next;
	        }
	      });
	    },
	    get() {
	      const listeners = [];
	      let listener = first;
	      while (listener) {
	        listeners.push(listener);
	        listener = listener.next;
	      }
	      return listeners;
	    },
	    subscribe(callback) {
	      let isSubscribed = true;
	      const listener = last = {
	        callback,
	        next: null,
	        prev: last
	      };
	      if (listener.prev) {
	        listener.prev.next = listener;
	      } else {
	        first = listener;
	      }
	      return function unsubscribe() {
	        if (!isSubscribed || first === null)
	          return;
	        isSubscribed = false;
	        if (listener.next) {
	          listener.next.prev = listener.prev;
	        } else {
	          last = listener.prev;
	        }
	        if (listener.prev) {
	          listener.prev.next = listener.next;
	        } else {
	          first = listener.next;
	        }
	      };
	    }
	  };
	}
	var nullListeners = {
	  notify() {
	  },
	  get: () => []
	};
	function createSubscription(store, parentSub) {
	  let unsubscribe;
	  let listeners = nullListeners;
	  let subscriptionsAmount = 0;
	  let selfSubscribed = false;
	  function addNestedSub(listener) {
	    trySubscribe();
	    const cleanupListener = listeners.subscribe(listener);
	    let removed = false;
	    return () => {
	      if (!removed) {
	        removed = true;
	        cleanupListener();
	        tryUnsubscribe();
	      }
	    };
	  }
	  function notifyNestedSubs() {
	    listeners.notify();
	  }
	  function handleChangeWrapper() {
	    if (subscription.onStateChange) {
	      subscription.onStateChange();
	    }
	  }
	  function isSubscribed() {
	    return selfSubscribed;
	  }
	  function trySubscribe() {
	    subscriptionsAmount++;
	    if (!unsubscribe) {
	      unsubscribe = store.subscribe(handleChangeWrapper);
	      listeners = createListenerCollection();
	    }
	  }
	  function tryUnsubscribe() {
	    subscriptionsAmount--;
	    if (unsubscribe && subscriptionsAmount === 0) {
	      unsubscribe();
	      unsubscribe = void 0;
	      listeners.clear();
	      listeners = nullListeners;
	    }
	  }
	  function trySubscribeSelf() {
	    if (!selfSubscribed) {
	      selfSubscribed = true;
	      trySubscribe();
	    }
	  }
	  function tryUnsubscribeSelf() {
	    if (selfSubscribed) {
	      selfSubscribed = false;
	      tryUnsubscribe();
	    }
	  }
	  const subscription = {
	    addNestedSub,
	    notifyNestedSubs,
	    handleChangeWrapper,
	    isSubscribed,
	    trySubscribe: trySubscribeSelf,
	    tryUnsubscribe: tryUnsubscribeSelf,
	    getListeners: () => listeners
	  };
	  return subscription;
	}

	// src/utils/useIsomorphicLayoutEffect.ts
	var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
	var useIsomorphicLayoutEffect$2 = canUseDOM ? React$1.useLayoutEffect : React$1.useEffect;

	// src/components/Provider.tsx
	function Provider({
	  store,
	  context,
	  children,
	  serverState,
	  stabilityCheck = "once",
	  identityFunctionCheck = "once"
	}) {
	  const contextValue = React$1.useMemo(() => {
	    const subscription = createSubscription(store);
	    return {
	      store,
	      subscription,
	      getServerState: serverState ? () => serverState : void 0,
	      stabilityCheck,
	      identityFunctionCheck
	    };
	  }, [store, serverState, stabilityCheck, identityFunctionCheck]);
	  const previousState = React$1.useMemo(() => store.getState(), [store]);
	  useIsomorphicLayoutEffect$2(() => {
	    const { subscription } = contextValue;
	    subscription.onStateChange = subscription.notifyNestedSubs;
	    subscription.trySubscribe();
	    if (previousState !== store.getState()) {
	      subscription.notifyNestedSubs();
	    }
	    return () => {
	      subscription.tryUnsubscribe();
	      subscription.onStateChange = void 0;
	    };
	  }, [contextValue, previousState]);
	  const Context = context || ReactReduxContext;
	  return /* @__PURE__ */ React$1.createElement(Context.Provider, { value: contextValue }, children);
	}
	var Provider_default = Provider;

	// src/hooks/useStore.ts
	function createStoreHook(context = ReactReduxContext) {
	  const useReduxContext2 = context === ReactReduxContext ? useReduxContext : (
	    // @ts-ignore
	    createReduxContextHook(context)
	  );
	  const useStore2 = () => {
	    const { store } = useReduxContext2();
	    return store;
	  };
	  Object.assign(useStore2, {
	    withTypes: () => useStore2
	  });
	  return useStore2;
	}
	var useStore = /* @__PURE__ */ createStoreHook();

	// src/hooks/useDispatch.ts
	function createDispatchHook(context = ReactReduxContext) {
	  const useStore2 = context === ReactReduxContext ? useStore : createStoreHook(context);
	  const useDispatch2 = () => {
	    const store = useStore2();
	    return store.dispatch;
	  };
	  Object.assign(useDispatch2, {
	    withTypes: () => useDispatch2
	  });
	  return useDispatch2;
	}
	var useDispatch = /* @__PURE__ */ createDispatchHook();

	// src/index.ts
	initializeUseSelector(withSelectorExports.useSyncExternalStoreWithSelector);

	function selectStateMatches(
	    stateStringOrObj
	) {
	    return (state) => state.matches(stateStringOrObj);
	}

	var AttachmentState; (function (AttachmentState) {
	    const Pending = 0; AttachmentState[AttachmentState["Pending"] = Pending] = "Pending";
	    const Finished = Pending + 1; AttachmentState[AttachmentState["Finished"] = Finished] = "Finished";
	})(AttachmentState || (AttachmentState = {}));

	mod.enum(["audio", "image"]);
	 

	const WireAudioAttachmentMetadata = mod.object({
	    title: mod.string().optional(),
	    artist: mod.string().optional(),
	});
	 



	const WireImageAttachmentMetadata = mod.object({});
	 



	mod.union([
	    WireAudioAttachmentMetadata,
	    WireImageAttachmentMetadata,
	]);

	const AskState = mod.enum(["pending", "responded", "deleted"]);
	 

	const FilteredProject = mod.object({
	    projectId: ProjectId,
	    handle: ProjectHandle,
	    avatarURL: mod.string(),
	    avatarPreviewURL: mod.string(),
	    privacy: ProjectPrivacyEnum,
	    flags: ProjectFlag.array(),
	    avatarShape: AvatarShape,
	    displayName: mod.string(),
	});

	const WireAskModel = mod.discriminatedUnion("anon", [
	    mod.object({
	        anon: mod.literal(true),
	        loggedIn: mod.boolean(),
	        askingProject: mod.undefined(),
	        askId: AskId,
	        content: mod.string(),
	        sentAt: ISODateString,
	    }),
	    mod.object({
	        anon: mod.literal(false),
	        loggedIn: mod.literal(true),
	        askingProject: FilteredProject,
	        askId: AskId,
	        content: mod.string(),
	        sentAt: ISODateString,
	    }),
	]);
	 

	WireAskModel.and(
	    mod.object({
	        state: AskState,
	    })
	);

	/**
	 * Post Blocks
	 *
	 * Specifies all the types for the block-based Post system.
	 * @module
	 */


	/**
	 * @internal
	 */
	const BaseBlock = mod.object({
	    type: mod.string(),
	});




	/**
	 * @category Storage Blocks
	 *
	 * Blocks as they are stored in the database.
	 * Only contains minimal information needed to reproduce content, used as the base to generate [[View Blocks]].
	 */

	/**
	 * @category Storage Blocks
	 */
	const MarkdownStorageBlock = BaseBlock.extend({
	    type: mod.literal("markdown"),
	    markdown: mod.object({
	        /** Raw markdown to be parsed at render-time. */
	        content: mod.string(),
	    }),
	});
	 

	/**
	 * @category Storage Blocks
	 */
	const AttachmentStorageBlock = BaseBlock.extend({
	    type: mod.literal("attachment"),
	    attachment: mod.object({
	        /** ID for the [[`Attachment`]] to be rendered. */
	        attachmentId: AttachmentId,
	        altText: mod.string().optional(),
	    }),
	});
	 

	AttachmentStorageBlock.extend({
	    attachment: AttachmentStorageBlock.shape.attachment.extend({
	        attachmentId: mod.null(),
	    }),
	});
	 



	const AttachmentRowStorageBlock = BaseBlock.extend({
	    type: mod.literal("attachment-row"),
	    attachments: mod.array(AttachmentStorageBlock),
	});
	 



	/**
	 * Union type used on the [[`Post`]] model
	 *
	 * @category Storage Blocks
	 */
	mod.union([
	    MarkdownStorageBlock,
	    AttachmentStorageBlock,
	    AttachmentRowStorageBlock,
	]);
	 

	/**
	 * @category View Blocks
	 * View Blocks _must_ contain all data needed to render the block.
	 * This is a wire-safe type and as a result _must_ not contain anything the client can't see.
	 *
	 */

	/**
	 * No changes are currently required from the [[`MarkdownStorageBlock`]]
	 * so this is currently a simple alias.
	 *
	 * @category View Blocks
	 * */
	const MarkdownViewBlock = MarkdownStorageBlock.extend({});
	 

	/**
	 * Adds the image URL for rendering
	 *
	 * @category View Blocks
	 */
	const ImageAttachmentViewModel = AttachmentStorageBlock.shape.attachment
	    .extend({
	        previewURL: mod.string(),
	        fileURL: mod.string(),
	        kind: mod.literal("image"),
	        width: mod.number().nullish(),
	        height: mod.number().nullish(),
	    })
	    .extend(WireImageAttachmentMetadata.shape);

	const AudioAttachmentViewModel = AttachmentStorageBlock.shape.attachment.extend(
	    {
	        previewURL: mod.string(),
	        fileURL: mod.string(),
	        kind: mod.literal("audio"),
	        artist: mod.string().optional(),
	        title: mod.string().optional(),
	    }
	);

	const AttachmentViewModel = mod.discriminatedUnion("kind", [
	    ImageAttachmentViewModel,
	    AudioAttachmentViewModel,
	]);

	const AttachmentViewBlock = AttachmentStorageBlock.extend({
	    attachment: AttachmentViewModel,
	});

	 

	const AttachmentRowViewBlock = AttachmentRowStorageBlock.extend({
	    attachments: mod.array(AttachmentViewBlock),
	});
	 

	/**
	 * NOTE: AskViewBlock DOES NOT have a corresponding storage block. It is
	 * generated by the server.
	 */
	const AskViewBlock = BaseBlock.extend({
	    type: mod.literal("ask"),
	    ask: WireAskModel,
	});
	 

	/**
	 * Union type used for [[`PostViewModel`]] and component renderers.
	 * @category View Blocks
	 */
	mod.union([
	    MarkdownViewBlock,
	    AttachmentViewBlock,
	    AskViewBlock,
	    AttachmentRowViewBlock,
	]);
	 

	function isAttachmentViewBlock(
	    test
	) {
	    return AttachmentViewBlock.safeParse(test).success;
	}

	function isMarkdownViewBlock(test) {
	    return MarkdownViewBlock.safeParse(test).success;
	}

	function isAskViewBlock(test) {
	    return AskViewBlock.safeParse(test).success;
	}

	function isAttachmentRowViewBlock(
	    test
	) {
	    return AttachmentRowViewBlock.safeParse(test).success;
	}

	function isAttachmentStorageBlock(
	    test
	) {
	    return AttachmentStorageBlock.safeParse(test).success;
	}

	function isAttachmentRowStorageBlock(
	    test
	) {
	    return AttachmentRowStorageBlock.safeParse(test).success;
	}

	function isMarkdownStorageBlock(
	    test
	) {
	    return MarkdownStorageBlock.safeParse(test).success;
	}

	// via https://github.com/colinhacks/zod/issues/627#issuecomment-911679836
	// could be worth investigating a factory function?
	function parseAttachmentViewBlocks(originalBlocks) {
	    return mod
	        .preprocess(
	            (blocks) =>
	                mod.array(mod.any()).parse(blocks).filter(isAttachmentViewBlock),
	            mod.array(AttachmentViewBlock)
	        )
	        .parse(originalBlocks);
	}

	function summaryContent(block) {
	    switch (block.type) {
	        case "markdown":
	            return block.markdown.content;
	        case "attachment": {
	            const encodedFilename = block.attachment.fileURL.split("/").pop();

	            return encodedFilename
	                ? `[${block.attachment.kind}: ${decodeURIComponent(
                      encodedFilename
                  )}]`
	                : `[${block.attachment.kind}]`;
	        }
	        case "attachment-row":
	            return block.attachments
	                .map((attachment) => summaryContent(attachment))
	                .join("\n");
	        case "ask": {
	            const askerString = block.ask.anon
	                ? block.ask.loggedIn
	                    ? "Anonymous User asked:"
	                    : "Anonymous Guest asked:"
	                : `@${block.ask.askingProject.handle} asked:`;
	            return `${askerString}
> ${block.ask.content.split("\n").join("\n> ")}`;
	        }
	    }
	}

	function getAttachmentViewBlocks(
	    blocks
	) {
	    return blocks.reduce((blocks, block) => {
	        if (isAttachmentViewBlock(block)) {
	            return [...blocks, block];
	        }

	        if (isAttachmentRowViewBlock(block)) {
	            return [...blocks, ...block.attachments];
	        }

	        return blocks;
	    }, []);
	}

	var PostState; (function (PostState) {
	    const Unpublished = 0; PostState[PostState["Unpublished"] = Unpublished] = "Unpublished";
	    const Published = Unpublished + 1; PostState[PostState["Published"] = Published] = "Published";
	    const Deleted = Published + 1; PostState[PostState["Deleted"] = Deleted] = "Deleted";
	})(PostState || (PostState = {}));

	mod.nativeEnum(PostState);

	var isEmpty$1 = {exports: {}};

	var assertString = {exports: {}};

	(function (module, exports) {

		Object.defineProperty(exports, "__esModule", {
		  value: true
		});
		exports.default = assertString;

		function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

		function assertString(input) {
		  var isString = typeof input === 'string' || input instanceof String;

		  if (!isString) {
		    var invalidType = _typeof(input);

		    if (input === null) invalidType = 'null';else if (invalidType === 'object') invalidType = input.constructor.name;
		    throw new TypeError("Expected a string but received a ".concat(invalidType));
		  }
		}

		module.exports = exports.default;
		module.exports.default = exports.default; 
	} (assertString, assertString.exports));

	var assertStringExports = assertString.exports;

	var merge$3 = {exports: {}};

	(function (module, exports) {

		Object.defineProperty(exports, "__esModule", {
		  value: true
		});
		exports.default = merge;

		function merge() {
		  var obj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
		  var defaults = arguments.length > 1 ? arguments[1] : undefined;

		  for (var key in defaults) {
		    if (typeof obj[key] === 'undefined') {
		      obj[key] = defaults[key];
		    }
		  }

		  return obj;
		}

		module.exports = exports.default;
		module.exports.default = exports.default; 
	} (merge$3, merge$3.exports));

	var mergeExports = merge$3.exports;

	(function (module, exports) {

		Object.defineProperty(exports, "__esModule", {
		  value: true
		});
		exports.default = isEmpty;

		var _assertString = _interopRequireDefault(assertStringExports);

		var _merge = _interopRequireDefault(mergeExports);

		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

		var default_is_empty_options = {
		  ignore_whitespace: false
		};

		function isEmpty(str, options) {
		  (0, _assertString.default)(str);
		  options = (0, _merge.default)(options, default_is_empty_options);
		  return (options.ignore_whitespace ? str.trim().length : str.length) === 0;
		}

		module.exports = exports.default;
		module.exports.default = exports.default; 
	} (isEmpty$1, isEmpty$1.exports));

	var isEmptyExports = isEmpty$1.exports;
	var isEmpty = /*@__PURE__*/getDefaultExportFromCjs(isEmptyExports);

	const getImageDimensions$1 = (
	    url
	) => {
	    return new Promise((resolve, reject) => {
	        const img = new Image();
	        img.onload = () =>
	            resolve({
	                width: img.width,
	                height: img.height,
	            });
	        img.onerror = (error) => reject(error);
	        img.src = url;
	    });
	};












































































	const postEditorMachine = createMachine


	(
	    {
	        context: {
	            // we need to have a value set for projecthandle
	            // state so we deliberately set invalid ones since it'll be
	            // overwritten in the post composer.
	            projectHandle: "" ,
	            isActivated: false,
	            hasCohostPlus: false,
	            sizeLimits: defaultConfig.limits.attachmentSize,
	            currentPostState: undefined,
	            headline: "",
	            attachments: [],
	            validationErrors: new Map(),
	            markdownBlocks: [],
	            newPostState: PostState.Published,
	            shareOfPostId: null,
	            responseToAskId: null,
	            adultContent: false,
	            maximumAllowedAttachments: 4,
	            tags: [],
	            cws: [],
	            editingCws: false,
	            dirty: false,
	            editingTransparentShare: false,
	        },
	        initial: "launching",
	        id: "editor",
	        states: {
	            launching: {
	                invoke: {
	                    src: "verifyInitialContext",
	                    onDone: [
	                        {
	                            // assign generated state
	                            actions: assign$1


	({
	                                editingCws: (context, event) =>
	                                    event.data.editingCws,
	                            }),
	                            target: "editing",
	                        },
	                    ],
	                    onError: [
	                        {
	                            actions: assign$1


	({
	                                validationErrors: (context, event) =>
	                                    (context.validationErrors =
	                                        context.validationErrors.set(
	                                            "app",
	                                            `FAILED INITIAL CONTEXT CHECK: ${event.data.errors.join(
                                                ", "
                                            )}`
	                                        )),
	                            }),
	                            target: "unrecoverable",
	                        },
	                    ],
	                },
	            },
	            editing: {
	                type: "parallel",
	                states: {
	                    headline: {
	                        initial: "typing",
	                        states: {
	                            typing: {
	                                on: {
	                                    HEADLINE_INPUT: {
	                                        actions: ["assignHeadline"],
	                                    },
	                                },
	                            },
	                        },
	                    },
	                    body: {
	                        initial: "typing",
	                        states: {
	                            typing: {
	                                on: {
	                                    BODY_INPUT: {
	                                        target: "typing",
	                                        actions: assign$1({
	                                            markdownBlocks: (context, event) =>
	                                                (context.markdownBlocks =
	                                                    event.body
	                                                        .split("\n\n")
	                                                        .map(
	                                                            (p) => ({
	                                                                type: "markdown",
	                                                                markdown: {
	                                                                    content: p,
	                                                                },
	                                                            })
	                                                        )),
	                                            dirty: (context) =>
	                                                (context.dirty = true),
	                                        }),
	                                    },
	                                },
	                            },
	                        },
	                    },
	                    attachments: {
	                        initial: "waitingForSelection",
	                        states: {
	                            waitingForSelection: {
	                                always: {
	                                    cond: "maximumFilesSelected",
	                                    target: "waitingForUpload",
	                                },
	                                on: {
	                                    SELECT_FILE: {
	                                        target: "validatingAttachment",
	                                    },
	                                    REMOVE_ATTACHMENT: {
	                                        actions: "removeAttachment",
	                                    },
	                                },
	                            },
	                            validatingAttachment: {
	                                invoke: {
	                                    src: "validateAttachments",
	                                    onDone: [
	                                        {
	                                            actions: assign$1({
	                                                attachments: (
	                                                    context,
	                                                    event




	                                                ) => {
	                                                    return [
	                                                        ...context.attachments,
	                                                        {
	                                                            ...event.data,
	                                                            state: AttachmentState.Pending,
	                                                        },
	                                                    ];
	                                                },
	                                                validationErrors: (context) =>
	                                                    context.validationErrors.delete(
	                                                        "attachments"
	                                                    )
	                                                        ? context.validationErrors
	                                                        : context.validationErrors,
	                                                dirty: (context) =>
	                                                    (context.dirty = true),
	                                            }),
	                                            target: "waitingForSelection",
	                                        },
	                                    ],
	                                    onError: [
	                                        {
	                                            actions: assign$1({
	                                                validationErrors: (
	                                                    context,
	                                                    event


	                                                ) =>
	                                                    context.validationErrors.set(
	                                                        "attachments",
	                                                        event.data.error
	                                                    ),
	                                            }),
	                                            target: "waitingForSelection",
	                                        },
	                                    ],
	                                },
	                            },
	                            waitingForUpload: {
	                                on: {
	                                    REMOVE_ATTACHMENT: {
	                                        actions: "removeAttachment",
	                                        target: "waitingForSelection",
	                                    },
	                                },
	                            },
	                        },
	                    },
	                    postState: {
	                        initial: "waiting",
	                        states: {
	                            waiting: {
	                                on: {
	                                    SET_POST_STATE: {
	                                        actions: assign$1({
	                                            newPostState: (context, event) =>
	                                                (context.newPostState =
	                                                    event.newPostState),
	                                            dirty: (context) =>
	                                                (context.dirty = true),
	                                        }),
	                                    },
	                                },
	                            },
	                        },
	                    },
	                    adultContent: {
	                        initial: "waiting",
	                        states: {
	                            waiting: {
	                                on: {
	                                    SET_ADULT_CONTENT: {
	                                        actions: assign$1({
	                                            adultContent: (context, event) =>
	                                                (context.adultContent =
	                                                    event.adultContent),
	                                            dirty: (context) =>
	                                                (context.dirty = true),
	                                        }),
	                                    },
	                                },
	                            },
	                        },
	                    },
	                    tags: {
	                        initial: "waiting",
	                        states: {
	                            waiting: {
	                                on: {
	                                    TAGS_INPUT: {
	                                        actions: assign$1({
	                                            tags: (context, event) =>
	                                                (context.tags = event.tags),
	                                            dirty: (context) =>
	                                                (context.dirty = true),
	                                        }),
	                                    },
	                                },
	                            },
	                        },
	                    },
	                    cws: {
	                        initial: "waiting",
	                        states: {
	                            waiting: {
	                                on: {
	                                    CWS_INPUT: {
	                                        actions: assign$1({
	                                            cws: (context, event) =>
	                                                (context.cws = event.cws),
	                                            dirty: (context) =>
	                                                (context.dirty = true),
	                                        }),
	                                    },
	                                },
	                            },
	                        },
	                    },
	                    altText: {
	                        initial: "typing",
	                        states: {
	                            typing: {
	                                on: {
	                                    ALT_TEXT_INPUT: {
	                                        actions: assign$1({
	                                            attachments: (context, event) => {
	                                                const attachment =
	                                                    context.attachments[
	                                                        event.index
	                                                    ];

	                                                if (
	                                                    attachment.kind !== "image"
	                                                ) {
	                                                    console.error(
	                                                        "editing alt text on non-image attachment?"
	                                                    );
	                                                    return context.attachments;
	                                                }

	                                                return [
	                                                    ...context.attachments.slice(
	                                                        0,
	                                                        event.index
	                                                    ),
	                                                    {
	                                                        ...attachment,
	                                                        metadata: {
	                                                            ...attachment.metadata,
	                                                            altText:
	                                                                event.input,
	                                                        },
	                                                    },
	                                                    ...context.attachments.slice(
	                                                        event.index + 1
	                                                    ),
	                                                ];
	                                            },
	                                            dirty: (context) =>
	                                                (context.dirty = true),
	                                        }),
	                                    },
	                                },
	                            },
	                        },
	                    },
	                    audioMetadata: {
	                        initial: "typing",
	                        states: {
	                            typing: {
	                                on: {
	                                    AUDIO_METADATA_INPUT: {
	                                        actions: assign$1({
	                                            attachments: (context, event) => {
	                                                const attachment =
	                                                    context.attachments[
	                                                        event.index
	                                                    ];

	                                                if (
	                                                    attachment.kind !== "audio"
	                                                ) {
	                                                    console.error(
	                                                        "editing metadata on non-audio attachment?"
	                                                    );
	                                                    return context.attachments;
	                                                }

	                                                attachment.metadata = {
	                                                    title: event.title,
	                                                    artist: event.artist,
	                                                };

	                                                return [
	                                                    ...context.attachments.slice(
	                                                        0,
	                                                        event.index
	                                                    ),
	                                                    attachment,
	                                                    ...context.attachments.slice(
	                                                        event.index + 1
	                                                    ),
	                                                ];
	                                            },
	                                        }),
	                                    },
	                                },
	                            },
	                        },
	                    },
	                },
	                on: {
	                    SUBMIT_POST: {
	                        target: "validating",
	                    },
	                    CHANGE_PROJECT: {
	                        actions: assign$1({
	                            projectHandle: (context, event) =>
	                                (context.projectHandle = event.projectHandle),
	                        }),
	                    },
	                    TOGGLE_CWS_INPUT: {
	                        actions: assign$1({
	                            editingCws: (context) => {
	                                // if there's already text input then you can't disable CWs
	                                if (context.cws.length > 0) return true;
	                                return !context.editingCws;
	                            },
	                        }),
	                    },
	                },
	            },
	            validating: {
	                invoke: {
	                    src: "validatePost",
	                    onDone: [
	                        {
	                            target: "posting",
	                            actions: assign$1({
	                                dirty: (context) => (context.dirty = false),
	                            }),
	                        },
	                    ],
	                    onError: [
	                        {
	                            actions: assign$1


	({
	                                validationErrors: (context, event) =>
	                                    (context.validationErrors =
	                                        context.validationErrors.set(
	                                            "app",
	                                            event.data
	                                        )),
	                            }),
	                            target: "editing",
	                        },
	                    ],
	                },
	            },
	            posting: {
	                initial: "startingUpload",
	                states: {
	                    startingUpload: {
	                        always: [
	                            {
	                                cond: "hasPostId",
	                                target: "maybeUploadingAttachments",
	                            },
	                            {
	                                target: "creatingPost",
	                            },
	                        ],
	                    },
	                    creatingPost: {
	                        invoke: {
	                            src: "createPost",
	                            onDone: [
	                                {
	                                    actions: assign$1


	({
	                                        postId: (context, event) =>
	                                            (context.postId = event.data),
	                                    }),
	                                    target: "maybeUploadingAttachments",
	                                },
	                            ],
	                        },
	                    },
	                    maybeUploadingAttachments: {
	                        always: [
	                            {
	                                cond: "hasPendingAttachments",
	                                target: "uploadingAttachments",
	                            },
	                            {
	                                cond: "isNewPost",
	                                target: "#editor.posted",
	                            },
	                            {
	                                target: "updatingPost",
	                            },
	                        ],
	                    },
	                    uploadingAttachments: {
	                        initial: "startingAttachments",
	                        states: {
	                            startingAttachments: {
	                                invoke: {
	                                    src: "createAttachments",
	                                    onDone: [
	                                        {
	                                            actions:
	                                                "assignAttachmentUploadData",
	                                            target: "uploadingFiles",
	                                        },
	                                    ],
	                                },
	                            },
	                            uploadingFiles: {
	                                invoke: {
	                                    src: "uploadFiles",
	                                    onDone: [
	                                        {
	                                            target: "finishingAttachments",
	                                        },
	                                    ],
	                                },
	                            },
	                            finishingAttachments: {
	                                invoke: {
	                                    src: "finishAttachments",
	                                    onDone: [
	                                        {
	                                            actions: assign$1




	({
	                                                attachments: (context, event) =>
	                                                    (context.attachments =
	                                                        context.attachments.map(
	                                                            (
	                                                                attachment,
	                                                                i
	                                                            ) => ({
	                                                                ...attachment,
	                                                                state: AttachmentState.Finished,
	                                                                src: event.data[
	                                                                    i
	                                                                ].url,
	                                                            })
	                                                        )),
	                                            }),
	                                            target: "#editor.posting.updatingPost",
	                                        },
	                                    ],
	                                },
	                            },
	                        },
	                    },
	                    updatingPost: {
	                        invoke: {
	                            src: "updatePost",
	                            onDone: [
	                                {
	                                    target: "#editor.posted",
	                                },
	                            ],
	                            onError: [
	                                {
	                                    target: "#editor.postingFailed",
	                                },
	                            ],
	                        },
	                    },
	                },
	            },
	            posted: {},
	            postingFailed: {},
	            unrecoverable: {
	                type: "final",
	            },
	        },
	    },
	    {
	        guards: {
	            hasPostId: (context) => !!context.postId,
	            hasPendingAttachments: ({ attachments }) =>
	                attachments.some(
	                    (attachment) => attachment.state == AttachmentState.Pending
	                ),
	            maximumFilesSelected: ({
	                attachments,
	                maximumAllowedAttachments,
	            }) => attachments.length >= maximumAllowedAttachments,
	            shouldUpdatePostState: ({ currentPostState, newPostState }) =>
	                currentPostState !== newPostState,
	            isNewPost: ({ currentPostState }) => currentPostState === undefined,
	        },
	        services: {
	            /**
	             * Check to make sure our initial boot context is correct.
	             * `projectHandle` is mandatory for the editor to function
	             * but is dependent on the runtime context and thus can't be set
	             * by default.
	             * @param context
	             * @returns
	             */
	            verifyInitialContext: (context) => {
	                const errors = [];

	                if (!context.projectHandle) {
	                    errors.push("MISSING PROJECT HANDLE");
	                }

	                if (errors.length > 0) {
	                    return Promise.reject({
	                        errors,
	                    });
	                }

	                // generated context
	                return Promise.resolve({
	                    // display the CW edit field by default iff
	                    // the initial context has one or more content warnings
	                    // set
	                    editingCws: context.cws.length > 0,
	                });
	            },
	            /**
	             * Check to see if any validation errors are currently set,
	             * if so reject to block upload.
	             * @param param0
	             * @returns
	             */
	            validatePost: (context) => {
	                // filter out the markdown blocks without any content
	                const contentfulBlocks = context.markdownBlocks.filter(
	                    (block) => block.markdown.content.trim().length > 0
	                );

	                const anyContent =
	                    !isEmpty(context.headline) ||
	                    contentfulBlocks.length > 0 ||
	                    context.attachments.length > 0 ||
	                    context.shareOfPostId;
	                const anyBrokenAttachments = !!context.attachments.find(
	                    (at) =>
	                        // allow for NIL uuid for non-uploaded attachments to avoid zod parsing issues
	                        at.state !== AttachmentState.Pending &&
	                        at.attachmentId === nil
	                );

	                if (anyBrokenAttachments) {
	                    // t("client:post-editor.broken-attachment", "at least one of the attachments on this post failed to upload.  please remove it and try attaching it again.")
	                    return Promise.reject(
	                        "client:post-editor.broken-attachment"
	                    );
	                }

	                if (!anyContent) {
	                    // t("client:post-editor.must-contain-content", "must contain a headline, any body content, or any attachment")
	                    return Promise.reject(
	                        "client:post-editor.must-contain-content"
	                    );
	                }
	                return Promise.resolve();
	            },
	            validateAttachments: async (context, event) => {
	                if (event.type !== "SELECT_FILE") {
	                    return Promise.reject({
	                        error: `Tried to validate attachments with invalid event ${event.type}`,
	                    });
	                }

	                const effectiveLimit = context.hasCohostPlus
	                    ? context.sizeLimits.cohostPlus
	                    : context.sizeLimits.normal;

	                const file = event.file;

	                const validityResult = isValidAttachmentContentType(
	                    defaultConfig,
	                    file.type
	                );

	                if (!validityResult.valid) {
	                    // t("client:post-editor.attachment-must-be-image", "one or more attachments is not of a supported file type!")
	                    return Promise.reject({
	                        error: "client:post-editor.attachment-must-be-image",
	                    });
	                }

	                if (file.size > effectiveLimit) {
	                    // TODO: figure out how to get the interpolation to work
	                    // here since we're just passing the key.
	                    // t("client:post-editor.attachment-too-large", "attachments must be less than 5mb!")
	                    // t("client:post-editor.attachment-too-large-cohost-plus", "attachments must be less than 10mb!")
	                    const key = context.hasCohostPlus
	                        ? "client:post-editor.attachment-too-large-cohost-plus"
	                        : "client:post-editor.attachment-too-large";
	                    return Promise.reject({
	                        error: key,
	                    });
	                }

	                switch (validityResult.kind) {
	                    case "image": {
	                        let dimensions = { width: 0, height: 0 };

	                        try {
	                            dimensions = await getImageDimensions$1(
	                                URL.createObjectURL(file)
	                            );
	                        } catch (e) {
	                            // nothing to do here
	                        }

	                        return Promise.resolve({
	                            file,
	                            kind: "image",
	                            metadata: {
	                                altText: "",
	                                ...dimensions,
	                            },
	                        });
	                    }
	                    case "audio": {
	                        return Promise.resolve({
	                            file,
	                            kind: "audio",
	                            metadata: {
	                                artist: "",
	                                title: "",
	                            },
	                        });
	                    }
	                }
	            },
	            createPost: async (context) => {
	                let effectiveState = PostState.Unpublished;

	                // if we don't have any attachments to upload we can go straight to the True State
	                if (
	                    !context.attachments.some(
	                        (attachment) =>
	                            attachment.state === AttachmentState.Pending
	                    )
	                ) {
	                    effectiveState = context.newPostState;
	                }

	                const blocks = [];
	                // FIXME: between here and post upload completing successfully,
	                // the post contains a broken attachment block with no attachment
	                // ID; we should figure out a more elegant way to do this
	                blocks.push(
	                    ...context.attachments.map(
	                        (attachment) => ({
	                            type: "attachment",
	                            attachment: {
	                                attachmentId:
	                                    attachment.attachmentId ??
	                                    (nil ),
	                                altText:
	                                    attachment.kind === "image"
	                                        ? attachment.metadata.altText
	                                        : undefined,
	                            },
	                        })
	                    )
	                );
	                blocks.push(
	                    ...context.markdownBlocks
	                        .map((block) => ({
	                            ...block,
	                            markdown: {
	                                content: block.markdown.content,
	                            },
	                        }))
	                        .filter((block) => !!block.markdown.content)
	                );
	                const body = {
	                    postState: effectiveState,
	                    headline: context.headline,
	                    adultContent: context.adultContent,
	                    blocks,
	                    cws: context.cws
	                        .filter((cw) => cw.length > 0)
	                        .map((cw) => cw.trim()),
	                    tags: context.tags
	                        .filter((tag) => tag.length > 0)
	                        .map((tag) => tag.trim()),
	                    shareOfPostId:
	                        context.shareOfPostId && !isNaN(context.shareOfPostId)
	                            ? context.shareOfPostId
	                            : undefined,
	                    responseToAskId: context.responseToAskId
	                        ? context.responseToAskId
	                        : undefined,
	                };

	                const trpcClient = getVanillaClient();
	                const { postId } = await trpcClient.posts.create.mutate({
	                    projectHandle: context.projectHandle,
	                    content: body,
	                });

	                return postId;
	            },
	            createAttachments: ({ attachments, postId, projectHandle }) => {
	                return Promise.all(
	                    attachments.map(async (attachment) => {
	                        if (attachment.state !== AttachmentState.Pending)
	                            return attachment;

	                        const { file } = attachment;
	                        if (!file) {
	                            throw "tried to create an attachment without a file!";
	                        }

	                        if (!postId)
	                            throw new Error(
	                                "Tried to upload attachment without post ID"
	                            );

	                        const trpcClient = getVanillaClient();

	                        switch (attachment.kind) {
	                            case "image":
	                                return trpcClient.posts.attachment.start.mutate(
	                                    {
	                                        projectHandle,
	                                        postId,
	                                        filename: file.name,
	                                        contentType: file.type,
	                                        contentLength: file.size,
	                                        width: attachment.metadata.width,
	                                        height: attachment.metadata.height,
	                                    }
	                                );
	                            case "audio":
	                                return trpcClient.posts.attachment.start.mutate(
	                                    {
	                                        projectHandle,
	                                        postId,
	                                        filename: file.name,
	                                        contentType: file.type,
	                                        contentLength: file.size,
	                                        metadata: attachment.metadata,
	                                    }
	                                );
	                        }
	                    })
	                );
	            },
	            uploadFiles: ({ attachments }) => {
	                return Promise.all(
	                    attachments
	                        .filter(
	                            (attachment) =>
	                                attachment.state === AttachmentState.Pending
	                        )
	                        .map(async (attachment, index, array) => {
	                            if (!attachment.file || !attachment.uploadUrl) {
	                                console.error(
	                                    index,
	                                    array.length,
	                                    attachment.file,
	                                    attachment.uploadUrl
	                                );
	                                throw new Error(
	                                    "Missing file or upload URL for pending attachment!"
	                                );
	                            }

	                            const formData = new FormData();
	                            for (const name in attachment.requiredFields) {
	                                formData.append(
	                                    name,
	                                    attachment.requiredFields[name]
	                                );
	                            }
	                            formData.append("file", attachment.file);
	                            formData.append(
	                                "Content-Type",
	                                attachment.file.type
	                            );
	                            await axios$1.post(attachment.uploadUrl, formData, {
	                                withCredentials: false,
	                            });
	                            return null;
	                        })
	                );
	            },
	            finishAttachments: ({ attachments, projectHandle, postId }) => {
	                const trpcClient = getVanillaClient();

	                return Promise.all(
	                    attachments.map(async (attachment) => {
	                        if (attachment.state !== AttachmentState.Pending) {
	                            return {
	                                attachmentId: attachment.attachmentId,
	                                url: attachment.src,
	                            } ;
	                        }

	                        const { attachmentId } = attachment;
	                        if (!postId || !attachmentId) throw new Error();

	                        return trpcClient.posts.attachment.finish.mutate({
	                            projectHandle,
	                            postId,
	                            attachmentId,
	                        });
	                    })
	                );
	            },
	            updatePost: async (context) => {
	                if (!context.postId) throw new Error();
	                const blocks = [];
	                blocks.push(
	                    ...context.attachments
	                        .filter((attachment) => !!attachment.attachmentId)
	                        .map((attachment) => ({
	                            type: "attachment",
	                            attachment: {
	                                attachmentId: attachment.attachmentId,
	                                altText:
	                                    attachment.kind === "image"
	                                        ? attachment.metadata.altText
	                                        : undefined,
	                            },
	                        }))
	                );
	                blocks.push(
	                    ...context.markdownBlocks
	                        .map((block) => ({
	                            ...block,
	                            markdown: {
	                                content: block.markdown.content,
	                            },
	                        }))
	                        .filter((block) => !!block.markdown.content)
	                );
	                const body = {
	                    postState: context.newPostState,
	                    headline: context.headline,
	                    adultContent: context.adultContent,
	                    blocks,
	                    cws: context.cws
	                        .filter((cw) => cw.length > 0)
	                        .map((cw) => cw.trim()),
	                    tags: context.tags
	                        .filter((tag) => tag.length > 0)
	                        .map((tag) => tag.trim()),
	                    shareOfPostId:
	                        context.shareOfPostId && !isNaN(context.shareOfPostId)
	                            ? context.shareOfPostId
	                            : undefined,
	                };

	                const trpcClient = getVanillaClient();

	                await trpcClient.posts.update.mutate({
	                    projectHandle: context.projectHandle,
	                    postId: context.postId,
	                    content: body,
	                });
	            },
	        },
	        /**
	         * You're going to see a lot of explicit-any here with the rule
	         * disabled. Unfortunately, this is a limitation of typescript and this
	         * is the preferred solution in the Xstate docs.
	         * see: https://xstate.js.org/docs/guides/typescript.html#ondone-onerror-events-in-machine-options
	         */
	        actions: {
	            /**
	             * I realize this is currently unused, I'm reworking how validation
	             * works right now.
	             */
	            assignValidationErrorToContext: assign$1({
	                // eslint-disable-next-line @typescript-eslint/no-explicit-any
	                validationErrors: (context, event) => {
	                    const { fieldName, error } = (
	                        event 
	                    ).data;
	                    return (context.validationErrors = {
	                        ...context.validationErrors,
	                        [fieldName]: error,
	                    });
	                },
	            }),
	            assignHeadline: assign$1({
	                headline: (context, event) => {
	                    if (event.type !== "HEADLINE_INPUT")
	                        return context.headline;

	                    return (context.headline = event.headline
	                        .replace("\n", " ")
	                        .slice(0, 140));
	                },
	                dirty: (context) => (context.dirty = true),
	            }),
	            assignAttachmentUploadData: assign$1({
	                // eslint-disable-next-line @typescript-eslint/no-explicit-any
	                attachments: (context, _event) => {
	                    const event = _event 

	;
	                    return (context.attachments =
	                        context.attachments.map((attachment, i) => {
	                            if (event.data[i]) {
	                                return {
	                                    ...attachment,
	                                    attachmentId: event.data[i].attachmentId,
	                                    uploadUrl: event.data[i].url,
	                                    requiredFields:
	                                        event.data[i].requiredFields,
	                                };
	                            } else {
	                                return attachment;
	                            }
	                        }));
	                },
	            }),
	            removeAttachment: assign$1({
	                attachments: (context, event) => {
	                    if (event.type !== "REMOVE_ATTACHMENT")
	                        return context.attachments;
	                    const attachments = [...context.attachments];
	                    attachments.splice(event.index, 1);
	                    return (context.attachments = attachments);
	                },
	                dirty: (context) => (context.dirty = true),
	            }),
	        },
	    }
	);

	const useBeforeUnload = (cb) => {
	    const handleBeforeUnload = reactExports.useCallback(
	        (evt) => {
	            const returnValue = cb(evt);
	            if (returnValue) {
	                evt.preventDefault();
	                evt.returnValue = returnValue;
	            }
	            return returnValue;
	        },
	        [cb]
	    );

	    reactExports.useEffect(() => {
	        window.addEventListener("beforeunload", handleBeforeUnload);
	        return () =>
	            window.removeEventListener("beforeunload", handleBeforeUnload);
	    }, [handleBeforeUnload]);
	};

	const FilePicker = ({
	    children,
	    onFilesPicked,
	}) => {
	    const fileInput = reactExports.useRef();
	    const siteConfig = useSiteConfig();

	    const onClick = reactExports.useCallback(() => {
	        if (!fileInput.current) {
	            fileInput.current = document.createElement("input");
	            fileInput.current.type = "file";
	            fileInput.current.accept =
	                listValidAttachmentContentTypes(siteConfig).join(",");
	            fileInput.current.onchange = () => {
	                if (fileInput.current?.files && onFilesPicked)
	                    onFilesPicked(fileInput.current.files);
	                fileInput.current = undefined;
	            };
	        }

	        fileInput.current.click();
	    }, [onFilesPicked, siteConfig]);

	    return (
	        React$2.createElement(React$2.Fragment, null
	            , React$2.Children.toArray(children)
	                .filter(reactExports.isValidElement)
	                .map((child) =>
	                    reactExports.isValidElement(child)
	                        ? reactExports.cloneElement(child, {
	                              onClick,
	                          })
	                        : null
	                )
	        )
	    );
	};

	// do not edit .js files directly - edit src/index.jst



	var fastDeepEqual = function equal(a, b) {
	  if (a === b) return true;

	  if (a && b && typeof a == 'object' && typeof b == 'object') {
	    if (a.constructor !== b.constructor) return false;

	    var length, i, keys;
	    if (Array.isArray(a)) {
	      length = a.length;
	      if (length != b.length) return false;
	      for (i = length; i-- !== 0;)
	        if (!equal(a[i], b[i])) return false;
	      return true;
	    }



	    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
	    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
	    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();

	    keys = Object.keys(a);
	    length = keys.length;
	    if (length !== Object.keys(b).length) return false;

	    for (i = length; i-- !== 0;)
	      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;

	    for (i = length; i-- !== 0;) {
	      var key = keys[i];

	      if (!equal(a[key], b[key])) return false;
	    }

	    return true;
	  }

	  // true if both NaN, false otherwise
	  return a!==a && b!==b;
	};

	var equal = /*@__PURE__*/getDefaultExportFromCjs(fastDeepEqual);

	// suppress the useLayoutEffect warning on server side.
	const useIsomorphicLayoutEffect$1 = typeof window !== 'undefined' ? reactExports.useLayoutEffect : reactExports.useEffect;

	/**
	 *
	 * @param monitor The monitor to collect state from
	 * @param collect The collecting function
	 * @param onUpdate A method to invoke when updates occur
	 */ function useCollector(monitor, collect, onUpdate) {
	    const [collected, setCollected] = reactExports.useState(()=>collect(monitor)
	    );
	    const updateCollected = reactExports.useCallback(()=>{
	        const nextValue = collect(monitor);
	        // This needs to be a deep-equality check because some monitor-collected values
	        // include XYCoord objects that may be equivalent, but do not have instance equality.
	        if (!equal(collected, nextValue)) {
	            setCollected(nextValue);
	            if (onUpdate) {
	                onUpdate();
	            }
	        }
	    }, [
	        collected,
	        monitor,
	        onUpdate
	    ]);
	    // update the collected properties after react renders.
	    // Note that the "Dustbin Stress Test" fails if this is not
	    // done when the component updates
	    useIsomorphicLayoutEffect$1(updateCollected);
	    return [
	        collected,
	        updateCollected
	    ];
	}

	function useMonitorOutput(monitor, collect, onCollect) {
	    const [collected, updateCollected] = useCollector(monitor, collect, onCollect);
	    useIsomorphicLayoutEffect$1(function subscribeToMonitorStateChange() {
	        const handlerId = monitor.getHandlerId();
	        if (handlerId == null) {
	            return;
	        }
	        return monitor.subscribeToStateChange(updateCollected, {
	            handlerIds: [
	                handlerId
	            ]
	        });
	    }, [
	        monitor,
	        updateCollected
	    ]);
	    return collected;
	}

	function useCollectedProps(collector, monitor, connector) {
	    return useMonitorOutput(monitor, collector || (()=>({})
	    ), ()=>connector.reconnect()
	    );
	}

	function useOptionalFactory(arg, deps) {
	    const memoDeps = [
	        ...deps || []
	    ];
	    if (deps == null && typeof arg !== 'function') {
	        memoDeps.push(arg);
	    }
	    return reactExports.useMemo(()=>{
	        return typeof arg === 'function' ? arg() : arg;
	    }, memoDeps);
	}

	function useConnectDropTarget(connector) {
	    return reactExports.useMemo(()=>connector.hooks.dropTarget()
	    , [
	        connector
	    ]);
	}

	/**
	 * Use invariant() to assert state which your program assumes to be true.
	 *
	 * Provide sprintf-style format (only %s is supported) and arguments
	 * to provide information about what broke and what you were
	 * expecting.
	 *
	 * The invariant message will be stripped in production, but the invariant
	 * will remain to ensure logic does not differ in production.
	 */ function invariant$1(condition, format, ...args) {
	    if (isProduction()) {
	        if (format === undefined) {
	            throw new Error('invariant requires an error message argument');
	        }
	    }
	    if (!condition) {
	        let error;
	        if (format === undefined) {
	            error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
	        } else {
	            let argIndex = 0;
	            error = new Error(format.replace(/%s/g, function() {
	                return args[argIndex++];
	            }));
	            error.name = 'Invariant Violation';
	        }
	        error.framesToPop = 1 // we don't care about invariant's own frame
	        ;
	        throw error;
	    }
	}
	function isProduction() {
	    return typeof process !== 'undefined' && process.env['NODE_ENV'] === 'production';
	}

	let isCallingCanDrop = false;
	class DropTargetMonitorImpl {
	    receiveHandlerId(targetId) {
	        this.targetId = targetId;
	    }
	    getHandlerId() {
	        return this.targetId;
	    }
	    subscribeToStateChange(listener, options) {
	        return this.internalMonitor.subscribeToStateChange(listener, options);
	    }
	    canDrop() {
	        // Cut out early if the target id has not been set. This should prevent errors
	        // where the user has an older version of dnd-core like in
	        // https://github.com/react-dnd/react-dnd/issues/1310
	        if (!this.targetId) {
	            return false;
	        }
	        invariant$1(!isCallingCanDrop, 'You may not call monitor.canDrop() inside your canDrop() implementation. ' + 'Read more: http://react-dnd.github.io/react-dnd/docs/api/drop-target-monitor');
	        try {
	            isCallingCanDrop = true;
	            return this.internalMonitor.canDropOnTarget(this.targetId);
	        } finally{
	            isCallingCanDrop = false;
	        }
	    }
	    isOver(options) {
	        if (!this.targetId) {
	            return false;
	        }
	        return this.internalMonitor.isOverTarget(this.targetId, options);
	    }
	    getItemType() {
	        return this.internalMonitor.getItemType();
	    }
	    getItem() {
	        return this.internalMonitor.getItem();
	    }
	    getDropResult() {
	        return this.internalMonitor.getDropResult();
	    }
	    didDrop() {
	        return this.internalMonitor.didDrop();
	    }
	    getInitialClientOffset() {
	        return this.internalMonitor.getInitialClientOffset();
	    }
	    getInitialSourceClientOffset() {
	        return this.internalMonitor.getInitialSourceClientOffset();
	    }
	    getSourceClientOffset() {
	        return this.internalMonitor.getSourceClientOffset();
	    }
	    getClientOffset() {
	        return this.internalMonitor.getClientOffset();
	    }
	    getDifferenceFromInitialOffset() {
	        return this.internalMonitor.getDifferenceFromInitialOffset();
	    }
	    constructor(manager){
	        this.targetId = null;
	        this.internalMonitor = manager.getMonitor();
	    }
	}

	function isRef(obj) {
	    return(// eslint-disable-next-line no-prototype-builtins
	    obj !== null && typeof obj === 'object' && Object.prototype.hasOwnProperty.call(obj, 'current'));
	}

	function registerTarget(type, target, manager) {
	    const registry = manager.getRegistry();
	    const targetId = registry.addTarget(type, target);
	    return [
	        targetId,
	        ()=>registry.removeTarget(targetId)
	    ];
	}

	function shallowEqual(objA, objB, compare, compareContext) {
	    let compareResult = void 0;
	    if (compareResult !== void 0) {
	        return !!compareResult;
	    }
	    if (objA === objB) {
	        return true;
	    }
	    if (typeof objA !== 'object' || !objA || typeof objB !== 'object' || !objB) {
	        return false;
	    }
	    const keysA = Object.keys(objA);
	    const keysB = Object.keys(objB);
	    if (keysA.length !== keysB.length) {
	        return false;
	    }
	    const bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
	    // Test for A's keys different from B.
	    for(let idx = 0; idx < keysA.length; idx++){
	        const key = keysA[idx];
	        if (!bHasOwnProperty(key)) {
	            return false;
	        }
	        const valueA = objA[key];
	        const valueB = objB[key];
	        compareResult = void 0;
	        if (compareResult === false || compareResult === void 0 && valueA !== valueB) {
	            return false;
	        }
	    }
	    return true;
	}

	function throwIfCompositeComponentElement(element) {
	    // Custom components can no longer be wrapped directly in React DnD 2.0
	    // so that we don't need to depend on findDOMNode() from react-dom.
	    if (typeof element.type === 'string') {
	        return;
	    }
	    const displayName = element.type.displayName || element.type.name || 'the component';
	    throw new Error('Only native element nodes can now be passed to React DnD connectors.' + `You can either wrap ${displayName} into a <div>, or turn it into a ` + 'drag source or a drop target itself.');
	}
	function wrapHookToRecognizeElement(hook) {
	    return (elementOrNode = null, options = null)=>{
	        // When passed a node, call the hook straight away.
	        if (!reactExports.isValidElement(elementOrNode)) {
	            const node = elementOrNode;
	            hook(node, options);
	            // return the node so it can be chained (e.g. when within callback refs
	            // <div ref={node => connectDragSource(connectDropTarget(node))}/>
	            return node;
	        }
	        // If passed a ReactElement, clone it and attach this function as a ref.
	        // This helps us achieve a neat API where user doesn't even know that refs
	        // are being used under the hood.
	        const element = elementOrNode;
	        throwIfCompositeComponentElement(element);
	        // When no options are passed, use the hook directly
	        const ref = options ? (node)=>hook(node, options)
	         : hook;
	        return cloneWithRef(element, ref);
	    };
	}
	function wrapConnectorHooks(hooks) {
	    const wrappedHooks = {};
	    Object.keys(hooks).forEach((key)=>{
	        const hook = hooks[key];
	        // ref objects should be passed straight through without wrapping
	        if (key.endsWith('Ref')) {
	            wrappedHooks[key] = hooks[key];
	        } else {
	            const wrappedHook = wrapHookToRecognizeElement(hook);
	            wrappedHooks[key] = ()=>wrappedHook
	            ;
	        }
	    });
	    return wrappedHooks;
	}
	function setRef(ref, node) {
	    if (typeof ref === 'function') {
	        ref(node);
	    } else {
	        ref.current = node;
	    }
	}
	function cloneWithRef(element, newRef) {
	    const previousRef = element.ref;
	    invariant$1(typeof previousRef !== 'string', 'Cannot connect React DnD to an element with an existing string ref. ' + 'Please convert it to use a callback ref instead, or wrap it into a <span> or <div>. ' + 'Read more: https://reactjs.org/docs/refs-and-the-dom.html#callback-refs');
	    if (!previousRef) {
	        // When there is no ref on the element, use the new ref directly
	        return reactExports.cloneElement(element, {
	            ref: newRef
	        });
	    } else {
	        return reactExports.cloneElement(element, {
	            ref: (node)=>{
	                setRef(previousRef, node);
	                setRef(newRef, node);
	            }
	        });
	    }
	}

	class TargetConnector {
	    get connectTarget() {
	        return this.dropTarget;
	    }
	    reconnect() {
	        // if nothing has changed then don't resubscribe
	        const didChange = this.didHandlerIdChange() || this.didDropTargetChange() || this.didOptionsChange();
	        if (didChange) {
	            this.disconnectDropTarget();
	        }
	        const dropTarget = this.dropTarget;
	        if (!this.handlerId) {
	            return;
	        }
	        if (!dropTarget) {
	            this.lastConnectedDropTarget = dropTarget;
	            return;
	        }
	        if (didChange) {
	            this.lastConnectedHandlerId = this.handlerId;
	            this.lastConnectedDropTarget = dropTarget;
	            this.lastConnectedDropTargetOptions = this.dropTargetOptions;
	            this.unsubscribeDropTarget = this.backend.connectDropTarget(this.handlerId, dropTarget, this.dropTargetOptions);
	        }
	    }
	    receiveHandlerId(newHandlerId) {
	        if (newHandlerId === this.handlerId) {
	            return;
	        }
	        this.handlerId = newHandlerId;
	        this.reconnect();
	    }
	    get dropTargetOptions() {
	        return this.dropTargetOptionsInternal;
	    }
	    set dropTargetOptions(options) {
	        this.dropTargetOptionsInternal = options;
	    }
	    didHandlerIdChange() {
	        return this.lastConnectedHandlerId !== this.handlerId;
	    }
	    didDropTargetChange() {
	        return this.lastConnectedDropTarget !== this.dropTarget;
	    }
	    didOptionsChange() {
	        return !shallowEqual(this.lastConnectedDropTargetOptions, this.dropTargetOptions);
	    }
	    disconnectDropTarget() {
	        if (this.unsubscribeDropTarget) {
	            this.unsubscribeDropTarget();
	            this.unsubscribeDropTarget = undefined;
	        }
	    }
	    get dropTarget() {
	        return this.dropTargetNode || this.dropTargetRef && this.dropTargetRef.current;
	    }
	    clearDropTarget() {
	        this.dropTargetRef = null;
	        this.dropTargetNode = null;
	    }
	    constructor(backend){
	        this.hooks = wrapConnectorHooks({
	            dropTarget: (node, options)=>{
	                this.clearDropTarget();
	                this.dropTargetOptions = options;
	                if (isRef(node)) {
	                    this.dropTargetRef = node;
	                } else {
	                    this.dropTargetNode = node;
	                }
	                this.reconnect();
	            }
	        });
	        this.handlerId = null;
	        // The drop target may either be attached via ref or connect function
	        this.dropTargetRef = null;
	        this.dropTargetOptionsInternal = null;
	        this.lastConnectedHandlerId = null;
	        this.lastConnectedDropTarget = null;
	        this.lastConnectedDropTargetOptions = null;
	        this.backend = backend;
	    }
	}

	/**
	 * Create the React Context
	 */ const DndContext = reactExports.createContext({
	    dragDropManager: undefined
	});

	var jsxRuntime = {exports: {}};

	var reactJsxRuntime_production_min = {};

	var f$2=reactExports,k$4=Symbol.for("react.element"),l$5=Symbol.for("react.fragment"),m$3=Object.prototype.hasOwnProperty,n$4=f$2.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p$3={key:!0,ref:!0,__self:!0,__source:!0};
	function q$2(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=""+g);void 0!==a.key&&(e=""+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m$3.call(a,b)&&!p$3.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return {$$typeof:k$4,type:c,key:e,ref:h,props:d,_owner:n$4.current}}reactJsxRuntime_production_min.Fragment=l$5;reactJsxRuntime_production_min.jsx=q$2;reactJsxRuntime_production_min.jsxs=q$2;

	{
	  jsxRuntime.exports = reactJsxRuntime_production_min;
	}

	var jsxRuntimeExports = jsxRuntime.exports;

	// src/utils/formatProdErrorMessage.ts
	function formatProdErrorMessage$1(code) {
	  return `Minified Redux error #${code}; visit https://redux.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
	}

	// src/utils/symbol-observable.ts
	var $$observable = /* @__PURE__ */ (() => typeof Symbol === "function" && Symbol.observable || "@@observable")();
	var symbol_observable_default = $$observable;

	// src/utils/actionTypes.ts
	var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
	var ActionTypes = {
	  INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
	  REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
	  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`
	};
	var actionTypes_default = ActionTypes;

	// src/utils/isPlainObject.ts
	function isPlainObject$3(obj) {
	  if (typeof obj !== "object" || obj === null)
	    return false;
	  let proto = obj;
	  while (Object.getPrototypeOf(proto) !== null) {
	    proto = Object.getPrototypeOf(proto);
	  }
	  return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;
	}

	// src/createStore.ts
	function createStore(reducer, preloadedState, enhancer) {
	  if (typeof reducer !== "function") {
	    throw new Error(formatProdErrorMessage$1(2) );
	  }
	  if (typeof preloadedState === "function" && typeof enhancer === "function" || typeof enhancer === "function" && typeof arguments[3] === "function") {
	    throw new Error(formatProdErrorMessage$1(0) );
	  }
	  if (typeof preloadedState === "function" && typeof enhancer === "undefined") {
	    enhancer = preloadedState;
	    preloadedState = void 0;
	  }
	  if (typeof enhancer !== "undefined") {
	    if (typeof enhancer !== "function") {
	      throw new Error(formatProdErrorMessage$1(1) );
	    }
	    return enhancer(createStore)(reducer, preloadedState);
	  }
	  let currentReducer = reducer;
	  let currentState = preloadedState;
	  let currentListeners = /* @__PURE__ */ new Map();
	  let nextListeners = currentListeners;
	  let listenerIdCounter = 0;
	  let isDispatching = false;
	  function ensureCanMutateNextListeners() {
	    if (nextListeners === currentListeners) {
	      nextListeners = /* @__PURE__ */ new Map();
	      currentListeners.forEach((listener, key) => {
	        nextListeners.set(key, listener);
	      });
	    }
	  }
	  function getState() {
	    if (isDispatching) {
	      throw new Error(formatProdErrorMessage$1(3) );
	    }
	    return currentState;
	  }
	  function subscribe(listener) {
	    if (typeof listener !== "function") {
	      throw new Error(formatProdErrorMessage$1(4) );
	    }
	    if (isDispatching) {
	      throw new Error(formatProdErrorMessage$1(5) );
	    }
	    let isSubscribed = true;
	    ensureCanMutateNextListeners();
	    const listenerId = listenerIdCounter++;
	    nextListeners.set(listenerId, listener);
	    return function unsubscribe() {
	      if (!isSubscribed) {
	        return;
	      }
	      if (isDispatching) {
	        throw new Error(formatProdErrorMessage$1(6) );
	      }
	      isSubscribed = false;
	      ensureCanMutateNextListeners();
	      nextListeners.delete(listenerId);
	      currentListeners = null;
	    };
	  }
	  function dispatch(action) {
	    if (!isPlainObject$3(action)) {
	      throw new Error(formatProdErrorMessage$1(7) );
	    }
	    if (typeof action.type === "undefined") {
	      throw new Error(formatProdErrorMessage$1(8) );
	    }
	    if (typeof action.type !== "string") {
	      throw new Error(formatProdErrorMessage$1(17) );
	    }
	    if (isDispatching) {
	      throw new Error(formatProdErrorMessage$1(9) );
	    }
	    try {
	      isDispatching = true;
	      currentState = currentReducer(currentState, action);
	    } finally {
	      isDispatching = false;
	    }
	    const listeners = currentListeners = nextListeners;
	    listeners.forEach((listener) => {
	      listener();
	    });
	    return action;
	  }
	  function replaceReducer(nextReducer) {
	    if (typeof nextReducer !== "function") {
	      throw new Error(formatProdErrorMessage$1(10) );
	    }
	    currentReducer = nextReducer;
	    dispatch({
	      type: actionTypes_default.REPLACE
	    });
	  }
	  function observable() {
	    const outerSubscribe = subscribe;
	    return {
	      /**
	       * The minimal observable subscription method.
	       * @param observer Any object that can be used as an observer.
	       * The observer object should have a `next` method.
	       * @returns An object with an `unsubscribe` method that can
	       * be used to unsubscribe the observable from the store, and prevent further
	       * emission of values from the observable.
	       */
	      subscribe(observer) {
	        if (typeof observer !== "object" || observer === null) {
	          throw new Error(formatProdErrorMessage$1(11) );
	        }
	        function observeState() {
	          const observerAsObserver = observer;
	          if (observerAsObserver.next) {
	            observerAsObserver.next(getState());
	          }
	        }
	        observeState();
	        const unsubscribe = outerSubscribe(observeState);
	        return {
	          unsubscribe
	        };
	      },
	      [symbol_observable_default]() {
	        return this;
	      }
	    };
	  }
	  dispatch({
	    type: actionTypes_default.INIT
	  });
	  const store = {
	    dispatch,
	    subscribe,
	    getState,
	    replaceReducer,
	    [symbol_observable_default]: observable
	  };
	  return store;
	}
	function assertReducerShape(reducers) {
	  Object.keys(reducers).forEach((key) => {
	    const reducer = reducers[key];
	    const initialState = reducer(void 0, {
	      type: actionTypes_default.INIT
	    });
	    if (typeof initialState === "undefined") {
	      throw new Error(formatProdErrorMessage$1(12) );
	    }
	    if (typeof reducer(void 0, {
	      type: actionTypes_default.PROBE_UNKNOWN_ACTION()
	    }) === "undefined") {
	      throw new Error(formatProdErrorMessage$1(13) );
	    }
	  });
	}
	function combineReducers(reducers) {
	  const reducerKeys = Object.keys(reducers);
	  const finalReducers = {};
	  for (let i = 0; i < reducerKeys.length; i++) {
	    const key = reducerKeys[i];
	    if (typeof reducers[key] === "function") {
	      finalReducers[key] = reducers[key];
	    }
	  }
	  const finalReducerKeys = Object.keys(finalReducers);
	  let shapeAssertionError;
	  try {
	    assertReducerShape(finalReducers);
	  } catch (e) {
	    shapeAssertionError = e;
	  }
	  return function combination(state = {}, action) {
	    if (shapeAssertionError) {
	      throw shapeAssertionError;
	    }
	    let hasChanged = false;
	    const nextState = {};
	    for (let i = 0; i < finalReducerKeys.length; i++) {
	      const key = finalReducerKeys[i];
	      const reducer = finalReducers[key];
	      const previousStateForKey = state[key];
	      const nextStateForKey = reducer(previousStateForKey, action);
	      if (typeof nextStateForKey === "undefined") {
	        action && action.type;
	        throw new Error(formatProdErrorMessage$1(14) );
	      }
	      nextState[key] = nextStateForKey;
	      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
	    }
	    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;
	    return hasChanged ? nextState : state;
	  };
	}

	// src/compose.ts
	function compose(...funcs) {
	  if (funcs.length === 0) {
	    return (arg) => arg;
	  }
	  if (funcs.length === 1) {
	    return funcs[0];
	  }
	  return funcs.reduce((a, b) => (...args) => a(b(...args)));
	}

	// src/applyMiddleware.ts
	function applyMiddleware(...middlewares) {
	  return (createStore2) => (reducer, preloadedState) => {
	    const store = createStore2(reducer, preloadedState);
	    let dispatch = () => {
	      throw new Error(formatProdErrorMessage$1(15) );
	    };
	    const middlewareAPI = {
	      getState: store.getState,
	      dispatch: (action, ...args) => dispatch(action, ...args)
	    };
	    const chain = middlewares.map((middleware) => middleware(middlewareAPI));
	    dispatch = compose(...chain)(store.dispatch);
	    return {
	      ...store,
	      dispatch
	    };
	  };
	}

	// src/utils/isAction.ts
	function isAction(action) {
	  return isPlainObject$3(action) && "type" in action && typeof action.type === "string";
	}

	// cheap lodash replacements
	/**
	 * drop-in replacement for _.get
	 * @param obj
	 * @param path
	 * @param defaultValue
	 */ function get$3(obj, path, defaultValue) {
	    return path.split('.').reduce((a, c)=>a && a[c] ? a[c] : defaultValue || null
	    , obj);
	}
	/**
	 * drop-in replacement for _.without
	 */ function without$1(items, item) {
	    return items.filter((i)=>i !== item
	    );
	}
	/**
	 * drop-in replacement for _.isString
	 * @param input
	 */ function isObject(input) {
	    return typeof input === 'object';
	}
	/**
	 * replacement for _.xor
	 * @param itemsA
	 * @param itemsB
	 */ function xor(itemsA, itemsB) {
	    const map = new Map();
	    const insertItem = (item)=>{
	        map.set(item, map.has(item) ? map.get(item) + 1 : 1);
	    };
	    itemsA.forEach(insertItem);
	    itemsB.forEach(insertItem);
	    const result = [];
	    map.forEach((count, key)=>{
	        if (count === 1) {
	            result.push(key);
	        }
	    });
	    return result;
	}
	/**
	 * replacement for _.intersection
	 * @param itemsA
	 * @param itemsB
	 */ function intersection(itemsA, itemsB) {
	    return itemsA.filter((t)=>itemsB.indexOf(t) > -1
	    );
	}

	const INIT_COORDS = 'dnd-core/INIT_COORDS';
	const BEGIN_DRAG = 'dnd-core/BEGIN_DRAG';
	const PUBLISH_DRAG_SOURCE = 'dnd-core/PUBLISH_DRAG_SOURCE';
	const HOVER = 'dnd-core/HOVER';
	const DROP = 'dnd-core/DROP';
	const END_DRAG = 'dnd-core/END_DRAG';

	function setClientOffset(clientOffset, sourceClientOffset) {
	    return {
	        type: INIT_COORDS,
	        payload: {
	            sourceClientOffset: sourceClientOffset || null,
	            clientOffset: clientOffset || null
	        }
	    };
	}

	const ResetCoordinatesAction = {
	    type: INIT_COORDS,
	    payload: {
	        clientOffset: null,
	        sourceClientOffset: null
	    }
	};
	function createBeginDrag(manager) {
	    return function beginDrag(sourceIds = [], options = {
	        publishSource: true
	    }) {
	        const { publishSource =true , clientOffset , getSourceClientOffset ,  } = options;
	        const monitor = manager.getMonitor();
	        const registry = manager.getRegistry();
	        // Initialize the coordinates using the client offset
	        manager.dispatch(setClientOffset(clientOffset));
	        verifyInvariants$1(sourceIds, monitor, registry);
	        // Get the draggable source
	        const sourceId = getDraggableSource(sourceIds, monitor);
	        if (sourceId == null) {
	            manager.dispatch(ResetCoordinatesAction);
	            return;
	        }
	        // Get the source client offset
	        let sourceClientOffset = null;
	        if (clientOffset) {
	            if (!getSourceClientOffset) {
	                throw new Error('getSourceClientOffset must be defined');
	            }
	            verifyGetSourceClientOffsetIsFunction(getSourceClientOffset);
	            sourceClientOffset = getSourceClientOffset(sourceId);
	        }
	        // Initialize the full coordinates
	        manager.dispatch(setClientOffset(clientOffset, sourceClientOffset));
	        const source = registry.getSource(sourceId);
	        const item = source.beginDrag(monitor, sourceId);
	        // If source.beginDrag returns null, this is an indicator to cancel the drag
	        if (item == null) {
	            return undefined;
	        }
	        verifyItemIsObject(item);
	        registry.pinSource(sourceId);
	        const itemType = registry.getSourceType(sourceId);
	        return {
	            type: BEGIN_DRAG,
	            payload: {
	                itemType,
	                item,
	                sourceId,
	                clientOffset: clientOffset || null,
	                sourceClientOffset: sourceClientOffset || null,
	                isSourcePublic: !!publishSource
	            }
	        };
	    };
	}
	function verifyInvariants$1(sourceIds, monitor, registry) {
	    invariant$1(!monitor.isDragging(), 'Cannot call beginDrag while dragging.');
	    sourceIds.forEach(function(sourceId) {
	        invariant$1(registry.getSource(sourceId), 'Expected sourceIds to be registered.');
	    });
	}
	function verifyGetSourceClientOffsetIsFunction(getSourceClientOffset) {
	    invariant$1(typeof getSourceClientOffset === 'function', 'When clientOffset is provided, getSourceClientOffset must be a function.');
	}
	function verifyItemIsObject(item) {
	    invariant$1(isObject(item), 'Item must be an object.');
	}
	function getDraggableSource(sourceIds, monitor) {
	    let sourceId = null;
	    for(let i = sourceIds.length - 1; i >= 0; i--){
	        if (monitor.canDragSource(sourceIds[i])) {
	            sourceId = sourceIds[i];
	            break;
	        }
	    }
	    return sourceId;
	}

	function _defineProperty$5(obj, key, value) {
	    if (key in obj) {
	        Object.defineProperty(obj, key, {
	            value: value,
	            enumerable: true,
	            configurable: true,
	            writable: true
	        });
	    } else {
	        obj[key] = value;
	    }
	    return obj;
	}
	function _objectSpread$7(target) {
	    for(var i = 1; i < arguments.length; i++){
	        var source = arguments[i] != null ? arguments[i] : {};
	        var ownKeys = Object.keys(source);
	        if (typeof Object.getOwnPropertySymbols === 'function') {
	            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
	                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
	            }));
	        }
	        ownKeys.forEach(function(key) {
	            _defineProperty$5(target, key, source[key]);
	        });
	    }
	    return target;
	}
	function createDrop(manager) {
	    return function drop(options = {}) {
	        const monitor = manager.getMonitor();
	        const registry = manager.getRegistry();
	        verifyInvariants(monitor);
	        const targetIds = getDroppableTargets(monitor);
	        // Multiple actions are dispatched here, which is why this doesn't return an action
	        targetIds.forEach((targetId, index)=>{
	            const dropResult = determineDropResult(targetId, index, registry, monitor);
	            const action = {
	                type: DROP,
	                payload: {
	                    dropResult: _objectSpread$7({}, options, dropResult)
	                }
	            };
	            manager.dispatch(action);
	        });
	    };
	}
	function verifyInvariants(monitor) {
	    invariant$1(monitor.isDragging(), 'Cannot call drop while not dragging.');
	    invariant$1(!monitor.didDrop(), 'Cannot call drop twice during one drag operation.');
	}
	function determineDropResult(targetId, index, registry, monitor) {
	    const target = registry.getTarget(targetId);
	    let dropResult = target ? target.drop(monitor, targetId) : undefined;
	    verifyDropResultType(dropResult);
	    if (typeof dropResult === 'undefined') {
	        dropResult = index === 0 ? {} : monitor.getDropResult();
	    }
	    return dropResult;
	}
	function verifyDropResultType(dropResult) {
	    invariant$1(typeof dropResult === 'undefined' || isObject(dropResult), 'Drop result must either be an object or undefined.');
	}
	function getDroppableTargets(monitor) {
	    const targetIds = monitor.getTargetIds().filter(monitor.canDropOnTarget, monitor);
	    targetIds.reverse();
	    return targetIds;
	}

	function createEndDrag(manager) {
	    return function endDrag() {
	        const monitor = manager.getMonitor();
	        const registry = manager.getRegistry();
	        verifyIsDragging(monitor);
	        const sourceId = monitor.getSourceId();
	        if (sourceId != null) {
	            const source = registry.getSource(sourceId, true);
	            source.endDrag(monitor, sourceId);
	            registry.unpinSource();
	        }
	        return {
	            type: END_DRAG
	        };
	    };
	}
	function verifyIsDragging(monitor) {
	    invariant$1(monitor.isDragging(), 'Cannot call endDrag while not dragging.');
	}

	function matchesType(targetType, draggedItemType) {
	    if (draggedItemType === null) {
	        return targetType === null;
	    }
	    return Array.isArray(targetType) ? targetType.some((t)=>t === draggedItemType
	    ) : targetType === draggedItemType;
	}

	function createHover(manager) {
	    return function hover(targetIdsArg, { clientOffset  } = {}) {
	        verifyTargetIdsIsArray(targetIdsArg);
	        const targetIds = targetIdsArg.slice(0);
	        const monitor = manager.getMonitor();
	        const registry = manager.getRegistry();
	        const draggedItemType = monitor.getItemType();
	        removeNonMatchingTargetIds(targetIds, registry, draggedItemType);
	        checkInvariants(targetIds, monitor, registry);
	        hoverAllTargets(targetIds, monitor, registry);
	        return {
	            type: HOVER,
	            payload: {
	                targetIds,
	                clientOffset: clientOffset || null
	            }
	        };
	    };
	}
	function verifyTargetIdsIsArray(targetIdsArg) {
	    invariant$1(Array.isArray(targetIdsArg), 'Expected targetIds to be an array.');
	}
	function checkInvariants(targetIds, monitor, registry) {
	    invariant$1(monitor.isDragging(), 'Cannot call hover while not dragging.');
	    invariant$1(!monitor.didDrop(), 'Cannot call hover after drop.');
	    for(let i = 0; i < targetIds.length; i++){
	        const targetId = targetIds[i];
	        invariant$1(targetIds.lastIndexOf(targetId) === i, 'Expected targetIds to be unique in the passed array.');
	        const target = registry.getTarget(targetId);
	        invariant$1(target, 'Expected targetIds to be registered.');
	    }
	}
	function removeNonMatchingTargetIds(targetIds, registry, draggedItemType) {
	    // Remove those targetIds that don't match the targetType.  This
	    // fixes shallow isOver which would only be non-shallow because of
	    // non-matching targets.
	    for(let i = targetIds.length - 1; i >= 0; i--){
	        const targetId = targetIds[i];
	        const targetType = registry.getTargetType(targetId);
	        if (!matchesType(targetType, draggedItemType)) {
	            targetIds.splice(i, 1);
	        }
	    }
	}
	function hoverAllTargets(targetIds, monitor, registry) {
	    // Finally call hover on all matching targets.
	    targetIds.forEach(function(targetId) {
	        const target = registry.getTarget(targetId);
	        target.hover(monitor, targetId);
	    });
	}

	function createPublishDragSource(manager) {
	    return function publishDragSource() {
	        const monitor = manager.getMonitor();
	        if (monitor.isDragging()) {
	            return {
	                type: PUBLISH_DRAG_SOURCE
	            };
	        }
	        return;
	    };
	}

	function createDragDropActions(manager) {
	    return {
	        beginDrag: createBeginDrag(manager),
	        publishDragSource: createPublishDragSource(manager),
	        hover: createHover(manager),
	        drop: createDrop(manager),
	        endDrag: createEndDrag(manager)
	    };
	}

	class DragDropManagerImpl {
	    receiveBackend(backend) {
	        this.backend = backend;
	    }
	    getMonitor() {
	        return this.monitor;
	    }
	    getBackend() {
	        return this.backend;
	    }
	    getRegistry() {
	        return this.monitor.registry;
	    }
	    getActions() {
	        /* eslint-disable-next-line @typescript-eslint/no-this-alias */ const manager = this;
	        const { dispatch  } = this.store;
	        function bindActionCreator(actionCreator) {
	            return (...args)=>{
	                const action = actionCreator.apply(manager, args);
	                if (typeof action !== 'undefined') {
	                    dispatch(action);
	                }
	            };
	        }
	        const actions = createDragDropActions(this);
	        return Object.keys(actions).reduce((boundActions, key)=>{
	            const action = actions[key];
	            boundActions[key] = bindActionCreator(action);
	            return boundActions;
	        }, {});
	    }
	    dispatch(action) {
	        this.store.dispatch(action);
	    }
	    constructor(store, monitor){
	        this.isSetUp = false;
	        this.handleRefCountChange = ()=>{
	            const shouldSetUp = this.store.getState().refCount > 0;
	            if (this.backend) {
	                if (shouldSetUp && !this.isSetUp) {
	                    this.backend.setup();
	                    this.isSetUp = true;
	                } else if (!shouldSetUp && this.isSetUp) {
	                    this.backend.teardown();
	                    this.isSetUp = false;
	                }
	            }
	        };
	        this.store = store;
	        this.monitor = monitor;
	        store.subscribe(this.handleRefCountChange);
	    }
	}

	/**
	 * Coordinate addition
	 * @param a The first coordinate
	 * @param b The second coordinate
	 */ function add(a, b) {
	    return {
	        x: a.x + b.x,
	        y: a.y + b.y
	    };
	}
	/**
	 * Coordinate subtraction
	 * @param a The first coordinate
	 * @param b The second coordinate
	 */ function subtract(a, b) {
	    return {
	        x: a.x - b.x,
	        y: a.y - b.y
	    };
	}
	/**
	 * Returns the cartesian distance of the drag source component's position, based on its position
	 * at the time when the current drag operation has started, and the movement difference.
	 *
	 * Returns null if no item is being dragged.
	 *
	 * @param state The offset state to compute from
	 */ function getSourceClientOffset(state) {
	    const { clientOffset , initialClientOffset , initialSourceClientOffset  } = state;
	    if (!clientOffset || !initialClientOffset || !initialSourceClientOffset) {
	        return null;
	    }
	    return subtract(add(clientOffset, initialSourceClientOffset), initialClientOffset);
	}
	/**
	 * Determines the x,y offset between the client offset and the initial client offset
	 *
	 * @param state The offset state to compute from
	 */ function getDifferenceFromInitialOffset(state) {
	    const { clientOffset , initialClientOffset  } = state;
	    if (!clientOffset || !initialClientOffset) {
	        return null;
	    }
	    return subtract(clientOffset, initialClientOffset);
	}

	const NONE = [];
	const ALL = [];
	NONE.__IS_NONE__ = true;
	ALL.__IS_ALL__ = true;
	/**
	 * Determines if the given handler IDs are dirty or not.
	 *
	 * @param dirtyIds The set of dirty handler ids
	 * @param handlerIds The set of handler ids to check
	 */ function areDirty(dirtyIds, handlerIds) {
	    if (dirtyIds === NONE) {
	        return false;
	    }
	    if (dirtyIds === ALL || typeof handlerIds === 'undefined') {
	        return true;
	    }
	    const commonIds = intersection(handlerIds, dirtyIds);
	    return commonIds.length > 0;
	}

	class DragDropMonitorImpl {
	    subscribeToStateChange(listener, options = {}) {
	        const { handlerIds  } = options;
	        invariant$1(typeof listener === 'function', 'listener must be a function.');
	        invariant$1(typeof handlerIds === 'undefined' || Array.isArray(handlerIds), 'handlerIds, when specified, must be an array of strings.');
	        let prevStateId = this.store.getState().stateId;
	        const handleChange = ()=>{
	            const state = this.store.getState();
	            const currentStateId = state.stateId;
	            try {
	                const canSkipListener = currentStateId === prevStateId || currentStateId === prevStateId + 1 && !areDirty(state.dirtyHandlerIds, handlerIds);
	                if (!canSkipListener) {
	                    listener();
	                }
	            } finally{
	                prevStateId = currentStateId;
	            }
	        };
	        return this.store.subscribe(handleChange);
	    }
	    subscribeToOffsetChange(listener) {
	        invariant$1(typeof listener === 'function', 'listener must be a function.');
	        let previousState = this.store.getState().dragOffset;
	        const handleChange = ()=>{
	            const nextState = this.store.getState().dragOffset;
	            if (nextState === previousState) {
	                return;
	            }
	            previousState = nextState;
	            listener();
	        };
	        return this.store.subscribe(handleChange);
	    }
	    canDragSource(sourceId) {
	        if (!sourceId) {
	            return false;
	        }
	        const source = this.registry.getSource(sourceId);
	        invariant$1(source, `Expected to find a valid source. sourceId=${sourceId}`);
	        if (this.isDragging()) {
	            return false;
	        }
	        return source.canDrag(this, sourceId);
	    }
	    canDropOnTarget(targetId) {
	        // undefined on initial render
	        if (!targetId) {
	            return false;
	        }
	        const target = this.registry.getTarget(targetId);
	        invariant$1(target, `Expected to find a valid target. targetId=${targetId}`);
	        if (!this.isDragging() || this.didDrop()) {
	            return false;
	        }
	        const targetType = this.registry.getTargetType(targetId);
	        const draggedItemType = this.getItemType();
	        return matchesType(targetType, draggedItemType) && target.canDrop(this, targetId);
	    }
	    isDragging() {
	        return Boolean(this.getItemType());
	    }
	    isDraggingSource(sourceId) {
	        // undefined on initial render
	        if (!sourceId) {
	            return false;
	        }
	        const source = this.registry.getSource(sourceId, true);
	        invariant$1(source, `Expected to find a valid source. sourceId=${sourceId}`);
	        if (!this.isDragging() || !this.isSourcePublic()) {
	            return false;
	        }
	        const sourceType = this.registry.getSourceType(sourceId);
	        const draggedItemType = this.getItemType();
	        if (sourceType !== draggedItemType) {
	            return false;
	        }
	        return source.isDragging(this, sourceId);
	    }
	    isOverTarget(targetId, options = {
	        shallow: false
	    }) {
	        // undefined on initial render
	        if (!targetId) {
	            return false;
	        }
	        const { shallow  } = options;
	        if (!this.isDragging()) {
	            return false;
	        }
	        const targetType = this.registry.getTargetType(targetId);
	        const draggedItemType = this.getItemType();
	        if (draggedItemType && !matchesType(targetType, draggedItemType)) {
	            return false;
	        }
	        const targetIds = this.getTargetIds();
	        if (!targetIds.length) {
	            return false;
	        }
	        const index = targetIds.indexOf(targetId);
	        if (shallow) {
	            return index === targetIds.length - 1;
	        } else {
	            return index > -1;
	        }
	    }
	    getItemType() {
	        return this.store.getState().dragOperation.itemType;
	    }
	    getItem() {
	        return this.store.getState().dragOperation.item;
	    }
	    getSourceId() {
	        return this.store.getState().dragOperation.sourceId;
	    }
	    getTargetIds() {
	        return this.store.getState().dragOperation.targetIds;
	    }
	    getDropResult() {
	        return this.store.getState().dragOperation.dropResult;
	    }
	    didDrop() {
	        return this.store.getState().dragOperation.didDrop;
	    }
	    isSourcePublic() {
	        return Boolean(this.store.getState().dragOperation.isSourcePublic);
	    }
	    getInitialClientOffset() {
	        return this.store.getState().dragOffset.initialClientOffset;
	    }
	    getInitialSourceClientOffset() {
	        return this.store.getState().dragOffset.initialSourceClientOffset;
	    }
	    getClientOffset() {
	        return this.store.getState().dragOffset.clientOffset;
	    }
	    getSourceClientOffset() {
	        return getSourceClientOffset(this.store.getState().dragOffset);
	    }
	    getDifferenceFromInitialOffset() {
	        return getDifferenceFromInitialOffset(this.store.getState().dragOffset);
	    }
	    constructor(store, registry){
	        this.store = store;
	        this.registry = registry;
	    }
	}

	// Safari 6 and 6.1 for desktop, iPad, and iPhone are the only browsers that
	// have WebKitMutationObserver but not un-prefixed MutationObserver.
	// Must use `global` or `self` instead of `window` to work in both frames and web
	// workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.
	/* globals self */ const scope = typeof global !== 'undefined' ? global : self;
	const BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver;
	function makeRequestCallFromTimer(callback) {
	    return function requestCall() {
	        // We dispatch a timeout with a specified delay of 0 for engines that
	        // can reliably accommodate that request. This will usually be snapped
	        // to a 4 milisecond delay, but once we're flushing, there's no delay
	        // between events.
	        const timeoutHandle = setTimeout(handleTimer, 0);
	        // However, since this timer gets frequently dropped in Firefox
	        // workers, we enlist an interval handle that will try to fire
	        // an event 20 times per second until it succeeds.
	        const intervalHandle = setInterval(handleTimer, 50);
	        function handleTimer() {
	            // Whichever timer succeeds will cancel both timers and
	            // execute the callback.
	            clearTimeout(timeoutHandle);
	            clearInterval(intervalHandle);
	            callback();
	        }
	    };
	}
	// To request a high priority event, we induce a mutation observer by toggling
	// the text of a text node between "1" and "-1".
	function makeRequestCallFromMutationObserver(callback) {
	    let toggle = 1;
	    const observer = new BrowserMutationObserver(callback);
	    const node = document.createTextNode('');
	    observer.observe(node, {
	        characterData: true
	    });
	    return function requestCall() {
	        toggle = -toggle;
	        node.data = toggle;
	    };
	}
	const makeRequestCall = typeof BrowserMutationObserver === 'function' ? // reliably everywhere they are implemented.
	// They are implemented in all modern browsers.
	//
	// - Android 4-4.3
	// - Chrome 26-34
	// - Firefox 14-29
	// - Internet Explorer 11
	// - iPad Safari 6-7.1
	// - iPhone Safari 7-7.1
	// - Safari 6-7
	makeRequestCallFromMutationObserver : // task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera
	// 11-12, and in web workers in many engines.
	// Although message channels yield to any queued rendering and IO tasks, they
	// would be better than imposing the 4ms delay of timers.
	// However, they do not work reliably in Internet Explorer or Safari.
	// Internet Explorer 10 is the only browser that has setImmediate but does
	// not have MutationObservers.
	// Although setImmediate yields to the browser's renderer, it would be
	// preferrable to falling back to setTimeout since it does not have
	// the minimum 4ms penalty.
	// Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and
	// Desktop to a lesser extent) that renders both setImmediate and
	// MessageChannel useless for the purposes of ASAP.
	// https://github.com/kriskowal/q/issues/396
	// Timers are implemented universally.
	// We fall back to timers in workers in most engines, and in foreground
	// contexts in the following browsers.
	// However, note that even this simple case requires nuances to operate in a
	// broad spectrum of browsers.
	//
	// - Firefox 3-13
	// - Internet Explorer 6-9
	// - iPad Safari 4.3
	// - Lynx 2.8.7
	makeRequestCallFromTimer;

	class AsapQueue {
	    // Use the fastest means possible to execute a task in its own turn, with
	    // priority over other events including IO, animation, reflow, and redraw
	    // events in browsers.
	    //
	    // An exception thrown by a task will permanently interrupt the processing of
	    // subsequent tasks. The higher level `asap` function ensures that if an
	    // exception is thrown by a task, that the task queue will continue flushing as
	    // soon as possible, but if you use `rawAsap` directly, you are responsible to
	    // either ensure that no exceptions are thrown from your task, or to manually
	    // call `rawAsap.requestFlush` if an exception is thrown.
	    enqueueTask(task) {
	        const { queue: q , requestFlush  } = this;
	        if (!q.length) {
	            requestFlush();
	            this.flushing = true;
	        }
	        // Equivalent to push, but avoids a function call.
	        q[q.length] = task;
	    }
	    constructor(){
	        this.queue = [];
	        // We queue errors to ensure they are thrown in right order (FIFO).
	        // Array-as-queue is good enough here, since we are just dealing with exceptions.
	        this.pendingErrors = [];
	        // Once a flush has been requested, no further calls to `requestFlush` are
	        // necessary until the next `flush` completes.
	        // @ts-ignore
	        this.flushing = false;
	        // The position of the next task to execute in the task queue. This is
	        // preserved between calls to `flush` so that it can be resumed if
	        // a task throws an exception.
	        this.index = 0;
	        // If a task schedules additional tasks recursively, the task queue can grow
	        // unbounded. To prevent memory exhaustion, the task queue will periodically
	        // truncate already-completed tasks.
	        this.capacity = 1024;
	        // The flush function processes all tasks that have been scheduled with
	        // `rawAsap` unless and until one of those tasks throws an exception.
	        // If a task throws an exception, `flush` ensures that its state will remain
	        // consistent and will resume where it left off when called again.
	        // However, `flush` does not make any arrangements to be called again if an
	        // exception is thrown.
	        this.flush = ()=>{
	            const { queue: q  } = this;
	            while(this.index < q.length){
	                const currentIndex = this.index;
	                // Advance the index before calling the task. This ensures that we will
	                // begin flushing on the next task the task throws an error.
	                this.index++;
	                q[currentIndex].call();
	                // Prevent leaking memory for long chains of recursive calls to `asap`.
	                // If we call `asap` within tasks scheduled by `asap`, the queue will
	                // grow, but to avoid an O(n) walk for every task we execute, we don't
	                // shift tasks off the queue after they have been executed.
	                // Instead, we periodically shift 1024 tasks off the queue.
	                if (this.index > this.capacity) {
	                    // Manually shift all values starting at the index back to the
	                    // beginning of the queue.
	                    for(let scan = 0, newLength = q.length - this.index; scan < newLength; scan++){
	                        q[scan] = q[scan + this.index];
	                    }
	                    q.length -= this.index;
	                    this.index = 0;
	                }
	            }
	            q.length = 0;
	            this.index = 0;
	            this.flushing = false;
	        };
	        // In a web browser, exceptions are not fatal. However, to avoid
	        // slowing down the queue of pending tasks, we rethrow the error in a
	        // lower priority turn.
	        this.registerPendingError = (err)=>{
	            this.pendingErrors.push(err);
	            this.requestErrorThrow();
	        };
	        // `requestFlush` requests that the high priority event queue be flushed as
	        // soon as possible.
	        // This is useful to prevent an error thrown in a task from stalling the event
	        // queue if the exception handled by Node.js’s
	        // `process.on("uncaughtException")` or by a domain.
	        // `requestFlush` is implemented using a strategy based on data collected from
	        // every available SauceLabs Selenium web driver worker at time of writing.
	        // https://docs.google.com/spreadsheets/d/1mG-5UYGup5qxGdEMWkhP6BWCz053NUb2E1QoUTU16uA/edit#gid=783724593
	        this.requestFlush = makeRequestCall(this.flush);
	        this.requestErrorThrow = makeRequestCallFromTimer(()=>{
	            // Throw first error
	            if (this.pendingErrors.length) {
	                throw this.pendingErrors.shift();
	            }
	        });
	    }
	} // The message channel technique was discovered by Malte Ubl and was the
	 // original foundation for this library.
	 // http://www.nonblocking.io/2011/06/windownexttick.html
	 // Safari 6.0.5 (at least) intermittently fails to create message ports on a
	 // page's first load. Thankfully, this version of Safari supports
	 // MutationObservers, so we don't need to fall back in that case.
	 // function makeRequestCallFromMessageChannel(callback) {
	 //     var channel = new MessageChannel();
	 //     channel.port1.onmessage = callback;
	 //     return function requestCall() {
	 //         channel.port2.postMessage(0);
	 //     };
	 // }
	 // For reasons explained above, we are also unable to use `setImmediate`
	 // under any circumstances.
	 // Even if we were, there is another bug in Internet Explorer 10.
	 // It is not sufficient to assign `setImmediate` to `requestFlush` because
	 // `setImmediate` must be called *by name* and therefore must be wrapped in a
	 // closure.
	 // Never forget.
	 // function makeRequestCallFromSetImmediate(callback) {
	 //     return function requestCall() {
	 //         setImmediate(callback);
	 //     };
	 // }
	 // Safari 6.0 has a problem where timers will get lost while the user is
	 // scrolling. This problem does not impact ASAP because Safari 6.0 supports
	 // mutation observers, so that implementation is used instead.
	 // However, if we ever elect to use timers in Safari, the prevalent work-around
	 // is to add a scroll event listener that calls for a flush.
	 // `setTimeout` does not call the passed callback if the delay is less than
	 // approximately 7 in web workers in Firefox 8 through 18, and sometimes not
	 // even then.
	 // This is for `asap.js` only.
	 // Its name will be periodically randomized to break any code that depends on
	 // // its existence.
	 // rawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer
	 // ASAP was originally a nextTick shim included in Q. This was factored out
	 // into this ASAP package. It was later adapted to RSVP which made further
	 // amendments. These decisions, particularly to marginalize MessageChannel and
	 // to capture the MutationObserver implementation in a closure, were integrated
	 // back into ASAP proper.
	 // https://github.com/tildeio/rsvp.js/blob/cddf7232546a9cf858524b75cde6f9edf72620a7/lib/rsvp/asap.js

	// `call`, just like a function.
	class RawTask {
	    call() {
	        try {
	            this.task && this.task();
	        } catch (error) {
	            this.onError(error);
	        } finally{
	            this.task = null;
	            this.release(this);
	        }
	    }
	    constructor(onError, release){
	        this.onError = onError;
	        this.release = release;
	        this.task = null;
	    }
	}

	class TaskFactory {
	    create(task) {
	        const tasks = this.freeTasks;
	        const t1 = tasks.length ? tasks.pop() : new RawTask(this.onError, (t)=>tasks[tasks.length] = t
	        );
	        t1.task = task;
	        return t1;
	    }
	    constructor(onError){
	        this.onError = onError;
	        this.freeTasks = [];
	    }
	}

	const asapQueue = new AsapQueue();
	const taskFactory = new TaskFactory(asapQueue.registerPendingError);
	/**
	 * Calls a task as soon as possible after returning, in its own event, with priority
	 * over other events like animation, reflow, and repaint. An error thrown from an
	 * event will not interrupt, nor even substantially slow down the processing of
	 * other events, but will be rather postponed to a lower priority event.
	 * @param {{call}} task A callable object, typically a function that takes no
	 * arguments.
	 */ function asap(task) {
	    asapQueue.enqueueTask(taskFactory.create(task));
	}

	const ADD_SOURCE = 'dnd-core/ADD_SOURCE';
	const ADD_TARGET = 'dnd-core/ADD_TARGET';
	const REMOVE_SOURCE = 'dnd-core/REMOVE_SOURCE';
	const REMOVE_TARGET = 'dnd-core/REMOVE_TARGET';
	function addSource(sourceId) {
	    return {
	        type: ADD_SOURCE,
	        payload: {
	            sourceId
	        }
	    };
	}
	function addTarget(targetId) {
	    return {
	        type: ADD_TARGET,
	        payload: {
	            targetId
	        }
	    };
	}
	function removeSource(sourceId) {
	    return {
	        type: REMOVE_SOURCE,
	        payload: {
	            sourceId
	        }
	    };
	}
	function removeTarget(targetId) {
	    return {
	        type: REMOVE_TARGET,
	        payload: {
	            targetId
	        }
	    };
	}

	function validateSourceContract(source) {
	    invariant$1(typeof source.canDrag === 'function', 'Expected canDrag to be a function.');
	    invariant$1(typeof source.beginDrag === 'function', 'Expected beginDrag to be a function.');
	    invariant$1(typeof source.endDrag === 'function', 'Expected endDrag to be a function.');
	}
	function validateTargetContract(target) {
	    invariant$1(typeof target.canDrop === 'function', 'Expected canDrop to be a function.');
	    invariant$1(typeof target.hover === 'function', 'Expected hover to be a function.');
	    invariant$1(typeof target.drop === 'function', 'Expected beginDrag to be a function.');
	}
	function validateType(type, allowArray) {
	    if (allowArray && Array.isArray(type)) {
	        type.forEach((t)=>validateType(t, false)
	        );
	        return;
	    }
	    invariant$1(typeof type === 'string' || typeof type === 'symbol', allowArray ? 'Type can only be a string, a symbol, or an array of either.' : 'Type can only be a string or a symbol.');
	}

	var HandlerRole;
	(function(HandlerRole) {
	    HandlerRole["SOURCE"] = "SOURCE";
	    HandlerRole["TARGET"] = "TARGET";
	})(HandlerRole || (HandlerRole = {}));

	let nextUniqueId = 0;
	function getNextUniqueId() {
	    return nextUniqueId++;
	}

	function getNextHandlerId(role) {
	    const id = getNextUniqueId().toString();
	    switch(role){
	        case HandlerRole.SOURCE:
	            return `S${id}`;
	        case HandlerRole.TARGET:
	            return `T${id}`;
	        default:
	            throw new Error(`Unknown Handler Role: ${role}`);
	    }
	}
	function parseRoleFromHandlerId(handlerId) {
	    switch(handlerId[0]){
	        case 'S':
	            return HandlerRole.SOURCE;
	        case 'T':
	            return HandlerRole.TARGET;
	        default:
	            throw new Error(`Cannot parse handler ID: ${handlerId}`);
	    }
	}
	function mapContainsValue(map, searchValue) {
	    const entries = map.entries();
	    let isDone = false;
	    do {
	        const { done , value: [, value] ,  } = entries.next();
	        if (value === searchValue) {
	            return true;
	        }
	        isDone = !!done;
	    }while (!isDone)
	    return false;
	}
	class HandlerRegistryImpl {
	    addSource(type, source) {
	        validateType(type);
	        validateSourceContract(source);
	        const sourceId = this.addHandler(HandlerRole.SOURCE, type, source);
	        this.store.dispatch(addSource(sourceId));
	        return sourceId;
	    }
	    addTarget(type, target) {
	        validateType(type, true);
	        validateTargetContract(target);
	        const targetId = this.addHandler(HandlerRole.TARGET, type, target);
	        this.store.dispatch(addTarget(targetId));
	        return targetId;
	    }
	    containsHandler(handler) {
	        return mapContainsValue(this.dragSources, handler) || mapContainsValue(this.dropTargets, handler);
	    }
	    getSource(sourceId, includePinned = false) {
	        invariant$1(this.isSourceId(sourceId), 'Expected a valid source ID.');
	        const isPinned = includePinned && sourceId === this.pinnedSourceId;
	        const source = isPinned ? this.pinnedSource : this.dragSources.get(sourceId);
	        return source;
	    }
	    getTarget(targetId) {
	        invariant$1(this.isTargetId(targetId), 'Expected a valid target ID.');
	        return this.dropTargets.get(targetId);
	    }
	    getSourceType(sourceId) {
	        invariant$1(this.isSourceId(sourceId), 'Expected a valid source ID.');
	        return this.types.get(sourceId);
	    }
	    getTargetType(targetId) {
	        invariant$1(this.isTargetId(targetId), 'Expected a valid target ID.');
	        return this.types.get(targetId);
	    }
	    isSourceId(handlerId) {
	        const role = parseRoleFromHandlerId(handlerId);
	        return role === HandlerRole.SOURCE;
	    }
	    isTargetId(handlerId) {
	        const role = parseRoleFromHandlerId(handlerId);
	        return role === HandlerRole.TARGET;
	    }
	    removeSource(sourceId) {
	        invariant$1(this.getSource(sourceId), 'Expected an existing source.');
	        this.store.dispatch(removeSource(sourceId));
	        asap(()=>{
	            this.dragSources.delete(sourceId);
	            this.types.delete(sourceId);
	        });
	    }
	    removeTarget(targetId) {
	        invariant$1(this.getTarget(targetId), 'Expected an existing target.');
	        this.store.dispatch(removeTarget(targetId));
	        this.dropTargets.delete(targetId);
	        this.types.delete(targetId);
	    }
	    pinSource(sourceId) {
	        const source = this.getSource(sourceId);
	        invariant$1(source, 'Expected an existing source.');
	        this.pinnedSourceId = sourceId;
	        this.pinnedSource = source;
	    }
	    unpinSource() {
	        invariant$1(this.pinnedSource, 'No source is pinned at the time.');
	        this.pinnedSourceId = null;
	        this.pinnedSource = null;
	    }
	    addHandler(role, type, handler) {
	        const id = getNextHandlerId(role);
	        this.types.set(id, type);
	        if (role === HandlerRole.SOURCE) {
	            this.dragSources.set(id, handler);
	        } else if (role === HandlerRole.TARGET) {
	            this.dropTargets.set(id, handler);
	        }
	        return id;
	    }
	    constructor(store){
	        this.types = new Map();
	        this.dragSources = new Map();
	        this.dropTargets = new Map();
	        this.pinnedSourceId = null;
	        this.pinnedSource = null;
	        this.store = store;
	    }
	}

	const strictEquality = (a, b)=>a === b
	;
	/**
	 * Determine if two cartesian coordinate offsets are equal
	 * @param offsetA
	 * @param offsetB
	 */ function areCoordsEqual(offsetA, offsetB) {
	    if (!offsetA && !offsetB) {
	        return true;
	    } else if (!offsetA || !offsetB) {
	        return false;
	    } else {
	        return offsetA.x === offsetB.x && offsetA.y === offsetB.y;
	    }
	}
	/**
	 * Determines if two arrays of items are equal
	 * @param a The first array of items
	 * @param b The second array of items
	 */ function areArraysEqual(a, b, isEqual = strictEquality) {
	    if (a.length !== b.length) {
	        return false;
	    }
	    for(let i = 0; i < a.length; ++i){
	        if (!isEqual(a[i], b[i])) {
	            return false;
	        }
	    }
	    return true;
	}

	function reduce$5(// eslint-disable-next-line @typescript-eslint/no-unused-vars
	_state = NONE, action) {
	    switch(action.type){
	        case HOVER:
	            break;
	        case ADD_SOURCE:
	        case ADD_TARGET:
	        case REMOVE_TARGET:
	        case REMOVE_SOURCE:
	            return NONE;
	        case BEGIN_DRAG:
	        case PUBLISH_DRAG_SOURCE:
	        case END_DRAG:
	        case DROP:
	        default:
	            return ALL;
	    }
	    const { targetIds =[] , prevTargetIds =[]  } = action.payload;
	    const result = xor(targetIds, prevTargetIds);
	    const didChange = result.length > 0 || !areArraysEqual(targetIds, prevTargetIds);
	    if (!didChange) {
	        return NONE;
	    }
	    // Check the target ids at the innermost position. If they are valid, add them
	    // to the result
	    const prevInnermostTargetId = prevTargetIds[prevTargetIds.length - 1];
	    const innermostTargetId = targetIds[targetIds.length - 1];
	    if (prevInnermostTargetId !== innermostTargetId) {
	        if (prevInnermostTargetId) {
	            result.push(prevInnermostTargetId);
	        }
	        if (innermostTargetId) {
	            result.push(innermostTargetId);
	        }
	    }
	    return result;
	}

	function _defineProperty$4(obj, key, value) {
	    if (key in obj) {
	        Object.defineProperty(obj, key, {
	            value: value,
	            enumerable: true,
	            configurable: true,
	            writable: true
	        });
	    } else {
	        obj[key] = value;
	    }
	    return obj;
	}
	function _objectSpread$6(target) {
	    for(var i = 1; i < arguments.length; i++){
	        var source = arguments[i] != null ? arguments[i] : {};
	        var ownKeys = Object.keys(source);
	        if (typeof Object.getOwnPropertySymbols === 'function') {
	            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
	                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
	            }));
	        }
	        ownKeys.forEach(function(key) {
	            _defineProperty$4(target, key, source[key]);
	        });
	    }
	    return target;
	}
	const initialState$2 = {
	    initialSourceClientOffset: null,
	    initialClientOffset: null,
	    clientOffset: null
	};
	function reduce$4(state = initialState$2, action) {
	    const { payload  } = action;
	    switch(action.type){
	        case INIT_COORDS:
	        case BEGIN_DRAG:
	            return {
	                initialSourceClientOffset: payload.sourceClientOffset,
	                initialClientOffset: payload.clientOffset,
	                clientOffset: payload.clientOffset
	            };
	        case HOVER:
	            if (areCoordsEqual(state.clientOffset, payload.clientOffset)) {
	                return state;
	            }
	            return _objectSpread$6({}, state, {
	                clientOffset: payload.clientOffset
	            });
	        case END_DRAG:
	        case DROP:
	            return initialState$2;
	        default:
	            return state;
	    }
	}

	function _defineProperty$3(obj, key, value) {
	    if (key in obj) {
	        Object.defineProperty(obj, key, {
	            value: value,
	            enumerable: true,
	            configurable: true,
	            writable: true
	        });
	    } else {
	        obj[key] = value;
	    }
	    return obj;
	}
	function _objectSpread$5(target) {
	    for(var i = 1; i < arguments.length; i++){
	        var source = arguments[i] != null ? arguments[i] : {};
	        var ownKeys = Object.keys(source);
	        if (typeof Object.getOwnPropertySymbols === 'function') {
	            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
	                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
	            }));
	        }
	        ownKeys.forEach(function(key) {
	            _defineProperty$3(target, key, source[key]);
	        });
	    }
	    return target;
	}
	const initialState$1 = {
	    itemType: null,
	    item: null,
	    sourceId: null,
	    targetIds: [],
	    dropResult: null,
	    didDrop: false,
	    isSourcePublic: null
	};
	function reduce$3(state = initialState$1, action) {
	    const { payload  } = action;
	    switch(action.type){
	        case BEGIN_DRAG:
	            return _objectSpread$5({}, state, {
	                itemType: payload.itemType,
	                item: payload.item,
	                sourceId: payload.sourceId,
	                isSourcePublic: payload.isSourcePublic,
	                dropResult: null,
	                didDrop: false
	            });
	        case PUBLISH_DRAG_SOURCE:
	            return _objectSpread$5({}, state, {
	                isSourcePublic: true
	            });
	        case HOVER:
	            return _objectSpread$5({}, state, {
	                targetIds: payload.targetIds
	            });
	        case REMOVE_TARGET:
	            if (state.targetIds.indexOf(payload.targetId) === -1) {
	                return state;
	            }
	            return _objectSpread$5({}, state, {
	                targetIds: without$1(state.targetIds, payload.targetId)
	            });
	        case DROP:
	            return _objectSpread$5({}, state, {
	                dropResult: payload.dropResult,
	                didDrop: true,
	                targetIds: []
	            });
	        case END_DRAG:
	            return _objectSpread$5({}, state, {
	                itemType: null,
	                item: null,
	                sourceId: null,
	                dropResult: null,
	                didDrop: false,
	                isSourcePublic: null,
	                targetIds: []
	            });
	        default:
	            return state;
	    }
	}

	function reduce$2(state = 0, action) {
	    switch(action.type){
	        case ADD_SOURCE:
	        case ADD_TARGET:
	            return state + 1;
	        case REMOVE_SOURCE:
	        case REMOVE_TARGET:
	            return state - 1;
	        default:
	            return state;
	    }
	}

	function reduce$1(state = 0) {
	    return state + 1;
	}

	function _defineProperty$2(obj, key, value) {
	    if (key in obj) {
	        Object.defineProperty(obj, key, {
	            value: value,
	            enumerable: true,
	            configurable: true,
	            writable: true
	        });
	    } else {
	        obj[key] = value;
	    }
	    return obj;
	}
	function _objectSpread$4(target) {
	    for(var i = 1; i < arguments.length; i++){
	        var source = arguments[i] != null ? arguments[i] : {};
	        var ownKeys = Object.keys(source);
	        if (typeof Object.getOwnPropertySymbols === 'function') {
	            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
	                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
	            }));
	        }
	        ownKeys.forEach(function(key) {
	            _defineProperty$2(target, key, source[key]);
	        });
	    }
	    return target;
	}
	function reduce(state = {}, action) {
	    return {
	        dirtyHandlerIds: reduce$5(state.dirtyHandlerIds, {
	            type: action.type,
	            payload: _objectSpread$4({}, action.payload, {
	                prevTargetIds: get$3(state, 'dragOperation.targetIds', [])
	            })
	        }),
	        dragOffset: reduce$4(state.dragOffset, action),
	        refCount: reduce$2(state.refCount, action),
	        dragOperation: reduce$3(state.dragOperation, action),
	        stateId: reduce$1(state.stateId)
	    };
	}

	function createDragDropManager(backendFactory, globalContext = undefined, backendOptions = {}, debugMode = false) {
	    const store = makeStoreInstance(debugMode);
	    const monitor = new DragDropMonitorImpl(store, new HandlerRegistryImpl(store));
	    const manager = new DragDropManagerImpl(store, monitor);
	    const backend = backendFactory(manager, globalContext, backendOptions);
	    manager.receiveBackend(backend);
	    return manager;
	}
	function makeStoreInstance(debugMode) {
	    // TODO: if we ever make a react-native version of this,
	    // we'll need to consider how to pull off dev-tooling
	    const reduxDevTools = typeof window !== 'undefined' && window.__REDUX_DEVTOOLS_EXTENSION__;
	    return createStore(reduce, debugMode && reduxDevTools && reduxDevTools({
	        name: 'dnd-core',
	        instanceId: 'dnd-core'
	    }));
	}

	function _objectWithoutProperties(source, excluded) {
	    if (source == null) return {};
	    var target = _objectWithoutPropertiesLoose(source, excluded);
	    var key, i;
	    if (Object.getOwnPropertySymbols) {
	        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
	        for(i = 0; i < sourceSymbolKeys.length; i++){
	            key = sourceSymbolKeys[i];
	            if (excluded.indexOf(key) >= 0) continue;
	            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
	            target[key] = source[key];
	        }
	    }
	    return target;
	}
	function _objectWithoutPropertiesLoose(source, excluded) {
	    if (source == null) return {};
	    var target = {};
	    var sourceKeys = Object.keys(source);
	    var key, i;
	    for(i = 0; i < sourceKeys.length; i++){
	        key = sourceKeys[i];
	        if (excluded.indexOf(key) >= 0) continue;
	        target[key] = source[key];
	    }
	    return target;
	}
	let refCount = 0;
	const INSTANCE_SYM = Symbol.for('__REACT_DND_CONTEXT_INSTANCE__');
	var DndProvider = /*#__PURE__*/ reactExports.memo(function DndProvider(_param) {
	    var { children  } = _param, props = _objectWithoutProperties(_param, [
	        "children"
	    ]);
	    const [manager, isGlobalInstance] = getDndContextValue(props) // memoized from props
	    ;
	    /**
			 * If the global context was used to store the DND context
			 * then where theres no more references to it we should
			 * clean it up to avoid memory leaks
			 */ reactExports.useEffect(()=>{
	        if (isGlobalInstance) {
	            const context = getGlobalContext();
	            ++refCount;
	            return ()=>{
	                if (--refCount === 0) {
	                    context[INSTANCE_SYM] = null;
	                }
	            };
	        }
	        return;
	    }, []);
	    return /*#__PURE__*/ jsxRuntimeExports.jsx(DndContext.Provider, {
	        value: manager,
	        children: children
	    });
	});
	function getDndContextValue(props) {
	    if ('manager' in props) {
	        const manager = {
	            dragDropManager: props.manager
	        };
	        return [
	            manager,
	            false
	        ];
	    }
	    const manager = createSingletonDndContext(props.backend, props.context, props.options, props.debugMode);
	    const isGlobalInstance = !props.context;
	    return [
	        manager,
	        isGlobalInstance
	    ];
	}
	function createSingletonDndContext(backend, context = getGlobalContext(), options, debugMode) {
	    const ctx = context;
	    if (!ctx[INSTANCE_SYM]) {
	        ctx[INSTANCE_SYM] = {
	            dragDropManager: createDragDropManager(backend, context, options, debugMode)
	        };
	    }
	    return ctx[INSTANCE_SYM];
	}
	function getGlobalContext() {
	    return typeof global !== 'undefined' ? global : window;
	}

	/**
	 * A hook to retrieve the DragDropManager from Context
	 */ function useDragDropManager() {
	    const { dragDropManager  } = reactExports.useContext(DndContext);
	    invariant$1(dragDropManager != null, 'Expected drag drop context');
	    return dragDropManager;
	}

	function useDropTargetConnector(options) {
	    const manager = useDragDropManager();
	    const connector = reactExports.useMemo(()=>new TargetConnector(manager.getBackend())
	    , [
	        manager
	    ]);
	    useIsomorphicLayoutEffect$1(()=>{
	        connector.dropTargetOptions = options || null;
	        connector.reconnect();
	        return ()=>connector.disconnectDropTarget()
	        ;
	    }, [
	        options
	    ]);
	    return connector;
	}

	function useDropTargetMonitor() {
	    const manager = useDragDropManager();
	    return reactExports.useMemo(()=>new DropTargetMonitorImpl(manager)
	    , [
	        manager
	    ]);
	}

	/**
	 * Internal utility hook to get an array-version of spec.accept.
	 * The main utility here is that we aren't creating a new array on every render if a non-array spec.accept is passed in.
	 * @param spec
	 */ function useAccept(spec) {
	    const { accept  } = spec;
	    return reactExports.useMemo(()=>{
	        invariant$1(spec.accept != null, 'accept must be defined');
	        return Array.isArray(accept) ? accept : [
	            accept
	        ];
	    }, [
	        accept
	    ]);
	}

	class DropTargetImpl {
	    canDrop() {
	        const spec = this.spec;
	        const monitor = this.monitor;
	        return spec.canDrop ? spec.canDrop(monitor.getItem(), monitor) : true;
	    }
	    hover() {
	        const spec = this.spec;
	        const monitor = this.monitor;
	        if (spec.hover) {
	            spec.hover(monitor.getItem(), monitor);
	        }
	    }
	    drop() {
	        const spec = this.spec;
	        const monitor = this.monitor;
	        if (spec.drop) {
	            return spec.drop(monitor.getItem(), monitor);
	        }
	        return;
	    }
	    constructor(spec, monitor){
	        this.spec = spec;
	        this.monitor = monitor;
	    }
	}

	function useDropTarget(spec, monitor) {
	    const dropTarget = reactExports.useMemo(()=>new DropTargetImpl(spec, monitor)
	    , [
	        monitor
	    ]);
	    reactExports.useEffect(()=>{
	        dropTarget.spec = spec;
	    }, [
	        spec
	    ]);
	    return dropTarget;
	}

	function useRegisteredDropTarget(spec, monitor, connector) {
	    const manager = useDragDropManager();
	    const dropTarget = useDropTarget(spec, monitor);
	    const accept = useAccept(spec);
	    useIsomorphicLayoutEffect$1(function registerDropTarget() {
	        const [handlerId, unregister] = registerTarget(accept, dropTarget, manager);
	        monitor.receiveHandlerId(handlerId);
	        connector.receiveHandlerId(handlerId);
	        return unregister;
	    }, [
	        manager,
	        monitor,
	        dropTarget,
	        connector,
	        accept.map((a)=>a.toString()
	        ).join('|'), 
	    ]);
	}

	/**
	 * useDropTarget Hook
	 * @param spec The drop target specification (object or function, function preferred)
	 * @param deps The memoization deps array to use when evaluating spec changes
	 */ function useDrop(specArg, deps) {
	    const spec = useOptionalFactory(specArg, deps);
	    const monitor = useDropTargetMonitor();
	    const connector = useDropTargetConnector(spec.options);
	    useRegisteredDropTarget(spec, monitor, connector);
	    return [
	        useCollectedProps(spec.collect, monitor, connector),
	        useConnectDropTarget(connector), 
	    ];
	}

	// cheap lodash replacements
	function memoize(fn) {
	    let result = null;
	    const memoized = ()=>{
	        if (result == null) {
	            result = fn();
	        }
	        return result;
	    };
	    return memoized;
	}
	/**
	 * drop-in replacement for _.without
	 */ function without(items, item) {
	    return items.filter((i)=>i !== item
	    );
	}
	function union(itemsA, itemsB) {
	    const set = new Set();
	    const insertItem = (item)=>set.add(item)
	    ;
	    itemsA.forEach(insertItem);
	    itemsB.forEach(insertItem);
	    const result = [];
	    set.forEach((key)=>result.push(key)
	    );
	    return result;
	}

	class EnterLeaveCounter {
	    enter(enteringNode) {
	        const previousLength = this.entered.length;
	        const isNodeEntered = (node)=>this.isNodeInDocument(node) && (!node.contains || node.contains(enteringNode))
	        ;
	        this.entered = union(this.entered.filter(isNodeEntered), [
	            enteringNode
	        ]);
	        return previousLength === 0 && this.entered.length > 0;
	    }
	    leave(leavingNode) {
	        const previousLength = this.entered.length;
	        this.entered = without(this.entered.filter(this.isNodeInDocument), leavingNode);
	        return previousLength > 0 && this.entered.length === 0;
	    }
	    reset() {
	        this.entered = [];
	    }
	    constructor(isNodeInDocument){
	        this.entered = [];
	        this.isNodeInDocument = isNodeInDocument;
	    }
	}

	class NativeDragSource {
	    initializeExposedProperties() {
	        Object.keys(this.config.exposeProperties).forEach((property)=>{
	            Object.defineProperty(this.item, property, {
	                configurable: true,
	                enumerable: true,
	                get () {
	                    // eslint-disable-next-line no-console
	                    console.warn(`Browser doesn't allow reading "${property}" until the drop event.`);
	                    return null;
	                }
	            });
	        });
	    }
	    loadDataTransfer(dataTransfer) {
	        if (dataTransfer) {
	            const newProperties = {};
	            Object.keys(this.config.exposeProperties).forEach((property)=>{
	                const propertyFn = this.config.exposeProperties[property];
	                if (propertyFn != null) {
	                    newProperties[property] = {
	                        value: propertyFn(dataTransfer, this.config.matchesTypes),
	                        configurable: true,
	                        enumerable: true
	                    };
	                }
	            });
	            Object.defineProperties(this.item, newProperties);
	        }
	    }
	    canDrag() {
	        return true;
	    }
	    beginDrag() {
	        return this.item;
	    }
	    isDragging(monitor, handle) {
	        return handle === monitor.getSourceId();
	    }
	    endDrag() {
	    // empty
	    }
	    constructor(config){
	        this.config = config;
	        this.item = {};
	        this.initializeExposedProperties();
	    }
	}

	const FILE = '__NATIVE_FILE__';
	const URL$1 = '__NATIVE_URL__';
	const TEXT = '__NATIVE_TEXT__';
	const HTML$4 = '__NATIVE_HTML__';

	var NativeTypes = /*#__PURE__*/Object.freeze({
		__proto__: null,
		FILE: FILE,
		HTML: HTML$4,
		TEXT: TEXT,
		URL: URL$1
	});

	function getDataFromDataTransfer(dataTransfer, typesToTry, defaultValue) {
	    const result = typesToTry.reduce((resultSoFar, typeToTry)=>resultSoFar || dataTransfer.getData(typeToTry)
	    , '');
	    return result != null ? result : defaultValue;
	}

	const nativeTypesConfig = {
	    [FILE]: {
	        exposeProperties: {
	            files: (dataTransfer)=>Array.prototype.slice.call(dataTransfer.files)
	            ,
	            items: (dataTransfer)=>dataTransfer.items
	            ,
	            dataTransfer: (dataTransfer)=>dataTransfer
	        },
	        matchesTypes: [
	            'Files'
	        ]
	    },
	    [HTML$4]: {
	        exposeProperties: {
	            html: (dataTransfer, matchesTypes)=>getDataFromDataTransfer(dataTransfer, matchesTypes, '')
	            ,
	            dataTransfer: (dataTransfer)=>dataTransfer
	        },
	        matchesTypes: [
	            'Html',
	            'text/html'
	        ]
	    },
	    [URL$1]: {
	        exposeProperties: {
	            urls: (dataTransfer, matchesTypes)=>getDataFromDataTransfer(dataTransfer, matchesTypes, '').split('\n')
	            ,
	            dataTransfer: (dataTransfer)=>dataTransfer
	        },
	        matchesTypes: [
	            'Url',
	            'text/uri-list'
	        ]
	    },
	    [TEXT]: {
	        exposeProperties: {
	            text: (dataTransfer, matchesTypes)=>getDataFromDataTransfer(dataTransfer, matchesTypes, '')
	            ,
	            dataTransfer: (dataTransfer)=>dataTransfer
	        },
	        matchesTypes: [
	            'Text',
	            'text/plain'
	        ]
	    }
	};

	function createNativeDragSource(type, dataTransfer) {
	    const config = nativeTypesConfig[type];
	    if (!config) {
	        throw new Error(`native type ${type} has no configuration`);
	    }
	    const result = new NativeDragSource(config);
	    result.loadDataTransfer(dataTransfer);
	    return result;
	}
	function matchNativeItemType(dataTransfer) {
	    if (!dataTransfer) {
	        return null;
	    }
	    const dataTransferTypes = Array.prototype.slice.call(dataTransfer.types || []);
	    return Object.keys(nativeTypesConfig).filter((nativeItemType)=>{
	        const typeConfig = nativeTypesConfig[nativeItemType];
	        if (!(typeConfig === null || typeConfig === void 0 ? void 0 : typeConfig.matchesTypes)) {
	            return false;
	        }
	        return typeConfig.matchesTypes.some((t)=>dataTransferTypes.indexOf(t) > -1
	        );
	    })[0] || null;
	}

	const isFirefox$1 = memoize(()=>/firefox/i.test(navigator.userAgent)
	);
	const isSafari$1 = memoize(()=>Boolean(window.safari)
	);

	class MonotonicInterpolant {
	    interpolate(x) {
	        const { xs , ys , c1s , c2s , c3s  } = this;
	        // The rightmost point in the dataset should give an exact result
	        let i = xs.length - 1;
	        if (x === xs[i]) {
	            return ys[i];
	        }
	        // Search for the interval x is in, returning the corresponding y if x is one of the original xs
	        let low = 0;
	        let high = c3s.length - 1;
	        let mid;
	        while(low <= high){
	            mid = Math.floor(0.5 * (low + high));
	            const xHere = xs[mid];
	            if (xHere < x) {
	                low = mid + 1;
	            } else if (xHere > x) {
	                high = mid - 1;
	            } else {
	                return ys[mid];
	            }
	        }
	        i = Math.max(0, high);
	        // Interpolate
	        const diff = x - xs[i];
	        const diffSq = diff * diff;
	        return ys[i] + c1s[i] * diff + c2s[i] * diffSq + c3s[i] * diff * diffSq;
	    }
	    constructor(xs, ys){
	        const { length  } = xs;
	        // Rearrange xs and ys so that xs is sorted
	        const indexes = [];
	        for(let i = 0; i < length; i++){
	            indexes.push(i);
	        }
	        indexes.sort((a, b)=>xs[a] < xs[b] ? -1 : 1
	        );
	        const dxs = [];
	        const ms = [];
	        let dx;
	        let dy;
	        for(let i1 = 0; i1 < length - 1; i1++){
	            dx = xs[i1 + 1] - xs[i1];
	            dy = ys[i1 + 1] - ys[i1];
	            dxs.push(dx);
	            ms.push(dy / dx);
	        }
	        // Get degree-1 coefficients
	        const c1s = [
	            ms[0]
	        ];
	        for(let i2 = 0; i2 < dxs.length - 1; i2++){
	            const m2 = ms[i2];
	            const mNext = ms[i2 + 1];
	            if (m2 * mNext <= 0) {
	                c1s.push(0);
	            } else {
	                dx = dxs[i2];
	                const dxNext = dxs[i2 + 1];
	                const common = dx + dxNext;
	                c1s.push(3 * common / ((common + dxNext) / m2 + (common + dx) / mNext));
	            }
	        }
	        c1s.push(ms[ms.length - 1]);
	        // Get degree-2 and degree-3 coefficients
	        const c2s = [];
	        const c3s = [];
	        let m;
	        for(let i3 = 0; i3 < c1s.length - 1; i3++){
	            m = ms[i3];
	            const c1 = c1s[i3];
	            const invDx = 1 / dxs[i3];
	            const common = c1 + c1s[i3 + 1] - m - m;
	            c2s.push((m - c1 - common) * invDx);
	            c3s.push(common * invDx * invDx);
	        }
	        this.xs = xs;
	        this.ys = ys;
	        this.c1s = c1s;
	        this.c2s = c2s;
	        this.c3s = c3s;
	    }
	}

	const ELEMENT_NODE = 1;
	function getNodeClientOffset(node) {
	    const el = node.nodeType === ELEMENT_NODE ? node : node.parentElement;
	    if (!el) {
	        return null;
	    }
	    const { top , left  } = el.getBoundingClientRect();
	    return {
	        x: left,
	        y: top
	    };
	}
	function getEventClientOffset(e) {
	    return {
	        x: e.clientX,
	        y: e.clientY
	    };
	}
	function isImageNode(node) {
	    var ref;
	    return node.nodeName === 'IMG' && (isFirefox$1() || !((ref = document.documentElement) === null || ref === void 0 ? void 0 : ref.contains(node)));
	}
	function getDragPreviewSize(isImage, dragPreview, sourceWidth, sourceHeight) {
	    let dragPreviewWidth = isImage ? dragPreview.width : sourceWidth;
	    let dragPreviewHeight = isImage ? dragPreview.height : sourceHeight;
	    // Work around @2x coordinate discrepancies in browsers
	    if (isSafari$1() && isImage) {
	        dragPreviewHeight /= window.devicePixelRatio;
	        dragPreviewWidth /= window.devicePixelRatio;
	    }
	    return {
	        dragPreviewWidth,
	        dragPreviewHeight
	    };
	}
	function getDragPreviewOffset(sourceNode, dragPreview, clientOffset, anchorPoint, offsetPoint) {
	    // The browsers will use the image intrinsic size under different conditions.
	    // Firefox only cares if it's an image, but WebKit also wants it to be detached.
	    const isImage = isImageNode(dragPreview);
	    const dragPreviewNode = isImage ? sourceNode : dragPreview;
	    const dragPreviewNodeOffsetFromClient = getNodeClientOffset(dragPreviewNode);
	    const offsetFromDragPreview = {
	        x: clientOffset.x - dragPreviewNodeOffsetFromClient.x,
	        y: clientOffset.y - dragPreviewNodeOffsetFromClient.y
	    };
	    const { offsetWidth: sourceWidth , offsetHeight: sourceHeight  } = sourceNode;
	    const { anchorX , anchorY  } = anchorPoint;
	    const { dragPreviewWidth , dragPreviewHeight  } = getDragPreviewSize(isImage, dragPreview, sourceWidth, sourceHeight);
	    const calculateYOffset = ()=>{
	        const interpolantY = new MonotonicInterpolant([
	            0,
	            0.5,
	            1
	        ], [
	            // Dock to the top
	            offsetFromDragPreview.y,
	            // Align at the center
	            (offsetFromDragPreview.y / sourceHeight) * dragPreviewHeight,
	            // Dock to the bottom
	            offsetFromDragPreview.y + dragPreviewHeight - sourceHeight, 
	        ]);
	        let y = interpolantY.interpolate(anchorY);
	        // Work around Safari 8 positioning bug
	        if (isSafari$1() && isImage) {
	            // We'll have to wait for @3x to see if this is entirely correct
	            y += (window.devicePixelRatio - 1) * dragPreviewHeight;
	        }
	        return y;
	    };
	    const calculateXOffset = ()=>{
	        // Interpolate coordinates depending on anchor point
	        // If you know a simpler way to do this, let me know
	        const interpolantX = new MonotonicInterpolant([
	            0,
	            0.5,
	            1
	        ], [
	            // Dock to the left
	            offsetFromDragPreview.x,
	            // Align at the center
	            (offsetFromDragPreview.x / sourceWidth) * dragPreviewWidth,
	            // Dock to the right
	            offsetFromDragPreview.x + dragPreviewWidth - sourceWidth, 
	        ]);
	        return interpolantX.interpolate(anchorX);
	    };
	    // Force offsets if specified in the options.
	    const { offsetX , offsetY  } = offsetPoint;
	    const isManualOffsetX = offsetX === 0 || offsetX;
	    const isManualOffsetY = offsetY === 0 || offsetY;
	    return {
	        x: isManualOffsetX ? offsetX : calculateXOffset(),
	        y: isManualOffsetY ? offsetY : calculateYOffset()
	    };
	}

	class OptionsReader {
	    get window() {
	        if (this.globalContext) {
	            return this.globalContext;
	        } else if (typeof window !== 'undefined') {
	            return window;
	        }
	        return undefined;
	    }
	    get document() {
	        var ref;
	        if ((ref = this.globalContext) === null || ref === void 0 ? void 0 : ref.document) {
	            return this.globalContext.document;
	        } else if (this.window) {
	            return this.window.document;
	        } else {
	            return undefined;
	        }
	    }
	    get rootElement() {
	        var ref;
	        return ((ref = this.optionsArgs) === null || ref === void 0 ? void 0 : ref.rootElement) || this.window;
	    }
	    constructor(globalContext, options){
	        this.ownerDocument = null;
	        this.globalContext = globalContext;
	        this.optionsArgs = options;
	    }
	}

	function _defineProperty$1(obj, key, value) {
	    if (key in obj) {
	        Object.defineProperty(obj, key, {
	            value: value,
	            enumerable: true,
	            configurable: true,
	            writable: true
	        });
	    } else {
	        obj[key] = value;
	    }
	    return obj;
	}
	function _objectSpread$3(target) {
	    for(var i = 1; i < arguments.length; i++){
	        var source = arguments[i] != null ? arguments[i] : {};
	        var ownKeys = Object.keys(source);
	        if (typeof Object.getOwnPropertySymbols === 'function') {
	            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
	                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
	            }));
	        }
	        ownKeys.forEach(function(key) {
	            _defineProperty$1(target, key, source[key]);
	        });
	    }
	    return target;
	}
	class HTML5BackendImpl {
	    /**
		 * Generate profiling statistics for the HTML5Backend.
		 */ profile() {
	        var ref, ref1;
	        return {
	            sourcePreviewNodes: this.sourcePreviewNodes.size,
	            sourcePreviewNodeOptions: this.sourcePreviewNodeOptions.size,
	            sourceNodeOptions: this.sourceNodeOptions.size,
	            sourceNodes: this.sourceNodes.size,
	            dragStartSourceIds: ((ref = this.dragStartSourceIds) === null || ref === void 0 ? void 0 : ref.length) || 0,
	            dropTargetIds: this.dropTargetIds.length,
	            dragEnterTargetIds: this.dragEnterTargetIds.length,
	            dragOverTargetIds: ((ref1 = this.dragOverTargetIds) === null || ref1 === void 0 ? void 0 : ref1.length) || 0
	        };
	    }
	    // public for test
	    get window() {
	        return this.options.window;
	    }
	    get document() {
	        return this.options.document;
	    }
	    /**
		 * Get the root element to use for event subscriptions
		 */ get rootElement() {
	        return this.options.rootElement;
	    }
	    setup() {
	        const root = this.rootElement;
	        if (root === undefined) {
	            return;
	        }
	        if (root.__isReactDndBackendSetUp) {
	            throw new Error('Cannot have two HTML5 backends at the same time.');
	        }
	        root.__isReactDndBackendSetUp = true;
	        this.addEventListeners(root);
	    }
	    teardown() {
	        const root = this.rootElement;
	        if (root === undefined) {
	            return;
	        }
	        root.__isReactDndBackendSetUp = false;
	        this.removeEventListeners(this.rootElement);
	        this.clearCurrentDragSourceNode();
	        if (this.asyncEndDragFrameId) {
	            var ref;
	            (ref = this.window) === null || ref === void 0 ? void 0 : ref.cancelAnimationFrame(this.asyncEndDragFrameId);
	        }
	    }
	    connectDragPreview(sourceId, node, options) {
	        this.sourcePreviewNodeOptions.set(sourceId, options);
	        this.sourcePreviewNodes.set(sourceId, node);
	        return ()=>{
	            this.sourcePreviewNodes.delete(sourceId);
	            this.sourcePreviewNodeOptions.delete(sourceId);
	        };
	    }
	    connectDragSource(sourceId, node, options) {
	        this.sourceNodes.set(sourceId, node);
	        this.sourceNodeOptions.set(sourceId, options);
	        const handleDragStart = (e)=>this.handleDragStart(e, sourceId)
	        ;
	        const handleSelectStart = (e)=>this.handleSelectStart(e)
	        ;
	        node.setAttribute('draggable', 'true');
	        node.addEventListener('dragstart', handleDragStart);
	        node.addEventListener('selectstart', handleSelectStart);
	        return ()=>{
	            this.sourceNodes.delete(sourceId);
	            this.sourceNodeOptions.delete(sourceId);
	            node.removeEventListener('dragstart', handleDragStart);
	            node.removeEventListener('selectstart', handleSelectStart);
	            node.setAttribute('draggable', 'false');
	        };
	    }
	    connectDropTarget(targetId, node) {
	        const handleDragEnter = (e)=>this.handleDragEnter(e, targetId)
	        ;
	        const handleDragOver = (e)=>this.handleDragOver(e, targetId)
	        ;
	        const handleDrop = (e)=>this.handleDrop(e, targetId)
	        ;
	        node.addEventListener('dragenter', handleDragEnter);
	        node.addEventListener('dragover', handleDragOver);
	        node.addEventListener('drop', handleDrop);
	        return ()=>{
	            node.removeEventListener('dragenter', handleDragEnter);
	            node.removeEventListener('dragover', handleDragOver);
	            node.removeEventListener('drop', handleDrop);
	        };
	    }
	    addEventListeners(target) {
	        // SSR Fix (https://github.com/react-dnd/react-dnd/pull/813
	        if (!target.addEventListener) {
	            return;
	        }
	        target.addEventListener('dragstart', this.handleTopDragStart);
	        target.addEventListener('dragstart', this.handleTopDragStartCapture, true);
	        target.addEventListener('dragend', this.handleTopDragEndCapture, true);
	        target.addEventListener('dragenter', this.handleTopDragEnter);
	        target.addEventListener('dragenter', this.handleTopDragEnterCapture, true);
	        target.addEventListener('dragleave', this.handleTopDragLeaveCapture, true);
	        target.addEventListener('dragover', this.handleTopDragOver);
	        target.addEventListener('dragover', this.handleTopDragOverCapture, true);
	        target.addEventListener('drop', this.handleTopDrop);
	        target.addEventListener('drop', this.handleTopDropCapture, true);
	    }
	    removeEventListeners(target) {
	        // SSR Fix (https://github.com/react-dnd/react-dnd/pull/813
	        if (!target.removeEventListener) {
	            return;
	        }
	        target.removeEventListener('dragstart', this.handleTopDragStart);
	        target.removeEventListener('dragstart', this.handleTopDragStartCapture, true);
	        target.removeEventListener('dragend', this.handleTopDragEndCapture, true);
	        target.removeEventListener('dragenter', this.handleTopDragEnter);
	        target.removeEventListener('dragenter', this.handleTopDragEnterCapture, true);
	        target.removeEventListener('dragleave', this.handleTopDragLeaveCapture, true);
	        target.removeEventListener('dragover', this.handleTopDragOver);
	        target.removeEventListener('dragover', this.handleTopDragOverCapture, true);
	        target.removeEventListener('drop', this.handleTopDrop);
	        target.removeEventListener('drop', this.handleTopDropCapture, true);
	    }
	    getCurrentSourceNodeOptions() {
	        const sourceId = this.monitor.getSourceId();
	        const sourceNodeOptions = this.sourceNodeOptions.get(sourceId);
	        return _objectSpread$3({
	            dropEffect: this.altKeyPressed ? 'copy' : 'move'
	        }, sourceNodeOptions || {});
	    }
	    getCurrentDropEffect() {
	        if (this.isDraggingNativeItem()) {
	            // It makes more sense to default to 'copy' for native resources
	            return 'copy';
	        }
	        return this.getCurrentSourceNodeOptions().dropEffect;
	    }
	    getCurrentSourcePreviewNodeOptions() {
	        const sourceId = this.monitor.getSourceId();
	        const sourcePreviewNodeOptions = this.sourcePreviewNodeOptions.get(sourceId);
	        return _objectSpread$3({
	            anchorX: 0.5,
	            anchorY: 0.5,
	            captureDraggingState: false
	        }, sourcePreviewNodeOptions || {});
	    }
	    isDraggingNativeItem() {
	        const itemType = this.monitor.getItemType();
	        return Object.keys(NativeTypes).some((key)=>NativeTypes[key] === itemType
	        );
	    }
	    beginDragNativeItem(type, dataTransfer) {
	        this.clearCurrentDragSourceNode();
	        this.currentNativeSource = createNativeDragSource(type, dataTransfer);
	        this.currentNativeHandle = this.registry.addSource(type, this.currentNativeSource);
	        this.actions.beginDrag([
	            this.currentNativeHandle
	        ]);
	    }
	    setCurrentDragSourceNode(node) {
	        this.clearCurrentDragSourceNode();
	        this.currentDragSourceNode = node;
	        // A timeout of > 0 is necessary to resolve Firefox issue referenced
	        // See:
	        //   * https://github.com/react-dnd/react-dnd/pull/928
	        //   * https://github.com/react-dnd/react-dnd/issues/869
	        const MOUSE_MOVE_TIMEOUT = 1000;
	        // Receiving a mouse event in the middle of a dragging operation
	        // means it has ended and the drag source node disappeared from DOM,
	        // so the browser didn't dispatch the dragend event.
	        //
	        // We need to wait before we start listening for mousemove events.
	        // This is needed because the drag preview needs to be drawn or else it fires an 'mousemove' event
	        // immediately in some browsers.
	        //
	        // See:
	        //   * https://github.com/react-dnd/react-dnd/pull/928
	        //   * https://github.com/react-dnd/react-dnd/issues/869
	        //
	        this.mouseMoveTimeoutTimer = setTimeout(()=>{
	            var ref;
	            return (ref = this.rootElement) === null || ref === void 0 ? void 0 : ref.addEventListener('mousemove', this.endDragIfSourceWasRemovedFromDOM, true);
	        }, MOUSE_MOVE_TIMEOUT);
	    }
	    clearCurrentDragSourceNode() {
	        if (this.currentDragSourceNode) {
	            this.currentDragSourceNode = null;
	            if (this.rootElement) {
	                var ref;
	                (ref = this.window) === null || ref === void 0 ? void 0 : ref.clearTimeout(this.mouseMoveTimeoutTimer || undefined);
	                this.rootElement.removeEventListener('mousemove', this.endDragIfSourceWasRemovedFromDOM, true);
	            }
	            this.mouseMoveTimeoutTimer = null;
	            return true;
	        }
	        return false;
	    }
	    handleDragStart(e, sourceId) {
	        if (e.defaultPrevented) {
	            return;
	        }
	        if (!this.dragStartSourceIds) {
	            this.dragStartSourceIds = [];
	        }
	        this.dragStartSourceIds.unshift(sourceId);
	    }
	    handleDragEnter(_e, targetId) {
	        this.dragEnterTargetIds.unshift(targetId);
	    }
	    handleDragOver(_e, targetId) {
	        if (this.dragOverTargetIds === null) {
	            this.dragOverTargetIds = [];
	        }
	        this.dragOverTargetIds.unshift(targetId);
	    }
	    handleDrop(_e, targetId) {
	        this.dropTargetIds.unshift(targetId);
	    }
	    constructor(manager, globalContext, options){
	        this.sourcePreviewNodes = new Map();
	        this.sourcePreviewNodeOptions = new Map();
	        this.sourceNodes = new Map();
	        this.sourceNodeOptions = new Map();
	        this.dragStartSourceIds = null;
	        this.dropTargetIds = [];
	        this.dragEnterTargetIds = [];
	        this.currentNativeSource = null;
	        this.currentNativeHandle = null;
	        this.currentDragSourceNode = null;
	        this.altKeyPressed = false;
	        this.mouseMoveTimeoutTimer = null;
	        this.asyncEndDragFrameId = null;
	        this.dragOverTargetIds = null;
	        this.lastClientOffset = null;
	        this.hoverRafId = null;
	        this.getSourceClientOffset = (sourceId)=>{
	            const source = this.sourceNodes.get(sourceId);
	            return source && getNodeClientOffset(source) || null;
	        };
	        this.endDragNativeItem = ()=>{
	            if (!this.isDraggingNativeItem()) {
	                return;
	            }
	            this.actions.endDrag();
	            if (this.currentNativeHandle) {
	                this.registry.removeSource(this.currentNativeHandle);
	            }
	            this.currentNativeHandle = null;
	            this.currentNativeSource = null;
	        };
	        this.isNodeInDocument = (node)=>{
	            // Check the node either in the main document or in the current context
	            return Boolean(node && this.document && this.document.body && this.document.body.contains(node));
	        };
	        this.endDragIfSourceWasRemovedFromDOM = ()=>{
	            const node = this.currentDragSourceNode;
	            if (node == null || this.isNodeInDocument(node)) {
	                return;
	            }
	            if (this.clearCurrentDragSourceNode() && this.monitor.isDragging()) {
	                this.actions.endDrag();
	            }
	            this.cancelHover();
	        };
	        this.scheduleHover = (dragOverTargetIds)=>{
	            if (this.hoverRafId === null && typeof requestAnimationFrame !== 'undefined') {
	                this.hoverRafId = requestAnimationFrame(()=>{
	                    if (this.monitor.isDragging()) {
	                        this.actions.hover(dragOverTargetIds || [], {
	                            clientOffset: this.lastClientOffset
	                        });
	                    }
	                    this.hoverRafId = null;
	                });
	            }
	        };
	        this.cancelHover = ()=>{
	            if (this.hoverRafId !== null && typeof cancelAnimationFrame !== 'undefined') {
	                cancelAnimationFrame(this.hoverRafId);
	                this.hoverRafId = null;
	            }
	        };
	        this.handleTopDragStartCapture = ()=>{
	            this.clearCurrentDragSourceNode();
	            this.dragStartSourceIds = [];
	        };
	        this.handleTopDragStart = (e)=>{
	            if (e.defaultPrevented) {
	                return;
	            }
	            const { dragStartSourceIds  } = this;
	            this.dragStartSourceIds = null;
	            const clientOffset = getEventClientOffset(e);
	            // Avoid crashing if we missed a drop event or our previous drag died
	            if (this.monitor.isDragging()) {
	                this.actions.endDrag();
	                this.cancelHover();
	            }
	            // Don't publish the source just yet (see why below)
	            this.actions.beginDrag(dragStartSourceIds || [], {
	                publishSource: false,
	                getSourceClientOffset: this.getSourceClientOffset,
	                clientOffset
	            });
	            const { dataTransfer  } = e;
	            const nativeType = matchNativeItemType(dataTransfer);
	            if (this.monitor.isDragging()) {
	                if (dataTransfer && typeof dataTransfer.setDragImage === 'function') {
	                    // Use custom drag image if user specifies it.
	                    // If child drag source refuses drag but parent agrees,
	                    // use parent's node as drag image. Neither works in IE though.
	                    const sourceId = this.monitor.getSourceId();
	                    const sourceNode = this.sourceNodes.get(sourceId);
	                    const dragPreview = this.sourcePreviewNodes.get(sourceId) || sourceNode;
	                    if (dragPreview) {
	                        const { anchorX , anchorY , offsetX , offsetY  } = this.getCurrentSourcePreviewNodeOptions();
	                        const anchorPoint = {
	                            anchorX,
	                            anchorY
	                        };
	                        const offsetPoint = {
	                            offsetX,
	                            offsetY
	                        };
	                        const dragPreviewOffset = getDragPreviewOffset(sourceNode, dragPreview, clientOffset, anchorPoint, offsetPoint);
	                        dataTransfer.setDragImage(dragPreview, dragPreviewOffset.x, dragPreviewOffset.y);
	                    }
	                }
	                try {
	                    // Firefox won't drag without setting data
	                    dataTransfer === null || dataTransfer === void 0 ? void 0 : dataTransfer.setData('application/json', {});
	                } catch (err) {
	                // IE doesn't support MIME types in setData
	                }
	                // Store drag source node so we can check whether
	                // it is removed from DOM and trigger endDrag manually.
	                this.setCurrentDragSourceNode(e.target);
	                // Now we are ready to publish the drag source.. or are we not?
	                const { captureDraggingState  } = this.getCurrentSourcePreviewNodeOptions();
	                if (!captureDraggingState) {
	                    // Usually we want to publish it in the next tick so that browser
	                    // is able to screenshot the current (not yet dragging) state.
	                    //
	                    // It also neatly avoids a situation where render() returns null
	                    // in the same tick for the source element, and browser freaks out.
	                    setTimeout(()=>this.actions.publishDragSource()
	                    , 0);
	                } else {
	                    // In some cases the user may want to override this behavior, e.g.
	                    // to work around IE not supporting custom drag previews.
	                    //
	                    // When using a custom drag layer, the only way to prevent
	                    // the default drag preview from drawing in IE is to screenshot
	                    // the dragging state in which the node itself has zero opacity
	                    // and height. In this case, though, returning null from render()
	                    // will abruptly end the dragging, which is not obvious.
	                    //
	                    // This is the reason such behavior is strictly opt-in.
	                    this.actions.publishDragSource();
	                }
	            } else if (nativeType) {
	                // A native item (such as URL) dragged from inside the document
	                this.beginDragNativeItem(nativeType);
	            } else if (dataTransfer && !dataTransfer.types && (e.target && !e.target.hasAttribute || !e.target.hasAttribute('draggable'))) {
	                // Looks like a Safari bug: dataTransfer.types is null, but there was no draggable.
	                // Just let it drag. It's a native type (URL or text) and will be picked up in
	                // dragenter handler.
	                return;
	            } else {
	                // If by this time no drag source reacted, tell browser not to drag.
	                e.preventDefault();
	            }
	        };
	        this.handleTopDragEndCapture = ()=>{
	            if (this.clearCurrentDragSourceNode() && this.monitor.isDragging()) {
	                // Firefox can dispatch this event in an infinite loop
	                // if dragend handler does something like showing an alert.
	                // Only proceed if we have not handled it already.
	                this.actions.endDrag();
	            }
	            this.cancelHover();
	        };
	        this.handleTopDragEnterCapture = (e)=>{
	            this.dragEnterTargetIds = [];
	            if (this.isDraggingNativeItem()) {
	                var ref;
	                (ref = this.currentNativeSource) === null || ref === void 0 ? void 0 : ref.loadDataTransfer(e.dataTransfer);
	            }
	            const isFirstEnter = this.enterLeaveCounter.enter(e.target);
	            if (!isFirstEnter || this.monitor.isDragging()) {
	                return;
	            }
	            const { dataTransfer  } = e;
	            const nativeType = matchNativeItemType(dataTransfer);
	            if (nativeType) {
	                // A native item (such as file or URL) dragged from outside the document
	                this.beginDragNativeItem(nativeType, dataTransfer);
	            }
	        };
	        this.handleTopDragEnter = (e)=>{
	            const { dragEnterTargetIds  } = this;
	            this.dragEnterTargetIds = [];
	            if (!this.monitor.isDragging()) {
	                // This is probably a native item type we don't understand.
	                return;
	            }
	            this.altKeyPressed = e.altKey;
	            // If the target changes position as the result of `dragenter`, `dragover` might still
	            // get dispatched despite target being no longer there. The easy solution is to check
	            // whether there actually is a target before firing `hover`.
	            if (dragEnterTargetIds.length > 0) {
	                this.actions.hover(dragEnterTargetIds, {
	                    clientOffset: getEventClientOffset(e)
	                });
	            }
	            const canDrop = dragEnterTargetIds.some((targetId)=>this.monitor.canDropOnTarget(targetId)
	            );
	            if (canDrop) {
	                // IE requires this to fire dragover events
	                e.preventDefault();
	                if (e.dataTransfer) {
	                    e.dataTransfer.dropEffect = this.getCurrentDropEffect();
	                }
	            }
	        };
	        this.handleTopDragOverCapture = (e)=>{
	            this.dragOverTargetIds = [];
	            if (this.isDraggingNativeItem()) {
	                var ref;
	                (ref = this.currentNativeSource) === null || ref === void 0 ? void 0 : ref.loadDataTransfer(e.dataTransfer);
	            }
	        };
	        this.handleTopDragOver = (e)=>{
	            const { dragOverTargetIds  } = this;
	            this.dragOverTargetIds = [];
	            if (!this.monitor.isDragging()) {
	                // This is probably a native item type we don't understand.
	                // Prevent default "drop and blow away the whole document" action.
	                e.preventDefault();
	                if (e.dataTransfer) {
	                    e.dataTransfer.dropEffect = 'none';
	                }
	                return;
	            }
	            this.altKeyPressed = e.altKey;
	            this.lastClientOffset = getEventClientOffset(e);
	            this.scheduleHover(dragOverTargetIds);
	            const canDrop = (dragOverTargetIds || []).some((targetId)=>this.monitor.canDropOnTarget(targetId)
	            );
	            if (canDrop) {
	                // Show user-specified drop effect.
	                e.preventDefault();
	                if (e.dataTransfer) {
	                    e.dataTransfer.dropEffect = this.getCurrentDropEffect();
	                }
	            } else if (this.isDraggingNativeItem()) {
	                // Don't show a nice cursor but still prevent default
	                // "drop and blow away the whole document" action.
	                e.preventDefault();
	            } else {
	                e.preventDefault();
	                if (e.dataTransfer) {
	                    e.dataTransfer.dropEffect = 'none';
	                }
	            }
	        };
	        this.handleTopDragLeaveCapture = (e)=>{
	            if (this.isDraggingNativeItem()) {
	                e.preventDefault();
	            }
	            const isLastLeave = this.enterLeaveCounter.leave(e.target);
	            if (!isLastLeave) {
	                return;
	            }
	            if (this.isDraggingNativeItem()) {
	                setTimeout(()=>this.endDragNativeItem()
	                , 0);
	            }
	            this.cancelHover();
	        };
	        this.handleTopDropCapture = (e)=>{
	            this.dropTargetIds = [];
	            if (this.isDraggingNativeItem()) {
	                var ref;
	                e.preventDefault();
	                (ref = this.currentNativeSource) === null || ref === void 0 ? void 0 : ref.loadDataTransfer(e.dataTransfer);
	            } else if (matchNativeItemType(e.dataTransfer)) {
	                // Dragging some elements, like <a> and <img> may still behave like a native drag event,
	                // even if the current drag event matches a user-defined type.
	                // Stop the default behavior when we're not expecting a native item to be dropped.
	                e.preventDefault();
	            }
	            this.enterLeaveCounter.reset();
	        };
	        this.handleTopDrop = (e)=>{
	            const { dropTargetIds  } = this;
	            this.dropTargetIds = [];
	            this.actions.hover(dropTargetIds, {
	                clientOffset: getEventClientOffset(e)
	            });
	            this.actions.drop({
	                dropEffect: this.getCurrentDropEffect()
	            });
	            if (this.isDraggingNativeItem()) {
	                this.endDragNativeItem();
	            } else if (this.monitor.isDragging()) {
	                this.actions.endDrag();
	            }
	            this.cancelHover();
	        };
	        this.handleSelectStart = (e)=>{
	            const target = e.target;
	            // Only IE requires us to explicitly say
	            // we want drag drop operation to start
	            if (typeof target.dragDrop !== 'function') {
	                return;
	            }
	            // Inputs and textareas should be selectable
	            if (target.tagName === 'INPUT' || target.tagName === 'SELECT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {
	                return;
	            }
	            // For other targets, ask IE
	            // to enable drag and drop
	            e.preventDefault();
	            target.dragDrop();
	        };
	        this.options = new OptionsReader(globalContext, options);
	        this.actions = manager.getActions();
	        this.monitor = manager.getMonitor();
	        this.registry = manager.getRegistry();
	        this.enterLeaveCounter = new EnterLeaveCounter(this.isNodeInDocument);
	    }
	}

	const HTML5Backend = function createBackend(manager, context, options) {
	    return new HTML5BackendImpl(manager, context, options);
	};

	const LazyDnD = (
	    props
	) => {
	    return React$2.createElement(DndProvider, { backend: HTML5Backend,}, props.children);
	};

	const BUTTON_TYPE$1 = "button" ;

	const AuthnButton = ({
	    as: Component = BUTTON_TYPE$1,
	    children,
	    ...props
	}) => {
	    const className = props.className ?? "";
	    return (
	        React$2.createElement(Component, {
	            ...props,
	            className: `flex h-12 max-w-xs
            items-center justify-center rounded-lg bg-foreground px-6 text-lg text-text
            hover:bg-foreground-600 active:bg-foreground-700 disabled:bg-foreground-200 ${className}`,}

	            , children
	        )
	    );
	};

	const selectBlocks = (state) =>
	    state.context.markdownBlocks;
	const selectCws$1 = (state) => state.context.cws;
	const selectEditingCws = (state) =>
	    state.context.editingCws;

	const selectHeadline$1 = (state) => state.context.headline;
	const selectTags$1 = (state) => state.context.tags;
	const selectAttachments = (state) =>
	    state.context.attachments;
	const selectIsEditing$5 = selectStateMatches("editing");

	const selectIsCreatingPost = selectStateMatches("posting.creatingPost");
	const selectIsStartingAttachments = selectStateMatches(
	    "posting.uploadingAttachments.startingAttachments"
	);
	const selectIsFinishingAttachments = selectStateMatches(
	    "posting.uploadingAttachments.finishingAttachments"
	);

	function makeSourceURL$1(attachment) {
	    if (
	        attachment.state === AttachmentState.Finished &&
	        attachment.attachmentId
	    ) {
	        return sitemap.public
	            .redirectToAttachment({
	                attachmentId: attachment.attachmentId,
	            })
	            .toString();
	    } else if (attachment.file) {
	        return URL.createObjectURL(attachment.file);
	    } else
	        return sitemap.public.static
	            .staticAsset({ path: missingAttachment })
	            .toString();
	}

	mod.enum(["small", "regular"]);
	 

	const smallClasses = "text-xs font-bold";
	const regularClasses = "text-base font-normal";

	/**
	 * a new button component designed to match "button/basic" in the master design
	 * system doc
	 */

	mod.enum([
	    "cherry",
	    "mango",
	    "green",
	    "destructive",
	    "theme-sensitive-1",
	    "stroke",
	    "post-box-filled",
	]);
	 








	const cherryClasses$1 = `text-notWhite bg-cherry-500 hover:bg-cherry-600 
    active:bg-cherry-700 disabled:bg-cherry-100 disabled:text-cherry-600`;
	const mangoClasses$1 = `text-notBlack bg-mango-300 hover:bg-mango-400
    active:bg-mango-500 disabled:bg-mango-100 disabled:text-mango-700`;
	const greenClasses$1 = `text-notWhite bg-green-600 hover:bg-green-700 
    active:bg-green-800 disabled:bg-green-100 disabled:text-green-800`;
	const destructiveClasses = `text-notWhite bg-red-500 hover:bg-red-600 
    active:bg-red-700 disabled:bg-red-300 disabled:text-red-800`;
	const strokeClasses = `text-cherry-600 bg-notWhite hover:bg-longan-100
    active:bg-longan-200 border-2 border-cherry-500 disabled:bg-notWhite
    disabled:text-cherry-400 disabled:border-cherry-400`;

	// first used for the "refresh" button on cohost reader, this button is
	// black-on-longan in the light theme and white-on-cherry in the dark theme
	const themeSensitive1Classes = `bg-longan-300 hover:bg-longan-400 
    active:bg-longan-500 dark:bg-cherry-700 dark:hover:bg-cherry-600 
    dark:active:bg-cherry-600 text-notBlack dark:text-notWhite`;

	const makeClasses = (props) =>
	    classNames("rounded-lg", "px-3", "py-2", {
	        [smallClasses]: props.buttonSize === "small",
	        [regularClasses]: props.buttonSize === "regular",
	        [cherryClasses$1]: props.buttonColor === "cherry",
	        [mangoClasses$1]: props.buttonColor === "mango",
	        [greenClasses$1]: props.buttonColor === "green",
	        [destructiveClasses]: props.buttonColor === "destructive",
	        [themeSensitive1Classes]: props.buttonColor === "theme-sensitive-1",
	        [strokeClasses]: props.buttonColor === "stroke",
	    });

	function UnwrappedBasicButton(
	    { as: Component = "button", ...props },
	    ref
	) {
	    const { buttonSize, buttonColor, extraClasses, ...otherProps } = props;
	    const layoutClasses =
	        "flex flex-row justify-center items-center text-center"; // to normalize layout between buttons and anchors
	    let classes;

	    switch (buttonColor) {
	        case "post-box-filled":
	            classes = classNames(
	                makeClasses(props),
	                extraClasses,
	                layoutClasses,
	                "co-filled-button"
	            ) ;
	            break;
	        default:
	            classes = classNames(
	                makeClasses(props),
	                extraClasses,
	                layoutClasses
	            ) ;
	    }

	    return (
	        React$2.createElement(Component, { ...otherProps, className: classes, ref: ref,}
	            , props.children
	        )
	    );
	}

	const BasicButton = React$2.forwardRef(UnwrappedBasicButton);

	/**
	 * Adapted from https://css-tricks.com/the-cleanest-trick-for-autogrowing-textareas/
	 */







	const copyStyles = (
	    styles,
	    node,
	    minRows
	) => {
	    node.style.fontSize = styles.fontSize;
	    node.style.fontFamily = styles.fontFamily;
	    node.style.fontWeight = styles.fontWeight;
	    node.style.fontStyle = styles.fontStyle;
	    node.style.letterSpacing = styles.letterSpacing;
	    node.style.textTransform = styles.textTransform;
	    node.style.padding = styles.padding;
	    node.style.lineHeight = styles.lineHeight;
	    node.style.minHeight = `${minRows * parseInt(styles.lineHeight)}px`;
	};

	const ExpandingTextArea = reactExports.forwardRef


	(({ minRows, className, ...props }, ref) => {
	    const textAreaRef = reactExports.useRef(null);
	    reactExports.useImperativeHandle(
	        ref,
	        () => textAreaRef.current
	    );

	    const resizerRef = reactExports.useRef(null);

	    reactExports.useEffect(() => {
	        if (resizerRef.current && textAreaRef.current) {
	            const styles = window.getComputedStyle(textAreaRef.current);
	            copyStyles(styles, resizerRef.current, minRows);
	        }
	    }, [minRows]);

	    const classes = reactExports.useMemo(
	        () =>
	            `${
                className ?? ""
            } w-full row-start-1 row-end-2 col-start-1 col-end-2 min-h-0`,
	        [className]
	    );

	    return (
	        React$2.createElement('div', { className: `relative grid w-full overflow-auto`,}
	            , React$2.createElement('div', {
	                ref: resizerRef,
	                className: `invisible col-start-1 col-end-2 row-start-1 row-end-2
                            h-min overflow-auto whitespace-pre-wrap break-words`,}

	                , props.value, " "
	            )
	            , React$2.createElement('textarea', {
	                style: {
	                    resize: "none",
	                    overflow: "hidden",
	                },
	                ...props,
	                className: classes,
	                ref: textAreaRef,
	                rows: 1,}
	            )
	        )
	    );
	});
	ExpandingTextArea.displayName = "ExpandingTextArea";







	const ControllableExpandingTextArea = ({
	    control,
	    name,
	    rules,
	    ...props
	}) => {
	    const { field, fieldState } = useController({
	        control,
	        name,
	        rules,
	    });

	    return (
	        React$2.createElement(ExpandingTextArea, {
	            ...props,
	            ...field,
	            className: `border-0 ${props.className ?? ""}`,}
	        )
	    );
	};

	const PostComposerContext = React$2.createContext(
	    {} 
	);

	const AttachmentComposer$1 = React$2.forwardRef

	((props, ref) => {
	    const service = reactExports.useContext(PostComposerContext);
	    const send = service.send;
	    const attachments = useSelector$1(service, selectAttachments);
	    const [isOpen, setIsOpen] = reactExports.useState(false);
	    const dynamicTheme = useDynamicTheme();

	    const attachmentChooserData = reactExports.useMemo(() => {
	        const data



	 = [];

	        attachments.forEach((attachment, index) => {
	            if (attachment.kind === "image")
	                data.push({
	                    index,
	                    attachment,
	                    sourceURL: makeSourceURL$1(attachment),
	                });
	        });

	        return data;
	    }, [attachments]);

	    const [activeAttachmentIndex, setActiveAttachmentIndex] = reactExports.useState

	(undefined);

	    const activeAttachmentChooserData = reactExports.useMemo(
	        () =>
	            attachmentChooserData.find(
	                (data) => data.index === activeAttachmentIndex
	            ),
	        [attachmentChooserData, activeAttachmentIndex]
	    );

	    reactExports.useImperativeHandle(
	        ref,
	        () => {
	            return {
	                open(initialIndex) {
	                    setIsOpen(true);
	                    setActiveAttachmentIndex(initialIndex);
	                },
	            };
	        },
	        []
	    );

	    const onAltTextChange = reactExports.useCallback

	(
	        (e) => {
	            if (activeAttachmentIndex !== undefined) {
	                send({
	                    type: "ALT_TEXT_INPUT",
	                    index: activeAttachmentIndex,
	                    input: e.currentTarget.value,
	                });
	            }
	        },
	        [activeAttachmentIndex, send]
	    );

	    const altTextEditorRef = reactExports.useRef(null);

	    const [dialogRef, setDialogRef] = reactExports.useState(null);

	    reactExports.useEffect(() => {
	        if (isOpen && dialogRef?.open !== true) {
	            dialogRef?.showModal();
	        } else if (!isOpen && dialogRef?.open === true) {
	            dialogRef?.close();
	        }
	    }, [dialogRef, isOpen]);

	    return (
	        React$2.createElement('dialog', {
	            ref: setDialogRef,
	            // @ts-expect-error again, typedefs are broken for dialog
	            onClose: () => {
	                setIsOpen(false);
	            },
	            'data-theme': dynamicTheme.current,
	            className: "co-themed-box co-attachment-composer cohost-shadow-light dark:cohost-shadow-dark h-max w-full max-w-prose flex-col gap-2 rounded-lg p-3 backdrop:bg-notBlack/90 open:flex"            ,}

	            , React$2.createElement('div', { className: "flex flex-row justify-center gap-9"   ,}
	                , attachmentChooserData.map((data) => (
	                    React$2.createElement('button', {
	                        key: data.index,
	                        onClick: () => setActiveAttachmentIndex(data.index),}

	                        , React$2.createElement('img', {
	                            src: data.sourceURL,
	                            className: classNames(
	                                "h-[4.5rem] w-[4.5rem] object-cover",
	                                data.index === activeAttachmentIndex
	                                    ? tw`co-active border-4`
	                                    : "opacity-50"
	                            ),
	                            alt: data.attachment.metadata.altText,}
	                        )
	                    )
	                ))
	            )

	            , React$2.createElement('label', null
	                , React$2.createElement('p', { className: tw`co-ui-text font-bold`,}, "image description" )

	                , React$2.createElement(ExpandingTextArea, {
	                    name: "alt-text",
	                    ref: altTextEditorRef,
	                    minRows: 1,
	                    onChange: onAltTextChange,
	                    className: "co-editable-body",
	                    value: 
	                        activeAttachmentChooserData?.attachment.metadata.altText
	                    ,}
	                )
	            )

	            , React$2.createElement(BasicButton, {
	                buttonSize: "regular",
	                buttonColor: "post-box-filled",
	                extraClasses: "self-end",
	                onClick: () => setIsOpen(false),}
	, "done"

	            )
	        )
	    );
	});
	AttachmentComposer$1.displayName = "AttachmentComposer";

	const AttachmentComposerContext$1 = React$2.createContext

	(undefined);

	function useAudioPlayback(
	    audio,
	    onPlaybackError
	) {
	    const [snapshot, setSnapshot] = reactExports.useState({
	        currentTime: 0,
	        totalDuration: 0,
	        isPlaying: false,
	    });
	    const updateSnapshot = reactExports.useMemo(() => {
	        return (callback) => () => {
	            if (!audio.current) return;

	            setSnapshot({
	                currentTime: audio.current.currentTime,
	                totalDuration: audio.current.duration,
	                isPlaying: !audio.current.paused,
	            });

	            callback();
	        };
	    }, [audio]);

	    const subscribe = reactExports.useCallback(
	        (callback) => {
	            if (!audio.current) return lodashExports.noop;
	            const newCb = updateSnapshot(callback);

	            audio.current.addEventListener("loadedmetadata", newCb);
	            audio.current.addEventListener("timeupdate", newCb);
	            audio.current.addEventListener("play", newCb);
	            audio.current.addEventListener("pause", newCb);
	            return () => {
	                audio.current?.removeEventListener("loadedmetadata", newCb);
	                audio.current?.removeEventListener("timeupdate", newCb);
	                audio.current?.removeEventListener("play", newCb);
	                audio.current?.removeEventListener("pause", newCb);
	            };
	        },
	        [audio, updateSnapshot]
	    );

	    const getSnapshot = reactExports.useCallback(() => {
	        return snapshot;
	    }, [snapshot]);

	    const getServerSnapshot = () => {
	        // this is required for SSR but audio elements obvs don't exist on the
	        // server.
	        return {
	            currentTime: 0,
	            totalDuration: 0,
	            isPlaying: false,
	        };
	    };

	    const metadataStore = reactExports.useSyncExternalStore(
	        subscribe,
	        getSnapshot,
	        getServerSnapshot
	    );
	    const togglePlayback = reactExports.useCallback(async () => {
	        if (!audio.current) return;

	        if (audio.current.paused) {
	            try {
	                await audio.current.play();
	            } catch (e) {
	                console.error(e);

	                if (onPlaybackError) {
	                    onPlaybackError(e );
	                }
	            }
	        } else {
	            audio.current.pause();
	        }
	    }, [audio, onPlaybackError]);

	    const seek = reactExports.useCallback(
	        (time) => {
	            if (!audio.current) return;

	            audio.current.currentTime = time;
	        },
	        [audio]
	    );

	    return {
	        togglePlayback,
	        seek,
	        ...metadataStore,
	    };
	}

	function AttachmentLayoutRow({
	    attachments,
	    attachmentDimensions,
	    renderOne,
	    attachmentIndices: indices,
	    testRowIndex,
	}) {
	    const largestAttachment = attachments.reduce((prev, curr) => {
	        const currDimensions = attachmentDimensions(curr),
	            prevDimensions = prev ? attachmentDimensions(prev) : undefined;

	        if (
	            currDimensions &&
	            (!prevDimensions ||
	                currDimensions.height * currDimensions.width >
	                    prevDimensions.height * prevDimensions.width)
	        ) {
	            return curr;
	        } else {
	            return prev;
	        }
	    });

	    const largestAttachmentDimensions = largestAttachment
	        ? attachmentDimensions(largestAttachment)
	        : undefined;
	    let aspectRatio = undefined;

	    if (attachments.length > 1) {
	        if (
	            largestAttachmentDimensions &&
	            largestAttachmentDimensions.width &&
	            largestAttachmentDimensions.height
	        ) {
	            aspectRatio =
	                largestAttachmentDimensions.width /
	                largestAttachmentDimensions.height;
	        } else {
	            aspectRatio = 16 / 9;
	        }
	    }

	    return (
	        React$2.createElement('div', {
	            className: "flex w-full flex-nowrap content-start justify-between"    ,
	            'data-testid': 
	                testRowIndex !== undefined ? `row-${testRowIndex}` : undefined
	            ,}

	            , attachments.map((attachment, i) =>
	                renderOne({
	                    attachment,
	                    index: indices[i],
	                    rowLength: attachments.length,
	                    aspectRatio,
	                })
	            )
	        )
	    );
	}

	function AttachmentLayoutV1({
	    attachments,
	    attachmentKind,
	    attachmentDimensions,
	    renderOne,
	}) {
	    const components = [];

	    // render image attachments
	    const imageAttachments = [];
	    const imageAttachmentIndices = [];

	    for (let index = 0; index < attachments.length; index++) {
	        if (attachmentKind(attachments[index]) === "image") {
	            imageAttachments.push(attachments[index]);
	            imageAttachmentIndices.push(index);
	        }
	    }

	    if (imageAttachments.length) {
	        if (imageAttachments.length % 2 === 0) {
	            // even
	            for (let i = 0; i < imageAttachments.length; i += 2) {
	                components.push(
	                    React$2.createElement(AttachmentLayoutRow, {
	                        attachments: imageAttachments.slice(i, i + 2),
	                        attachmentIndices: imageAttachmentIndices.slice(
	                            i,
	                            i + 2
	                        ),
	                        attachmentKind: attachmentKind,
	                        attachmentDimensions: attachmentDimensions,
	                        renderOne: renderOne,
	                        key: `image-${i}`,}
	                    )
	                );
	            }
	        } else if (imageAttachments.length >= 3) {
	            // odd, >= 3 (currently only exactly 3, this will change at some point)
	            const firstThree = imageAttachments.splice(0, 3);
	            const firstThreeIndices = imageAttachmentIndices.splice(0, 3);
	            components.push(
	                React$2.createElement(AttachmentLayoutRow, {
	                    attachments: firstThree,
	                    attachmentIndices: firstThreeIndices,
	                    attachmentKind: attachmentKind,
	                    attachmentDimensions: attachmentDimensions,
	                    renderOne: renderOne,
	                    key: "image-firstThree",}
	                )
	            );
	            for (let i = 0; i < imageAttachments.length; i += 2) {
	                components.push(
	                    React$2.createElement(AttachmentLayoutRow, {
	                        attachments: imageAttachments.slice(i, i + 2),
	                        attachmentIndices: imageAttachmentIndices.slice(
	                            i,
	                            i + 2
	                        ),
	                        attachmentKind: attachmentKind,
	                        attachmentDimensions: attachmentDimensions,
	                        renderOne: renderOne,
	                        key: `image-rest-${i}`,}
	                    )
	                );
	            }
	        } else {
	            // only one
	            components.push(
	                React$2.createElement(AttachmentLayoutRow, {
	                    attachments: imageAttachments,
	                    attachmentIndices: imageAttachmentIndices,
	                    attachmentKind: attachmentKind,
	                    attachmentDimensions: attachmentDimensions,
	                    renderOne: renderOne,
	                    key: "image-solo",}
	                )
	            );
	        }
	    }

	    // render audio attachments; these can't share a row with each other so
	    // rendering them is easier
	    const audioAttachments = [];
	    const audioAttachmentIndices = [];

	    for (let index = 0; index < attachments.length; index++) {
	        if (attachmentKind(attachments[index]) === "audio") {
	            audioAttachments.push(attachments[index]);
	            audioAttachmentIndices.push(index);
	        }
	    }

	    components.push(
	        ...audioAttachments
	            .map((audio, i) =>
	                renderOne({
	                    attachment: audio,
	                    index: audioAttachmentIndices[i],
	                    rowLength: 1,
	                    aspectRatio: undefined,
	                })
	            )
	            .filter(
	                (component) =>
	                    component !== null
	            )
	    );

	    return components.length ? (
	        React$2.createElement('div', null
	            /* dumb but throwing this in a div suppresses the between-row gap */
	            , components
	        )
	    ) : null;
	}

	function layoutImages(
	    accum,
	    attachmentKind,
	    attachmentDimensions,
	    renderOne,
	    testStartRowIndex
	) {
	    switch (accum.length) {
	        case 0:
	            return [];
	        case 1:
	            return [
	                React$2.createElement(AttachmentLayoutRow, {
	                    attachments: [accum[0].attachment],
	                    attachmentIndices: [accum[0].index],
	                    attachmentKind: attachmentKind,
	                    attachmentDimensions: attachmentDimensions,
	                    renderOne: renderOne,
	                    key: `image-${accum[0].index}`,
	                    testRowIndex: testStartRowIndex,}
	                ),
	            ];
	        /* n = 2 is handled by the default case */
	        case 3:
	            return [
	                React$2.createElement(AttachmentLayoutRow, {
	                    attachments: [
	                        accum[0].attachment,
	                        accum[1].attachment,
	                        accum[2].attachment,
	                    ],
	                    attachmentIndices: [
	                        accum[0].index,
	                        accum[1].index,
	                        accum[2].index,
	                    ],
	                    attachmentKind: attachmentKind,
	                    attachmentDimensions: attachmentDimensions,
	                    renderOne: renderOne,
	                    key: `images-${accum[0].index}-${accum[1].index}-${accum[2].index}`,
	                    testRowIndex: testStartRowIndex,}
	                ),
	            ];
	        default:
	            return [
	                React$2.createElement(AttachmentLayoutRow, {
	                    attachments: [accum[0].attachment, accum[1].attachment],
	                    attachmentIndices: [accum[0].index, accum[1].index],
	                    attachmentKind: attachmentKind,
	                    attachmentDimensions: attachmentDimensions,
	                    renderOne: renderOne,
	                    key: `images-${accum[0].index}-${accum[1].index}`,
	                    testRowIndex: testStartRowIndex,}
	                ),
	                ...layoutImages(
	                    accum.slice(2),
	                    attachmentKind,
	                    attachmentDimensions,
	                    renderOne,
	                    testStartRowIndex + 1
	                ),
	            ];
	    }
	}

	function AttachmentLayoutV2({
	    attachments,
	    attachmentKind,
	    attachmentDimensions,
	    renderOne,
	}) {
	    const components = [];
	    let imagesAccum = [];
	    let rowIndex = 0;

	    for (let index = 0; index < attachments.length; index++) {
	        const attachment = attachments[index];

	        switch (attachmentKind(attachment)) {
	            case "image":
	                imagesAccum.push({ attachment, index });
	                break;
	            case "audio":
	                // empty out the image accumulator
	                components.push(
	                    ...layoutImages(
	                        imagesAccum,
	                        attachmentKind,
	                        attachmentDimensions,
	                        renderOne,
	                        rowIndex++
	                    )
	                );
	                imagesAccum = [];

	                // render the audio attachment
	                {
	                    const renderedAudio = renderOne({
	                        attachment,
	                        index,
	                        rowLength: 1,
	                        aspectRatio: undefined,
	                        testRowIndex: rowIndex++,
	                    });

	                    if (renderedAudio) {
	                        components.push(renderedAudio);
	                    }
	                }
	                break;
	        }
	    }

	    // if any images are left in the accumulator, render those out too
	    components.push(
	        ...layoutImages(
	            imagesAccum,
	            attachmentKind,
	            attachmentDimensions,
	            renderOne,
	            rowIndex++
	        )
	    );

	    return components.length ? (
	        React$2.createElement('div', null
	            /* dumb but throwing this in a div suppresses the between-row gap */
	            , components
	        )
	    ) : null;
	}

	const AttachmentDeleteButton

	 = ({ onDelete }) => (
	    React$2.createElement(IconEgg, {
	        className: "absolute right-3 top-3 hidden h-6 cursor-pointer fill-cherry text-notWhite hover:fill-cherry-700 group-hover:block"         ,
	        onClick: onDelete,
	        scale: 0.7,}

	        , React$2.createElement(ForwardRef$M, null )
	    )
	);

	const AudioPlayPauseButton = ({
	    mode,
	    togglePlayback,
	    className,
	}) => {
	    let content = null;
	    let title = undefined;

	    switch (mode) {
	        case "playing":
	            content = React$2.createElement(ForwardRef$11, { className: "m-auto h-9 w-9"  ,} );
	            title = "pause";
	            break;
	        case "paused":
	            content = React$2.createElement(ForwardRef$Z, { className: "m-auto h-9 w-9"  ,} );
	            title = "play";
	            break;
	        case "uploading:starting":
	        case "uploading:pending":
	        case "uploading:finishing":
	        case "uploading:finished": {
	            const submode = mode.split(":")[1];

	            content = (
	                React$2.createElement(React$2.Fragment, null
	                    , React$2.createElement(LoadingIcon, null )
	                    , React$2.createElement('div', { className: "text-xs",}
	                        , t$5(`client:post-editor.attachment-state.${submode}`)
	                    )
	                )
	            );
	            break;
	        }
	    }

	    return (
	        React$2.createElement('button', {
	            type: "button",
	            className: classNames("w-[76px] bg-cherry", className),
	            onClick: togglePlayback,
	            title: title,}

	            , content
	        )
	    );
	};

	function formatPlaybackTime(seconds) {
	    const duration = Duration_1.fromMillis(seconds * 1000);

	    return duration.toFormat("mm:ss");
	}

	const AudioSeekBar = ({
	    currentTime,
	    totalDuration,
	    seek,
	}) => {
	    const [displayTimeRemaining, setDisplayTimeRemaining] = reactExports.useState(false);

	    const onRightTimeClick = reactExports.useCallback(() => {
	        setDisplayTimeRemaining(!displayTimeRemaining);
	    }, [displayTimeRemaining]);

	    return (
	        React$2.createElement('div', { className: "flex flex-row items-center"  ,}
	            , React$2.createElement('div', { className: "text-xs tabular-nums" ,}
	                , formatPlaybackTime(currentTime)
	            )
	            , React$2.createElement('input', {
	                type: "range",
	                className: "audio-controls mx-1 flex-1 accent-mango"   ,
	                value: currentTime,
	                max: totalDuration,
	                step: "any",
	                onChange: (e) => {
	                    seek(e.target.valueAsNumber);
	                },}
	            )
	            , 
	                /* display total duration only after we know the number is valid */
	                totalDuration ? (
	                    React$2.createElement('button', {
	                        className: "cursor-pointer text-xs tabular-nums"  ,
	                        onClick: onRightTimeClick,
	                        type: "button",}

	                        , formatPlaybackTime(
	                            displayTimeRemaining
	                                ? totalDuration - currentTime
	                                : totalDuration
	                        )
	                    )
	                ) : null
	            
	        )
	    );
	};

	var isMergeableObject = function isMergeableObject(value) {
		return isNonNullObject(value)
			&& !isSpecial(value)
	};

	function isNonNullObject(value) {
		return !!value && typeof value === 'object'
	}

	function isSpecial(value) {
		var stringValue = Object.prototype.toString.call(value);

		return stringValue === '[object RegExp]'
			|| stringValue === '[object Date]'
			|| isReactElement(value)
	}

	// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
	var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
	var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;

	function isReactElement(value) {
		return value.$$typeof === REACT_ELEMENT_TYPE
	}

	function emptyTarget(val) {
		return Array.isArray(val) ? [] : {}
	}

	function cloneUnlessOtherwiseSpecified(value, options) {
		return (options.clone !== false && options.isMergeableObject(value))
			? deepmerge(emptyTarget(value), value, options)
			: value
	}

	function defaultArrayMerge(target, source, options) {
		return target.concat(source).map(function(element) {
			return cloneUnlessOtherwiseSpecified(element, options)
		})
	}

	function getMergeFunction(key, options) {
		if (!options.customMerge) {
			return deepmerge
		}
		var customMerge = options.customMerge(key);
		return typeof customMerge === 'function' ? customMerge : deepmerge
	}

	function getEnumerableOwnPropertySymbols(target) {
		return Object.getOwnPropertySymbols
			? Object.getOwnPropertySymbols(target).filter(function(symbol) {
				return target.propertyIsEnumerable(symbol)
			})
			: []
	}

	function getKeys(target) {
		return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
	}

	function propertyIsOnObject(object, property) {
		try {
			return property in object
		} catch(_) {
			return false
		}
	}

	// Protects from prototype poisoning and unexpected merging up the prototype chain.
	function propertyIsUnsafe(target, key) {
		return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
			&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
				&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
	}

	function mergeObject(target, source, options) {
		var destination = {};
		if (options.isMergeableObject(target)) {
			getKeys(target).forEach(function(key) {
				destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
			});
		}
		getKeys(source).forEach(function(key) {
			if (propertyIsUnsafe(target, key)) {
				return
			}

			if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
				destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
			} else {
				destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
			}
		});
		return destination
	}

	function deepmerge(target, source, options) {
		options = options || {};
		options.arrayMerge = options.arrayMerge || defaultArrayMerge;
		options.isMergeableObject = options.isMergeableObject || isMergeableObject;
		// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
		// implementations can use it. The caller may not replace it.
		options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;

		var sourceIsArray = Array.isArray(source);
		var targetIsArray = Array.isArray(target);
		var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;

		if (!sourceAndTargetTypesMatch) {
			return cloneUnlessOtherwiseSpecified(source, options)
		} else if (sourceIsArray) {
			return options.arrayMerge(target, source, options)
		} else {
			return mergeObject(target, source, options)
		}
	}

	deepmerge.all = function deepmergeAll(array, options) {
		if (!Array.isArray(array)) {
			throw new Error('first argument should be an array')
		}

		return array.reduce(function(prev, next) {
			return deepmerge(prev, next, options)
		}, {})
	};

	var deepmerge_1 = deepmerge;

	var cjs = deepmerge_1;

	var deepmerge$1 = /*@__PURE__*/getDefaultExportFromCjs(cjs);

	/** @type {import('./index.js').Schema} */
	const defaultSchema = {
	  strip: ['script'],
	  clobberPrefix: 'user-content-',
	  clobber: ['name', 'id'],
	  ancestors: {
	    tbody: ['table'],
	    tfoot: ['table'],
	    thead: ['table'],
	    td: ['table'],
	    th: ['table'],
	    tr: ['table']
	  },
	  protocols: {
	    href: ['http', 'https', 'mailto', 'xmpp', 'irc', 'ircs'],
	    cite: ['http', 'https'],
	    src: ['http', 'https'],
	    longDesc: ['http', 'https']
	  },
	  tagNames: [
	    'h1',
	    'h2',
	    'h3',
	    'h4',
	    'h5',
	    'h6',
	    'br',
	    'b',
	    'i',
	    'strong',
	    'em',
	    'a',
	    'pre',
	    'code',
	    'img',
	    'tt',
	    'div',
	    'ins',
	    'del',
	    'sup',
	    'sub',
	    'p',
	    'ol',
	    'ul',
	    'table',
	    'thead',
	    'tbody',
	    'tfoot',
	    'blockquote',
	    'dl',
	    'dt',
	    'dd',
	    'kbd',
	    'q',
	    'samp',
	    'var',
	    'hr',
	    'ruby',
	    'rt',
	    'rp',
	    'li',
	    'tr',
	    'td',
	    'th',
	    's',
	    'strike',
	    'summary',
	    'details',
	    'caption',
	    'figure',
	    'figcaption',
	    'abbr',
	    'bdo',
	    'cite',
	    'dfn',
	    'mark',
	    'small',
	    'span',
	    'time',
	    'wbr',
	    'input'
	  ],
	  attributes: {
	    a: ['href'],
	    img: ['src', 'longDesc'],
	    input: [
	      ['type', 'checkbox'],
	      ['disabled', true]
	    ],
	    li: [['className', 'task-list-item']],
	    div: ['itemScope', 'itemType'],
	    blockquote: ['cite'],
	    del: ['cite'],
	    ins: ['cite'],
	    q: ['cite'],
	    '*': [
	      'abbr',
	      'accept',
	      'acceptCharset',
	      'accessKey',
	      'action',
	      'align',
	      'alt',
	      'ariaDescribedBy',
	      'ariaHidden',
	      'ariaLabel',
	      'ariaLabelledBy',
	      'axis',
	      'border',
	      'cellPadding',
	      'cellSpacing',
	      'char',
	      'charOff',
	      'charSet',
	      'checked',
	      'clear',
	      'cols',
	      'colSpan',
	      'color',
	      'compact',
	      'coords',
	      'dateTime',
	      'dir',
	      'disabled',
	      'encType',
	      'htmlFor',
	      'frame',
	      'headers',
	      'height',
	      'hrefLang',
	      'hSpace',
	      'isMap',
	      'id',
	      'label',
	      'lang',
	      'maxLength',
	      'media',
	      'method',
	      'multiple',
	      'name',
	      'noHref',
	      'noShade',
	      'noWrap',
	      'open',
	      'prompt',
	      'readOnly',
	      'rel',
	      'rev',
	      'rows',
	      'rowSpan',
	      'rules',
	      'scope',
	      'selected',
	      'shape',
	      'size',
	      'span',
	      'start',
	      'summary',
	      'tabIndex',
	      'target',
	      'title',
	      'type',
	      'useMap',
	      'vAlign',
	      'value',
	      'vSpace',
	      'width',
	      'itemProp'
	    ]
	  },
	  required: {
	    input: {
	      type: 'checkbox',
	      disabled: true
	    }
	  }
	};

	/**
	 * @typedef {import('hast').Parent} Parent
	 * @typedef {import('hast').Root} Root
	 * @typedef {import('hast').Properties} Properties
	 * @typedef {Parent['children'][number]|Root} Node
	 *
	 * @typedef {Properties[string]} PropertyValue Possible property values
	 * @typedef {string|number|boolean} PrimitivePropertyValue Possible primitive HTML attribute values
	 * @typedef {string|[string, ...PrimitivePropertyValue[]]} AttributeValue
	 * @typedef {Object.<string, Array.<PrimitivePropertyValue>>} AttributeMap
	 *
	 * @typedef Schema Sanitization configuration
	 * @property {Object<string, Array<AttributeValue>>} [attributes] Map of tag names to allowed property names. The special '*' key defines property names allowed on all elements
	 * @property {Object<string, Object<string, PropertyValue>>} [required] Map of tag names to required property names and their default property value
	 * @property {Array.<string>} [tagNames] List of allowed tag names
	 * @property {Object<string, Array.<string>>} [protocols] Map of protocols to allow in property values
	 * @property {Object<string, Array.<string>>} [ancestors] Map of tag names to their required ancestor elements
	 * @property {Array.<string>} [clobber] List of allowed property names which can clobber
	 * @property {string} [clobberPrefix] Prefix to use before potentially clobbering property names
	 * @property {Array.<string>} [strip] Names of elements to strip from the tree
	 * @property {boolean} [allowComments] Whether to allow comments
	 * @property {boolean} [allowDoctypes] Whether to allow doctypes
	 *
	 * @typedef {(schema: Schema, value: unknown, node: Node, stack: Array.<string>) => unknown} Handler
	 * @typedef {Object.<string, Handler>} NodeDefinition
	 * @typedef {((schema: Schema, node: Node) => NodeDefinition)} NodeDefinitionGetter
	 * @typedef {Object.<string, NodeDefinition|NodeDefinitionGetter>} NodeSchema
	 */


	var own$g = {}.hasOwnProperty;
	var push$1 = [].push;

	/** @type {NodeSchema} */
	var nodeSchema = {
	  root: {children: all$4},
	  doctype: handleDoctype,
	  comment: handleComment,
	  element: {
	    tagName: handleTagName$1,
	    properties: handleProperties,
	    children: all$4
	  },
	  text: {value: handleValue},
	  '*': {data: allow, position: allow}
	};

	/**
	 * Utility to sanitize a tree
	 *
	 * @param {Node} node Hast tree to sanitize
	 * @param {Schema} [schema] Schema defining how to sanitize - defaults to Github style sanitation
	 */
	function sanitize(node, schema) {
	  /** @type {Node} */
	  var ctx = {type: 'root', children: []};
	  /** @type {Node|Array.<Node>} */
	  var replace;

	  if (node && typeof node === 'object' && node.type) {
	    replace = one$4(Object.assign({}, defaultSchema, schema || {}), node, []);

	    if (replace) {
	      if (Array.isArray(replace)) {
	        if (replace.length === 1) {
	          ctx = replace[0];
	        } else {
	          // @ts-ignore Assume `root` is not a child.
	          ctx.children = replace;
	        }
	      } else {
	        ctx = replace;
	      }
	    }
	  }

	  return ctx
	}

	/**
	 * Sanitize `node`.
	 *
	 * @param {Schema} schema
	 * @param {Node} node
	 * @param {Array.<string>} stack
	 * @returns {Node|Array.<Node>|null}
	 */
	function one$4(schema, node, stack) {
	  var type = node && node.type;
	  /** @type {Node} */
	  // @ts-ignore rest of props added later.
	  var replacement = {type: node.type};
	  /** @type {boolean} */
	  var replace;
	  /** @type {NodeDefinition|NodeDefinitionGetter} */
	  var definition;
	  /** @type {NodeDefinition} */
	  var allowed;
	  /** @type {unknown} */
	  var result;
	  /** @type {string} */
	  var key;

	  if (own$g.call(nodeSchema, type)) {
	    definition = nodeSchema[type];

	    if (typeof definition === 'function') {
	      definition = definition(schema, node);
	    }

	    if (definition) {
	      replace = true;
	      allowed = Object.assign({}, definition, nodeSchema['*']);

	      for (key in allowed) {
	        if (own$g.call(allowed, key)) {
	          result = allowed[key](schema, node[key], node, stack);

	          // eslint-disable-next-line max-depth
	          if (result === false) {
	            replace = null;
	            // Set the non-safe value.
	            replacement[key] = node[key];
	          } else if (result !== undefined && result !== null) {
	            replacement[key] = result;
	          }
	        }
	      }
	    }
	  }

	  if (replace) {
	    return replacement
	  }

	  return replacement.type === 'element' &&
	    !schema.strip.includes(replacement.tagName)
	    ? replacement.children
	    : null
	}

	/**
	 * Sanitize `children`.
	 *
	 * @type {Handler}
	 * @param {Array.<Node>} children
	 * @returns {Array.<Node>}
	 */
	function all$4(schema, children, node, stack) {
	  /** @type {Array.<Node>} */
	  var results = [];
	  var index = -1;
	  /** @type {Node|Array.<Node>} */
	  var value;

	  if (Array.isArray(children)) {
	    if (node.type === 'element') {
	      stack.push(node.tagName);
	    }

	    while (++index < children.length) {
	      value = one$4(schema, children[index], stack);

	      if (value) {
	        if ('length' in value) {
	          push$1.apply(results, value);
	        } else {
	          results.push(value);
	        }
	      }
	    }

	    if (node.type === 'element') {
	      stack.pop();
	    }
	  }

	  return results
	}

	/** @type {NodeDefinitionGetter} */
	function handleDoctype(schema) {
	  return schema.allowDoctypes ? {name: handleDoctypeName} : null
	}

	/** @type {NodeDefinitionGetter} */
	function handleComment(schema) {
	  return schema.allowComments ? {value: handleCommentValue} : null
	}

	/**
	 * Sanitize `properties`.
	 *
	 * @type {Handler}
	 * @param {Properties} properties
	 * @returns {Properties}
	 */
	function handleProperties(schema, properties, node, stack) {
	  var name = handleTagName$1(schema, node.tagName, node, stack);
	  /* c8 ignore next */
	  var reqs = schema.required || {};
	  var props = properties || {};
	  var allowed = Object.assign(
	    {},
	    toPropertyValueMap(schema.attributes['*']),
	    toPropertyValueMap(
	      name && own$g.call(schema.attributes, name) ? schema.attributes[name] : []
	    )
	  );
	  /** @type {Properties} */
	  var result = {};
	  /** @type {Array.<PrimitivePropertyValue>} */
	  var definition;
	  /** @type {PropertyValue} */
	  var value;
	  /** @type {string} */
	  var key;

	  for (key in props) {
	    if (own$g.call(props, key)) {
	      if (own$g.call(allowed, key)) {
	        definition = allowed[key];
	      } else if (data$1(key) && own$g.call(allowed, 'data*')) {
	        definition = allowed['data*'];
	      } else {
	        continue
	      }

	      value = props[key];
	      value = Array.isArray(value)
	        ? handlePropertyValues(schema, value, key, definition)
	        : handlePropertyValue(schema, value, key, definition);

	      if (value !== undefined && value !== null) {
	        result[key] = value;
	      }
	    }
	  }

	  if (name && own$g.call(reqs, name)) {
	    for (key in reqs[name]) {
	      if (!own$g.call(result, key)) {
	        result[key] = reqs[name][key];
	      }
	    }
	  }

	  return result
	}

	/**
	 * Always return a valid HTML5 doctype.
	 *
	 * @type {Handler}
	 * @returns {string}
	 */
	function handleDoctypeName() {
	  return 'html'
	}

	/**
	 * Sanitize `tagName`.
	 *
	 * @type {Handler}
	 * @returns {string|false}
	 */
	function handleTagName$1(schema, tagName, _, stack) {
	  var name = typeof tagName === 'string' ? tagName : '';
	  var index = -1;

	  if (!name || name === '*' || !schema.tagNames.includes(name)) {
	    return false
	  }

	  // Some nodes can break out of their context if they don’t have a certain
	  // ancestor.
	  if (own$g.call(schema.ancestors, name)) {
	    while (++index < schema.ancestors[name].length) {
	      if (stack.includes(schema.ancestors[name][index])) {
	        return name
	      }
	    }

	    return false
	  }

	  return name
	}

	/**
	 * See <https://html.spec.whatwg.org/multipage/parsing.html#serialising-html-fragments>
	 *
	 * @type {Handler}
	 * @returns {string}
	 */
	function handleCommentValue(_, value) {
	  /** @type {string} */
	  var result = typeof value === 'string' ? value : '';
	  var index = result.indexOf('-->');
	  return index < 0 ? result : result.slice(0, index)
	}

	/**
	 * Sanitize `value`.
	 *
	 * @type {Handler}
	 * @returns {string}
	 */
	function handleValue(_, value) {
	  return typeof value === 'string' ? value : ''
	}

	/**
	 * Allow `value`.
	 *
	 * @type {Handler}
	 */
	function allow(_, value) {
	  return value
	}

	/**
	 * Sanitize a property value which is a list.
	 *
	 * @param {Schema} schema
	 * @param {Array.<unknown>} values
	 * @param {string} prop
	 * @param {Array.<PrimitivePropertyValue>} definition
	 * @returns {Array.<string|number>}
	 */
	function handlePropertyValues(schema, values, prop, definition) {
	  var index = -1;
	  /** @type {Array.<string|number>} */
	  var result = [];
	  /** @type {PropertyValue} */
	  var value;

	  while (++index < values.length) {
	    value = handlePropertyValue(schema, values[index], prop, definition);

	    if (value !== undefined && value !== null) {
	      // @ts-ignore Assume no booleans were in arrays.
	      result.push(value);
	    }
	  }

	  return result
	}

	/**
	 * Sanitize a property value.
	 *
	 * @param {Schema} schema
	 * @param {unknown} value
	 * @param {string} prop
	 * @param {Array.<PropertyValue>} definition
	 * @returns {PropertyValue}
	 */
	function handlePropertyValue(schema, value, prop, definition) {
	  if (
	    (typeof value === 'boolean' ||
	      typeof value === 'number' ||
	      typeof value === 'string') &&
	    safeProtocol(schema, value, prop) &&
	    (definition.length === 0 || definition.includes(value))
	  ) {
	    return schema.clobber.includes(prop) ? schema.clobberPrefix + value : value
	  }
	}

	/**
	 * Check whether `value` is a safe URL.
	 *
	 * @param {Schema} schema
	 * @param {unknown} value
	 * @param {string} prop
	 * @returns {boolean}
	 */
	function safeProtocol(schema, value, prop) {
	  var url = String(value);
	  var colon = url.indexOf(':');
	  var questionMark = url.indexOf('?');
	  var numberSign = url.indexOf('#');
	  var slash = url.indexOf('/');
	  var protocols = own$g.call(schema.protocols, prop)
	    ? schema.protocols[prop].concat()
	    : [];
	  var index = -1;

	  if (
	    protocols.length === 0 ||
	    colon < 0 ||
	    // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.
	    (slash > -1 && colon > slash) ||
	    (questionMark > -1 && colon > questionMark) ||
	    (numberSign > -1 && colon > numberSign)
	  ) {
	    return true
	  }

	  while (++index < protocols.length) {
	    if (
	      colon === protocols[index].length &&
	      url.slice(0, protocols[index].length) === protocols[index]
	    ) {
	      return true
	    }
	  }

	  return false
	}

	/**
	 * Create a map from a list of props or a list of properties and values.
	 *
	 * @param {Array.<AttributeValue>} values
	 * @returns {AttributeMap}
	 */
	function toPropertyValueMap(values) {
	  /** @type {AttributeMap} */
	  var result = {};
	  var index = -1;
	  /** @type {AttributeValue} */
	  var value;

	  while (++index < values.length) {
	    value = values[index];

	    if (Array.isArray(value)) {
	      result[value[0]] = value.slice(1);
	    } else {
	      result[value] = [];
	    }
	  }

	  return result
	}

	/**
	 * Check if `prop` is a data property.
	 *
	 * @param {string} prop
	 * @returns {boolean}
	 */
	function data$1(prop) {
	  return prop.length > 4 && prop.slice(0, 4).toLowerCase() === 'data'
	}

	/**
	 * @typedef {import('hast').Root} Root
	 *
	 * @typedef {import('hast-util-sanitize').Schema} Options
	 *   The sanitation schema defines how and if nodes and properties should be cleaned.
	 *   See `hast-util-sanitize`.
	 *   The default schema is exported as `defaultSchema`.
	 */


	/**
	 * Plugin to sanitize HTML.
	 *
	 * @type {import('unified').Plugin<[Options?] | Array<void>, Root, Root>}
	 */
	function rehypeSanitize(options = defaultSchema) {
	  // @ts-expect-error: assume input `root` matches output root.
	  return (tree) => sanitize(tree, options)
	}

	// http://www.w3.org/TR/CSS21/grammar.html
	// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027
	var COMMENT_REGEX = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;

	var NEWLINE_REGEX = /\n/g;
	var WHITESPACE_REGEX = /^\s*/;

	// declaration
	var PROPERTY_REGEX = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/;
	var COLON_REGEX = /^:\s*/;
	var VALUE_REGEX = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/;
	var SEMICOLON_REGEX = /^[;\s]*/;

	// https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim#Polyfill
	var TRIM_REGEX = /^\s+|\s+$/g;

	// strings
	var NEWLINE = '\n';
	var FORWARD_SLASH = '/';
	var ASTERISK = '*';
	var EMPTY_STRING = '';

	// types
	var TYPE_COMMENT = 'comment';
	var TYPE_DECLARATION = 'declaration';

	/**
	 * @param {String} style
	 * @param {Object} [options]
	 * @return {Object[]}
	 * @throws {TypeError}
	 * @throws {Error}
	 */
	var inlineStyleParser = function(style, options) {
	  if (typeof style !== 'string') {
	    throw new TypeError('First argument must be a string');
	  }

	  if (!style) return [];

	  options = options || {};

	  /**
	   * Positional.
	   */
	  var lineno = 1;
	  var column = 1;

	  /**
	   * Update lineno and column based on `str`.
	   *
	   * @param {String} str
	   */
	  function updatePosition(str) {
	    var lines = str.match(NEWLINE_REGEX);
	    if (lines) lineno += lines.length;
	    var i = str.lastIndexOf(NEWLINE);
	    column = ~i ? str.length - i : column + str.length;
	  }

	  /**
	   * Mark position and patch `node.position`.
	   *
	   * @return {Function}
	   */
	  function position() {
	    var start = { line: lineno, column: column };
	    return function(node) {
	      node.position = new Position(start);
	      whitespace();
	      return node;
	    };
	  }

	  /**
	   * Store position information for a node.
	   *
	   * @constructor
	   * @property {Object} start
	   * @property {Object} end
	   * @property {undefined|String} source
	   */
	  function Position(start) {
	    this.start = start;
	    this.end = { line: lineno, column: column };
	    this.source = options.source;
	  }

	  /**
	   * Non-enumerable source string.
	   */
	  Position.prototype.content = style;

	  /**
	   * Error `msg`.
	   *
	   * @param {String} msg
	   * @throws {Error}
	   */
	  function error(msg) {
	    var err = new Error(
	      options.source + ':' + lineno + ':' + column + ': ' + msg
	    );
	    err.reason = msg;
	    err.filename = options.source;
	    err.line = lineno;
	    err.column = column;
	    err.source = style;

	    if (options.silent) ; else {
	      throw err;
	    }
	  }

	  /**
	   * Match `re` and return captures.
	   *
	   * @param {RegExp} re
	   * @return {undefined|Array}
	   */
	  function match(re) {
	    var m = re.exec(style);
	    if (!m) return;
	    var str = m[0];
	    updatePosition(str);
	    style = style.slice(str.length);
	    return m;
	  }

	  /**
	   * Parse whitespace.
	   */
	  function whitespace() {
	    match(WHITESPACE_REGEX);
	  }

	  /**
	   * Parse comments.
	   *
	   * @param {Object[]} [rules]
	   * @return {Object[]}
	   */
	  function comments(rules) {
	    var c;
	    rules = rules || [];
	    while ((c = comment())) {
	      if (c !== false) {
	        rules.push(c);
	      }
	    }
	    return rules;
	  }

	  /**
	   * Parse comment.
	   *
	   * @return {Object}
	   * @throws {Error}
	   */
	  function comment() {
	    var pos = position();
	    if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;

	    var i = 2;
	    while (
	      EMPTY_STRING != style.charAt(i) &&
	      (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))
	    ) {
	      ++i;
	    }
	    i += 2;

	    if (EMPTY_STRING === style.charAt(i - 1)) {
	      return error('End of comment missing');
	    }

	    var str = style.slice(2, i - 2);
	    column += 2;
	    updatePosition(str);
	    style = style.slice(i);
	    column += 2;

	    return pos({
	      type: TYPE_COMMENT,
	      comment: str
	    });
	  }

	  /**
	   * Parse declaration.
	   *
	   * @return {Object}
	   * @throws {Error}
	   */
	  function declaration() {
	    var pos = position();

	    // prop
	    var prop = match(PROPERTY_REGEX);
	    if (!prop) return;
	    comment();

	    // :
	    if (!match(COLON_REGEX)) return error("property missing ':'");

	    // val
	    var val = match(VALUE_REGEX);

	    var ret = pos({
	      type: TYPE_DECLARATION,
	      property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),
	      value: val
	        ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING))
	        : EMPTY_STRING
	    });

	    // ;
	    match(SEMICOLON_REGEX);

	    return ret;
	  }

	  /**
	   * Parse declarations.
	   *
	   * @return {Object[]}
	   */
	  function declarations() {
	    var decls = [];

	    comments(decls);

	    // declarations
	    var decl;
	    while ((decl = declaration())) {
	      if (decl !== false) {
	        decls.push(decl);
	        comments(decls);
	      }
	    }

	    return decls;
	  }

	  whitespace();
	  return declarations();
	};

	/**
	 * Trim `str`.
	 *
	 * @param {String} str
	 * @return {String}
	 */
	function trim(str) {
	  return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;
	}

	var parse$4 = inlineStyleParser;

	/**
	 * Parses inline style to object.
	 *
	 * @example
	 * // returns { 'line-height': '42' }
	 * StyleToObject('line-height: 42;');
	 *
	 * @param  {String}      style      - The inline style.
	 * @param  {Function}    [iterator] - The iterator function.
	 * @return {null|Object}
	 */
	function StyleToObject(style, iterator) {
	  var output = null;
	  if (!style || typeof style !== 'string') {
	    return output;
	  }

	  var declaration;
	  var declarations = parse$4(style);
	  var hasIterator = typeof iterator === 'function';
	  var property;
	  var value;

	  for (var i = 0, len = declarations.length; i < len; i++) {
	    declaration = declarations[i];
	    property = declaration.property;
	    value = declaration.value;

	    if (hasIterator) {
	      iterator(property, value, declaration);
	    } else if (value) {
	      output || (output = {});
	      output[property] = value;
	    }
	  }

	  return output;
	}

	var styleToObject = StyleToObject;

	var style$1 = /*@__PURE__*/getDefaultExportFromCjs(styleToObject);

	/**
	 * @typedef {import('unist').Node} Node
	 * @typedef {import('unist').Parent} Parent
	 */

	/**
	 * @typedef {Record<string, unknown>} Props
	 * @typedef {null | undefined | string | Props | TestFunctionAnything | Array<string | Props | TestFunctionAnything>} Test
	 *   Check for an arbitrary node, unaware of TypeScript inferral.
	 *
	 * @callback TestFunctionAnything
	 *   Check if a node passes a test, unaware of TypeScript inferral.
	 * @param {unknown} this
	 *   The given context.
	 * @param {Node} node
	 *   A node.
	 * @param {number | null | undefined} [index]
	 *   The node’s position in its parent.
	 * @param {Parent | null | undefined} [parent]
	 *   The node’s parent.
	 * @returns {boolean | void}
	 *   Whether this node passes the test.
	 */

	/**
	 * @template {Node} Kind
	 *   Node type.
	 * @typedef {Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind> | Array<Kind['type'] | Partial<Kind> | TestFunctionPredicate<Kind>>} PredicateTest
	 *   Check for a node that can be inferred by TypeScript.
	 */

	/**
	 * Check if a node passes a certain test.
	 *
	 * @template {Node} Kind
	 *   Node type.
	 * @callback TestFunctionPredicate
	 *   Complex test function for a node that can be inferred by TypeScript.
	 * @param {Node} node
	 *   A node.
	 * @param {number | null | undefined} [index]
	 *   The node’s position in its parent.
	 * @param {Parent | null | undefined} [parent]
	 *   The node’s parent.
	 * @returns {node is Kind}
	 *   Whether this node passes the test.
	 */

	/**
	 * @callback AssertAnything
	 *   Check that an arbitrary value is a node, unaware of TypeScript inferral.
	 * @param {unknown} [node]
	 *   Anything (typically a node).
	 * @param {number | null | undefined} [index]
	 *   The node’s position in its parent.
	 * @param {Parent | null | undefined} [parent]
	 *   The node’s parent.
	 * @returns {boolean}
	 *   Whether this is a node and passes a test.
	 */

	/**
	 * Check if a node is a node and passes a certain node test.
	 *
	 * @template {Node} Kind
	 *   Node type.
	 * @callback AssertPredicate
	 *   Check that an arbitrary value is a specific node, aware of TypeScript.
	 * @param {unknown} [node]
	 *   Anything (typically a node).
	 * @param {number | null | undefined} [index]
	 *   The node’s position in its parent.
	 * @param {Parent | null | undefined} [parent]
	 *   The node’s parent.
	 * @returns {node is Kind}
	 *   Whether this is a node and passes a test.
	 */

	/**
	 * Check if `node` is a `Node` and whether it passes the given test.
	 *
	 * @param node
	 *   Thing to check, typically `Node`.
	 * @param test
	 *   A check for a specific node.
	 * @param index
	 *   The node’s position in its parent.
	 * @param parent
	 *   The node’s parent.
	 * @returns
	 *   Whether `node` is a node and passes a test.
	 */
	const is$2 =
	  /**
	   * @type {(
	   *   (() => false) &
	   *   (<Kind extends Node = Node>(node: unknown, test: PredicateTest<Kind>, index: number, parent: Parent, context?: unknown) => node is Kind) &
	   *   (<Kind extends Node = Node>(node: unknown, test: PredicateTest<Kind>, index?: null | undefined, parent?: null | undefined, context?: unknown) => node is Kind) &
	   *   ((node: unknown, test: Test, index: number, parent: Parent, context?: unknown) => boolean) &
	   *   ((node: unknown, test?: Test, index?: null | undefined, parent?: null | undefined, context?: unknown) => boolean)
	   * )}
	   */
	  (
	    /**
	     * @param {unknown} [node]
	     * @param {Test} [test]
	     * @param {number | null | undefined} [index]
	     * @param {Parent | null | undefined} [parent]
	     * @param {unknown} [context]
	     * @returns {boolean}
	     */
	    // eslint-disable-next-line max-params
	    function is(node, test, index, parent, context) {
	      const check = convert$5(test);

	      // @ts-expect-error Looks like a node.
	      return node && node.type && typeof node.type === 'string'
	        ? Boolean(check.call(context, node, index, parent))
	        : false
	    }
	  );

	/**
	 * Generate an assertion from a test.
	 *
	 * Useful if you’re going to test many nodes, for example when creating a
	 * utility where something else passes a compatible test.
	 *
	 * The created function is a bit faster because it expects valid input only:
	 * a `node`, `index`, and `parent`.
	 *
	 * @param test
	 *   *   when nullish, checks if `node` is a `Node`.
	 *   *   when `string`, works like passing `(node) => node.type === test`.
	 *   *   when `function` checks if function passed the node is true.
	 *   *   when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
	 *   *   when `array`, checks if any one of the subtests pass.
	 * @returns
	 *   An assertion.
	 */
	const convert$5 =
	  /**
	   * @type {(
	   *   (<Kind extends Node>(test: PredicateTest<Kind>) => AssertPredicate<Kind>) &
	   *   ((test?: Test) => AssertAnything)
	   * )}
	   */
	  (
	    /**
	     * @param {Test} [test]
	     * @returns {AssertAnything}
	     */
	    function (test) {
	      if (test === undefined || test === null) {
	        return ok$1
	      }

	      if (typeof test === 'string') {
	        return typeFactory$1(test)
	      }

	      if (typeof test === 'object') {
	        return Array.isArray(test) ? anyFactory$2(test) : propsFactory(test)
	      }

	      if (typeof test === 'function') {
	        return castFactory$1(test)
	      }

	      throw new Error('Expected function, string, or object as test')
	    }
	  );

	/**
	 * @param {Array<string | Props | TestFunctionAnything>} tests
	 * @returns {AssertAnything}
	 */
	function anyFactory$2(tests) {
	  /** @type {Array<AssertAnything>} */
	  const checks = [];
	  let index = -1;

	  while (++index < tests.length) {
	    checks[index] = convert$5(tests[index]);
	  }

	  return castFactory$1(any)

	  /**
	   * @this {unknown}
	   * @param {Array<unknown>} parameters
	   * @returns {boolean}
	   */
	  function any(...parameters) {
	    let index = -1;

	    while (++index < checks.length) {
	      if (checks[index].call(this, ...parameters)) return true
	    }

	    return false
	  }
	}

	/**
	 * Turn an object into a test for a node with a certain fields.
	 *
	 * @param {Props} check
	 * @returns {AssertAnything}
	 */
	function propsFactory(check) {
	  return castFactory$1(all)

	  /**
	   * @param {Node} node
	   * @returns {boolean}
	   */
	  function all(node) {
	    /** @type {string} */
	    let key;

	    for (key in check) {
	      // @ts-expect-error: hush, it sure works as an index.
	      if (node[key] !== check[key]) return false
	    }

	    return true
	  }
	}

	/**
	 * Turn a string into a test for a node with a certain type.
	 *
	 * @param {string} check
	 * @returns {AssertAnything}
	 */
	function typeFactory$1(check) {
	  return castFactory$1(type)

	  /**
	   * @param {Node} node
	   */
	  function type(node) {
	    return node && node.type === check
	  }
	}

	/**
	 * Turn a custom test into a test for a node that passes that test.
	 *
	 * @param {TestFunctionAnything} check
	 * @returns {AssertAnything}
	 */
	function castFactory$1(check) {
	  return assertion

	  /**
	   * @this {unknown}
	   * @param {unknown} node
	   * @param {Array<unknown>} parameters
	   * @returns {boolean}
	   */
	  function assertion(node, ...parameters) {
	    return Boolean(
	      node &&
	        typeof node === 'object' &&
	        'type' in node &&
	        // @ts-expect-error: fine.
	        Boolean(check.call(this, node, ...parameters))
	    )
	  }
	}

	function ok$1() {
	  return true
	}

	function color(x) { return x }

	/**
	 * @typedef {import('unist').Node} Node
	 * @typedef {import('unist').Parent} Parent
	 * @typedef {import('unist-util-is').Test} Test
	 */


	/**
	 * Continue traversing as normal.
	 */
	const CONTINUE$2 = true;

	/**
	 * Stop traversing immediately.
	 */
	const EXIT$2 = false;

	/**
	 * Do not traverse this node’s children.
	 */
	const SKIP$2 = 'skip';

	/**
	 * Visit nodes, with ancestral information.
	 *
	 * This algorithm performs *depth-first* *tree traversal* in *preorder*
	 * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).
	 *
	 * You can choose for which nodes `visitor` is called by passing a `test`.
	 * For complex tests, you should test yourself in `visitor`, as it will be
	 * faster and will have improved type information.
	 *
	 * Walking the tree is an intensive task.
	 * Make use of the return values of the visitor when possible.
	 * Instead of walking a tree multiple times, walk it once, use `unist-util-is`
	 * to check if a node matches, and then perform different operations.
	 *
	 * You can change the tree.
	 * See `Visitor` for more info.
	 *
	 * @param tree
	 *   Tree to traverse.
	 * @param test
	 *   `unist-util-is`-compatible test
	 * @param visitor
	 *   Handle each node.
	 * @param reverse
	 *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).
	 * @returns
	 *   Nothing.
	 */
	const visitParents$2 =
	  /**
	   * @type {(
	   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: BuildVisitor<Tree, Check>, reverse?: boolean | null | undefined) => void) &
	   *   (<Tree extends Node>(tree: Tree, visitor: BuildVisitor<Tree>, reverse?: boolean | null | undefined) => void)
	   * )}
	   */
	  (
	    /**
	     * @param {Node} tree
	     * @param {Test} test
	     * @param {Visitor<Node>} visitor
	     * @param {boolean | null | undefined} [reverse]
	     * @returns {void}
	     */
	    function (tree, test, visitor, reverse) {
	      if (typeof test === 'function' && typeof visitor !== 'function') {
	        reverse = visitor;
	        // @ts-expect-error no visitor given, so `visitor` is test.
	        visitor = test;
	        test = null;
	      }

	      const is = convert$5(test);
	      const step = reverse ? -1 : 1;

	      factory(tree, undefined, [])();

	      /**
	       * @param {Node} node
	       * @param {number | undefined} index
	       * @param {Array<Parent>} parents
	       */
	      function factory(node, index, parents) {
	        /** @type {Record<string, unknown>} */
	        // @ts-expect-error: hush
	        const value = node && typeof node === 'object' ? node : {};

	        if (typeof value.type === 'string') {
	          const name =
	            // `hast`
	            typeof value.tagName === 'string'
	              ? value.tagName
	              : // `xast`
	              typeof value.name === 'string'
	              ? value.name
	              : undefined;

	          Object.defineProperty(visit, 'name', {
	            value:
	              'node (' + color(node.type + (name ? '<' + name + '>' : '')) + ')'
	          });
	        }

	        return visit

	        function visit() {
	          /** @type {ActionTuple} */
	          let result = [];
	          /** @type {ActionTuple} */
	          let subresult;
	          /** @type {number} */
	          let offset;
	          /** @type {Array<Parent>} */
	          let grandparents;

	          if (!test || is(node, index, parents[parents.length - 1] || null)) {
	            result = toResult$1(visitor(node, parents));

	            if (result[0] === EXIT$2) {
	              return result
	            }
	          }

	          // @ts-expect-error looks like a parent.
	          if (node.children && result[0] !== SKIP$2) {
	            // @ts-expect-error looks like a parent.
	            offset = (reverse ? node.children.length : -1) + step;
	            // @ts-expect-error looks like a parent.
	            grandparents = parents.concat(node);

	            // @ts-expect-error looks like a parent.
	            while (offset > -1 && offset < node.children.length) {
	              // @ts-expect-error looks like a parent.
	              subresult = factory(node.children[offset], offset, grandparents)();

	              if (subresult[0] === EXIT$2) {
	                return subresult
	              }

	              offset =
	                typeof subresult[1] === 'number' ? subresult[1] : offset + step;
	            }
	          }

	          return result
	        }
	      }
	    }
	  );

	/**
	 * Turn a return value into a clean result.
	 *
	 * @param {VisitorResult} value
	 *   Valid return values from visitors.
	 * @returns {ActionTuple}
	 *   Clean result.
	 */
	function toResult$1(value) {
	  if (Array.isArray(value)) {
	    return value
	  }

	  if (typeof value === 'number') {
	    return [CONTINUE$2, value]
	  }

	  return [value]
	}

	/**
	 * @typedef {import('unist').Node} Node
	 * @typedef {import('unist').Parent} Parent
	 * @typedef {import('unist-util-is').Test} Test
	 * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult
	 * @typedef {import('./complex-types.js').Visitor} Visitor
	 */


	/**
	 * Visit children of tree which pass test.
	 *
	 * @param tree
	 *   Tree to walk
	 * @param [test]
	 *   `unist-util-is`-compatible test
	 * @param visitor
	 *   Function called for nodes that pass `test`.
	 * @param reverse
	 *   Traverse in reverse preorder (NRL) instead of preorder (NLR) (default).
	 */
	const visit$2 =
	  /**
	   * @type {(
	   *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types.js').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &
	   *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types.js').BuildVisitor<Tree>, reverse?: boolean) => void)
	   * )}
	   */
	  (
	    /**
	     * @param {Node} tree
	     * @param {Test} test
	     * @param {import('./complex-types.js').Visitor} visitor
	     * @param {boolean} [reverse]
	     */
	    function (tree, test, visitor, reverse) {
	      if (typeof test === 'function' && typeof visitor !== 'function') {
	        reverse = visitor;
	        visitor = test;
	        test = null;
	      }

	      visitParents$2(tree, test, overload, reverse);

	      /**
	       * @param {Node} node
	       * @param {Array<Parent>} parents
	       */
	      function overload(node, parents) {
	        const parent = parents[parents.length - 1];
	        return visitor(
	          node,
	          parent ? parent.children.indexOf(node) : null,
	          parent
	        )
	      }
	    }
	  );

	// this file is a .tsx so that tailwind will pick up on it















	const FIRST_AGE = {
	    schema: deepmerge$1(defaultSchema, {
	        attributes: {
	            "*": ["style"],
	        },
	        tagNames: ["video", "audio", "aside"], // consistency with current rules,
	    }),
	    // Wednesday, June 29, 2022 6:00:00 PM GMT
	    cutoffDate: new Date(1656525600000),
	    className: "",
	    additionalVisitor: lodashExports.noop,
	    singleLineBreaks: false,
	    forceAttachmentsToTop: true,
	    attachmentLayoutBehavior: "v1",
	    ask: {
	        allowEmbeddedMedia: true,
	    },
	};

	const SECOND_AGE = {
	    schema: deepmerge$1(defaultSchema, {
	        attributes: {
	            "*": ["style"],
	        },
	        tagNames: ["video", "audio", "aside"], // consistency with current rules,
	    }),
	    // Monday, November 14, 2022 6:00:00 AM GMT
	    cutoffDate: new Date(1668405600000),
	    className: "isolate",
	    additionalVisitor(hast) {
	        visit$2(hast, "element", (node, index, parent) => {
	            if (parent === null || index === null) return;

	            if (
	                node.properties?.style &&
	                typeof node.properties.style === "string"
	            ) {
	                try {
	                    let changed = false;
	                    const parsed = style$1(node.properties.style);
	                    if (
	                        parsed &&
	                        parsed["position"] &&
	                        [
	                            // every valid value of `position` _except_ `fixed`
	                            // (https://developer.mozilla.org/en-US/docs/Web/CSS/position),
	                            // which we disallow
	                            "static",
	                            "relative",
	                            "absolute",
	                            "sticky",
	                            "inherit",
	                            "initial",
	                            "revert",
	                            "revert-layer",
	                            "unset",
	                        ].indexOf(parsed["position"].toLowerCase()) === -1
	                    ) {
	                        parsed.position = "static";
	                        changed = true;
	                    }

	                    if (parsed && changed) {
	                        node.properties.style = Object.entries(parsed)
	                            .map(([k, v]) => `${k}:${v}`)
	                            .join(";");
	                    }
	                } catch (e) {
	                    // couldn't parse, don't worry about it
	                    return;
	                }
	            }
	        });
	    },
	    singleLineBreaks: false,
	    forceAttachmentsToTop: true,
	    attachmentLayoutBehavior: "v1",
	    ask: {
	        allowEmbeddedMedia: true,
	    },
	};

	const THIRD_AGE = {
	    schema: deepmerge$1(defaultSchema, {
	        attributes: {
	            "*": ["style"],
	        },
	        tagNames: ["video", "audio", "aside"], // consistency with current rules,
	    }),
	    // may 10 2023, 3pm EDT
	    cutoffDate: new Date("2023-05-10T15:00:00-04:00"),
	    className: "isolate co-contain-paint",
	    additionalVisitor(hast) {
	        // run the previous age's visitor first
	        SECOND_AGE.additionalVisitor(hast);

	        visit$2(hast, "element", (node, index, parent) => {
	            if (parent === null || index === null) return;

	            if (
	                node.properties?.style &&
	                typeof node.properties.style === "string"
	            ) {
	                try {
	                    let changed = false;
	                    const parsed = style$1(node.properties.style);

	                    if (parsed) {
	                        for (const key in parsed) {
	                            // drop all CSS variables
	                            if (key.startsWith("--")) {
	                                delete parsed[key];
	                                changed = true;
	                            }
	                        }
	                    }

	                    if (parsed && changed) {
	                        node.properties.style = Object.entries(parsed)
	                            .map(([k, v]) => `${k}:${v}`)
	                            .join(";");
	                    }
	                } catch (e) {
	                    // couldn't parse, don't worry about it
	                    return;
	                }
	            }
	        });
	    },
	    singleLineBreaks: false,
	    forceAttachmentsToTop: true,
	    attachmentLayoutBehavior: "v1",
	    ask: {
	        allowEmbeddedMedia: true,
	    },
	};

	const FOURTH_AGE = {
	    // no schema changes from third age
	    schema: THIRD_AGE.schema,
	    // july 17 2023, noon EDT
	    cutoffDate: new Date("2023-07-17T12:00:00-04:00"),
	    className: THIRD_AGE.className,
	    additionalVisitor: THIRD_AGE.additionalVisitor,
	    singleLineBreaks: true,
	    forceAttachmentsToTop: true,
	    attachmentLayoutBehavior: "v1",
	    ask: {
	        allowEmbeddedMedia: true,
	    },
	};

	// list pulled from dompurify
	const MATH_ML_SCHEMA = {
	    // allow mathml
	    tagNames: [
	        "math",
	        "menclose",
	        "merror",
	        "mfenced",
	        "mfrac",
	        "mglyph",
	        "mi",
	        "mlabeledtr",
	        "mmultiscripts",
	        "mn",
	        "mo",
	        "mover",
	        "mpadded",
	        "mphantom",
	        "mroot",
	        "mrow",
	        "ms",
	        "mspace",
	        "msqrt",
	        "mstyle",
	        "msub",
	        "msup",
	        "msubsup",
	        "mtable",
	        "mtd",
	        "mtext",
	        "mtr",
	        "munder",
	        "munderover",
	        "mprescripts",
	    ],
	    attributes: {
	        "*": [
	            "accent",
	            "accentunder",
	            "align",
	            "bevelled",
	            "close",
	            "columnsalign",
	            "columnlines",
	            "columnspan",
	            "denomalign",
	            "depth",
	            "dir",
	            "display",
	            "displaystyle",
	            "encoding",
	            "fence",
	            "frame",
	            "height",
	            "href",
	            "id",
	            "largeop",
	            "length",
	            "linethickness",
	            "lspace",
	            "lquote",
	            "mathbackground",
	            "mathcolor",
	            "mathsize",
	            "mathvariant",
	            "maxsize",
	            "minsize",
	            "movablelimits",
	            "notation",
	            "numalign",
	            "open",
	            "rowalign",
	            "rowlines",
	            "rowspacing",
	            "rowspan",
	            "rspace",
	            "rquote",
	            "scriptlevel",
	            "scriptminsize",
	            "scriptsizemultiplier",
	            "selection",
	            "separator",
	            "separators",
	            "stretchy",
	            "subscriptshift",
	            "supscriptshift",
	            "symmetric",
	            "voffset",
	            "width",
	            "xmlns",
	        ],
	        span: [["className", "math-inline"]],
	        div: [["className", "math-display"]],
	    },
	};

	const FIFTH_AGE = {
	    // we allow mathml now
	    schema: deepmerge$1(FOURTH_AGE.schema, MATH_ML_SCHEMA),
	    cutoffDate: new Date("2024-02-12T12:00:00-08:00"), // 2024/02/12 12:00 PST
	    className: FOURTH_AGE.className,
	    additionalVisitor: FOURTH_AGE.additionalVisitor,
	    singleLineBreaks: true,
	    forceAttachmentsToTop: true,
	    attachmentLayoutBehavior: "v1",
	    ask: {
	        allowEmbeddedMedia: true,
	    },
	};

	const SIXTH_AGE = {
	    schema: FIFTH_AGE.schema,
	    cutoffDate: new Date("2024-03-27T12:00:00-08:00"), // 2024/03/27 12:00 PDT
	    className: FIFTH_AGE.className,
	    additionalVisitor: FIFTH_AGE.additionalVisitor,
	    singleLineBreaks: true,
	    // attachments now render in post order instead of being pushed to the
	    // top of the post
	    forceAttachmentsToTop: false,
	    attachmentLayoutBehavior: "v1",
	    ask: {
	        allowEmbeddedMedia: true,
	    },
	};

	const SEVENTH_AGE = {
	    schema: SIXTH_AGE.schema,
	    cutoffDate: new Date("2024-03-29T12:00:00-08:00"), // 2024/03/29 12:00 PDT
	    className: SIXTH_AGE.className,
	    additionalVisitor: SIXTH_AGE.additionalVisitor,
	    singleLineBreaks: true,
	    forceAttachmentsToTop: false,
	    attachmentLayoutBehavior: "v2",
	    ask: {
	        allowEmbeddedMedia: true,
	    },
	};

	const EIGHTH_AGE = {
	    schema: SEVENTH_AGE.schema,
	    cutoffDate: null, // current age
	    className: SEVENTH_AGE.className,
	    additionalVisitor: SEVENTH_AGE.additionalVisitor,
	    singleLineBreaks: true,
	    forceAttachmentsToTop: false,
	    attachmentLayoutBehavior: "v2",
	    // asks no longer allow images, video, or audio to be embedded.
	    ask: {
	        allowEmbeddedMedia: false,
	    },
	};

	const AGE_LIST = [
	    FIRST_AGE,
	    SECOND_AGE,
	    THIRD_AGE,
	    FOURTH_AGE,
	    FIFTH_AGE,
	    SIXTH_AGE,
	    SEVENTH_AGE,
	    EIGHTH_AGE,
	] ;

	const chooseAgeRuleset = (postDate) =>
	    AGE_LIST.find((ruleset) => {
	        if (ruleset.cutoffDate) {
	            return postDate < ruleset.cutoffDate;
	        }

	        return true;
	    }) ?? AGE_LIST[AGE_LIST.length - 1];

	const AudioAttachmentPreview



	 = ({ attachment, canRemove, index }) => {
	    if (attachment.kind !== "audio") {
	        throw "attempting to render a non-audio attachment as audio?";
	    }

	    const service = reactExports.useContext(PostComposerContext);
	    const send = service.send;
	    const isEditing = useSelector$1(service, selectIsEditing$5);
	    const isCreatingPost = useSelector$1(service, selectIsCreatingPost);
	    const isStartingAttachments = useSelector$1(
	        service,
	        selectIsStartingAttachments
	    );
	    const isFinishingAttachments = useSelector$1(
	        service,
	        selectIsFinishingAttachments
	    );

	    const audio = reactExports.useRef(null);

	    const title = reactExports.useRef(null);
	    const artist = reactExports.useRef(null);

	    const { togglePlayback, currentTime, isPlaying, totalDuration, seek } =
	        useAudioPlayback(audio);

	    const sourceURL = reactExports.useMemo(() => makeSourceURL$1(attachment), [attachment]);

	    const inputStyleClasses = `
        w-full rounded-lg border-2 bg-transparent 
        read-only:bg-gray-700 border-gray-400 text-notWhite 
        placeholder:text-gray-400 focus:border-notWhite
    `;

	    const onRemove = reactExports.useCallback(() => {
	        if (canRemove && index !== undefined) {
	            send({ type: "REMOVE_ATTACHMENT", index });
	        }
	    }, [canRemove, index, send]);

	    const onMetadataChange = reactExports.useCallback

	(
	        (e) => {
	            if (
	                canRemove &&
	                index !== undefined &&
	                title.current &&
	                artist.current
	            ) {
	                send({
	                    type: "AUDIO_METADATA_INPUT",
	                    index,
	                    title: title.current.value,
	                    artist: artist.current.value,
	                });
	            }
	        },
	        [canRemove, index, send]
	    );

	    const displayTitle = reactExports.useMemo(() => {
	        if (attachment.metadata.title && attachment.metadata.title.length > 0) {
	            return attachment.metadata.title;
	        } else return "(no title specified)";
	    }, [attachment]);

	    const displayArtist = reactExports.useMemo(() => {
	        if (
	            attachment.metadata.artist &&
	            attachment.metadata.artist.length > 0
	        ) {
	            return attachment.metadata.artist;
	        } else return "(no artist specified)";
	    }, [attachment]);

	    const playPauseMode = reactExports.useMemo(() => {
	        if (isEditing) {
	            return isPlaying ? "playing" : "paused";
	        } else {
	            if (attachment.state === AttachmentState.Finished) {
	                return "uploading:finished";
	            }

	            if (isStartingAttachments || isCreatingPost) {
	                return "uploading:starting";
	            } else if (isFinishingAttachments) {
	                return "uploading:finishing";
	            } else {
	                return "uploading:pending";
	            }
	        }
	    }, [
	        attachment.state,
	        isCreatingPost,
	        isFinishingAttachments,
	        isStartingAttachments,
	        isEditing,
	        isPlaying,
	    ]);

	    return (
	        React$2.createElement('figure', { className: "group relative w-full flex-initial"   ,}
	            , React$2.createElement('audio', {
	                src: sourceURL,
	                preload: "metadata",
	                className: "w-full p-2" ,
	                ref: audio,}
	            )

	            , React$2.createElement('div', { className: "flex flex-row" ,}
	                , React$2.createElement(AudioPlayPauseButton, {
	                    mode: playPauseMode,
	                    className: "flex-shrink-0 flex-grow" ,
	                    togglePlayback: togglePlayback,}
	                )

	                , React$2.createElement('div', { className: "flex w-full flex-col bg-notBlack p-2"    ,}
	                    , canRemove ? (
	                        React$2.createElement(React$2.Fragment, null
	                            , React$2.createElement(AttachmentDeleteButton, { onDelete: onRemove,} )
	                            , React$2.createElement('input', {
	                                className: classNames(
	                                    inputStyleClasses,
	                                    "mb-1"
	                                ),
	                                type: "text",
	                                placeholder: "add title information"  ,
	                                defaultValue: attachment.metadata.title,
	                                ref: title,
	                                onChange: onMetadataChange,
	                                disabled: !isEditing,}
	                            )
	                            , React$2.createElement('input', {
	                                className: inputStyleClasses,
	                                type: "text",
	                                name: "artist",
	                                placeholder: "add artist information"  ,
	                                defaultValue: attachment.metadata.artist,
	                                ref: artist,
	                                onChange: onMetadataChange,
	                                disabled: !isEditing,}
	                            )
	                        )
	                    ) : (
	                        React$2.createElement(React$2.Fragment, null
	                            , React$2.createElement('div', null, displayTitle)
	                            , React$2.createElement('div', { className: "text-xs",}, displayArtist)

	                            , React$2.createElement(AudioSeekBar, {
	                                currentTime: currentTime,
	                                totalDuration: totalDuration,
	                                seek: seek,}
	                            )
	                        )
	                    )
	                )
	            )
	        )
	    );
	};
	AudioAttachmentPreview.displayName = "AudioAttachmentPreview";

	const ImageAttachmentPreview




	 = React$2.memo(({ attachment, canRemove, index, aspectRatio }) => {
	    if (attachment.kind !== "image") {
	        throw "attempting to render a non-image attachment as an image?";
	    }

	    const { t } = useTranslation();
	    const service = reactExports.useContext(PostComposerContext);
	    const attachmentComposerRef = reactExports.useContext(AttachmentComposerContext$1);
	    const send = service.send;
	    const isEditing = useSelector$1(service, selectIsEditing$5);
	    const isCreatingPost = useSelector$1(service, selectIsCreatingPost);
	    const isStartingAttachments = useSelector$1(
	        service,
	        selectIsStartingAttachments
	    );
	    const isFinishingAttachments = useSelector$1(
	        service,
	        selectIsFinishingAttachments
	    );

	    const onRemove = reactExports.useCallback(() => {
	        if (canRemove && index !== undefined) {
	            send({ type: "REMOVE_ATTACHMENT", index });
	        }
	    }, [canRemove, index, send]);

	    const displayString = reactExports.useMemo(() => {
	        if (attachment.state === AttachmentState.Finished) {
	            return t(
	                "client:post-editor.attachment-state.finished",
	                "uploaded!"
	            );
	        }

	        if (isStartingAttachments || isCreatingPost) {
	            return t(
	                "client:post-editor.attachment-state.starting",
	                "starting..."
	            );
	        } else if (isFinishingAttachments) {
	            return t(
	                "client:post-editor.attachment-state.finishing",
	                "finishing up..."
	            );
	        } else {
	            return t(
	                "client:post-editor.attachment-state.pending",
	                "uploading..."
	            );
	        }
	    }, [
	        attachment.state,
	        isCreatingPost,
	        isFinishingAttachments,
	        isStartingAttachments,
	        t,
	    ]);

	    const sourceURL = reactExports.useMemo(() => makeSourceURL$1(attachment), [attachment]);
	    const altTextButtonLabel = reactExports.useMemo(
	        () =>
	            (attachment.metadata.altText ?? "").length > 0
	                ? "edit description"
	                : "add description",
	        [attachment]
	    );

	    return (
	        React$2.createElement('div', { className: "group relative w-full flex-initial"   ,}
	            , React$2.createElement('img', {
	                src: sourceURL,
	                className: "h-full w-full object-cover"  ,
	                style: {
	                    aspectRatio: aspectRatio ? `${aspectRatio} / 1` : undefined,
	                },
	                alt: attachment.metadata.altText,}
	            )
	            , canRemove ? (
	                React$2.createElement(React$2.Fragment, null
	                    , React$2.createElement(AttachmentDeleteButton, { onDelete: onRemove,} )
	                    , React$2.createElement(BasicButton, {
	                        buttonSize: "small",
	                        buttonColor: "cherry",
	                        extraClasses: "absolute bottom-3 left-3"  ,
	                        disabled: !isEditing || !attachmentComposerRef?.current,
	                        onClick: () =>
	                            attachmentComposerRef?.current?.open(index)
	                        ,}

	                        , altTextButtonLabel
	                    )
	                )
	            ) : null
	            , React$2.createElement('div', {
	                className: `absolute inset-0 flex items-center justify-center bg-gray-700 bg-opacity-80 text-notWhite ${
                    !isEditing ? "block" : "hidden"
                }`,}

	                , displayString
	            )
	        )
	    );
	});
	ImageAttachmentPreview.displayName = "ImageAttachmentPreview";





	const magicPreviewAttachment = (canRemove) => {
	    const component = ({
	        attachment,
	        index,
	        rowLength,
	        aspectRatio,
	    }) => {
	        switch (attachment.kind) {
	            case "image":
	                return (
	                    React$2.createElement(ImageAttachmentPreview, {
	                        canRemove: canRemove,
	                        index: index,
	                        attachment: attachment,
	                        key: attachment.attachmentId ?? index,
	                        aspectRatio: aspectRatio,}
	                    )
	                );
	            case "audio":
	                return (
	                    React$2.createElement(AudioAttachmentPreview, {
	                        canRemove: canRemove,
	                        index: index,
	                        attachment: attachment,
	                        key: attachment.attachmentId ?? index,}
	                    )
	                );
	        }
	    };

	    component.displayName = "MagicPreviewAttachment";
	    return component;
	};

	function attachmentKind$1(attachment) {
	    return attachment.kind;
	}

	function attachmentDimensions$2(attachment) {
	    if (attachment.kind === "image") {
	        return {
	            width: attachment.metadata.width,
	            height: attachment.metadata.height,
	        };
	    } else return undefined;
	}

	const PreviewsFromAttachments =
	    React$2.memo(({ canRemove }) => {
	        const service = reactExports.useContext(PostComposerContext);
	        const attachments = useSelector$1(service, selectAttachments);
	        const ruleset = chooseAgeRuleset(new Date());

	        if (ruleset.attachmentLayoutBehavior === "v2") {
	            return (
	                React$2.createElement(AttachmentLayoutV2, {
	                    attachments: attachments,
	                    attachmentKind: attachmentKind$1,
	                    attachmentDimensions: attachmentDimensions$2,
	                    renderOne: magicPreviewAttachment(canRemove),}
	                )
	            );
	        } else {
	            return (
	                React$2.createElement(AttachmentLayoutV1, {
	                    attachments: attachments,
	                    attachmentKind: attachmentKind$1,
	                    attachmentDimensions: attachmentDimensions$2,
	                    renderOne: magicPreviewAttachment(canRemove),}
	                )
	            );
	        }
	    });
	PreviewsFromAttachments.displayName = "PreviewsFromAttachments";

	const selectIsEditing$4 = selectStateMatches("editing");
	const selectPlainTextBody = (state) =>
	    state.context.markdownBlocks
	        .map((block) => block.markdown.content)
	        .join("\n\n");

	const BodyInput

	 = ({ textAreaRef }) => {
	    const service = reactExports.useContext(PostComposerContext);
	    const { send } = service;
	    const { t } = useTranslation();

	    const isEditing = useSelector$1(service, selectIsEditing$4);
	    const plainTextBody = useSelector$1(service, selectPlainTextBody);

	    const onBodyInput =
	        reactExports.useCallback(
	            ({ currentTarget }) => {
	                send({ type: "BODY_INPUT", body: currentTarget.value });
	            },
	            [send]
	        );

	    return (
	        React$2.createElement(ExpandingTextArea, {
	            onInput: onBodyInput,
	            disabled: !isEditing,
	            className: "co-editable-body w-full resize-none overflow-hidden border-none p-0 px-3 focus:ring-0"
	                      ,
	            placeholder: t(
	                "client:post-editor.body-placeholder",
	                "post body (accepts markdown!)"
	            ),
	            minRows: 4,
	            value: plainTextBody,
	            ref: textAreaRef,}
	        )
	    );
	};

	var propTypes = {exports: {}};

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */

	var ReactPropTypesSecret$1 = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';

	var ReactPropTypesSecret_1 = ReactPropTypesSecret$1;

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */

	var ReactPropTypesSecret = ReactPropTypesSecret_1;

	function emptyFunction() {}
	function emptyFunctionWithReset() {}
	emptyFunctionWithReset.resetWarningCache = emptyFunction;

	var factoryWithThrowingShims = function() {
	  function shim(props, propName, componentName, location, propFullName, secret) {
	    if (secret === ReactPropTypesSecret) {
	      // It is still safe when called from React.
	      return;
	    }
	    var err = new Error(
	      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
	      'Use PropTypes.checkPropTypes() to call them. ' +
	      'Read more at http://fb.me/use-check-prop-types'
	    );
	    err.name = 'Invariant Violation';
	    throw err;
	  }  shim.isRequired = shim;
	  function getShim() {
	    return shim;
	  }  // Important!
	  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
	  var ReactPropTypes = {
	    array: shim,
	    bigint: shim,
	    bool: shim,
	    func: shim,
	    number: shim,
	    object: shim,
	    string: shim,
	    symbol: shim,

	    any: shim,
	    arrayOf: getShim,
	    element: shim,
	    elementType: shim,
	    instanceOf: getShim,
	    node: shim,
	    objectOf: getShim,
	    oneOf: getShim,
	    oneOfType: getShim,
	    shape: getShim,
	    exact: getShim,

	    checkPropTypes: emptyFunctionWithReset,
	    resetWarningCache: emptyFunction
	  };

	  ReactPropTypes.PropTypes = ReactPropTypes;

	  return ReactPropTypes;
	};

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */

	{
	  // By explicitly using `prop-types` you are opting into new production behavior.
	  // http://fb.me/prop-types-in-prod
	  propTypes.exports = factoryWithThrowingShims();
	}

	var propTypesExports = propTypes.exports;
	var PropTypes = /*@__PURE__*/getDefaultExportFromCjs(propTypesExports);

	let e$1=e=>"object"==typeof e&&null!=e&&1===e.nodeType,t$3=(e,t)=>(!t||"hidden"!==e)&&("visible"!==e&&"clip"!==e),n$3=(e,n)=>{if(e.clientHeight<e.scrollHeight||e.clientWidth<e.scrollWidth){let l=getComputedStyle(e,null);return t$3(l.overflowY,n)||t$3(l.overflowX,n)||(e=>{let t=(e=>{if(!e.ownerDocument||!e.ownerDocument.defaultView)return null;try{return e.ownerDocument.defaultView.frameElement}catch(e){return null}})(e);return !!t&&(t.clientHeight<e.scrollHeight||t.clientWidth<e.scrollWidth)})(e)}return !1},l$4=(e,t,n,l,i,o,r,d)=>o<e&&r>t||o>e&&r<t?0:o<=e&&d<=n||r>=t&&d>=n?o-e-l:r>t&&d<n||o<e&&d>n?r-t+i:0,i$2=e=>{let t=e.parentElement;return null==t?e.getRootNode().host||null:t};var o$2=(t,o)=>{var r,d,h,f,u,s;if("undefined"==typeof document)return [];let{scrollMode:a,block:c,inline:g,boundary:m,skipOverflowHiddenElements:p}=o,w="function"==typeof m?m:e=>e!==m;if(!e$1(t))throw new TypeError("Invalid target");let W=document.scrollingElement||document.documentElement,H=[],b=t;for(;e$1(b)&&w(b);){if(b=i$2(b),b===W){H.push(b);break}null!=b&&b===document.body&&n$3(b)&&!n$3(document.documentElement)||null!=b&&n$3(b,p)&&H.push(b);}let v=null!=(d=null==(r=window.visualViewport)?void 0:r.width)?d:innerWidth,y=null!=(f=null==(h=window.visualViewport)?void 0:h.height)?f:innerHeight,E=null!=(u=window.scrollX)?u:pageXOffset,M=null!=(s=window.scrollY)?s:pageYOffset,{height:x,width:I,top:C,right:R,bottom:T,left:V}=t.getBoundingClientRect(),k="start"===c||"nearest"===c?C:"end"===c?T:C+x/2,B="center"===g?V+I/2:"end"===g?R:V,D=[];for(let e=0;e<H.length;e++){let t=H[e],{height:n,width:i,top:o,right:r,bottom:d,left:h}=t.getBoundingClientRect();if("if-needed"===a&&C>=0&&V>=0&&T<=y&&R<=v&&C>=o&&T<=d&&V>=h&&R<=r)return D;let f=getComputedStyle(t),u=parseInt(f.borderLeftWidth,10),s=parseInt(f.borderTopWidth,10),m=parseInt(f.borderRightWidth,10),p=parseInt(f.borderBottomWidth,10),w=0,b=0,O="offsetWidth"in t?t.offsetWidth-t.clientWidth-u-m:0,X="offsetHeight"in t?t.offsetHeight-t.clientHeight-s-p:0,Y="offsetWidth"in t?0===t.offsetWidth?0:i/t.offsetWidth:0,L="offsetHeight"in t?0===t.offsetHeight?0:n/t.offsetHeight:0;if(W===t)w="start"===c?k:"end"===c?k-y:"nearest"===c?l$4(M,M+y,y,s,p,M+k,M+k+x,x):k-y/2,b="start"===g?B:"center"===g?B-v/2:"end"===g?B-v:l$4(E,E+v,v,u,m,E+B,E+B+I,I),w=Math.max(0,w+M),b=Math.max(0,b+E);else {w="start"===c?k-o-s:"end"===c?k-d+p+X:"nearest"===c?l$4(o,d,n,s,p+X,k,k+x,x):k-(o+n/2)+X/2,b="start"===g?B-h-u:"center"===g?B-(h+i/2)+O/2:"end"===g?B-r+m+O:l$4(h,r,i,u,m+O,B,B+I,I);let{scrollLeft:e,scrollTop:f}=t;w=Math.max(0,Math.min(f+w/L,t.scrollHeight-n/L+X)),b=Math.max(0,Math.min(e+b/Y,t.scrollWidth-i/Y+O)),k+=f-w,B+=e-b;}D.push({el:t,top:w,left:b});}return D};

	var idCounter = 0;
	function noop$1() {}

	/**
	 * Scroll node into view if necessary
	 * @param {HTMLElement} node the element that should scroll into view
	 * @param {HTMLElement} menuNode the menu element of the component
	 */
	function scrollIntoView(node, menuNode) {
	  if (!node) {
	    return;
	  }
	  var actions = o$2(node, {
	    boundary: menuNode,
	    block: 'nearest',
	    scrollMode: 'if-needed'
	  });
	  actions.forEach(function (_ref) {
	    var el = _ref.el,
	      top = _ref.top,
	      left = _ref.left;
	    el.scrollTop = top;
	    el.scrollLeft = left;
	  });
	}

	/**
	 * @param {HTMLElement} parent the parent node
	 * @param {HTMLElement} child the child node
	 * @param {Window} environment The window context where downshift renders.
	 * @return {Boolean} whether the parent is the child or the child is in the parent
	 */
	function isOrContainsNode(parent, child, environment) {
	  var result = parent === child || child instanceof environment.Node && parent.contains && parent.contains(child);
	  return result;
	}

	/**
	 * Simple debounce implementation. Will call the given
	 * function once after the time given has passed since
	 * it was last called.
	 * @param {Function} fn the function to call after the time
	 * @param {Number} time the time to wait
	 * @return {Function} the debounced function
	 */
	function debounce(fn, time) {
	  var timeoutId;
	  function cancel() {
	    if (timeoutId) {
	      clearTimeout(timeoutId);
	    }
	  }
	  function wrapper() {
	    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	    cancel();
	    timeoutId = setTimeout(function () {
	      timeoutId = null;
	      fn.apply(void 0, args);
	    }, time);
	  }
	  wrapper.cancel = cancel;
	  return wrapper;
	}

	/**
	 * This is intended to be used to compose event handlers.
	 * They are executed in order until one of them sets
	 * `event.preventDownshiftDefault = true`.
	 * @param {...Function} fns the event handler functions
	 * @return {Function} the event handler to add to an element
	 */
	function callAllEventHandlers() {
	  for (var _len2 = arguments.length, fns = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
	    fns[_key2] = arguments[_key2];
	  }
	  return function (event) {
	    for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
	      args[_key3 - 1] = arguments[_key3];
	    }
	    return fns.some(function (fn) {
	      if (fn) {
	        fn.apply(void 0, [event].concat(args));
	      }
	      return event.preventDownshiftDefault || event.hasOwnProperty('nativeEvent') && event.nativeEvent.preventDownshiftDefault;
	    });
	  };
	}
	function handleRefs() {
	  for (var _len4 = arguments.length, refs = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
	    refs[_key4] = arguments[_key4];
	  }
	  return function (node) {
	    refs.forEach(function (ref) {
	      if (typeof ref === 'function') {
	        ref(node);
	      } else if (ref) {
	        ref.current = node;
	      }
	    });
	  };
	}

	/**
	 * This generates a unique ID for an instance of Downshift
	 * @return {String} the unique ID
	 */
	function generateId() {
	  return String(idCounter++);
	}

	/**
	 * Default implementation for status message. Only added when menu is open.
	 * Will specify if there are results in the list, and if so, how many,
	 * and what keys are relevant.
	 *
	 * @param {Object} param the downshift state and other relevant properties
	 * @return {String} the a11y status message
	 */
	function getA11yStatusMessage$1(_ref2) {
	  var isOpen = _ref2.isOpen,
	    resultCount = _ref2.resultCount,
	    previousResultCount = _ref2.previousResultCount;
	  if (!isOpen) {
	    return '';
	  }
	  if (!resultCount) {
	    return 'No results are available.';
	  }
	  if (resultCount !== previousResultCount) {
	    return resultCount + " result" + (resultCount === 1 ? ' is' : 's are') + " available, use up and down arrow keys to navigate. Press Enter key to select.";
	  }
	  return '';
	}

	/**
	 * This will perform a shallow merge of the given state object
	 * with the state coming from props
	 * (for the controlled component scenario)
	 * This is used in state updater functions so they're referencing
	 * the right state regardless of where it comes from.
	 *
	 * @param {Object} state The state of the component/hook.
	 * @param {Object} props The props that may contain controlled values.
	 * @returns {Object} The merged controlled state.
	 */
	function getState(state, props) {
	  return Object.keys(state).reduce(function (prevState, key) {
	    prevState[key] = isControlledProp(props, key) ? props[key] : state[key];
	    return prevState;
	  }, {});
	}

	/**
	 * This determines whether a prop is a "controlled prop" meaning it is
	 * state which is controlled by the outside of this component rather
	 * than within this component.
	 *
	 * @param {Object} props The props that may contain controlled values.
	 * @param {String} key the key to check
	 * @return {Boolean} whether it is a controlled controlled prop
	 */
	function isControlledProp(props, key) {
	  return props[key] !== undefined;
	}

	/**
	 * Normalizes the 'key' property of a KeyboardEvent in IE/Edge
	 * @param {Object} event a keyboardEvent object
	 * @return {String} keyboard key
	 */
	function normalizeArrowKey(event) {
	  var key = event.key,
	    keyCode = event.keyCode;
	  /* istanbul ignore next (ie) */
	  if (keyCode >= 37 && keyCode <= 40 && key.indexOf('Arrow') !== 0) {
	    return "Arrow" + key;
	  }
	  return key;
	}

	/**
	 * Returns the new index in the list, in a circular way. If next value is out of bonds from the total,
	 * it will wrap to either 0 or itemCount - 1.
	 *
	 * @param {number} moveAmount Number of positions to move. Negative to move backwards, positive forwards.
	 * @param {number} baseIndex The initial position to move from.
	 * @param {number} itemCount The total number of items.
	 * @param {Function} getItemNodeFromIndex Used to check if item is disabled.
	 * @param {boolean} circular Specify if navigation is circular. Default is true.
	 * @returns {number} The new index after the move.
	 */
	function getNextWrappingIndex(moveAmount, baseIndex, itemCount, getItemNodeFromIndex, circular) {
	  if (circular === void 0) {
	    circular = true;
	  }
	  if (itemCount === 0) {
	    return -1;
	  }
	  var itemsLastIndex = itemCount - 1;
	  if (typeof baseIndex !== 'number' || baseIndex < 0 || baseIndex >= itemCount) {
	    baseIndex = moveAmount > 0 ? -1 : itemsLastIndex + 1;
	  }
	  var newIndex = baseIndex + moveAmount;
	  if (newIndex < 0) {
	    newIndex = circular ? itemsLastIndex : 0;
	  } else if (newIndex > itemsLastIndex) {
	    newIndex = circular ? 0 : itemsLastIndex;
	  }
	  var nonDisabledNewIndex = getNextNonDisabledIndex(moveAmount, newIndex, itemCount, getItemNodeFromIndex, circular);
	  if (nonDisabledNewIndex === -1) {
	    return baseIndex >= itemCount ? -1 : baseIndex;
	  }
	  return nonDisabledNewIndex;
	}

	/**
	 * Returns the next index in the list of an item that is not disabled.
	 *
	 * @param {number} moveAmount Number of positions to move. Negative to move backwards, positive forwards.
	 * @param {number} baseIndex The initial position to move from.
	 * @param {number} itemCount The total number of items.
	 * @param {Function} getItemNodeFromIndex Used to check if item is disabled.
	 * @param {boolean} circular Specify if navigation is circular. Default is true.
	 * @returns {number} The new index. Returns baseIndex if item is not disabled. Returns next non-disabled item otherwise. If no non-disabled found it will return -1.
	 */
	function getNextNonDisabledIndex(moveAmount, baseIndex, itemCount, getItemNodeFromIndex, circular) {
	  var currentElementNode = getItemNodeFromIndex(baseIndex);
	  if (!currentElementNode || !currentElementNode.hasAttribute('disabled')) {
	    return baseIndex;
	  }
	  if (moveAmount > 0) {
	    for (var index = baseIndex + 1; index < itemCount; index++) {
	      if (!getItemNodeFromIndex(index).hasAttribute('disabled')) {
	        return index;
	      }
	    }
	  } else {
	    for (var _index = baseIndex - 1; _index >= 0; _index--) {
	      if (!getItemNodeFromIndex(_index).hasAttribute('disabled')) {
	        return _index;
	      }
	    }
	  }
	  if (circular) {
	    return moveAmount > 0 ? getNextNonDisabledIndex(1, 0, itemCount, getItemNodeFromIndex, false) : getNextNonDisabledIndex(-1, itemCount - 1, itemCount, getItemNodeFromIndex, false);
	  }
	  return -1;
	}

	/**
	 * Checks if event target is within the downshift elements.
	 *
	 * @param {EventTarget} target Target to check.
	 * @param {HTMLElement[]} downshiftElements The elements that form downshift (list, toggle button etc).
	 * @param {Window} environment The window context where downshift renders.
	 * @param {boolean} checkActiveElement Whether to also check activeElement.
	 *
	 * @returns {boolean} Whether or not the target is within downshift elements.
	 */
	function targetWithinDownshift(target, downshiftElements, environment, checkActiveElement) {
	  if (checkActiveElement === void 0) {
	    checkActiveElement = true;
	  }
	  return downshiftElements.some(function (contextNode) {
	    return contextNode && (isOrContainsNode(contextNode, target, environment) || checkActiveElement && isOrContainsNode(contextNode, environment.document.activeElement, environment));
	  });
	}

	var cleanupStatus = debounce(function (documentProp) {
	  getStatusDiv(documentProp).textContent = '';
	}, 500);

	/**
	 * @param {String} status the status message
	 * @param {Object} documentProp document passed by the user.
	 */
	function setStatus(status, documentProp) {
	  var div = getStatusDiv(documentProp);
	  if (!status) {
	    return;
	  }
	  div.textContent = status;
	  cleanupStatus(documentProp);
	}

	/**
	 * Get the status node or create it if it does not already exist.
	 * @param {Object} documentProp document passed by the user.
	 * @return {HTMLElement} the status node.
	 */
	function getStatusDiv(documentProp) {
	  if (documentProp === void 0) {
	    documentProp = document;
	  }
	  var statusDiv = documentProp.getElementById('a11y-status-message');
	  if (statusDiv) {
	    return statusDiv;
	  }
	  statusDiv = documentProp.createElement('div');
	  statusDiv.setAttribute('id', 'a11y-status-message');
	  statusDiv.setAttribute('role', 'status');
	  statusDiv.setAttribute('aria-live', 'polite');
	  statusDiv.setAttribute('aria-relevant', 'additions text');
	  Object.assign(statusDiv.style, {
	    border: '0',
	    clip: 'rect(0 0 0 0)',
	    height: '1px',
	    margin: '-1px',
	    overflow: 'hidden',
	    padding: '0',
	    position: 'absolute',
	    width: '1px'
	  });
	  documentProp.body.appendChild(statusDiv);
	  return statusDiv;
	}

	var _excluded$3 = ["isInitialMount", "highlightedIndex", "items", "environment"];
	var dropdownDefaultStateValues = {
	  highlightedIndex: -1,
	  isOpen: false,
	  selectedItem: null,
	  inputValue: ''
	};
	function callOnChangeProps(action, state, newState) {
	  var props = action.props,
	    type = action.type;
	  var changes = {};
	  Object.keys(state).forEach(function (key) {
	    invokeOnChangeHandler(key, action, state, newState);
	    if (newState[key] !== state[key]) {
	      changes[key] = newState[key];
	    }
	  });
	  if (props.onStateChange && Object.keys(changes).length) {
	    props.onStateChange(_extends$4({
	      type: type
	    }, changes));
	  }
	}
	function invokeOnChangeHandler(key, action, state, newState) {
	  var props = action.props,
	    type = action.type;
	  var handler = "on" + capitalizeString(key) + "Change";
	  if (props[handler] && newState[key] !== undefined && newState[key] !== state[key]) {
	    props[handler](_extends$4({
	      type: type
	    }, newState));
	  }
	}

	/**
	 * Default state reducer that returns the changes.
	 *
	 * @param {Object} s state.
	 * @param {Object} a action with changes.
	 * @returns {Object} changes.
	 */
	function stateReducer(s, a) {
	  return a.changes;
	}

	/**
	 * Returns a message to be added to aria-live region when item is selected.
	 *
	 * @param {Object} selectionParameters Parameters required to build the message.
	 * @returns {string} The a11y message.
	 */
	function getA11ySelectionMessage(selectionParameters) {
	  var selectedItem = selectionParameters.selectedItem,
	    itemToStringLocal = selectionParameters.itemToString;
	  return selectedItem ? itemToStringLocal(selectedItem) + " has been selected." : '';
	}

	/**
	 * Debounced call for updating the a11y message.
	 */
	var updateA11yStatus = debounce(function (getA11yMessage, document) {
	  setStatus(getA11yMessage(), document);
	}, 200);

	// istanbul ignore next
	var useIsomorphicLayoutEffect = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined' ? reactExports.useLayoutEffect : reactExports.useEffect;
	function useElementIds(_ref) {
	  var _ref$id = _ref.id,
	    id = _ref$id === void 0 ? "downshift-" + generateId() : _ref$id,
	    labelId = _ref.labelId,
	    menuId = _ref.menuId,
	    getItemId = _ref.getItemId,
	    toggleButtonId = _ref.toggleButtonId,
	    inputId = _ref.inputId;
	  var elementIdsRef = reactExports.useRef({
	    labelId: labelId || id + "-label",
	    menuId: menuId || id + "-menu",
	    getItemId: getItemId || function (index) {
	      return id + "-item-" + index;
	    },
	    toggleButtonId: toggleButtonId || id + "-toggle-button",
	    inputId: inputId || id + "-input"
	  });
	  return elementIdsRef.current;
	}
	function getItemAndIndex(itemProp, indexProp, items, errorMessage) {
	  var item, index;
	  if (itemProp === undefined) {
	    if (indexProp === undefined) {
	      throw new Error(errorMessage);
	    }
	    item = items[indexProp];
	    index = indexProp;
	  } else {
	    index = indexProp === undefined ? items.indexOf(itemProp) : indexProp;
	    item = itemProp;
	  }
	  return [item, index];
	}
	function itemToString(item) {
	  return item ? String(item) : '';
	}
	function capitalizeString(string) {
	  return "" + string.slice(0, 1).toUpperCase() + string.slice(1);
	}
	function useLatestRef$1(val) {
	  var ref = reactExports.useRef(val);
	  // technically this is not "concurrent mode safe" because we're manipulating
	  // the value during render (so it's not idempotent). However, the places this
	  // hook is used is to support memoizing callbacks which will be called
	  // *during* render, so we need the latest values *during* render.
	  // If not for this, then we'd probably want to use useLayoutEffect instead.
	  ref.current = val;
	  return ref;
	}

	/**
	 * Computes the controlled state using a the previous state, props,
	 * two reducers, one from downshift and an optional one from the user.
	 * Also calls the onChange handlers for state values that have changed.
	 *
	 * @param {Function} reducer Reducer function from downshift.
	 * @param {Object} initialState Initial state of the hook.
	 * @param {Object} props The hook props.
	 * @returns {Array} An array with the state and an action dispatcher.
	 */
	function useEnhancedReducer(reducer, initialState, props) {
	  var prevStateRef = reactExports.useRef();
	  var actionRef = reactExports.useRef();
	  var enhancedReducer = reactExports.useCallback(function (state, action) {
	    actionRef.current = action;
	    state = getState(state, action.props);
	    var changes = reducer(state, action);
	    var newState = action.props.stateReducer(state, _extends$4({}, action, {
	      changes: changes
	    }));
	    return newState;
	  }, [reducer]);
	  var _useReducer = reactExports.useReducer(enhancedReducer, initialState),
	    state = _useReducer[0],
	    dispatch = _useReducer[1];
	  var propsRef = useLatestRef$1(props);
	  var dispatchWithProps = reactExports.useCallback(function (action) {
	    return dispatch(_extends$4({
	      props: propsRef.current
	    }, action));
	  }, [propsRef]);
	  var action = actionRef.current;
	  reactExports.useEffect(function () {
	    if (action && prevStateRef.current && prevStateRef.current !== state) {
	      callOnChangeProps(action, getState(prevStateRef.current, action.props), state);
	    }
	    prevStateRef.current = state;
	  }, [state, props, action]);
	  return [state, dispatchWithProps];
	}

	/**
	 * Wraps the useEnhancedReducer and applies the controlled prop values before
	 * returning the new state.
	 *
	 * @param {Function} reducer Reducer function from downshift.
	 * @param {Object} initialState Initial state of the hook.
	 * @param {Object} props The hook props.
	 * @returns {Array} An array with the state and an action dispatcher.
	 */
	function useControlledReducer$1(reducer, initialState, props) {
	  var _useEnhancedReducer = useEnhancedReducer(reducer, initialState, props),
	    state = _useEnhancedReducer[0],
	    dispatch = _useEnhancedReducer[1];
	  return [getState(state, props), dispatch];
	}
	var defaultProps$3 = {
	  itemToString: itemToString,
	  stateReducer: stateReducer,
	  getA11ySelectionMessage: getA11ySelectionMessage,
	  scrollIntoView: scrollIntoView,
	  environment: /* istanbul ignore next (ssr) */
	  typeof window === 'undefined' ? {} : window
	};
	function getDefaultValue$1(props, propKey, defaultStateValues) {
	  if (defaultStateValues === void 0) {
	    defaultStateValues = dropdownDefaultStateValues;
	  }
	  var defaultValue = props["default" + capitalizeString(propKey)];
	  if (defaultValue !== undefined) {
	    return defaultValue;
	  }
	  return defaultStateValues[propKey];
	}
	function getInitialValue$1(props, propKey, defaultStateValues) {
	  if (defaultStateValues === void 0) {
	    defaultStateValues = dropdownDefaultStateValues;
	  }
	  var value = props[propKey];
	  if (value !== undefined) {
	    return value;
	  }
	  var initialValue = props["initial" + capitalizeString(propKey)];
	  if (initialValue !== undefined) {
	    return initialValue;
	  }
	  return getDefaultValue$1(props, propKey, defaultStateValues);
	}
	function getInitialState$2(props) {
	  var selectedItem = getInitialValue$1(props, 'selectedItem');
	  var isOpen = getInitialValue$1(props, 'isOpen');
	  var highlightedIndex = getInitialValue$1(props, 'highlightedIndex');
	  var inputValue = getInitialValue$1(props, 'inputValue');
	  return {
	    highlightedIndex: highlightedIndex < 0 && selectedItem && isOpen ? props.items.indexOf(selectedItem) : highlightedIndex,
	    isOpen: isOpen,
	    selectedItem: selectedItem,
	    inputValue: inputValue
	  };
	}
	function getHighlightedIndexOnOpen(props, state, offset) {
	  var items = props.items,
	    initialHighlightedIndex = props.initialHighlightedIndex,
	    defaultHighlightedIndex = props.defaultHighlightedIndex;
	  var selectedItem = state.selectedItem,
	    highlightedIndex = state.highlightedIndex;
	  if (items.length === 0) {
	    return -1;
	  }

	  // initialHighlightedIndex will give value to highlightedIndex on initial state only.
	  if (initialHighlightedIndex !== undefined && highlightedIndex === initialHighlightedIndex) {
	    return initialHighlightedIndex;
	  }
	  if (defaultHighlightedIndex !== undefined) {
	    return defaultHighlightedIndex;
	  }
	  if (selectedItem) {
	    return items.indexOf(selectedItem);
	  }
	  if (offset === 0) {
	    return -1;
	  }
	  return offset < 0 ? items.length - 1 : 0;
	}

	/**
	 * Reuse the movement tracking of mouse and touch events.
	 *
	 * @param {boolean} isOpen Whether the dropdown is open or not.
	 * @param {Array<Object>} downshiftElementRefs Downshift element refs to track movement (toggleButton, menu etc.)
	 * @param {Object} environment Environment where component/hook exists.
	 * @param {Function} handleBlur Handler on blur from mouse or touch.
	 * @returns {Object} Ref containing whether mouseDown or touchMove event is happening
	 */
	function useMouseAndTouchTracker(isOpen, downshiftElementRefs, environment, handleBlur) {
	  var mouseAndTouchTrackersRef = reactExports.useRef({
	    isMouseDown: false,
	    isTouchMove: false
	  });
	  reactExports.useEffect(function () {
	    if ((environment == null ? void 0 : environment.addEventListener) == null) {
	      return;
	    }

	    // The same strategy for checking if a click occurred inside or outside downshift
	    // as in downshift.js.
	    var onMouseDown = function onMouseDown() {
	      mouseAndTouchTrackersRef.current.isMouseDown = true;
	    };
	    var onMouseUp = function onMouseUp(event) {
	      mouseAndTouchTrackersRef.current.isMouseDown = false;
	      if (isOpen && !targetWithinDownshift(event.target, downshiftElementRefs.map(function (ref) {
	        return ref.current;
	      }), environment)) {
	        handleBlur();
	      }
	    };
	    var onTouchStart = function onTouchStart() {
	      mouseAndTouchTrackersRef.current.isTouchMove = false;
	    };
	    var onTouchMove = function onTouchMove() {
	      mouseAndTouchTrackersRef.current.isTouchMove = true;
	    };
	    var onTouchEnd = function onTouchEnd(event) {
	      if (isOpen && !mouseAndTouchTrackersRef.current.isTouchMove && !targetWithinDownshift(event.target, downshiftElementRefs.map(function (ref) {
	        return ref.current;
	      }), environment, false)) {
	        handleBlur();
	      }
	    };
	    environment.addEventListener('mousedown', onMouseDown);
	    environment.addEventListener('mouseup', onMouseUp);
	    environment.addEventListener('touchstart', onTouchStart);
	    environment.addEventListener('touchmove', onTouchMove);
	    environment.addEventListener('touchend', onTouchEnd);

	    // eslint-disable-next-line consistent-return
	    return function cleanup() {
	      environment.removeEventListener('mousedown', onMouseDown);
	      environment.removeEventListener('mouseup', onMouseUp);
	      environment.removeEventListener('touchstart', onTouchStart);
	      environment.removeEventListener('touchmove', onTouchMove);
	      environment.removeEventListener('touchend', onTouchEnd);
	    };
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	  }, [isOpen, environment]);
	  return mouseAndTouchTrackersRef;
	}

	/* istanbul ignore next */
	// eslint-disable-next-line import/no-mutable-exports
	var useGetterPropsCalledChecker = function useGetterPropsCalledChecker() {
	  return noop$1;
	};
	function useA11yMessageSetter(getA11yMessage, dependencyArray, _ref2) {
	  var isInitialMount = _ref2.isInitialMount,
	    highlightedIndex = _ref2.highlightedIndex,
	    items = _ref2.items,
	    environment = _ref2.environment,
	    rest = _objectWithoutPropertiesLoose$2(_ref2, _excluded$3);
	  // Sets a11y status message on changes in state.
	  reactExports.useEffect(function () {
	    if (isInitialMount || false) {
	      return;
	    }
	    updateA11yStatus(function () {
	      return getA11yMessage(_extends$4({
	        highlightedIndex: highlightedIndex,
	        highlightedItem: items[highlightedIndex],
	        resultCount: items.length
	      }, rest));
	    }, environment.document);
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	  }, dependencyArray);
	}
	function useScrollIntoView(_ref3) {
	  var highlightedIndex = _ref3.highlightedIndex,
	    isOpen = _ref3.isOpen,
	    itemRefs = _ref3.itemRefs,
	    getItemNodeFromIndex = _ref3.getItemNodeFromIndex,
	    menuElement = _ref3.menuElement,
	    scrollIntoViewProp = _ref3.scrollIntoView;
	  // used not to scroll on highlight by mouse.
	  var shouldScrollRef = reactExports.useRef(true);
	  // Scroll on highlighted item if change comes from keyboard.
	  useIsomorphicLayoutEffect(function () {
	    if (highlightedIndex < 0 || !isOpen || !Object.keys(itemRefs.current).length) {
	      return;
	    }
	    if (shouldScrollRef.current === false) {
	      shouldScrollRef.current = true;
	    } else {
	      scrollIntoViewProp(getItemNodeFromIndex(highlightedIndex), menuElement);
	    }
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	  }, [highlightedIndex]);
	  return shouldScrollRef;
	}

	// eslint-disable-next-line import/no-mutable-exports
	var useControlPropsValidator = noop$1;

	/**
	 * Handles selection on Enter / Alt + ArrowUp. Closes the menu and resets the highlighted index, unless there is a highlighted.
	 * In that case, selects the item and resets to defaults for open state and highlighted idex.
	 * @param {Object} props The useCombobox props.
	 * @param {number} highlightedIndex The index from the state.
	 * @param {boolean} inputValue Also return the input value for state.
	 * @returns The changes for the state.
	 */
	function getChangesOnSelection(props, highlightedIndex, inputValue) {
	  var _props$items;
	  if (inputValue === void 0) {
	    inputValue = true;
	  }
	  var shouldSelect = ((_props$items = props.items) == null ? void 0 : _props$items.length) && highlightedIndex >= 0;
	  return _extends$4({
	    isOpen: false,
	    highlightedIndex: -1
	  }, shouldSelect && _extends$4({
	    selectedItem: props.items[highlightedIndex],
	    isOpen: getDefaultValue$1(props, 'isOpen'),
	    highlightedIndex: getDefaultValue$1(props, 'highlightedIndex')
	  }, inputValue && {
	    inputValue: props.itemToString(props.items[highlightedIndex])
	  }));
	}

	function downshiftCommonReducer(state, action, stateChangeTypes) {
	  var type = action.type,
	    props = action.props;
	  var changes;
	  switch (type) {
	    case stateChangeTypes.ItemMouseMove:
	      changes = {
	        highlightedIndex: action.disabled ? -1 : action.index
	      };
	      break;
	    case stateChangeTypes.MenuMouseLeave:
	      changes = {
	        highlightedIndex: -1
	      };
	      break;
	    case stateChangeTypes.ToggleButtonClick:
	    case stateChangeTypes.FunctionToggleMenu:
	      changes = {
	        isOpen: !state.isOpen,
	        highlightedIndex: state.isOpen ? -1 : getHighlightedIndexOnOpen(props, state, 0)
	      };
	      break;
	    case stateChangeTypes.FunctionOpenMenu:
	      changes = {
	        isOpen: true,
	        highlightedIndex: getHighlightedIndexOnOpen(props, state, 0)
	      };
	      break;
	    case stateChangeTypes.FunctionCloseMenu:
	      changes = {
	        isOpen: false
	      };
	      break;
	    case stateChangeTypes.FunctionSetHighlightedIndex:
	      changes = {
	        highlightedIndex: action.highlightedIndex
	      };
	      break;
	    case stateChangeTypes.FunctionSetInputValue:
	      changes = {
	        inputValue: action.inputValue
	      };
	      break;
	    case stateChangeTypes.FunctionReset:
	      changes = {
	        highlightedIndex: getDefaultValue$1(props, 'highlightedIndex'),
	        isOpen: getDefaultValue$1(props, 'isOpen'),
	        selectedItem: getDefaultValue$1(props, 'selectedItem'),
	        inputValue: getDefaultValue$1(props, 'inputValue')
	      };
	      break;
	    default:
	      throw new Error('Reducer called without proper action type.');
	  }
	  return _extends$4({}, state, changes);
	}
	({
	    items: PropTypes.array.isRequired,
	    itemToString: PropTypes.func,
	    getA11yStatusMessage: PropTypes.func,
	    getA11ySelectionMessage: PropTypes.func,
	    highlightedIndex: PropTypes.number,
	    defaultHighlightedIndex: PropTypes.number,
	    initialHighlightedIndex: PropTypes.number,
	    isOpen: PropTypes.bool,
	    defaultIsOpen: PropTypes.bool,
	    initialIsOpen: PropTypes.bool,
	    selectedItem: PropTypes.any,
	    initialSelectedItem: PropTypes.any,
	    defaultSelectedItem: PropTypes.any,
	    id: PropTypes.string,
	    labelId: PropTypes.string,
	    menuId: PropTypes.string,
	    getItemId: PropTypes.func,
	    toggleButtonId: PropTypes.string,
	    stateReducer: PropTypes.func,
	    onSelectedItemChange: PropTypes.func,
	    onHighlightedIndexChange: PropTypes.func,
	    onStateChange: PropTypes.func,
	    onIsOpenChange: PropTypes.func,
	    environment: PropTypes.shape({
	        addEventListener: PropTypes.func,
	        removeEventListener: PropTypes.func,
	        document: PropTypes.shape({
	            getElementById: PropTypes.func,
	            activeElement: PropTypes.any,
	            body: PropTypes.any
	        })
	    })
	});
	/**
	 * Default implementation for status message. Only added when menu is open.
	 * Will specift if there are results in the list, and if so, how many,
	 * and what keys are relevant.
	 *
	 * @param {Object} param the downshift state and other relevant properties
	 * @return {String} the a11y status message
	 */
	function getA11yStatusMessage(_a) {
	    var isOpen = _a.isOpen, resultCount = _a.resultCount, previousResultCount = _a.previousResultCount;
	    if (!isOpen) {
	        return '';
	    }
	    if (!resultCount) {
	        return 'No results are available.';
	    }
	    if (resultCount !== previousResultCount) {
	        return "".concat(resultCount, " result").concat(resultCount === 1 ? ' is' : 's are', " available, use up and down arrow keys to navigate. Press Enter or Space Bar keys to select.");
	    }
	    return '';
	}
	__assign$5(__assign$5({}, defaultProps$3), { getA11yStatusMessage: getA11yStatusMessage });

	var InputKeyDownArrowDown = 0;
	var InputKeyDownArrowUp = 1;
	var InputKeyDownEscape = 2;
	var InputKeyDownHome = 3;
	var InputKeyDownEnd = 4;
	var InputKeyDownPageUp = 5;
	var InputKeyDownPageDown = 6;
	var InputKeyDownEnter = 7;
	var InputChange = 8;
	var InputBlur = 9;
	var InputFocus = 10;
	var MenuMouseLeave = 11;
	var ItemMouseMove = 12;
	var ItemClick = 13;
	var ToggleButtonClick = 14;
	var FunctionToggleMenu = 15;
	var FunctionOpenMenu = 16;
	var FunctionCloseMenu = 17;
	var FunctionSetHighlightedIndex = 18;
	var FunctionSelectItem = 19;
	var FunctionSetInputValue = 20;
	var FunctionReset$1 = 21;
	var ControlledPropUpdatedSelectedItem = 22;

	var stateChangeTypes$1 = /*#__PURE__*/Object.freeze({
	  __proto__: null,
	  InputKeyDownArrowDown: InputKeyDownArrowDown,
	  InputKeyDownArrowUp: InputKeyDownArrowUp,
	  InputKeyDownEscape: InputKeyDownEscape,
	  InputKeyDownHome: InputKeyDownHome,
	  InputKeyDownEnd: InputKeyDownEnd,
	  InputKeyDownPageUp: InputKeyDownPageUp,
	  InputKeyDownPageDown: InputKeyDownPageDown,
	  InputKeyDownEnter: InputKeyDownEnter,
	  InputChange: InputChange,
	  InputBlur: InputBlur,
	  InputFocus: InputFocus,
	  MenuMouseLeave: MenuMouseLeave,
	  ItemMouseMove: ItemMouseMove,
	  ItemClick: ItemClick,
	  ToggleButtonClick: ToggleButtonClick,
	  FunctionToggleMenu: FunctionToggleMenu,
	  FunctionOpenMenu: FunctionOpenMenu,
	  FunctionCloseMenu: FunctionCloseMenu,
	  FunctionSetHighlightedIndex: FunctionSetHighlightedIndex,
	  FunctionSelectItem: FunctionSelectItem,
	  FunctionSetInputValue: FunctionSetInputValue,
	  FunctionReset: FunctionReset$1,
	  ControlledPropUpdatedSelectedItem: ControlledPropUpdatedSelectedItem
	});

	function getInitialState$1(props) {
	  var initialState = getInitialState$2(props);
	  var selectedItem = initialState.selectedItem;
	  var inputValue = initialState.inputValue;
	  if (inputValue === '' && selectedItem && props.defaultInputValue === undefined && props.initialInputValue === undefined && props.inputValue === undefined) {
	    inputValue = props.itemToString(selectedItem);
	  }
	  return _extends$4({}, initialState, {
	    inputValue: inputValue
	  });
	}
	({
	  items: PropTypes.array.isRequired,
	  itemToString: PropTypes.func,
	  selectedItemChanged: PropTypes.func,
	  getA11yStatusMessage: PropTypes.func,
	  getA11ySelectionMessage: PropTypes.func,
	  highlightedIndex: PropTypes.number,
	  defaultHighlightedIndex: PropTypes.number,
	  initialHighlightedIndex: PropTypes.number,
	  isOpen: PropTypes.bool,
	  defaultIsOpen: PropTypes.bool,
	  initialIsOpen: PropTypes.bool,
	  selectedItem: PropTypes.any,
	  initialSelectedItem: PropTypes.any,
	  defaultSelectedItem: PropTypes.any,
	  inputValue: PropTypes.string,
	  defaultInputValue: PropTypes.string,
	  initialInputValue: PropTypes.string,
	  id: PropTypes.string,
	  labelId: PropTypes.string,
	  menuId: PropTypes.string,
	  getItemId: PropTypes.func,
	  inputId: PropTypes.string,
	  toggleButtonId: PropTypes.string,
	  stateReducer: PropTypes.func,
	  onSelectedItemChange: PropTypes.func,
	  onHighlightedIndexChange: PropTypes.func,
	  onStateChange: PropTypes.func,
	  onIsOpenChange: PropTypes.func,
	  onInputValueChange: PropTypes.func,
	  environment: PropTypes.shape({
	    addEventListener: PropTypes.func,
	    removeEventListener: PropTypes.func,
	    document: PropTypes.shape({
	      getElementById: PropTypes.func,
	      activeElement: PropTypes.any,
	      body: PropTypes.any
	    })
	  })
	});

	/**
	 * The useCombobox version of useControlledReducer, which also
	 * checks if the controlled prop selectedItem changed between
	 * renders. If so, it will also update inputValue with its
	 * string equivalent. It uses the common useEnhancedReducer to
	 * compute the rest of the state.
	 *
	 * @param {Function} reducer Reducer function from downshift.
	 * @param {Object} initialState Initial state of the hook.
	 * @param {Object} props The hook props.
	 * @returns {Array} An array with the state and an action dispatcher.
	 */
	function useControlledReducer(reducer, initialState, props) {
	  var previousSelectedItemRef = reactExports.useRef();
	  var _useEnhancedReducer = useEnhancedReducer(reducer, initialState, props),
	    state = _useEnhancedReducer[0],
	    dispatch = _useEnhancedReducer[1];

	  // ToDo: if needed, make same approach as selectedItemChanged from Downshift.
	  reactExports.useEffect(function () {
	    if (!isControlledProp(props, 'selectedItem')) {
	      return;
	    }
	    if (props.selectedItemChanged(previousSelectedItemRef.current, props.selectedItem)) {
	      dispatch({
	        type: ControlledPropUpdatedSelectedItem,
	        inputValue: props.itemToString(props.selectedItem)
	      });
	    }
	    previousSelectedItemRef.current = state.selectedItem === previousSelectedItemRef.current ? props.selectedItem : state.selectedItem;
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	  }, [state.selectedItem, props.selectedItem]);
	  return [getState(state, props), dispatch];
	}
	var defaultProps$1 = _extends$4({}, defaultProps$3, {
	  selectedItemChanged: function selectedItemChanged(prevItem, item) {
	    return prevItem !== item;
	  },
	  getA11yStatusMessage: getA11yStatusMessage$1
	});

	/* eslint-disable complexity */
	function downshiftUseComboboxReducer(state, action) {
	  var _props$items;
	  var type = action.type,
	    props = action.props,
	    altKey = action.altKey;
	  var changes;
	  switch (type) {
	    case ItemClick:
	      changes = {
	        isOpen: getDefaultValue$1(props, 'isOpen'),
	        highlightedIndex: getDefaultValue$1(props, 'highlightedIndex'),
	        selectedItem: props.items[action.index],
	        inputValue: props.itemToString(props.items[action.index])
	      };
	      break;
	    case InputKeyDownArrowDown:
	      if (state.isOpen) {
	        changes = {
	          highlightedIndex: getNextWrappingIndex(1, state.highlightedIndex, props.items.length, action.getItemNodeFromIndex, true)
	        };
	      } else {
	        changes = {
	          highlightedIndex: altKey && state.selectedItem == null ? -1 : getHighlightedIndexOnOpen(props, state, 1, action.getItemNodeFromIndex),
	          isOpen: props.items.length >= 0
	        };
	      }
	      break;
	    case InputKeyDownArrowUp:
	      if (state.isOpen) {
	        if (altKey) {
	          changes = getChangesOnSelection(props, state.highlightedIndex);
	        } else {
	          changes = {
	            highlightedIndex: getNextWrappingIndex(-1, state.highlightedIndex, props.items.length, action.getItemNodeFromIndex, true)
	          };
	        }
	      } else {
	        changes = {
	          highlightedIndex: getHighlightedIndexOnOpen(props, state, -1, action.getItemNodeFromIndex),
	          isOpen: props.items.length >= 0
	        };
	      }
	      break;
	    case InputKeyDownEnter:
	      changes = getChangesOnSelection(props, state.highlightedIndex);
	      break;
	    case InputKeyDownEscape:
	      changes = _extends$4({
	        isOpen: false,
	        highlightedIndex: -1
	      }, !state.isOpen && {
	        selectedItem: null,
	        inputValue: ''
	      });
	      break;
	    case InputKeyDownPageUp:
	      changes = {
	        highlightedIndex: getNextWrappingIndex(-10, state.highlightedIndex, props.items.length, action.getItemNodeFromIndex, false)
	      };
	      break;
	    case InputKeyDownPageDown:
	      changes = {
	        highlightedIndex: getNextWrappingIndex(10, state.highlightedIndex, props.items.length, action.getItemNodeFromIndex, false)
	      };
	      break;
	    case InputKeyDownHome:
	      changes = {
	        highlightedIndex: getNextNonDisabledIndex(1, 0, props.items.length, action.getItemNodeFromIndex, false)
	      };
	      break;
	    case InputKeyDownEnd:
	      changes = {
	        highlightedIndex: getNextNonDisabledIndex(-1, props.items.length - 1, props.items.length, action.getItemNodeFromIndex, false)
	      };
	      break;
	    case InputBlur:
	      changes = _extends$4({
	        isOpen: false,
	        highlightedIndex: -1
	      }, state.highlightedIndex >= 0 && ((_props$items = props.items) == null ? void 0 : _props$items.length) && action.selectItem && {
	        selectedItem: props.items[state.highlightedIndex],
	        inputValue: props.itemToString(props.items[state.highlightedIndex])
	      });
	      break;
	    case InputChange:
	      changes = {
	        isOpen: true,
	        highlightedIndex: getDefaultValue$1(props, 'highlightedIndex'),
	        inputValue: action.inputValue
	      };
	      break;
	    case InputFocus:
	      changes = {
	        isOpen: true,
	        highlightedIndex: getHighlightedIndexOnOpen(props, state, 0)
	      };
	      break;
	    case FunctionSelectItem:
	      changes = {
	        selectedItem: action.selectedItem,
	        inputValue: props.itemToString(action.selectedItem)
	      };
	      break;
	    case ControlledPropUpdatedSelectedItem:
	      changes = {
	        inputValue: action.inputValue
	      };
	      break;
	    default:
	      return downshiftCommonReducer(state, action, stateChangeTypes$1);
	  }
	  return _extends$4({}, state, changes);
	}
	/* eslint-enable complexity */

	var _excluded$1 = ["onMouseLeave", "refKey", "ref"],
	  _excluded2$1 = ["item", "index", "refKey", "ref", "onMouseMove", "onMouseDown", "onClick", "onPress", "disabled"],
	  _excluded3 = ["onClick", "onPress", "refKey", "ref"],
	  _excluded4 = ["onKeyDown", "onChange", "onInput", "onFocus", "onBlur", "onChangeText", "refKey", "ref"];
	useCombobox.stateChangeTypes = stateChangeTypes$1;
	function useCombobox(userProps) {
	  if (userProps === void 0) {
	    userProps = {};
	  }
	  // Props defaults and destructuring.
	  var props = _extends$4({}, defaultProps$1, userProps);
	  var initialIsOpen = props.initialIsOpen,
	    defaultIsOpen = props.defaultIsOpen,
	    items = props.items,
	    scrollIntoView = props.scrollIntoView,
	    environment = props.environment,
	    getA11yStatusMessage = props.getA11yStatusMessage,
	    getA11ySelectionMessage = props.getA11ySelectionMessage,
	    itemToString = props.itemToString;
	  // Initial state depending on controlled props.
	  var initialState = getInitialState$1(props);
	  var _useControlledReducer = useControlledReducer(downshiftUseComboboxReducer, initialState, props),
	    state = _useControlledReducer[0],
	    dispatch = _useControlledReducer[1];
	  var isOpen = state.isOpen,
	    highlightedIndex = state.highlightedIndex,
	    selectedItem = state.selectedItem,
	    inputValue = state.inputValue;

	  // Element refs.
	  var menuRef = reactExports.useRef(null);
	  var itemRefs = reactExports.useRef({});
	  var inputRef = reactExports.useRef(null);
	  var toggleButtonRef = reactExports.useRef(null);
	  var isInitialMountRef = reactExports.useRef(true);
	  // prevent id re-generation between renders.
	  var elementIds = useElementIds(props);
	  // used to keep track of how many items we had on previous cycle.
	  var previousResultCountRef = reactExports.useRef();
	  // utility callback to get item element.
	  var latest = useLatestRef$1({
	    state: state,
	    props: props
	  });
	  var getItemNodeFromIndex = reactExports.useCallback(function (index) {
	    return itemRefs.current[elementIds.getItemId(index)];
	  }, [elementIds]);

	  // Effects.
	  // Sets a11y status message on changes in state.
	  useA11yMessageSetter(getA11yStatusMessage, [isOpen, highlightedIndex, inputValue, items], _extends$4({
	    isInitialMount: isInitialMountRef.current,
	    previousResultCount: previousResultCountRef.current,
	    items: items,
	    environment: environment,
	    itemToString: itemToString
	  }, state));
	  // Sets a11y status message on changes in selectedItem.
	  useA11yMessageSetter(getA11ySelectionMessage, [selectedItem], _extends$4({
	    isInitialMount: isInitialMountRef.current,
	    previousResultCount: previousResultCountRef.current,
	    items: items,
	    environment: environment,
	    itemToString: itemToString
	  }, state));
	  // Scroll on highlighted item if change comes from keyboard.
	  var shouldScrollRef = useScrollIntoView({
	    menuElement: menuRef.current,
	    highlightedIndex: highlightedIndex,
	    isOpen: isOpen,
	    itemRefs: itemRefs,
	    scrollIntoView: scrollIntoView,
	    getItemNodeFromIndex: getItemNodeFromIndex
	  });
	  useControlPropsValidator({
	    isInitialMount: isInitialMountRef.current,
	    props: props,
	    state: state
	  });
	  // Focus the input on first render if required.
	  reactExports.useEffect(function () {
	    var focusOnOpen = initialIsOpen || defaultIsOpen || isOpen;
	    if (focusOnOpen && inputRef.current) {
	      inputRef.current.focus();
	    }
	    // eslint-disable-next-line react-hooks/exhaustive-deps
	  }, []);
	  reactExports.useEffect(function () {
	    if (isInitialMountRef.current) {
	      return;
	    }
	    previousResultCountRef.current = items.length;
	  });
	  // Add mouse/touch events to document.
	  var mouseAndTouchTrackersRef = useMouseAndTouchTracker(isOpen, [inputRef, menuRef, toggleButtonRef], environment, function () {
	    dispatch({
	      type: InputBlur,
	      selectItem: false
	    });
	  });
	  var setGetterPropCallInfo = useGetterPropsCalledChecker();
	  // Make initial ref false.
	  reactExports.useEffect(function () {
	    isInitialMountRef.current = false;
	    return function () {
	      isInitialMountRef.current = true;
	    };
	  }, []);
	  // Reset itemRefs on close.
	  reactExports.useEffect(function () {
	    var _environment$document;
	    if (!isOpen) {
	      itemRefs.current = {};
	    } else if (((_environment$document = environment.document) == null ? void 0 : _environment$document.activeElement) !== inputRef.current) {
	      var _inputRef$current;
	      inputRef == null ? void 0 : (_inputRef$current = inputRef.current) == null ? void 0 : _inputRef$current.focus();
	    }
	  }, [isOpen, environment]);

	  /* Event handler functions */
	  var inputKeyDownHandlers = reactExports.useMemo(function () {
	    return {
	      ArrowDown: function ArrowDown(event) {
	        event.preventDefault();
	        dispatch({
	          type: InputKeyDownArrowDown,
	          altKey: event.altKey,
	          getItemNodeFromIndex: getItemNodeFromIndex
	        });
	      },
	      ArrowUp: function ArrowUp(event) {
	        event.preventDefault();
	        dispatch({
	          type: InputKeyDownArrowUp,
	          altKey: event.altKey,
	          getItemNodeFromIndex: getItemNodeFromIndex
	        });
	      },
	      Home: function Home(event) {
	        if (!latest.current.state.isOpen) {
	          return;
	        }
	        event.preventDefault();
	        dispatch({
	          type: InputKeyDownHome,
	          getItemNodeFromIndex: getItemNodeFromIndex
	        });
	      },
	      End: function End(event) {
	        if (!latest.current.state.isOpen) {
	          return;
	        }
	        event.preventDefault();
	        dispatch({
	          type: InputKeyDownEnd,
	          getItemNodeFromIndex: getItemNodeFromIndex
	        });
	      },
	      Escape: function Escape(event) {
	        var latestState = latest.current.state;
	        if (latestState.isOpen || latestState.inputValue || latestState.selectedItem || latestState.highlightedIndex > -1) {
	          event.preventDefault();
	          dispatch({
	            type: InputKeyDownEscape
	          });
	        }
	      },
	      Enter: function Enter(event) {
	        var latestState = latest.current.state;
	        // if closed or no highlighted index, do nothing.
	        if (!latestState.isOpen || event.which === 229 // if IME composing, wait for next Enter keydown event.
	        ) {
	          return;
	        }
	        event.preventDefault();
	        dispatch({
	          type: InputKeyDownEnter,
	          getItemNodeFromIndex: getItemNodeFromIndex
	        });
	      },
	      PageUp: function PageUp(event) {
	        if (latest.current.state.isOpen) {
	          event.preventDefault();
	          dispatch({
	            type: InputKeyDownPageUp,
	            getItemNodeFromIndex: getItemNodeFromIndex
	          });
	        }
	      },
	      PageDown: function PageDown(event) {
	        if (latest.current.state.isOpen) {
	          event.preventDefault();
	          dispatch({
	            type: InputKeyDownPageDown,
	            getItemNodeFromIndex: getItemNodeFromIndex
	          });
	        }
	      }
	    };
	  }, [dispatch, latest, getItemNodeFromIndex]);

	  // Getter props.
	  var getLabelProps = reactExports.useCallback(function (labelProps) {
	    return _extends$4({
	      id: elementIds.labelId,
	      htmlFor: elementIds.inputId
	    }, labelProps);
	  }, [elementIds]);
	  var getMenuProps = reactExports.useCallback(function (_temp, _temp2) {
	    var _extends2;
	    var _ref = _temp === void 0 ? {} : _temp,
	      onMouseLeave = _ref.onMouseLeave,
	      _ref$refKey = _ref.refKey,
	      refKey = _ref$refKey === void 0 ? 'ref' : _ref$refKey,
	      ref = _ref.ref,
	      rest = _objectWithoutPropertiesLoose$2(_ref, _excluded$1);
	    var _ref2 = _temp2 === void 0 ? {} : _temp2;
	      _ref2.suppressRefError;
	    return _extends$4((_extends2 = {}, _extends2[refKey] = handleRefs(ref, function (menuNode) {
	      menuRef.current = menuNode;
	    }), _extends2.id = elementIds.menuId, _extends2.role = 'listbox', _extends2['aria-labelledby'] = rest && rest['aria-label'] ? undefined : "" + elementIds.labelId, _extends2.onMouseLeave = callAllEventHandlers(onMouseLeave, function () {
	      dispatch({
	        type: MenuMouseLeave
	      });
	    }), _extends2), rest);
	  }, [dispatch, setGetterPropCallInfo, elementIds]);
	  var getItemProps = reactExports.useCallback(function (_temp3) {
	    var _extends3, _ref4;
	    var _ref3 = _temp3 === void 0 ? {} : _temp3,
	      itemProp = _ref3.item,
	      indexProp = _ref3.index,
	      _ref3$refKey = _ref3.refKey,
	      refKey = _ref3$refKey === void 0 ? 'ref' : _ref3$refKey,
	      ref = _ref3.ref,
	      onMouseMove = _ref3.onMouseMove,
	      onMouseDown = _ref3.onMouseDown,
	      onClick = _ref3.onClick;
	      _ref3.onPress;
	      var disabled = _ref3.disabled,
	      rest = _objectWithoutPropertiesLoose$2(_ref3, _excluded2$1);
	    var _latest$current = latest.current,
	      latestProps = _latest$current.props,
	      latestState = _latest$current.state;
	    var _getItemAndIndex = getItemAndIndex(itemProp, indexProp, latestProps.items, 'Pass either item or index to getItemProps!'),
	      index = _getItemAndIndex[1];
	    var onSelectKey = 'onClick';
	    var customClickHandler = onClick;
	    var itemHandleMouseMove = function itemHandleMouseMove() {
	      if (index === latestState.highlightedIndex) {
	        return;
	      }
	      shouldScrollRef.current = false;
	      dispatch({
	        type: ItemMouseMove,
	        index: index,
	        disabled: disabled
	      });
	    };
	    var itemHandleClick = function itemHandleClick() {
	      dispatch({
	        type: ItemClick,
	        index: index
	      });
	    };
	    var itemHandleMouseDown = function itemHandleMouseDown(e) {
	      return e.preventDefault();
	    };
	    return _extends$4((_extends3 = {}, _extends3[refKey] = handleRefs(ref, function (itemNode) {
	      if (itemNode) {
	        itemRefs.current[elementIds.getItemId(index)] = itemNode;
	      }
	    }), _extends3.disabled = disabled, _extends3.role = 'option', _extends3['aria-selected'] = "" + (index === latestState.highlightedIndex), _extends3.id = elementIds.getItemId(index), _extends3), !disabled && (_ref4 = {}, _ref4[onSelectKey] = callAllEventHandlers(customClickHandler, itemHandleClick), _ref4), {
	      onMouseMove: callAllEventHandlers(onMouseMove, itemHandleMouseMove),
	      onMouseDown: callAllEventHandlers(onMouseDown, itemHandleMouseDown)
	    }, rest);
	  }, [dispatch, latest, shouldScrollRef, elementIds]);
	  var getToggleButtonProps = reactExports.useCallback(function (_temp4) {
	    var _extends4;
	    var _ref5 = _temp4 === void 0 ? {} : _temp4,
	      onClick = _ref5.onClick;
	      _ref5.onPress;
	      var _ref5$refKey = _ref5.refKey,
	      refKey = _ref5$refKey === void 0 ? 'ref' : _ref5$refKey,
	      ref = _ref5.ref,
	      rest = _objectWithoutPropertiesLoose$2(_ref5, _excluded3);
	    var latestState = latest.current.state;
	    var toggleButtonHandleClick = function toggleButtonHandleClick() {
	      dispatch({
	        type: ToggleButtonClick
	      });
	    };
	    return _extends$4((_extends4 = {}, _extends4[refKey] = handleRefs(ref, function (toggleButtonNode) {
	      toggleButtonRef.current = toggleButtonNode;
	    }), _extends4['aria-controls'] = elementIds.menuId, _extends4['aria-expanded'] = latestState.isOpen, _extends4.id = elementIds.toggleButtonId, _extends4.tabIndex = -1, _extends4), !rest.disabled && _extends$4({}, {
	      onClick: callAllEventHandlers(onClick, toggleButtonHandleClick)
	    }), rest);
	  }, [dispatch, latest, elementIds]);
	  var getInputProps = reactExports.useCallback(function (_temp5, _temp6) {
	    var _extends5;
	    var _ref6 = _temp5 === void 0 ? {} : _temp5,
	      onKeyDown = _ref6.onKeyDown,
	      onChange = _ref6.onChange,
	      onInput = _ref6.onInput,
	      onFocus = _ref6.onFocus,
	      onBlur = _ref6.onBlur;
	      _ref6.onChangeText;
	      var _ref6$refKey = _ref6.refKey,
	      refKey = _ref6$refKey === void 0 ? 'ref' : _ref6$refKey,
	      ref = _ref6.ref,
	      rest = _objectWithoutPropertiesLoose$2(_ref6, _excluded4);
	    var _ref7 = _temp6 === void 0 ? {} : _temp6;
	      _ref7.suppressRefError;
	    var latestState = latest.current.state;
	    var inputHandleKeyDown = function inputHandleKeyDown(event) {
	      var key = normalizeArrowKey(event);
	      if (key && inputKeyDownHandlers[key]) {
	        inputKeyDownHandlers[key](event);
	      }
	    };
	    var inputHandleChange = function inputHandleChange(event) {
	      dispatch({
	        type: InputChange,
	        inputValue: event.target.value
	      });
	    };
	    var inputHandleBlur = function inputHandleBlur(event) {
	      /* istanbul ignore else */
	      if (latestState.isOpen && !mouseAndTouchTrackersRef.current.isMouseDown) {
	        dispatch({
	          type: InputBlur,
	          selectItem: event.relatedTarget !== null
	        });
	      }
	    };
	    var inputHandleFocus = function inputHandleFocus() {
	      if (!latestState.isOpen) {
	        dispatch({
	          type: InputFocus
	        });
	      }
	    };

	    /* istanbul ignore next (preact) */
	    var onChangeKey = 'onChange';
	    var eventHandlers = {};
	    if (!rest.disabled) {
	      var _eventHandlers;
	      eventHandlers = (_eventHandlers = {}, _eventHandlers[onChangeKey] = callAllEventHandlers(onChange, onInput, inputHandleChange), _eventHandlers.onKeyDown = callAllEventHandlers(onKeyDown, inputHandleKeyDown), _eventHandlers.onBlur = callAllEventHandlers(onBlur, inputHandleBlur), _eventHandlers.onFocus = callAllEventHandlers(onFocus, inputHandleFocus), _eventHandlers);
	    }
	    return _extends$4((_extends5 = {}, _extends5[refKey] = handleRefs(ref, function (inputNode) {
	      inputRef.current = inputNode;
	    }), _extends5['aria-activedescendant'] = latestState.isOpen && latestState.highlightedIndex > -1 ? elementIds.getItemId(latestState.highlightedIndex) : '', _extends5['aria-autocomplete'] = 'list', _extends5['aria-controls'] = elementIds.menuId, _extends5['aria-expanded'] = latestState.isOpen, _extends5['aria-labelledby'] = rest && rest['aria-label'] ? undefined : "" + elementIds.labelId, _extends5.autoComplete = 'off', _extends5.id = elementIds.inputId, _extends5.role = 'combobox', _extends5.value = latestState.inputValue, _extends5), eventHandlers, rest);
	  }, [dispatch, inputKeyDownHandlers, latest, mouseAndTouchTrackersRef, setGetterPropCallInfo, elementIds]);

	  // returns
	  var toggleMenu = reactExports.useCallback(function () {
	    dispatch({
	      type: FunctionToggleMenu
	    });
	  }, [dispatch]);
	  var closeMenu = reactExports.useCallback(function () {
	    dispatch({
	      type: FunctionCloseMenu
	    });
	  }, [dispatch]);
	  var openMenu = reactExports.useCallback(function () {
	    dispatch({
	      type: FunctionOpenMenu
	    });
	  }, [dispatch]);
	  var setHighlightedIndex = reactExports.useCallback(function (newHighlightedIndex) {
	    dispatch({
	      type: FunctionSetHighlightedIndex,
	      highlightedIndex: newHighlightedIndex
	    });
	  }, [dispatch]);
	  var selectItem = reactExports.useCallback(function (newSelectedItem) {
	    dispatch({
	      type: FunctionSelectItem,
	      selectedItem: newSelectedItem
	    });
	  }, [dispatch]);
	  var setInputValue = reactExports.useCallback(function (newInputValue) {
	    dispatch({
	      type: FunctionSetInputValue,
	      inputValue: newInputValue
	    });
	  }, [dispatch]);
	  var reset = reactExports.useCallback(function () {
	    dispatch({
	      type: FunctionReset$1
	    });
	  }, [dispatch]);
	  return {
	    // prop getters.
	    getItemProps: getItemProps,
	    getLabelProps: getLabelProps,
	    getMenuProps: getMenuProps,
	    getInputProps: getInputProps,
	    getToggleButtonProps: getToggleButtonProps,
	    // actions.
	    toggleMenu: toggleMenu,
	    openMenu: openMenu,
	    closeMenu: closeMenu,
	    setHighlightedIndex: setHighlightedIndex,
	    setInputValue: setInputValue,
	    selectItem: selectItem,
	    reset: reset,
	    // state.
	    highlightedIndex: highlightedIndex,
	    isOpen: isOpen,
	    selectedItem: selectedItem,
	    inputValue: inputValue
	  };
	}

	var defaultStateValues = {
	  activeIndex: -1,
	  selectedItems: []
	};

	/**
	 * Returns the initial value for a state key in the following order:
	 * 1. controlled prop, 2. initial prop, 3. default prop, 4. default
	 * value from Downshift.
	 *
	 * @param {Object} props Props passed to the hook.
	 * @param {string} propKey Props key to generate the value for.
	 * @returns {any} The initial value for that prop.
	 */
	function getInitialValue(props, propKey) {
	  return getInitialValue$1(props, propKey, defaultStateValues);
	}

	/**
	 * Returns the default value for a state key in the following order:
	 * 1. controlled prop, 2. default prop, 3. default value from Downshift.
	 *
	 * @param {Object} props Props passed to the hook.
	 * @param {string} propKey Props key to generate the value for.
	 * @returns {any} The initial value for that prop.
	 */
	function getDefaultValue(props, propKey) {
	  return getDefaultValue$1(props, propKey, defaultStateValues);
	}

	/**
	 * Gets the initial state based on the provided props. It uses initial, default
	 * and controlled props related to state in order to compute the initial value.
	 *
	 * @param {Object} props Props passed to the hook.
	 * @returns {Object} The initial state.
	 */
	function getInitialState(props) {
	  var activeIndex = getInitialValue(props, 'activeIndex');
	  var selectedItems = getInitialValue(props, 'selectedItems');
	  return {
	    activeIndex: activeIndex,
	    selectedItems: selectedItems
	  };
	}

	/**
	 * Returns true if dropdown keydown operation is permitted. Should not be
	 * allowed on keydown with modifier keys (ctrl, alt, shift, meta), on
	 * input element with text content that is either highlighted or selection
	 * cursor is not at the starting position.
	 *
	 * @param {KeyboardEvent} event The event from keydown.
	 * @returns {boolean} Whether the operation is allowed.
	 */
	function isKeyDownOperationPermitted(event) {
	  if (event.shiftKey || event.metaKey || event.ctrlKey || event.altKey) {
	    return false;
	  }
	  var element = event.target;
	  if (element instanceof HTMLInputElement &&
	  // if element is a text input
	  element.value !== '' && (
	  // and we have text in it
	  // and cursor is either not at the start or is currently highlighting text.
	  element.selectionStart !== 0 || element.selectionEnd !== 0)) {
	    return false;
	  }
	  return true;
	}

	/**
	 * Returns a message to be added to aria-live region when item is removed.
	 *
	 * @param {Object} selectionParameters Parameters required to build the message.
	 * @returns {string} The a11y message.
	 */
	function getA11yRemovalMessage(selectionParameters) {
	  var removedSelectedItem = selectionParameters.removedSelectedItem,
	    itemToStringLocal = selectionParameters.itemToString;
	  return itemToStringLocal(removedSelectedItem) + " has been removed.";
	}
	({
	  selectedItems: PropTypes.array,
	  initialSelectedItems: PropTypes.array,
	  defaultSelectedItems: PropTypes.array,
	  itemToString: PropTypes.func,
	  getA11yRemovalMessage: PropTypes.func,
	  stateReducer: PropTypes.func,
	  activeIndex: PropTypes.number,
	  initialActiveIndex: PropTypes.number,
	  defaultActiveIndex: PropTypes.number,
	  onActiveIndexChange: PropTypes.func,
	  onSelectedItemsChange: PropTypes.func,
	  keyNavigationNext: PropTypes.string,
	  keyNavigationPrevious: PropTypes.string,
	  environment: PropTypes.shape({
	    addEventListener: PropTypes.func,
	    removeEventListener: PropTypes.func,
	    document: PropTypes.shape({
	      getElementById: PropTypes.func,
	      activeElement: PropTypes.any,
	      body: PropTypes.any
	    })
	  })
	});
	var defaultProps = {
	  itemToString: defaultProps$3.itemToString,
	  stateReducer: defaultProps$3.stateReducer,
	  environment: defaultProps$3.environment,
	  getA11yRemovalMessage: getA11yRemovalMessage,
	  keyNavigationNext: 'ArrowRight',
	  keyNavigationPrevious: 'ArrowLeft'
	};

	var SelectedItemClick = 0;
	var SelectedItemKeyDownDelete = 1;
	var SelectedItemKeyDownBackspace = 2;
	var SelectedItemKeyDownNavigationNext = 3;
	var SelectedItemKeyDownNavigationPrevious = 4;
	var DropdownKeyDownNavigationPrevious = 5;
	var DropdownKeyDownBackspace = 6;
	var DropdownClick = 7;
	var FunctionAddSelectedItem = 8;
	var FunctionRemoveSelectedItem = 9;
	var FunctionSetSelectedItems = 10;
	var FunctionSetActiveIndex = 11;
	var FunctionReset = 12;

	var stateChangeTypes = /*#__PURE__*/Object.freeze({
	  __proto__: null,
	  SelectedItemClick: SelectedItemClick,
	  SelectedItemKeyDownDelete: SelectedItemKeyDownDelete,
	  SelectedItemKeyDownBackspace: SelectedItemKeyDownBackspace,
	  SelectedItemKeyDownNavigationNext: SelectedItemKeyDownNavigationNext,
	  SelectedItemKeyDownNavigationPrevious: SelectedItemKeyDownNavigationPrevious,
	  DropdownKeyDownNavigationPrevious: DropdownKeyDownNavigationPrevious,
	  DropdownKeyDownBackspace: DropdownKeyDownBackspace,
	  DropdownClick: DropdownClick,
	  FunctionAddSelectedItem: FunctionAddSelectedItem,
	  FunctionRemoveSelectedItem: FunctionRemoveSelectedItem,
	  FunctionSetSelectedItems: FunctionSetSelectedItems,
	  FunctionSetActiveIndex: FunctionSetActiveIndex,
	  FunctionReset: FunctionReset
	});

	/* eslint-disable complexity */
	function downshiftMultipleSelectionReducer(state, action) {
	  var type = action.type,
	    index = action.index,
	    props = action.props,
	    selectedItem = action.selectedItem;
	  var activeIndex = state.activeIndex,
	    selectedItems = state.selectedItems;
	  var changes;
	  switch (type) {
	    case SelectedItemClick:
	      changes = {
	        activeIndex: index
	      };
	      break;
	    case SelectedItemKeyDownNavigationPrevious:
	      changes = {
	        activeIndex: activeIndex - 1 < 0 ? 0 : activeIndex - 1
	      };
	      break;
	    case SelectedItemKeyDownNavigationNext:
	      changes = {
	        activeIndex: activeIndex + 1 >= selectedItems.length ? -1 : activeIndex + 1
	      };
	      break;
	    case SelectedItemKeyDownBackspace:
	    case SelectedItemKeyDownDelete:
	      {
	        if (activeIndex < 0) {
	          break;
	        }
	        var newActiveIndex = activeIndex;
	        if (selectedItems.length === 1) {
	          newActiveIndex = -1;
	        } else if (activeIndex === selectedItems.length - 1) {
	          newActiveIndex = selectedItems.length - 2;
	        }
	        changes = _extends$4({
	          selectedItems: [].concat(selectedItems.slice(0, activeIndex), selectedItems.slice(activeIndex + 1))
	        }, {
	          activeIndex: newActiveIndex
	        });
	        break;
	      }
	    case DropdownKeyDownNavigationPrevious:
	      changes = {
	        activeIndex: selectedItems.length - 1
	      };
	      break;
	    case DropdownKeyDownBackspace:
	      changes = {
	        selectedItems: selectedItems.slice(0, selectedItems.length - 1)
	      };
	      break;
	    case FunctionAddSelectedItem:
	      changes = {
	        selectedItems: [].concat(selectedItems, [selectedItem])
	      };
	      break;
	    case DropdownClick:
	      changes = {
	        activeIndex: -1
	      };
	      break;
	    case FunctionRemoveSelectedItem:
	      {
	        var _newActiveIndex = activeIndex;
	        var selectedItemIndex = selectedItems.indexOf(selectedItem);
	        if (selectedItemIndex < 0) {
	          break;
	        }
	        if (selectedItems.length === 1) {
	          _newActiveIndex = -1;
	        } else if (selectedItemIndex === selectedItems.length - 1) {
	          _newActiveIndex = selectedItems.length - 2;
	        }
	        changes = {
	          selectedItems: [].concat(selectedItems.slice(0, selectedItemIndex), selectedItems.slice(selectedItemIndex + 1)),
	          activeIndex: _newActiveIndex
	        };
	        break;
	      }
	    case FunctionSetSelectedItems:
	      {
	        var newSelectedItems = action.selectedItems;
	        changes = {
	          selectedItems: newSelectedItems
	        };
	        break;
	      }
	    case FunctionSetActiveIndex:
	      {
	        var _newActiveIndex2 = action.activeIndex;
	        changes = {
	          activeIndex: _newActiveIndex2
	        };
	        break;
	      }
	    case FunctionReset:
	      changes = {
	        activeIndex: getDefaultValue(props, 'activeIndex'),
	        selectedItems: getDefaultValue(props, 'selectedItems')
	      };
	      break;
	    default:
	      throw new Error('Reducer called without proper action type.');
	  }
	  return _extends$4({}, state, changes);
	}

	var _excluded = ["refKey", "ref", "onClick", "onKeyDown", "selectedItem", "index"],
	  _excluded2 = ["refKey", "ref", "onKeyDown", "onClick", "preventKeyAction"];
	useMultipleSelection.stateChangeTypes = stateChangeTypes;
	function useMultipleSelection(userProps) {
	  if (userProps === void 0) {
	    userProps = {};
	  }
	  // Props defaults and destructuring.
	  var props = _extends$4({}, defaultProps, userProps);
	  var getA11yRemovalMessage = props.getA11yRemovalMessage,
	    itemToString = props.itemToString,
	    environment = props.environment,
	    keyNavigationNext = props.keyNavigationNext,
	    keyNavigationPrevious = props.keyNavigationPrevious;

	  // Reducer init.
	  var _useControlledReducer = useControlledReducer$1(downshiftMultipleSelectionReducer, getInitialState(props), props),
	    state = _useControlledReducer[0],
	    dispatch = _useControlledReducer[1];
	  var activeIndex = state.activeIndex,
	    selectedItems = state.selectedItems;

	  // Refs.
	  var isInitialMountRef = reactExports.useRef(true);
	  var dropdownRef = reactExports.useRef(null);
	  var previousSelectedItemsRef = reactExports.useRef(selectedItems);
	  var selectedItemRefs = reactExports.useRef();
	  selectedItemRefs.current = [];
	  var latest = useLatestRef$1({
	    state: state,
	    props: props
	  });

	  // Effects.
	  /* Sets a11y status message on changes in selectedItem. */
	  reactExports.useEffect(function () {
	    if (isInitialMountRef.current || false) {
	      return;
	    }
	    if (selectedItems.length < previousSelectedItemsRef.current.length) {
	      var removedSelectedItem = previousSelectedItemsRef.current.find(function (item) {
	        return selectedItems.indexOf(item) < 0;
	      });
	      setStatus(getA11yRemovalMessage({
	        itemToString: itemToString,
	        resultCount: selectedItems.length,
	        removedSelectedItem: removedSelectedItem,
	        activeIndex: activeIndex,
	        activeSelectedItem: selectedItems[activeIndex]
	      }), environment.document);
	    }
	    previousSelectedItemsRef.current = selectedItems;

	    // eslint-disable-next-line react-hooks/exhaustive-deps
	  }, [selectedItems.length]);
	  // Sets focus on active item.
	  reactExports.useEffect(function () {
	    if (isInitialMountRef.current) {
	      return;
	    }
	    if (activeIndex === -1 && dropdownRef.current) {
	      dropdownRef.current.focus();
	    } else if (selectedItemRefs.current[activeIndex]) {
	      selectedItemRefs.current[activeIndex].focus();
	    }
	  }, [activeIndex]);
	  useControlPropsValidator({
	    isInitialMount: isInitialMountRef.current,
	    props: props,
	    state: state
	  });
	  var setGetterPropCallInfo = useGetterPropsCalledChecker();
	  // Make initial ref false.
	  reactExports.useEffect(function () {
	    isInitialMountRef.current = false;
	    return function () {
	      isInitialMountRef.current = true;
	    };
	  }, []);

	  // Event handler functions.
	  var selectedItemKeyDownHandlers = reactExports.useMemo(function () {
	    var _ref;
	    return _ref = {}, _ref[keyNavigationPrevious] = function () {
	      dispatch({
	        type: SelectedItemKeyDownNavigationPrevious
	      });
	    }, _ref[keyNavigationNext] = function () {
	      dispatch({
	        type: SelectedItemKeyDownNavigationNext
	      });
	    }, _ref.Delete = function Delete() {
	      dispatch({
	        type: SelectedItemKeyDownDelete
	      });
	    }, _ref.Backspace = function Backspace() {
	      dispatch({
	        type: SelectedItemKeyDownBackspace
	      });
	    }, _ref;
	  }, [dispatch, keyNavigationNext, keyNavigationPrevious]);
	  var dropdownKeyDownHandlers = reactExports.useMemo(function () {
	    var _ref2;
	    return _ref2 = {}, _ref2[keyNavigationPrevious] = function (event) {
	      if (isKeyDownOperationPermitted(event)) {
	        dispatch({
	          type: DropdownKeyDownNavigationPrevious
	        });
	      }
	    }, _ref2.Backspace = function Backspace(event) {
	      if (isKeyDownOperationPermitted(event)) {
	        dispatch({
	          type: DropdownKeyDownBackspace
	        });
	      }
	    }, _ref2;
	  }, [dispatch, keyNavigationPrevious]);

	  // Getter props.
	  var getSelectedItemProps = reactExports.useCallback(function (_temp) {
	    var _extends2;
	    var _ref3 = _temp === void 0 ? {} : _temp,
	      _ref3$refKey = _ref3.refKey,
	      refKey = _ref3$refKey === void 0 ? 'ref' : _ref3$refKey,
	      ref = _ref3.ref,
	      onClick = _ref3.onClick,
	      onKeyDown = _ref3.onKeyDown,
	      selectedItemProp = _ref3.selectedItem,
	      indexProp = _ref3.index,
	      rest = _objectWithoutPropertiesLoose$2(_ref3, _excluded);
	    var latestState = latest.current.state;
	    var _getItemAndIndex = getItemAndIndex(selectedItemProp, indexProp, latestState.selectedItems, 'Pass either item or index to getSelectedItemProps!'),
	      index = _getItemAndIndex[1];
	    var isFocusable = index > -1 && index === latestState.activeIndex;
	    var selectedItemHandleClick = function selectedItemHandleClick() {
	      dispatch({
	        type: SelectedItemClick,
	        index: index
	      });
	    };
	    var selectedItemHandleKeyDown = function selectedItemHandleKeyDown(event) {
	      var key = normalizeArrowKey(event);
	      if (key && selectedItemKeyDownHandlers[key]) {
	        selectedItemKeyDownHandlers[key](event);
	      }
	    };
	    return _extends$4((_extends2 = {}, _extends2[refKey] = handleRefs(ref, function (selectedItemNode) {
	      if (selectedItemNode) {
	        selectedItemRefs.current.push(selectedItemNode);
	      }
	    }), _extends2.tabIndex = isFocusable ? 0 : -1, _extends2.onClick = callAllEventHandlers(onClick, selectedItemHandleClick), _extends2.onKeyDown = callAllEventHandlers(onKeyDown, selectedItemHandleKeyDown), _extends2), rest);
	  }, [dispatch, latest, selectedItemKeyDownHandlers]);
	  var getDropdownProps = reactExports.useCallback(function (_temp2, _temp3) {
	    var _extends3;
	    var _ref4 = _temp2 === void 0 ? {} : _temp2,
	      _ref4$refKey = _ref4.refKey,
	      refKey = _ref4$refKey === void 0 ? 'ref' : _ref4$refKey,
	      ref = _ref4.ref,
	      onKeyDown = _ref4.onKeyDown,
	      onClick = _ref4.onClick,
	      _ref4$preventKeyActio = _ref4.preventKeyAction,
	      preventKeyAction = _ref4$preventKeyActio === void 0 ? false : _ref4$preventKeyActio,
	      rest = _objectWithoutPropertiesLoose$2(_ref4, _excluded2);
	    var _ref5 = _temp3 === void 0 ? {} : _temp3;
	      _ref5.suppressRefError;
	    var dropdownHandleKeyDown = function dropdownHandleKeyDown(event) {
	      var key = normalizeArrowKey(event);
	      if (key && dropdownKeyDownHandlers[key]) {
	        dropdownKeyDownHandlers[key](event);
	      }
	    };
	    var dropdownHandleClick = function dropdownHandleClick() {
	      dispatch({
	        type: DropdownClick
	      });
	    };
	    return _extends$4((_extends3 = {}, _extends3[refKey] = handleRefs(ref, function (dropdownNode) {
	      if (dropdownNode) {
	        dropdownRef.current = dropdownNode;
	      }
	    }), _extends3), !preventKeyAction && {
	      onKeyDown: callAllEventHandlers(onKeyDown, dropdownHandleKeyDown),
	      onClick: callAllEventHandlers(onClick, dropdownHandleClick)
	    }, rest);
	  }, [dispatch, dropdownKeyDownHandlers, setGetterPropCallInfo]);

	  // returns
	  var addSelectedItem = reactExports.useCallback(function (selectedItem) {
	    dispatch({
	      type: FunctionAddSelectedItem,
	      selectedItem: selectedItem
	    });
	  }, [dispatch]);
	  var removeSelectedItem = reactExports.useCallback(function (selectedItem) {
	    dispatch({
	      type: FunctionRemoveSelectedItem,
	      selectedItem: selectedItem
	    });
	  }, [dispatch]);
	  var setSelectedItems = reactExports.useCallback(function (newSelectedItems) {
	    dispatch({
	      type: FunctionSetSelectedItems,
	      selectedItems: newSelectedItems
	    });
	  }, [dispatch]);
	  var setActiveIndex = reactExports.useCallback(function (newActiveIndex) {
	    dispatch({
	      type: FunctionSetActiveIndex,
	      activeIndex: newActiveIndex
	    });
	  }, [dispatch]);
	  var reset = reactExports.useCallback(function () {
	    dispatch({
	      type: FunctionReset
	    });
	  }, [dispatch]);
	  return {
	    getSelectedItemProps: getSelectedItemProps,
	    getDropdownProps: getDropdownProps,
	    addSelectedItem: addSelectedItem,
	    removeSelectedItem: removeSelectedItem,
	    setSelectedItems: setSelectedItems,
	    setActiveIndex: setActiveIndex,
	    reset: reset,
	    selectedItems: selectedItems,
	    activeIndex: activeIndex
	  };
	}

	const useTagSearch = (searchToken) => {
	    const results = trpc.tags.query.useQuery(
	        { query: searchToken },
	        {
	            trpc: {
	                ssr: true,
	            },
	            suspense: true,
	            initialData: () => {
	                if (searchToken.length < 3) {
	                    return { result: [] };
	                }
	            },
	        }
	    );
	    return {
	        suggestions: results.data,
	        mappedSuggestions: results.data?.result.map((tag) => tag.content) ?? [],
	    };
	};

	const useProjectSearch = (
	    searchToken,
	    { skipMinimum = false }
	) => {
	    const results = trpc.projects.searchByHandle.useQuery(
	        { query: searchToken, skipMinimum },
	        {
	            trpc: {
	                ssr: true,
	            },
	            suspense: true,
	            initialData: () => {
	                if (searchToken.length < 3 && !skipMinimum) {
	                    return { projects: [] };
	                }
	            },
	        }
	    );

	    return { projects: results.data?.projects };
	};

	const tokenSplitRegex = /[,;]/;

	 











	const TokenInput = ({
	    tokens,
	    setTokens,
	    disabled = false,
	    getSuggestions = false,
	    fieldName = "tag",
	    customSuggestions,
	    ...props
	}) => {
	    const [, startTransition] = reactExports.useTransition();
	    const [pendingToken, setPendingToken] = reactExports.useState("");
	    const [searchToken, setSearchToken] = reactExports.useState(pendingToken);
	    const [toastVisible, setToastVisible] = reactExports.useState(false);

	    // android workaround: skip input processing if keydown returns the actual value.
	    // see: https://bugs.chromium.org/p/chromium/issues/detail?id=118639
	    const unidentifiedKeyDown = reactExports.useRef(false);

	    const { mappedSuggestions } = useTagSearch(searchToken);

	    const {
	        getSelectedItemProps,
	        getDropdownProps,
	        addSelectedItem,
	        removeSelectedItem,
	    } = useMultipleSelection({
	        selectedItems: tokens,
	        onStateChange({ selectedItems: newTokens, type }) {
	            switch (type) {
	                case useMultipleSelection.stateChangeTypes
	                    .SelectedItemKeyDownBackspace:
	                case useMultipleSelection.stateChangeTypes
	                    .SelectedItemKeyDownDelete:
	                case useMultipleSelection.stateChangeTypes
	                    .DropdownKeyDownBackspace:
	                case useMultipleSelection.stateChangeTypes
	                    .FunctionRemoveSelectedItem:
	                case useMultipleSelection.stateChangeTypes
	                    .FunctionAddSelectedItem:
	                    setTokens(newTokens ?? []);
	                    break;
	            }
	        },
	    });

	    const filteredCustomSuggestions = reactExports.useMemo(() => {
	        if (customSuggestions === undefined) {
	            return [];
	        }

	        const initialFilter = customSuggestions.filter((token) => {
	            return tokens.indexOf(token) === -1;
	        });

	        return pendingToken === ""
	            ? initialFilter
	            : initialFilter.filter((suggestion) =>
	                  suggestion
	                      .toLowerCase()
	                      .replace(/\s+/g, "")
	                      .includes(pendingToken.toLowerCase().replace(/\s+/g, ""))
	              );
	    }, [customSuggestions, pendingToken, tokens]);

	    const suggestionsToDisplay = customSuggestions?.length
	        ? filteredCustomSuggestions
	        : getSuggestions
	        ? [pendingToken, ...mappedSuggestions].filter(isTruthy)
	        : pendingToken.length > 0
	        ? [pendingToken]
	        : [];

	    const {
	        isOpen,
	        getMenuProps,
	        getInputProps,
	        highlightedIndex,
	        getItemProps,
	        selectItem,
	        setInputValue,
	        openMenu,
	    } = useCombobox({
	        items: suggestionsToDisplay,
	        defaultHighlightedIndex: 0,
	        selectedItem: null,
	        inputValue: pendingToken,
	        stateReducer(state, actionAndChanges) {
	            return actionAndChanges.changes;
	        },
	        onStateChange({
	            inputValue: newInputValue,
	            type,
	            selectedItem: newToken,
	        }) {
	            switch (type) {
	                case useCombobox.stateChangeTypes.InputKeyDownEnter:
	                case useCombobox.stateChangeTypes.ItemClick:
	                case useCombobox.stateChangeTypes.FunctionSelectItem:
	                    if (newToken) {
	                        addSelectedItem(newToken);
	                        setPendingToken("");
	                        startTransition(() => {
	                            setSearchToken("");
	                        });
	                    }
	                    break;
	                case useCombobox.stateChangeTypes.InputChange: {
	                    // android workaround. overriding the change event doesn't work so we handle it here.
	                    if (unidentifiedKeyDown.current && newInputValue) {
	                        const key = newInputValue[newInputValue.length - 1];

	                        if (key.match(tokenSplitRegex)) {
	                            let token = newInputValue;
	                            if (token) {
	                                // if the token has the just entered key on the end, slice it off first
	                                if (token.endsWith(key)) {
	                                    token = token.slice(0, token.length - 1);
	                                }

	                                // add it like normal
	                                addSelectedItem(token);
	                                // because this isn't internally treated as a selection event, we have to reset the input ourselves
	                                setInputValue("");
	                                setPendingToken("");
	                                startTransition(() => {
	                                    setSearchToken("");
	                                });
	                                break;
	                            }
	                        }
	                    }

	                    setPendingToken(newInputValue ?? "");
	                    startTransition(() => {
	                        setSearchToken(newInputValue ?? "");
	                    });
	                    break;
	                }
	            }
	        },
	    });

	    return (
	        React$2.createElement('div', {
	            className: `${
                props.className ?? ""
            } relative flex flex-row flex-wrap gap-3 text-sm`,}

	            , toastVisible ? (
	                React$2.createElement('div', { className: "absolute -top-10 flex flex-row items-center gap-2 rounded-lg border border-cherry bg-white p-2 text-xs text-cherry"            ,}
	                    , React$2.createElement(ForwardRef$B, { className: "h-4 w-4" ,} )
	                    , React$2.createElement('span', null, "press "
	                         , React$2.createElement('kbd', null, ","), " or "  , React$2.createElement('kbd', null, "Enter"), " to save your"   , " "
	                        , fieldName, "!"
	                    )
	                )
	            ) : null
	            , tokens.map((token, index) => (
	                React$2.createElement('div', {
	                    key: `selected-token-${token}`,
	                    className: "group h-max cursor-pointer select-none"   ,
	                    ...getSelectedItemProps({
	                        selectedItem: token,
	                        index,
	                    }),}

	                    /* this weird nested div thing is to prevent a bug caused by having the default click handler and our removal handler on the same element */
	                    , React$2.createElement('button', {
	                        className: tw`co-filled-button flex items-center justify-start gap-1 rounded-full px-2 py-1 leading-none`,
	                        onClick: (e) => {
	                            e.stopPropagation();
	                            removeSelectedItem(token);
	                        },
	                        type: "button",}

	                        , React$2.createElement(props.TokenIcon, { className: "inline-block h-3.5 group-hover:hidden"  ,} )
	                        , React$2.createElement(ForwardRef$9, { className: "hidden h-3.5 group-hover:inline-block"  ,} )
	                        , React$2.createElement('span', { className: "block",}, token)
	                    )
	                )
	            ))
	            , React$2.createElement('div', { className: "relative",}
	                , React$2.createElement('input', {
	                    placeholder: props.placeholder,
	                    className: "co-editable-body border-0 border-none bg-inherit p-0 text-sm outline-0 focus:ring-0"       ,
	                    ...getInputProps({
	                        ...(getDropdownProps({
	                            onKeyDown: (e) => {
	                                // we're on android. set the ref so we know to process input.
	                                // keydown fires before input so we should still be fine here.
	                                if (e.key === "Unidentified") {
	                                    unidentifiedKeyDown.current = true;
	                                }

	                                if (
	                                    e.key.match(tokenSplitRegex) ||
	                                    e.key === "Tab"
	                                ) {
	                                    const token =
	                                        suggestionsToDisplay[highlightedIndex];
	                                    if (token) {
	                                        e.preventDefault();
	                                        e.stopPropagation();
	                                        selectItem(token);
	                                    }
	                                }
	                            },
	                        }) ), // for some reason this is typed as `any`,
	                        onFocus: () => {
	                            setToastVisible(true);
	                            customSuggestions?.length && openMenu();
	                        },
	                        onBlur: () => {
	                            setToastVisible(false);
	                        },
	                        // https://github.com/downshift-js/downshift/issues/1108
	                        onChange: (e) => {
	                            setPendingToken(
	                                (e.target ).value
	                            );
	                        },
	                        disabled,
	                    }),}
	                )
	                , React$2.createElement('ul', {
	                    ...getMenuProps(),
	                    className: `${
                        isOpen && suggestionsToDisplay.length
                            ? "block"
                            : "hidden"
                    } w-prose cohost-shadow-light mt-3 flex flex-col divide-y divide-gray-200 rounded-lg bg-notWhite py-3 text-notBlack`,}

	                    , isOpen &&
	                        suggestionsToDisplay.map((token, index) => (
	                            React$2.createElement('li', {
	                                className: `${
                                    highlightedIndex === index
                                        ? "bg-strawberry-200"
                                        : ""
                                } px-3 leading-relaxed`,
	                                key: `${token}-${index}`,
	                                ...getItemProps({
	                                    item: token,
	                                    index,
	                                }),}

	                                , token
	                            )
	                        ))
	                )
	            )
	        )
	    );
	};

	const CwsInput$1 = () => {
	    const service = reactExports.useContext(PostComposerContext);
	    const { send } = service;
	    const { t } = useTranslation();

	    const isEditing = useSelector$1(service, selectIsEditing$5);
	    const cws = useSelector$1(service, selectCws$1);
	    const editingCws = useSelector$1(service, selectEditingCws);

	    const onCwsChange = reactExports.useCallback(
	        (cws) => {
	            send({ type: "CWS_INPUT", cws });
	        },
	        [send]
	    );

	    return editingCws ? (
	        React$2.createElement(TokenInput, {
	            TokenIcon: ForwardRef$3,
	            className: "co-editable-body w-full p-0 px-3 leading-none"    ,
	            tokens: cws,
	            setTokens: onCwsChange,
	            placeholder: t(
	                "client:post-editor.cws-placeholder",
	                "add content warnings"
	            ),
	            disabled: !isEditing,
	            fieldName: "CW",}
	        )
	    ) : null;
	};

	const DropZone




	 = ({ children, handleFileDrop, className = "" }) => {
	    const [{ canDrop, isOver }, drop] = useDrop(
	        () => ({
	            accept: [FILE],
	            drop(item) {
	                handleFileDrop(item.files);
	            },
	            collect: (monitor) => ({
	                isOver: monitor.isOver(),
	                canDrop: monitor.canDrop(),
	            }),
	        }),
	        []
	    );
	    const isActive = canDrop && isOver;

	    const classes = classNames({
	        hidden: !isActive,
	        block: isActive,
	    });

	    return (
	        React$2.createElement('div', { ref: drop, className: `relative ${className}`,}
	            , React$2.createElement('div', {
	                className: `absolute inset-0 flex items-center justify-center
                bg-gray-700 bg-opacity-70 text-notWhite ${classes} z-50
                backdrop-blur-sm`,}
	, "RELEASE TO DROP"

	            )
	            , children
	        )
	    );
	};

	const HeadlineInput$1 = React$2.memo(() => {
	    const service = reactExports.useContext(PostComposerContext);
	    const { send } = service;
	    const { t } = useTranslation();

	    const onHeadlineInput =
	        reactExports.useCallback(
	            ({ currentTarget }) => {
	                send({
	                    type: "HEADLINE_INPUT",
	                    headline: currentTarget.value,
	                });
	            },
	            [send]
	        );

	    const headline = useSelector$1(service, selectHeadline$1);
	    const isEditing = useSelector$1(service, selectIsEditing$5);

	    return (
	        React$2.createElement('div', { className: "flex w-full flex-row items-end justify-between gap-3"     ,}
	            , React$2.createElement(ExpandingTextArea, {
	                className: tw`co-editable-body w-full flex-1 resize-none overflow-hidden 
                    break-words border-none p-0 px-3 font-atkinson text-xl font-bold focus:ring-0`,
	                placeholder: t(
	                    "client:post-editor.headline-placeholder",
	                    "headline"
	                ),
	                name: "headline",
	                onInput: onHeadlineInput,
	                disabled: !isEditing,
	                minRows: 1,
	                value: headline,}
	            )
	            , headline.length > 100 ? (
	                React$2.createElement('div', { className: "flex-none px-3 tabular-nums text-gray-500"   ,}
	                    , headline.length, "/140"

	                )
	            ) : null
	        )
	    );
	});
	HeadlineInput$1.displayName = "HeadlineInput";

	const TagsInput$1 = () => {
	    const postEditorService = reactExports.useContext(PostComposerContext);
	    const tags = useSelector$1(postEditorService, selectTags$1);
	    const isEditing = useSelector$1(postEditorService, selectIsEditing$5);

	    const { t } = useTranslation();

	    const onTagsChange = reactExports.useCallback(
	        (tags) => {
	            postEditorService.send({ type: "TAGS_INPUT", tags });
	        },
	        [postEditorService]
	    );

	    return (
	        React$2.createElement(TokenInput, {
	            className: "co-editable-body w-full p-0 px-3 leading-none"    ,
	            TokenIcon: ForwardRef$2,
	            tokens: tags,
	            setTokens: onTagsChange,
	            placeholder: t("client:post-editor.tags-placeholder", "#add tags"),
	            disabled: !isEditing,
	            getSuggestions: true,
	            fieldName: "tag",}
	        )
	    );
	};

	const selectEditingTransparentShare$2 = (
	    state
	) => state.context.editingTransparentShare;
	const selectShareOfPostId$1 = (state) =>
	    state.context.shareOfPostId;
	const selectProjectHandle$2 = (state) =>
	    state.context.projectHandle;

	const EditingPanel$1

	 = ({ textAreaRef }) => {
	    const service = reactExports.useContext(PostComposerContext);
	    const { send } = service;

	    const editingTransparentShare = useSelector$1(
	        service,
	        selectEditingTransparentShare$2
	    );
	    const shareOfPostId = useSelector$1(service, selectShareOfPostId$1);
	    const projectHandle = useSelector$1(service, selectProjectHandle$2);

	    const handleFileDrop = reactExports.useCallback(
	        (files) => {
	            files.forEach((file) => send({ type: "SELECT_FILE", file }));
	        },
	        [send]
	    );

	    return (
	        React$2.createElement(DropZone, { handleFileDrop: handleFileDrop,}
	            , React$2.createElement('div', { className: "flex flex-col gap-3 py-3"   ,}
	                , editingTransparentShare && shareOfPostId ? (
	                    React$2.createElement(InfoBox, { className: "!m-3 !w-auto" , level: "post-box-info",}
	                        , React$2.createElement('div', { className: tw`co-prose prose prose-sm`,}
	                            , React$2.createElement('p', null, "Shares without content can't have content added after posting. You "

	                                   , React$2.createElement('b', null, "can"), " edit the tags."
	                            )
	                            , React$2.createElement('p', null, "If you want, you can"
	                                    , " "
	                                , React$2.createElement('a', {
	                                    href: sitemap.public.project
	                                        .composePost({
	                                            projectHandle: projectHandle,
	                                            shareOfPostId: shareOfPostId,
	                                        })
	                                        .toString(),
	                                    target: "_blank",
	                                    rel: "noreferrer",}
	, "share this post again"

	                                ), " ", "and add your content there."

	                            )
	                        )
	                    )
	                ) : (
	                    React$2.createElement(React$2.Fragment, null
	                        , React$2.createElement(HeadlineInput$1, null )
	                        , React$2.createElement(PreviewsFromAttachments, { canRemove: true,} )
	                        , React$2.createElement(BodyInput, { textAreaRef: textAreaRef,} )
	                    )
	                )
	                , React$2.createElement(TagsInput$1, null )
	                , React$2.createElement(CwsInput$1, null )
	            )
	        )
	    );
	};

	var data = {"categories":[{"id":"people","emojis":["grinning","smiley","smile","grin","laughing","sweat_smile","rolling_on_the_floor_laughing","joy","slightly_smiling_face","upside_down_face","melting_face","wink","blush","innocent","smiling_face_with_3_hearts","heart_eyes","star-struck","kissing_heart","kissing","relaxed","kissing_closed_eyes","kissing_smiling_eyes","smiling_face_with_tear","yum","stuck_out_tongue","stuck_out_tongue_winking_eye","zany_face","stuck_out_tongue_closed_eyes","money_mouth_face","hugging_face","face_with_hand_over_mouth","face_with_open_eyes_and_hand_over_mouth","face_with_peeking_eye","shushing_face","thinking_face","saluting_face","zipper_mouth_face","face_with_raised_eyebrow","neutral_face","expressionless","no_mouth","dotted_line_face","face_in_clouds","smirk","unamused","face_with_rolling_eyes","grimacing","face_exhaling","lying_face","shaking_face","relieved","pensive","sleepy","drooling_face","sleeping","mask","face_with_thermometer","face_with_head_bandage","nauseated_face","face_vomiting","sneezing_face","hot_face","cold_face","woozy_face","dizzy_face","face_with_spiral_eyes","exploding_head","face_with_cowboy_hat","partying_face","disguised_face","sunglasses","nerd_face","face_with_monocle","confused","face_with_diagonal_mouth","worried","slightly_frowning_face","white_frowning_face","open_mouth","hushed","astonished","flushed","pleading_face","face_holding_back_tears","frowning","anguished","fearful","cold_sweat","disappointed_relieved","cry","sob","scream","confounded","persevere","disappointed","sweat","weary","tired_face","yawning_face","triumph","rage","angry","face_with_symbols_on_mouth","smiling_imp","imp","skull","skull_and_crossbones","hankey","clown_face","japanese_ogre","japanese_goblin","ghost","alien","space_invader","wave","raised_back_of_hand","raised_hand_with_fingers_splayed","hand","spock-hand","rightwards_hand","leftwards_hand","palm_down_hand","palm_up_hand","leftwards_pushing_hand","rightwards_pushing_hand","ok_hand","pinched_fingers","pinching_hand","v","crossed_fingers","hand_with_index_finger_and_thumb_crossed","i_love_you_hand_sign","the_horns","call_me_hand","point_left","point_right","point_up_2","middle_finger","point_down","point_up","index_pointing_at_the_viewer","+1","-1","fist","facepunch","left-facing_fist","right-facing_fist","clap","raised_hands","heart_hands","open_hands","palms_up_together","handshake","pray","writing_hand","nail_care","selfie","muscle","mechanical_arm","mechanical_leg","leg","foot","ear","ear_with_hearing_aid","nose","brain","anatomical_heart","lungs","tooth","bone","eyes","eye","tongue","lips","biting_lip","baby","child","boy","girl","adult","person_with_blond_hair","man","bearded_person","man_with_beard","woman_with_beard","red_haired_man","curly_haired_man","white_haired_man","bald_man","woman","red_haired_woman","red_haired_person","curly_haired_woman","curly_haired_person","white_haired_woman","white_haired_person","bald_woman","bald_person","blond-haired-woman","blond-haired-man","older_adult","older_man","older_woman","person_frowning","man-frowning","woman-frowning","person_with_pouting_face","man-pouting","woman-pouting","no_good","man-gesturing-no","woman-gesturing-no","ok_woman","man-gesturing-ok","woman-gesturing-ok","information_desk_person","man-tipping-hand","woman-tipping-hand","raising_hand","man-raising-hand","woman-raising-hand","deaf_person","deaf_man","deaf_woman","bow","man-bowing","woman-bowing","face_palm","man-facepalming","woman-facepalming","shrug","man-shrugging","woman-shrugging","health_worker","male-doctor","female-doctor","student","male-student","female-student","teacher","male-teacher","female-teacher","judge","male-judge","female-judge","farmer","male-farmer","female-farmer","cook","male-cook","female-cook","mechanic","male-mechanic","female-mechanic","factory_worker","male-factory-worker","female-factory-worker","office_worker","male-office-worker","female-office-worker","scientist","male-scientist","female-scientist","technologist","male-technologist","female-technologist","singer","male-singer","female-singer","artist","male-artist","female-artist","pilot","male-pilot","female-pilot","astronaut","male-astronaut","female-astronaut","firefighter","male-firefighter","female-firefighter","cop","male-police-officer","female-police-officer","sleuth_or_spy","male-detective","female-detective","guardsman","male-guard","female-guard","ninja","construction_worker","male-construction-worker","female-construction-worker","person_with_crown","prince","princess","man_with_turban","man-wearing-turban","woman-wearing-turban","man_with_gua_pi_mao","person_with_headscarf","person_in_tuxedo","man_in_tuxedo","woman_in_tuxedo","bride_with_veil","man_with_veil","woman_with_veil","pregnant_woman","pregnant_man","pregnant_person","breast-feeding","woman_feeding_baby","man_feeding_baby","person_feeding_baby","angel","santa","mrs_claus","mx_claus","superhero","male_superhero","female_superhero","supervillain","male_supervillain","female_supervillain","mage","male_mage","female_mage","fairy","male_fairy","female_fairy","vampire","male_vampire","female_vampire","merperson","merman","mermaid","elf","male_elf","female_elf","genie","male_genie","female_genie","zombie","male_zombie","female_zombie","troll","massage","man-getting-massage","woman-getting-massage","haircut","man-getting-haircut","woman-getting-haircut","walking","man-walking","woman-walking","standing_person","man_standing","woman_standing","kneeling_person","man_kneeling","woman_kneeling","person_with_probing_cane","man_with_probing_cane","woman_with_probing_cane","person_in_motorized_wheelchair","man_in_motorized_wheelchair","woman_in_motorized_wheelchair","person_in_manual_wheelchair","man_in_manual_wheelchair","woman_in_manual_wheelchair","runner","man-running","woman-running","dancer","man_dancing","man_in_business_suit_levitating","dancers","men-with-bunny-ears-partying","women-with-bunny-ears-partying","person_in_steamy_room","man_in_steamy_room","woman_in_steamy_room","person_climbing","man_climbing","woman_climbing","fencer","horse_racing","skier","snowboarder","golfer","man-golfing","woman-golfing","surfer","man-surfing","woman-surfing","rowboat","man-rowing-boat","woman-rowing-boat","swimmer","man-swimming","woman-swimming","person_with_ball","man-bouncing-ball","woman-bouncing-ball","weight_lifter","man-lifting-weights","woman-lifting-weights","bicyclist","man-biking","woman-biking","mountain_bicyclist","man-mountain-biking","woman-mountain-biking","person_doing_cartwheel","man-cartwheeling","woman-cartwheeling","wrestlers","man-wrestling","woman-wrestling","water_polo","man-playing-water-polo","woman-playing-water-polo","handball","man-playing-handball","woman-playing-handball","juggling","man-juggling","woman-juggling","person_in_lotus_position","man_in_lotus_position","woman_in_lotus_position","bath","sleeping_accommodation","people_holding_hands","two_women_holding_hands","man_and_woman_holding_hands","two_men_holding_hands","couplekiss","woman-kiss-man","man-kiss-man","woman-kiss-woman","couple_with_heart","woman-heart-man","man-heart-man","woman-heart-woman","family","man-woman-boy","man-woman-girl","man-woman-girl-boy","man-woman-boy-boy","man-woman-girl-girl","man-man-boy","man-man-girl","man-man-girl-boy","man-man-boy-boy","man-man-girl-girl","woman-woman-boy","woman-woman-girl","woman-woman-girl-boy","woman-woman-boy-boy","woman-woman-girl-girl","man-boy","man-boy-boy","man-girl","man-girl-boy","man-girl-girl","woman-boy","woman-boy-boy","woman-girl","woman-girl-boy","woman-girl-girl","speaking_head_in_silhouette","bust_in_silhouette","busts_in_silhouette","people_hugging","footprints","robot_face","smiley_cat","smile_cat","joy_cat","heart_eyes_cat","smirk_cat","kissing_cat","scream_cat","crying_cat_face","pouting_cat","see_no_evil","hear_no_evil","speak_no_evil","love_letter","cupid","gift_heart","sparkling_heart","heartpulse","heartbeat","revolving_hearts","two_hearts","heart_decoration","heavy_heart_exclamation_mark_ornament","broken_heart","heart_on_fire","mending_heart","heart","pink_heart","orange_heart","yellow_heart","green_heart","blue_heart","light_blue_heart","purple_heart","brown_heart","black_heart","grey_heart","white_heart","kiss","100","anger","boom","dizzy","sweat_drops","dash","hole","speech_balloon","eye-in-speech-bubble","left_speech_bubble","right_anger_bubble","thought_balloon","zzz"]},{"id":"nature","emojis":["monkey_face","monkey","gorilla","orangutan","dog","dog2","guide_dog","service_dog","poodle","wolf","fox_face","raccoon","cat","cat2","black_cat","lion_face","tiger","tiger2","leopard","horse","moose","donkey","racehorse","unicorn_face","zebra_face","deer","bison","cow","ox","water_buffalo","cow2","pig","pig2","boar","pig_nose","ram","sheep","goat","dromedary_camel","camel","llama","giraffe_face","elephant","mammoth","rhinoceros","hippopotamus","mouse","mouse2","rat","hamster","rabbit","rabbit2","chipmunk","beaver","hedgehog","bat","bear","polar_bear","koala","panda_face","sloth","otter","skunk","kangaroo","badger","feet","turkey","chicken","rooster","hatching_chick","baby_chick","hatched_chick","bird","penguin","dove_of_peace","eagle","duck","swan","owl","dodo","feather","flamingo","peacock","parrot","wing","black_bird","goose","frog","crocodile","turtle","lizard","snake","dragon_face","dragon","sauropod","t-rex","whale","whale2","dolphin","seal","fish","tropical_fish","blowfish","shark","octopus","shell","coral","jellyfish","snail","butterfly","bug","ant","bee","beetle","ladybug","cricket","cockroach","spider","spider_web","scorpion","mosquito","fly","worm","microbe","bouquet","cherry_blossom","white_flower","lotus","rosette","rose","wilted_flower","hibiscus","sunflower","blossom","tulip","hyacinth","seedling","potted_plant","evergreen_tree","deciduous_tree","palm_tree","cactus","ear_of_rice","herb","shamrock","four_leaf_clover","maple_leaf","fallen_leaf","leaves","empty_nest","nest_with_eggs","mushroom"]},{"id":"foods","emojis":["grapes","melon","watermelon","tangerine","lemon","banana","pineapple","mango","apple","green_apple","pear","peach","cherries","strawberry","blueberries","kiwifruit","tomato","olive","coconut","avocado","eggplant","potato","carrot","corn","hot_pepper","bell_pepper","cucumber","leafy_green","broccoli","garlic","onion","peanuts","beans","chestnut","ginger_root","pea_pod","bread","croissant","baguette_bread","flatbread","pretzel","bagel","pancakes","waffle","cheese_wedge","meat_on_bone","poultry_leg","cut_of_meat","bacon","hamburger","fries","pizza","hotdog","sandwich","taco","burrito","tamale","stuffed_flatbread","falafel","egg","fried_egg","shallow_pan_of_food","stew","fondue","bowl_with_spoon","green_salad","popcorn","butter","salt","canned_food","bento","rice_cracker","rice_ball","rice","curry","ramen","spaghetti","sweet_potato","oden","sushi","fried_shrimp","fish_cake","moon_cake","dango","dumpling","fortune_cookie","takeout_box","crab","lobster","shrimp","squid","oyster","icecream","shaved_ice","ice_cream","doughnut","cookie","birthday","cake","cupcake","pie","chocolate_bar","candy","lollipop","custard","honey_pot","baby_bottle","glass_of_milk","coffee","teapot","tea","sake","champagne","wine_glass","cocktail","tropical_drink","beer","beers","clinking_glasses","tumbler_glass","pouring_liquid","cup_with_straw","bubble_tea","beverage_box","mate_drink","ice_cube","chopsticks","knife_fork_plate","fork_and_knife","spoon","hocho","jar","amphora"]},{"id":"activity","emojis":["jack_o_lantern","christmas_tree","fireworks","sparkler","firecracker","sparkles","balloon","tada","confetti_ball","tanabata_tree","bamboo","dolls","flags","wind_chime","rice_scene","red_envelope","ribbon","gift","reminder_ribbon","admission_tickets","ticket","medal","trophy","sports_medal","first_place_medal","second_place_medal","third_place_medal","soccer","baseball","softball","basketball","volleyball","football","rugby_football","tennis","flying_disc","bowling","cricket_bat_and_ball","field_hockey_stick_and_ball","ice_hockey_stick_and_puck","lacrosse","table_tennis_paddle_and_ball","badminton_racquet_and_shuttlecock","boxing_glove","martial_arts_uniform","goal_net","golf","ice_skate","fishing_pole_and_fish","diving_mask","running_shirt_with_sash","ski","sled","curling_stone","dart","yo-yo","kite","gun","8ball","crystal_ball","magic_wand","video_game","joystick","slot_machine","game_die","jigsaw","teddy_bear","pinata","mirror_ball","nesting_dolls","spades","hearts","diamonds","clubs","chess_pawn","black_joker","mahjong","flower_playing_cards","performing_arts","frame_with_picture","art","thread","sewing_needle","yarn","knot"]},{"id":"places","emojis":["earth_africa","earth_americas","earth_asia","globe_with_meridians","world_map","japan","compass","snow_capped_mountain","mountain","volcano","mount_fuji","camping","beach_with_umbrella","desert","desert_island","national_park","stadium","classical_building","building_construction","bricks","rock","wood","hut","house_buildings","derelict_house_building","house","house_with_garden","office","post_office","european_post_office","hospital","bank","hotel","love_hotel","convenience_store","school","department_store","factory","japanese_castle","european_castle","wedding","tokyo_tower","statue_of_liberty","church","mosque","hindu_temple","synagogue","shinto_shrine","kaaba","fountain","tent","foggy","night_with_stars","cityscape","sunrise_over_mountains","sunrise","city_sunset","city_sunrise","bridge_at_night","hotsprings","carousel_horse","playground_slide","ferris_wheel","roller_coaster","barber","circus_tent","steam_locomotive","railway_car","bullettrain_side","bullettrain_front","train2","metro","light_rail","station","tram","monorail","mountain_railway","train","bus","oncoming_bus","trolleybus","minibus","ambulance","fire_engine","police_car","oncoming_police_car","taxi","oncoming_taxi","car","oncoming_automobile","blue_car","pickup_truck","truck","articulated_lorry","tractor","racing_car","racing_motorcycle","motor_scooter","manual_wheelchair","motorized_wheelchair","auto_rickshaw","bike","scooter","skateboard","roller_skate","busstop","motorway","railway_track","oil_drum","fuelpump","wheel","rotating_light","traffic_light","vertical_traffic_light","octagonal_sign","construction","anchor","ring_buoy","boat","canoe","speedboat","passenger_ship","ferry","motor_boat","ship","airplane","small_airplane","airplane_departure","airplane_arriving","parachute","seat","helicopter","suspension_railway","mountain_cableway","aerial_tramway","satellite","rocket","flying_saucer","bellhop_bell","luggage","hourglass","hourglass_flowing_sand","watch","alarm_clock","stopwatch","timer_clock","mantelpiece_clock","clock12","clock1230","clock1","clock130","clock2","clock230","clock3","clock330","clock4","clock430","clock5","clock530","clock6","clock630","clock7","clock730","clock8","clock830","clock9","clock930","clock10","clock1030","clock11","clock1130","new_moon","waxing_crescent_moon","first_quarter_moon","moon","full_moon","waning_gibbous_moon","last_quarter_moon","waning_crescent_moon","crescent_moon","new_moon_with_face","first_quarter_moon_with_face","last_quarter_moon_with_face","thermometer","sunny","full_moon_with_face","sun_with_face","ringed_planet","star","star2","stars","milky_way","cloud","partly_sunny","thunder_cloud_and_rain","mostly_sunny","barely_sunny","partly_sunny_rain","rain_cloud","snow_cloud","lightning","tornado","fog","wind_blowing_face","cyclone","rainbow","closed_umbrella","umbrella","umbrella_with_rain_drops","umbrella_on_ground","zap","snowflake","snowman","snowman_without_snow","comet","fire","droplet","ocean"]},{"id":"objects","emojis":["eyeglasses","dark_sunglasses","goggles","lab_coat","safety_vest","necktie","shirt","jeans","scarf","gloves","coat","socks","dress","kimono","sari","one-piece_swimsuit","briefs","shorts","bikini","womans_clothes","folding_hand_fan","purse","handbag","pouch","shopping_bags","school_satchel","thong_sandal","mans_shoe","athletic_shoe","hiking_boot","womans_flat_shoe","high_heel","sandal","ballet_shoes","boot","hair_pick","crown","womans_hat","tophat","mortar_board","billed_cap","military_helmet","helmet_with_white_cross","prayer_beads","lipstick","ring","gem","mute","speaker","sound","loud_sound","loudspeaker","mega","postal_horn","bell","no_bell","musical_score","musical_note","notes","studio_microphone","level_slider","control_knobs","microphone","headphones","radio","saxophone","accordion","guitar","musical_keyboard","trumpet","violin","banjo","drum_with_drumsticks","long_drum","maracas","flute","iphone","calling","phone","telephone_receiver","pager","fax","battery","low_battery","electric_plug","computer","desktop_computer","printer","keyboard","three_button_mouse","trackball","minidisc","floppy_disk","cd","dvd","abacus","movie_camera","film_frames","film_projector","clapper","tv","camera","camera_with_flash","video_camera","vhs","mag","mag_right","candle","bulb","flashlight","izakaya_lantern","diya_lamp","notebook_with_decorative_cover","closed_book","book","green_book","blue_book","orange_book","books","notebook","ledger","page_with_curl","scroll","page_facing_up","newspaper","rolled_up_newspaper","bookmark_tabs","bookmark","label","moneybag","coin","yen","dollar","euro","pound","money_with_wings","credit_card","receipt","chart","email","e-mail","incoming_envelope","envelope_with_arrow","outbox_tray","inbox_tray","package","mailbox","mailbox_closed","mailbox_with_mail","mailbox_with_no_mail","postbox","ballot_box_with_ballot","pencil2","black_nib","lower_left_fountain_pen","lower_left_ballpoint_pen","lower_left_paintbrush","lower_left_crayon","memo","briefcase","file_folder","open_file_folder","card_index_dividers","date","calendar","spiral_note_pad","spiral_calendar_pad","card_index","chart_with_upwards_trend","chart_with_downwards_trend","bar_chart","clipboard","pushpin","round_pushpin","paperclip","linked_paperclips","straight_ruler","triangular_ruler","scissors","card_file_box","file_cabinet","wastebasket","lock","unlock","lock_with_ink_pen","closed_lock_with_key","key","old_key","hammer","axe","pick","hammer_and_pick","hammer_and_wrench","dagger_knife","crossed_swords","bomb","boomerang","bow_and_arrow","shield","carpentry_saw","wrench","screwdriver","nut_and_bolt","gear","compression","scales","probing_cane","link","chains","hook","toolbox","magnet","ladder","alembic","test_tube","petri_dish","dna","microscope","telescope","satellite_antenna","syringe","drop_of_blood","pill","adhesive_bandage","crutch","stethoscope","x-ray","door","elevator","mirror","window","bed","couch_and_lamp","chair","toilet","plunger","shower","bathtub","mouse_trap","razor","lotion_bottle","safety_pin","broom","basket","roll_of_paper","bucket","soap","bubbles","toothbrush","sponge","fire_extinguisher","shopping_trolley","smoking","coffin","headstone","funeral_urn","nazar_amulet","hamsa","moyai","placard","identification_card"]},{"id":"symbols","emojis":["atm","put_litter_in_its_place","potable_water","wheelchair","mens","womens","restroom","baby_symbol","wc","passport_control","customs","baggage_claim","left_luggage","warning","children_crossing","no_entry","no_entry_sign","no_bicycles","no_smoking","do_not_litter","non-potable_water","no_pedestrians","no_mobile_phones","underage","radioactive_sign","biohazard_sign","arrow_up","arrow_upper_right","arrow_right","arrow_lower_right","arrow_down","arrow_lower_left","arrow_left","arrow_upper_left","arrow_up_down","left_right_arrow","leftwards_arrow_with_hook","arrow_right_hook","arrow_heading_up","arrow_heading_down","arrows_clockwise","arrows_counterclockwise","back","end","on","soon","top","place_of_worship","atom_symbol","om_symbol","star_of_david","wheel_of_dharma","yin_yang","latin_cross","orthodox_cross","star_and_crescent","peace_symbol","menorah_with_nine_branches","six_pointed_star","khanda","aries","taurus","gemini","cancer","leo","virgo","libra","scorpius","sagittarius","capricorn","aquarius","pisces","ophiuchus","twisted_rightwards_arrows","repeat","repeat_one","arrow_forward","fast_forward","black_right_pointing_double_triangle_with_vertical_bar","black_right_pointing_triangle_with_double_vertical_bar","arrow_backward","rewind","black_left_pointing_double_triangle_with_vertical_bar","arrow_up_small","arrow_double_up","arrow_down_small","arrow_double_down","double_vertical_bar","black_square_for_stop","black_circle_for_record","eject","cinema","low_brightness","high_brightness","signal_strength","wireless","vibration_mode","mobile_phone_off","female_sign","male_sign","transgender_symbol","heavy_multiplication_x","heavy_plus_sign","heavy_minus_sign","heavy_division_sign","heavy_equals_sign","infinity","bangbang","interrobang","question","grey_question","grey_exclamation","exclamation","wavy_dash","currency_exchange","heavy_dollar_sign","medical_symbol","recycle","fleur_de_lis","trident","name_badge","beginner","o","white_check_mark","ballot_box_with_check","heavy_check_mark","x","negative_squared_cross_mark","curly_loop","loop","part_alternation_mark","eight_spoked_asterisk","eight_pointed_black_star","sparkle","copyright","registered","tm","hash","keycap_star","zero","one","two","three","four","five","six","seven","eight","nine","keycap_ten","capital_abcd","abcd","1234","symbols","abc","a","ab","b","cl","cool","free","information_source","id","m","new","ng","o2","ok","parking","sos","up","vs","koko","sa","u6708","u6709","u6307","ideograph_advantage","u5272","u7121","u7981","accept","u7533","u5408","u7a7a","congratulations","secret","u55b6","u6e80","red_circle","large_orange_circle","large_yellow_circle","large_green_circle","large_blue_circle","large_purple_circle","large_brown_circle","black_circle","white_circle","large_red_square","large_orange_square","large_yellow_square","large_green_square","large_blue_square","large_purple_square","large_brown_square","black_large_square","white_large_square","black_medium_square","white_medium_square","black_medium_small_square","white_medium_small_square","black_small_square","white_small_square","large_orange_diamond","large_blue_diamond","small_orange_diamond","small_blue_diamond","small_red_triangle","small_red_triangle_down","diamond_shape_with_a_dot_inside","radio_button","white_square_button","black_square_button"]},{"id":"flags","emojis":["checkered_flag","cn","crossed_flags","de","es","flag-ac","flag-ad","flag-ae","flag-af","flag-ag","flag-ai","flag-al","flag-am","flag-ao","flag-aq","flag-ar","flag-as","flag-at","flag-au","flag-aw","flag-ax","flag-az","flag-ba","flag-bb","flag-bd","flag-be","flag-bf","flag-bg","flag-bh","flag-bi","flag-bj","flag-bl","flag-bm","flag-bn","flag-bo","flag-bq","flag-br","flag-bs","flag-bt","flag-bv","flag-bw","flag-by","flag-bz","flag-ca","flag-cc","flag-cd","flag-cf","flag-cg","flag-ch","flag-ci","flag-ck","flag-cl","flag-cm","flag-co","flag-cp","flag-cr","flag-cu","flag-cv","flag-cw","flag-cx","flag-cy","flag-cz","flag-dg","flag-dj","flag-dk","flag-dm","flag-do","flag-dz","flag-ea","flag-ec","flag-ee","flag-eg","flag-eh","flag-england","flag-er","flag-et","flag-eu","flag-fi","flag-fj","flag-fk","flag-fm","flag-fo","flag-ga","flag-gd","flag-ge","flag-gf","flag-gg","flag-gh","flag-gi","flag-gl","flag-gm","flag-gn","flag-gp","flag-gq","flag-gr","flag-gs","flag-gt","flag-gu","flag-gw","flag-gy","flag-hk","flag-hm","flag-hn","flag-hr","flag-ht","flag-hu","flag-ic","flag-id","flag-ie","flag-il","flag-im","flag-in","flag-io","flag-iq","flag-ir","flag-is","flag-je","flag-jm","flag-jo","flag-ke","flag-kg","flag-kh","flag-ki","flag-km","flag-kn","flag-kp","flag-kw","flag-ky","flag-kz","flag-la","flag-lb","flag-lc","flag-li","flag-lk","flag-lr","flag-ls","flag-lt","flag-lu","flag-lv","flag-ly","flag-ma","flag-mc","flag-md","flag-me","flag-mf","flag-mg","flag-mh","flag-mk","flag-ml","flag-mm","flag-mn","flag-mo","flag-mp","flag-mq","flag-mr","flag-ms","flag-mt","flag-mu","flag-mv","flag-mw","flag-mx","flag-my","flag-mz","flag-na","flag-nc","flag-ne","flag-nf","flag-ng","flag-ni","flag-nl","flag-no","flag-np","flag-nr","flag-nu","flag-nz","flag-om","flag-pa","flag-pe","flag-pf","flag-pg","flag-ph","flag-pk","flag-pl","flag-pm","flag-pn","flag-pr","flag-ps","flag-pt","flag-pw","flag-py","flag-qa","flag-re","flag-ro","flag-rs","flag-rw","flag-sa","flag-sb","flag-sc","flag-scotland","flag-sd","flag-se","flag-sg","flag-sh","flag-si","flag-sj","flag-sk","flag-sl","flag-sm","flag-sn","flag-so","flag-sr","flag-ss","flag-st","flag-sv","flag-sx","flag-sy","flag-sz","flag-ta","flag-tc","flag-td","flag-tf","flag-tg","flag-th","flag-tj","flag-tk","flag-tl","flag-tm","flag-tn","flag-to","flag-tr","flag-tt","flag-tv","flag-tw","flag-tz","flag-ua","flag-ug","flag-um","flag-un","flag-uy","flag-uz","flag-va","flag-vc","flag-ve","flag-vg","flag-vi","flag-vn","flag-vu","flag-wales","flag-wf","flag-ws","flag-xk","flag-ye","flag-yt","flag-za","flag-zm","flag-zw","fr","gb","it","jp","kr","pirate_flag","rainbow-flag","ru","transgender_flag","triangular_flag_on_post","us","waving_black_flag","waving_white_flag"]}],"emojis":{"100":{"id":"100","name":"Hundred Points","keywords":["100","score","perfect","numbers","century","exam","quiz","test","pass"],"skins":[{"unified":"1f4af","native":"💯"}],"version":1},"1234":{"id":"1234","name":"Input Numbers","keywords":["1234","blue","square","1","2","3","4"],"skins":[{"unified":"1f522","native":"🔢"}],"version":1},"grinning":{"id":"grinning","name":"Grinning Face","emoticons":[":D"],"keywords":["smile","happy","joy",":D","grin"],"skins":[{"unified":"1f600","native":"😀"}],"version":1},"smiley":{"id":"smiley","name":"Grinning Face with Big Eyes","emoticons":[":)","=)","=-)"],"keywords":["smiley","happy","joy","haha",":D",":)","smile","funny"],"skins":[{"unified":"1f603","native":"😃"}],"version":1},"smile":{"id":"smile","name":"Grinning Face with Smiling Eyes","emoticons":[":)","C:","c:",":D",":-D"],"keywords":["smile","happy","joy","funny","haha","laugh","like",":D",":)"],"skins":[{"unified":"1f604","native":"😄"}],"version":1},"grin":{"id":"grin","name":"Beaming Face with Smiling Eyes","keywords":["grin","happy","smile","joy","kawaii"],"skins":[{"unified":"1f601","native":"😁"}],"version":1},"laughing":{"id":"laughing","name":"Grinning Squinting Face","emoticons":[":>",":->"],"keywords":["laughing","satisfied","happy","joy","lol","haha","glad","XD","laugh"],"skins":[{"unified":"1f606","native":"😆"}],"version":1},"sweat_smile":{"id":"sweat_smile","name":"Grinning Face with Sweat","keywords":["smile","hot","happy","laugh","relief"],"skins":[{"unified":"1f605","native":"😅"}],"version":1},"rolling_on_the_floor_laughing":{"id":"rolling_on_the_floor_laughing","name":"Rolling on the Floor Laughing","keywords":["face","lol","haha","rofl"],"skins":[{"unified":"1f923","native":"🤣"}],"version":3},"joy":{"id":"joy","name":"Face with Tears of Joy","keywords":["cry","weep","happy","happytears","haha"],"skins":[{"unified":"1f602","native":"😂"}],"version":1},"slightly_smiling_face":{"id":"slightly_smiling_face","name":"Slightly Smiling Face","emoticons":[":)","(:",":-)"],"keywords":["smile"],"skins":[{"unified":"1f642","native":"🙂"}],"version":1},"upside_down_face":{"id":"upside_down_face","name":"Upside-Down Face","keywords":["upside","down","flipped","silly","smile"],"skins":[{"unified":"1f643","native":"🙃"}],"version":1},"melting_face":{"id":"melting_face","name":"Melting Face","keywords":["hot","heat"],"skins":[{"unified":"1fae0","native":"🫠"}],"version":14},"wink":{"id":"wink","name":"Winking Face","emoticons":[";)",";-)"],"keywords":["wink","happy","mischievous","secret",";)","smile","eye"],"skins":[{"unified":"1f609","native":"😉"}],"version":1},"blush":{"id":"blush","name":"Smiling Face with Smiling Eyes","emoticons":[":)"],"keywords":["blush","smile","happy","flushed","crush","embarrassed","shy","joy"],"skins":[{"unified":"1f60a","native":"😊"}],"version":1},"innocent":{"id":"innocent","name":"Smiling Face with Halo","keywords":["innocent","angel","heaven"],"skins":[{"unified":"1f607","native":"😇"}],"version":1},"smiling_face_with_3_hearts":{"id":"smiling_face_with_3_hearts","name":"Smiling Face with Hearts","keywords":["3","love","like","affection","valentines","infatuation","crush","adore"],"skins":[{"unified":"1f970","native":"🥰"}],"version":11},"heart_eyes":{"id":"heart_eyes","name":"Smiling Face with Heart-Eyes","keywords":["heart","eyes","love","like","affection","valentines","infatuation","crush"],"skins":[{"unified":"1f60d","native":"😍"}],"version":1},"star-struck":{"id":"star-struck","name":"Star-Struck","keywords":["star","struck","grinning","face","with","eyes","smile","starry"],"skins":[{"unified":"1f929","native":"🤩"}],"version":5},"kissing_heart":{"id":"kissing_heart","name":"Face Blowing a Kiss","emoticons":[":*",":-*"],"keywords":["kissing","heart","love","like","affection","valentines","infatuation"],"skins":[{"unified":"1f618","native":"😘"}],"version":1},"kissing":{"id":"kissing","name":"Kissing Face","keywords":["love","like","3","valentines","infatuation","kiss"],"skins":[{"unified":"1f617","native":"😗"}],"version":1},"relaxed":{"id":"relaxed","name":"Smiling Face","keywords":["relaxed","blush","massage","happiness"],"skins":[{"unified":"263a-fe0f","native":"☺️"}],"version":1},"kissing_closed_eyes":{"id":"kissing_closed_eyes","name":"Kissing Face with Closed Eyes","keywords":["love","like","affection","valentines","infatuation","kiss"],"skins":[{"unified":"1f61a","native":"😚"}],"version":1},"kissing_smiling_eyes":{"id":"kissing_smiling_eyes","name":"Kissing Face with Smiling Eyes","keywords":["affection","valentines","infatuation","kiss"],"skins":[{"unified":"1f619","native":"😙"}],"version":1},"smiling_face_with_tear":{"id":"smiling_face_with_tear","name":"Smiling Face with Tear","keywords":["sad","cry","pretend"],"skins":[{"unified":"1f972","native":"🥲"}],"version":13},"yum":{"id":"yum","name":"Face Savoring Food","keywords":["yum","happy","joy","tongue","smile","silly","yummy","nom","delicious","savouring"],"skins":[{"unified":"1f60b","native":"😋"}],"version":1},"stuck_out_tongue":{"id":"stuck_out_tongue","name":"Face with Tongue","emoticons":[":p",":-p",":P",":-P",":b",":-b"],"keywords":["stuck","out","prank","childish","playful","mischievous","smile"],"skins":[{"unified":"1f61b","native":"😛"}],"version":1},"stuck_out_tongue_winking_eye":{"id":"stuck_out_tongue_winking_eye","name":"Winking Face with Tongue","emoticons":[";p",";-p",";b",";-b",";P",";-P"],"keywords":["stuck","out","eye","prank","childish","playful","mischievous","smile","wink"],"skins":[{"unified":"1f61c","native":"😜"}],"version":1},"zany_face":{"id":"zany_face","name":"Zany Face","keywords":["grinning","with","one","large","and","small","eye","goofy","crazy"],"skins":[{"unified":"1f92a","native":"🤪"}],"version":5},"stuck_out_tongue_closed_eyes":{"id":"stuck_out_tongue_closed_eyes","name":"Squinting Face with Tongue","keywords":["stuck","out","closed","eyes","prank","playful","mischievous","smile"],"skins":[{"unified":"1f61d","native":"😝"}],"version":1},"money_mouth_face":{"id":"money_mouth_face","name":"Money-Mouth Face","keywords":["money","mouth","rich","dollar"],"skins":[{"unified":"1f911","native":"🤑"}],"version":1},"hugging_face":{"id":"hugging_face","name":"Hugging Face","keywords":["smile","hug"],"skins":[{"unified":"1f917","native":"🤗"}],"version":1},"face_with_hand_over_mouth":{"id":"face_with_hand_over_mouth","name":"Face with Hand over Mouth","keywords":["smiling","eyes","and","covering","whoops","shock","surprise"],"skins":[{"unified":"1f92d","native":"🤭"}],"version":5},"face_with_open_eyes_and_hand_over_mouth":{"id":"face_with_open_eyes_and_hand_over_mouth","name":"Face with Open Eyes and Hand over Mouth","keywords":["silence","secret","shock","surprise"],"skins":[{"unified":"1fae2","native":"🫢"}],"version":14},"face_with_peeking_eye":{"id":"face_with_peeking_eye","name":"Face with Peeking Eye","keywords":["scared","frightening","embarrassing","shy"],"skins":[{"unified":"1fae3","native":"🫣"}],"version":14},"shushing_face":{"id":"shushing_face","name":"Shushing Face","keywords":["with","finger","covering","closed","lips","quiet","shhh"],"skins":[{"unified":"1f92b","native":"🤫"}],"version":5},"thinking_face":{"id":"thinking_face","name":"Thinking Face","keywords":["hmmm","think","consider"],"skins":[{"unified":"1f914","native":"🤔"}],"version":1},"saluting_face":{"id":"saluting_face","name":"Saluting Face","keywords":["respect","salute"],"skins":[{"unified":"1fae1","native":"🫡"}],"version":14},"zipper_mouth_face":{"id":"zipper_mouth_face","name":"Zipper-Mouth Face","keywords":["zipper","mouth","sealed","secret"],"skins":[{"unified":"1f910","native":"🤐"}],"version":1},"face_with_raised_eyebrow":{"id":"face_with_raised_eyebrow","name":"Face with Raised Eyebrow","keywords":["one","distrust","scepticism","disapproval","disbelief","surprise"],"skins":[{"unified":"1f928","native":"🤨"}],"version":5},"neutral_face":{"id":"neutral_face","name":"Neutral Face","emoticons":[":|",":-|"],"keywords":["indifference","meh",":",""],"skins":[{"unified":"1f610","native":"😐"}],"version":1},"expressionless":{"id":"expressionless","name":"Expressionless Face","emoticons":["-_-"],"keywords":["indifferent","-","","meh","deadpan"],"skins":[{"unified":"1f611","native":"😑"}],"version":1},"no_mouth":{"id":"no_mouth","name":"Face Without Mouth","keywords":["no","hellokitty"],"skins":[{"unified":"1f636","native":"😶"}],"version":1},"dotted_line_face":{"id":"dotted_line_face","name":"Dotted Line Face","keywords":["invisible","lonely","isolation","depression"],"skins":[{"unified":"1fae5","native":"🫥"}],"version":14},"face_in_clouds":{"id":"face_in_clouds","name":"Face in Clouds","keywords":["shower","steam","dream"],"skins":[{"unified":"1f636-200d-1f32b-fe0f","native":"😶‍🌫️"}],"version":13.1},"smirk":{"id":"smirk","name":"Smirking Face","keywords":["smirk","smile","mean","prank","smug","sarcasm"],"skins":[{"unified":"1f60f","native":"😏"}],"version":1},"unamused":{"id":"unamused","name":"Unamused Face","emoticons":[":("],"keywords":["indifference","bored","straight","serious","sarcasm","unimpressed","skeptical","dubious","side","eye"],"skins":[{"unified":"1f612","native":"😒"}],"version":1},"face_with_rolling_eyes":{"id":"face_with_rolling_eyes","name":"Face with Rolling Eyes","keywords":["eyeroll","frustrated"],"skins":[{"unified":"1f644","native":"🙄"}],"version":1},"grimacing":{"id":"grimacing","name":"Grimacing Face","keywords":["grimace","teeth"],"skins":[{"unified":"1f62c","native":"😬"}],"version":1},"face_exhaling":{"id":"face_exhaling","name":"Face Exhaling","keywords":["relieve","relief","tired","sigh"],"skins":[{"unified":"1f62e-200d-1f4a8","native":"😮‍💨"}],"version":13.1},"lying_face":{"id":"lying_face","name":"Lying Face","keywords":["lie","pinocchio"],"skins":[{"unified":"1f925","native":"🤥"}],"version":3},"shaking_face":{"id":"shaking_face","name":"Shaking Face","keywords":["dizzy","shock","blurry","earthquake"],"skins":[{"unified":"1fae8","native":"🫨"}],"version":15},"relieved":{"id":"relieved","name":"Relieved Face","keywords":["relaxed","phew","massage","happiness"],"skins":[{"unified":"1f60c","native":"😌"}],"version":1},"pensive":{"id":"pensive","name":"Pensive Face","keywords":["sad","depressed","upset"],"skins":[{"unified":"1f614","native":"😔"}],"version":1},"sleepy":{"id":"sleepy","name":"Sleepy Face","keywords":["tired","rest","nap"],"skins":[{"unified":"1f62a","native":"😪"}],"version":1},"drooling_face":{"id":"drooling_face","name":"Drooling Face","keywords":[],"skins":[{"unified":"1f924","native":"🤤"}],"version":3},"sleeping":{"id":"sleeping","name":"Sleeping Face","keywords":["tired","sleepy","night","zzz"],"skins":[{"unified":"1f634","native":"😴"}],"version":1},"mask":{"id":"mask","name":"Face with Medical Mask","keywords":["sick","ill","disease","covid"],"skins":[{"unified":"1f637","native":"😷"}],"version":1},"face_with_thermometer":{"id":"face_with_thermometer","name":"Face with Thermometer","keywords":["sick","temperature","cold","fever","covid"],"skins":[{"unified":"1f912","native":"🤒"}],"version":1},"face_with_head_bandage":{"id":"face_with_head_bandage","name":"Face with Head-Bandage","keywords":["head","bandage","injured","clumsy","hurt"],"skins":[{"unified":"1f915","native":"🤕"}],"version":1},"nauseated_face":{"id":"nauseated_face","name":"Nauseated Face","keywords":["vomit","gross","green","sick","throw","up","ill"],"skins":[{"unified":"1f922","native":"🤢"}],"version":3},"face_vomiting":{"id":"face_vomiting","name":"Face Vomiting","keywords":["with","open","mouth","sick"],"skins":[{"unified":"1f92e","native":"🤮"}],"version":5},"sneezing_face":{"id":"sneezing_face","name":"Sneezing Face","keywords":["gesundheit","sneeze","sick","allergy"],"skins":[{"unified":"1f927","native":"🤧"}],"version":3},"hot_face":{"id":"hot_face","name":"Hot Face","keywords":["feverish","heat","red","sweating"],"skins":[{"unified":"1f975","native":"🥵"}],"version":11},"cold_face":{"id":"cold_face","name":"Cold Face","keywords":["blue","freezing","frozen","frostbite","icicles"],"skins":[{"unified":"1f976","native":"🥶"}],"version":11},"woozy_face":{"id":"woozy_face","name":"Woozy Face","keywords":["dizzy","intoxicated","tipsy","wavy"],"skins":[{"unified":"1f974","native":"🥴"}],"version":11},"dizzy_face":{"id":"dizzy_face","name":"Dizzy Face","keywords":["spent","unconscious","xox"],"skins":[{"unified":"1f635","native":"😵"}],"version":1},"face_with_spiral_eyes":{"id":"face_with_spiral_eyes","name":"Face with Spiral Eyes","keywords":["sick","ill","confused","nauseous","nausea"],"skins":[{"unified":"1f635-200d-1f4ab","native":"😵‍💫"}],"version":13.1},"exploding_head":{"id":"exploding_head","name":"Exploding Head","keywords":["shocked","face","with","mind","blown"],"skins":[{"unified":"1f92f","native":"🤯"}],"version":5},"face_with_cowboy_hat":{"id":"face_with_cowboy_hat","name":"Cowboy Hat Face","keywords":["with","cowgirl"],"skins":[{"unified":"1f920","native":"🤠"}],"version":3},"partying_face":{"id":"partying_face","name":"Partying Face","keywords":["celebration","woohoo"],"skins":[{"unified":"1f973","native":"🥳"}],"version":11},"disguised_face":{"id":"disguised_face","name":"Disguised Face","keywords":["pretent","brows","glasses","moustache"],"skins":[{"unified":"1f978","native":"🥸"}],"version":13},"sunglasses":{"id":"sunglasses","name":"Smiling Face with Sunglasses","emoticons":["8)"],"keywords":["cool","smile","summer","beach","sunglass"],"skins":[{"unified":"1f60e","native":"😎"}],"version":1},"nerd_face":{"id":"nerd_face","name":"Nerd Face","keywords":["nerdy","geek","dork"],"skins":[{"unified":"1f913","native":"🤓"}],"version":1},"face_with_monocle":{"id":"face_with_monocle","name":"Face with Monocle","keywords":["stuffy","wealthy"],"skins":[{"unified":"1f9d0","native":"🧐"}],"version":5},"confused":{"id":"confused","name":"Confused Face","emoticons":[":\\",":-\\",":/",":-/"],"keywords":["indifference","huh","weird","hmmm",":/"],"skins":[{"unified":"1f615","native":"😕"}],"version":1},"face_with_diagonal_mouth":{"id":"face_with_diagonal_mouth","name":"Face with Diagonal Mouth","keywords":["skeptic","confuse","frustrated","indifferent"],"skins":[{"unified":"1fae4","native":"🫤"}],"version":14},"worried":{"id":"worried","name":"Worried Face","keywords":["concern","nervous",":("],"skins":[{"unified":"1f61f","native":"😟"}],"version":1},"slightly_frowning_face":{"id":"slightly_frowning_face","name":"Slightly Frowning Face","keywords":["disappointed","sad","upset"],"skins":[{"unified":"1f641","native":"🙁"}],"version":1},"white_frowning_face":{"id":"white_frowning_face","name":"Frowning Face","keywords":["white","sad","upset","frown"],"skins":[{"unified":"2639-fe0f","native":"☹️"}],"version":1},"open_mouth":{"id":"open_mouth","name":"Face with Open Mouth","emoticons":[":o",":-o",":O",":-O"],"keywords":["surprise","impressed","wow","whoa",":O"],"skins":[{"unified":"1f62e","native":"😮"}],"version":1},"hushed":{"id":"hushed","name":"Hushed Face","keywords":["woo","shh"],"skins":[{"unified":"1f62f","native":"😯"}],"version":1},"astonished":{"id":"astonished","name":"Astonished Face","keywords":["xox","surprised","poisoned"],"skins":[{"unified":"1f632","native":"😲"}],"version":1},"flushed":{"id":"flushed","name":"Flushed Face","keywords":["blush","shy","flattered"],"skins":[{"unified":"1f633","native":"😳"}],"version":1},"pleading_face":{"id":"pleading_face","name":"Pleading Face","keywords":["begging","mercy","cry","tears","sad","grievance"],"skins":[{"unified":"1f97a","native":"🥺"}],"version":11},"face_holding_back_tears":{"id":"face_holding_back_tears","name":"Face Holding Back Tears","keywords":["touched","gratitude","cry"],"skins":[{"unified":"1f979","native":"🥹"}],"version":14},"frowning":{"id":"frowning","name":"Frowning Face with Open Mouth","keywords":["aw","what"],"skins":[{"unified":"1f626","native":"😦"}],"version":1},"anguished":{"id":"anguished","name":"Anguished Face","emoticons":["D:"],"keywords":["stunned","nervous"],"skins":[{"unified":"1f627","native":"😧"}],"version":1},"fearful":{"id":"fearful","name":"Fearful Face","keywords":["scared","terrified","nervous"],"skins":[{"unified":"1f628","native":"😨"}],"version":1},"cold_sweat":{"id":"cold_sweat","name":"Anxious Face with Sweat","keywords":["cold","nervous"],"skins":[{"unified":"1f630","native":"😰"}],"version":1},"disappointed_relieved":{"id":"disappointed_relieved","name":"Sad but Relieved Face","keywords":["disappointed","phew","sweat","nervous"],"skins":[{"unified":"1f625","native":"😥"}],"version":1},"cry":{"id":"cry","name":"Crying Face","emoticons":[":'("],"keywords":["cry","tears","sad","depressed","upset",":'("],"skins":[{"unified":"1f622","native":"😢"}],"version":1},"sob":{"id":"sob","name":"Loudly Crying Face","emoticons":[":'("],"keywords":["sob","cry","tears","sad","upset","depressed"],"skins":[{"unified":"1f62d","native":"😭"}],"version":1},"scream":{"id":"scream","name":"Face Screaming in Fear","keywords":["scream","munch","scared","omg"],"skins":[{"unified":"1f631","native":"😱"}],"version":1},"confounded":{"id":"confounded","name":"Confounded Face","keywords":["confused","sick","unwell","oops",":S"],"skins":[{"unified":"1f616","native":"😖"}],"version":1},"persevere":{"id":"persevere","name":"Persevering Face","keywords":["persevere","sick","no","upset","oops"],"skins":[{"unified":"1f623","native":"😣"}],"version":1},"disappointed":{"id":"disappointed","name":"Disappointed Face","emoticons":["):",":(",":-("],"keywords":["sad","upset","depressed",":("],"skins":[{"unified":"1f61e","native":"😞"}],"version":1},"sweat":{"id":"sweat","name":"Face with Cold Sweat","keywords":["downcast","hot","sad","tired","exercise"],"skins":[{"unified":"1f613","native":"😓"}],"version":1},"weary":{"id":"weary","name":"Weary Face","keywords":["tired","sleepy","sad","frustrated","upset"],"skins":[{"unified":"1f629","native":"😩"}],"version":1},"tired_face":{"id":"tired_face","name":"Tired Face","keywords":["sick","whine","upset","frustrated"],"skins":[{"unified":"1f62b","native":"😫"}],"version":1},"yawning_face":{"id":"yawning_face","name":"Yawning Face","keywords":["tired","sleepy"],"skins":[{"unified":"1f971","native":"🥱"}],"version":12},"triumph":{"id":"triumph","name":"Face with Look of Triumph","keywords":["steam","from","nose","gas","phew","proud","pride"],"skins":[{"unified":"1f624","native":"😤"}],"version":1},"rage":{"id":"rage","name":"Pouting Face","keywords":["rage","angry","mad","hate","despise"],"skins":[{"unified":"1f621","native":"😡"}],"version":1},"angry":{"id":"angry","name":"Angry Face","emoticons":[">:(",">:-("],"keywords":["mad","annoyed","frustrated"],"skins":[{"unified":"1f620","native":"😠"}],"version":1},"face_with_symbols_on_mouth":{"id":"face_with_symbols_on_mouth","name":"Face with Symbols on Mouth","keywords":["serious","covering","swearing","cursing","cussing","profanity","expletive"],"skins":[{"unified":"1f92c","native":"🤬"}],"version":5},"smiling_imp":{"id":"smiling_imp","name":"Smiling Face with Horns","keywords":["imp","devil"],"skins":[{"unified":"1f608","native":"😈"}],"version":1},"imp":{"id":"imp","name":"Imp","keywords":["angry","face","with","horns","devil"],"skins":[{"unified":"1f47f","native":"👿"}],"version":1},"skull":{"id":"skull","name":"Skull","keywords":["dead","skeleton","creepy","death"],"skins":[{"unified":"1f480","native":"💀"}],"version":1},"skull_and_crossbones":{"id":"skull_and_crossbones","name":"Skull and Crossbones","keywords":["poison","danger","deadly","scary","death","pirate","evil"],"skins":[{"unified":"2620-fe0f","native":"☠️"}],"version":1},"hankey":{"id":"hankey","name":"Pile of Poo","keywords":["hankey","poop","shit","shitface","fail","turd"],"skins":[{"unified":"1f4a9","native":"💩"}],"version":1},"clown_face":{"id":"clown_face","name":"Clown Face","keywords":[],"skins":[{"unified":"1f921","native":"🤡"}],"version":3},"japanese_ogre":{"id":"japanese_ogre","name":"Ogre","keywords":["japanese","monster","red","mask","halloween","scary","creepy","devil","demon"],"skins":[{"unified":"1f479","native":"👹"}],"version":1},"japanese_goblin":{"id":"japanese_goblin","name":"Goblin","keywords":["japanese","red","evil","mask","monster","scary","creepy"],"skins":[{"unified":"1f47a","native":"👺"}],"version":1},"ghost":{"id":"ghost","name":"Ghost","keywords":["halloween","spooky","scary"],"skins":[{"unified":"1f47b","native":"👻"}],"version":1},"alien":{"id":"alien","name":"Alien","keywords":["UFO","paul","weird","outer","space"],"skins":[{"unified":"1f47d","native":"👽"}],"version":1},"space_invader":{"id":"space_invader","name":"Alien Monster","keywords":["space","invader","game","arcade","play"],"skins":[{"unified":"1f47e","native":"👾"}],"version":1},"robot_face":{"id":"robot_face","name":"Robot","keywords":["face","computer","machine","bot"],"skins":[{"unified":"1f916","native":"🤖"}],"version":1},"smiley_cat":{"id":"smiley_cat","name":"Grinning Cat","keywords":["smiley","animal","cats","happy","smile"],"skins":[{"unified":"1f63a","native":"😺"}],"version":1},"smile_cat":{"id":"smile_cat","name":"Grinning Cat with Smiling Eyes","keywords":["smile","animal","cats"],"skins":[{"unified":"1f638","native":"😸"}],"version":1},"joy_cat":{"id":"joy_cat","name":"Cat with Tears of Joy","keywords":["animal","cats","haha","happy"],"skins":[{"unified":"1f639","native":"😹"}],"version":1},"heart_eyes_cat":{"id":"heart_eyes_cat","name":"Smiling Cat with Heart-Eyes","keywords":["heart","eyes","animal","love","like","affection","cats","valentines"],"skins":[{"unified":"1f63b","native":"😻"}],"version":1},"smirk_cat":{"id":"smirk_cat","name":"Cat with Wry Smile","keywords":["smirk","animal","cats"],"skins":[{"unified":"1f63c","native":"😼"}],"version":1},"kissing_cat":{"id":"kissing_cat","name":"Kissing Cat","keywords":["animal","cats","kiss"],"skins":[{"unified":"1f63d","native":"😽"}],"version":1},"scream_cat":{"id":"scream_cat","name":"Weary Cat","keywords":["scream","animal","cats","munch","scared"],"skins":[{"unified":"1f640","native":"🙀"}],"version":1},"crying_cat_face":{"id":"crying_cat_face","name":"Crying Cat","keywords":["face","animal","tears","weep","sad","cats","upset","cry"],"skins":[{"unified":"1f63f","native":"😿"}],"version":1},"pouting_cat":{"id":"pouting_cat","name":"Pouting Cat","keywords":["animal","cats"],"skins":[{"unified":"1f63e","native":"😾"}],"version":1},"see_no_evil":{"id":"see_no_evil","name":"See-No-Evil Monkey","keywords":["see","no","evil","animal","nature","haha"],"skins":[{"unified":"1f648","native":"🙈"}],"version":1},"hear_no_evil":{"id":"hear_no_evil","name":"Hear-No-Evil Monkey","keywords":["hear","no","evil","animal","nature"],"skins":[{"unified":"1f649","native":"🙉"}],"version":1},"speak_no_evil":{"id":"speak_no_evil","name":"Speak-No-Evil Monkey","keywords":["speak","no","evil","animal","nature","omg"],"skins":[{"unified":"1f64a","native":"🙊"}],"version":1},"love_letter":{"id":"love_letter","name":"Love Letter","keywords":["email","like","affection","envelope","valentines"],"skins":[{"unified":"1f48c","native":"💌"}],"version":1},"cupid":{"id":"cupid","name":"Heart with Arrow","keywords":["cupid","love","like","affection","valentines"],"skins":[{"unified":"1f498","native":"💘"}],"version":1},"gift_heart":{"id":"gift_heart","name":"Heart with Ribbon","keywords":["gift","love","valentines"],"skins":[{"unified":"1f49d","native":"💝"}],"version":1},"sparkling_heart":{"id":"sparkling_heart","name":"Sparkling Heart","keywords":["love","like","affection","valentines"],"skins":[{"unified":"1f496","native":"💖"}],"version":1},"heartpulse":{"id":"heartpulse","name":"Growing Heart","keywords":["heartpulse","like","love","affection","valentines","pink"],"skins":[{"unified":"1f497","native":"💗"}],"version":1},"heartbeat":{"id":"heartbeat","name":"Beating Heart","keywords":["heartbeat","love","like","affection","valentines","pink"],"skins":[{"unified":"1f493","native":"💓"}],"version":1},"revolving_hearts":{"id":"revolving_hearts","name":"Revolving Hearts","keywords":["love","like","affection","valentines"],"skins":[{"unified":"1f49e","native":"💞"}],"version":1},"two_hearts":{"id":"two_hearts","name":"Two Hearts","keywords":["love","like","affection","valentines","heart"],"skins":[{"unified":"1f495","native":"💕"}],"version":1},"heart_decoration":{"id":"heart_decoration","name":"Heart Decoration","keywords":["purple","square","love","like"],"skins":[{"unified":"1f49f","native":"💟"}],"version":1},"heavy_heart_exclamation_mark_ornament":{"id":"heavy_heart_exclamation_mark_ornament","name":"Heart Exclamation","keywords":["heavy","mark","ornament","decoration","love"],"skins":[{"unified":"2763-fe0f","native":"❣️"}],"version":1},"broken_heart":{"id":"broken_heart","name":"Broken Heart","emoticons":["</3"],"keywords":["sad","sorry","break","heartbreak"],"skins":[{"unified":"1f494","native":"💔"}],"version":1},"heart_on_fire":{"id":"heart_on_fire","name":"Heart on Fire","keywords":["passionate","enthusiastic"],"skins":[{"unified":"2764-fe0f-200d-1f525","native":"❤️‍🔥"}],"version":13.1},"mending_heart":{"id":"mending_heart","name":"Mending Heart","keywords":["broken","bandage","wounded"],"skins":[{"unified":"2764-fe0f-200d-1fa79","native":"❤️‍🩹"}],"version":13.1},"heart":{"id":"heart","name":"Red Heart","emoticons":["<3"],"keywords":["love","like","valentines"],"skins":[{"unified":"2764-fe0f","native":"❤️"}],"version":1},"pink_heart":{"id":"pink_heart","name":"Pink Heart","keywords":["valentines"],"skins":[{"unified":"1fa77","native":"🩷"}],"version":15},"orange_heart":{"id":"orange_heart","name":"Orange Heart","keywords":["love","like","affection","valentines"],"skins":[{"unified":"1f9e1","native":"🧡"}],"version":5},"yellow_heart":{"id":"yellow_heart","name":"Yellow Heart","emoticons":["<3"],"keywords":["love","like","affection","valentines"],"skins":[{"unified":"1f49b","native":"💛"}],"version":1},"green_heart":{"id":"green_heart","name":"Green Heart","emoticons":["<3"],"keywords":["love","like","affection","valentines"],"skins":[{"unified":"1f49a","native":"💚"}],"version":1},"blue_heart":{"id":"blue_heart","name":"Blue Heart","emoticons":["<3"],"keywords":["love","like","affection","valentines"],"skins":[{"unified":"1f499","native":"💙"}],"version":1},"light_blue_heart":{"id":"light_blue_heart","name":"Light Blue Heart","keywords":["ice","baby"],"skins":[{"unified":"1fa75","native":"🩵"}],"version":15},"purple_heart":{"id":"purple_heart","name":"Purple Heart","emoticons":["<3"],"keywords":["love","like","affection","valentines"],"skins":[{"unified":"1f49c","native":"💜"}],"version":1},"brown_heart":{"id":"brown_heart","name":"Brown Heart","keywords":["coffee"],"skins":[{"unified":"1f90e","native":"🤎"}],"version":12},"black_heart":{"id":"black_heart","name":"Black Heart","keywords":["evil"],"skins":[{"unified":"1f5a4","native":"🖤"}],"version":3},"grey_heart":{"id":"grey_heart","name":"Grey Heart","keywords":["silver","monochrome"],"skins":[{"unified":"1fa76","native":"🩶"}],"version":15},"white_heart":{"id":"white_heart","name":"White Heart","keywords":["pure"],"skins":[{"unified":"1f90d","native":"🤍"}],"version":12},"kiss":{"id":"kiss","name":"Kiss Mark","keywords":["face","lips","love","like","affection","valentines"],"skins":[{"unified":"1f48b","native":"💋"}],"version":1},"anger":{"id":"anger","name":"Anger Symbol","keywords":["angry","mad"],"skins":[{"unified":"1f4a2","native":"💢"}],"version":1},"boom":{"id":"boom","name":"Collision","keywords":["boom","bomb","explode","explosion","blown"],"skins":[{"unified":"1f4a5","native":"💥"}],"version":1},"dizzy":{"id":"dizzy","name":"Dizzy","keywords":["star","sparkle","shoot","magic"],"skins":[{"unified":"1f4ab","native":"💫"}],"version":1},"sweat_drops":{"id":"sweat_drops","name":"Sweat Droplets","keywords":["drops","water","drip","oops"],"skins":[{"unified":"1f4a6","native":"💦"}],"version":1},"dash":{"id":"dash","name":"Dash Symbol","keywords":["dashing","away","wind","air","fast","shoo","fart","smoke","puff"],"skins":[{"unified":"1f4a8","native":"💨"}],"version":1},"hole":{"id":"hole","name":"Hole","keywords":["embarrassing"],"skins":[{"unified":"1f573-fe0f","native":"🕳️"}],"version":1},"speech_balloon":{"id":"speech_balloon","name":"Speech Balloon","keywords":["bubble","words","message","talk","chatting"],"skins":[{"unified":"1f4ac","native":"💬"}],"version":1},"eye-in-speech-bubble":{"id":"eye-in-speech-bubble","name":"Eye in Speech Bubble","keywords":["in-speech-bubble","info"],"skins":[{"unified":"1f441-fe0f-200d-1f5e8-fe0f","native":"👁️‍🗨️"}],"version":2},"left_speech_bubble":{"id":"left_speech_bubble","name":"Left Speech Bubble","keywords":["words","message","talk","chatting"],"skins":[{"unified":"1f5e8-fe0f","native":"🗨️"}],"version":2},"right_anger_bubble":{"id":"right_anger_bubble","name":"Right Anger Bubble","keywords":["caption","speech","thinking","mad"],"skins":[{"unified":"1f5ef-fe0f","native":"🗯️"}],"version":1},"thought_balloon":{"id":"thought_balloon","name":"Thought Balloon","keywords":["bubble","cloud","speech","thinking","dream"],"skins":[{"unified":"1f4ad","native":"💭"}],"version":1},"zzz":{"id":"zzz","name":"Zzz","keywords":["sleepy","tired","dream"],"skins":[{"unified":"1f4a4","native":"💤"}],"version":1},"wave":{"id":"wave","name":"Waving Hand","keywords":["wave","hands","gesture","goodbye","solong","farewell","hello","hi","palm"],"skins":[{"unified":"1f44b","native":"👋"},{"unified":"1f44b-1f3fb","native":"👋🏻"},{"unified":"1f44b-1f3fc","native":"👋🏼"},{"unified":"1f44b-1f3fd","native":"👋🏽"},{"unified":"1f44b-1f3fe","native":"👋🏾"},{"unified":"1f44b-1f3ff","native":"👋🏿"}],"version":1},"raised_back_of_hand":{"id":"raised_back_of_hand","name":"Raised Back of Hand","keywords":["fingers","backhand"],"skins":[{"unified":"1f91a","native":"🤚"},{"unified":"1f91a-1f3fb","native":"🤚🏻"},{"unified":"1f91a-1f3fc","native":"🤚🏼"},{"unified":"1f91a-1f3fd","native":"🤚🏽"},{"unified":"1f91a-1f3fe","native":"🤚🏾"},{"unified":"1f91a-1f3ff","native":"🤚🏿"}],"version":3},"raised_hand_with_fingers_splayed":{"id":"raised_hand_with_fingers_splayed","name":"Hand with Fingers Splayed","keywords":["raised","palm"],"skins":[{"unified":"1f590-fe0f","native":"🖐️"},{"unified":"1f590-1f3fb","native":"🖐🏻"},{"unified":"1f590-1f3fc","native":"🖐🏼"},{"unified":"1f590-1f3fd","native":"🖐🏽"},{"unified":"1f590-1f3fe","native":"🖐🏾"},{"unified":"1f590-1f3ff","native":"🖐🏿"}],"version":1},"hand":{"id":"hand","name":"Raised Hand","keywords":["fingers","stop","highfive","high","five","palm","ban"],"skins":[{"unified":"270b","native":"✋"},{"unified":"270b-1f3fb","native":"✋🏻"},{"unified":"270b-1f3fc","native":"✋🏼"},{"unified":"270b-1f3fd","native":"✋🏽"},{"unified":"270b-1f3fe","native":"✋🏾"},{"unified":"270b-1f3ff","native":"✋🏿"}],"version":1},"spock-hand":{"id":"spock-hand","name":"Vulcan Salute","keywords":["spock","hand","fingers","star","trek"],"skins":[{"unified":"1f596","native":"🖖"},{"unified":"1f596-1f3fb","native":"🖖🏻"},{"unified":"1f596-1f3fc","native":"🖖🏼"},{"unified":"1f596-1f3fd","native":"🖖🏽"},{"unified":"1f596-1f3fe","native":"🖖🏾"},{"unified":"1f596-1f3ff","native":"🖖🏿"}],"version":1},"rightwards_hand":{"id":"rightwards_hand","name":"Rightwards Hand","keywords":["palm","offer"],"skins":[{"unified":"1faf1","native":"🫱"},{"unified":"1faf1-1f3fb","native":"🫱🏻"},{"unified":"1faf1-1f3fc","native":"🫱🏼"},{"unified":"1faf1-1f3fd","native":"🫱🏽"},{"unified":"1faf1-1f3fe","native":"🫱🏾"},{"unified":"1faf1-1f3ff","native":"🫱🏿"}],"version":14},"leftwards_hand":{"id":"leftwards_hand","name":"Leftwards Hand","keywords":["palm","offer"],"skins":[{"unified":"1faf2","native":"🫲"},{"unified":"1faf2-1f3fb","native":"🫲🏻"},{"unified":"1faf2-1f3fc","native":"🫲🏼"},{"unified":"1faf2-1f3fd","native":"🫲🏽"},{"unified":"1faf2-1f3fe","native":"🫲🏾"},{"unified":"1faf2-1f3ff","native":"🫲🏿"}],"version":14},"palm_down_hand":{"id":"palm_down_hand","name":"Palm Down Hand","keywords":["drop"],"skins":[{"unified":"1faf3","native":"🫳"},{"unified":"1faf3-1f3fb","native":"🫳🏻"},{"unified":"1faf3-1f3fc","native":"🫳🏼"},{"unified":"1faf3-1f3fd","native":"🫳🏽"},{"unified":"1faf3-1f3fe","native":"🫳🏾"},{"unified":"1faf3-1f3ff","native":"🫳🏿"}],"version":14},"palm_up_hand":{"id":"palm_up_hand","name":"Palm Up Hand","keywords":["lift","offer","demand"],"skins":[{"unified":"1faf4","native":"🫴"},{"unified":"1faf4-1f3fb","native":"🫴🏻"},{"unified":"1faf4-1f3fc","native":"🫴🏼"},{"unified":"1faf4-1f3fd","native":"🫴🏽"},{"unified":"1faf4-1f3fe","native":"🫴🏾"},{"unified":"1faf4-1f3ff","native":"🫴🏿"}],"version":14},"leftwards_pushing_hand":{"id":"leftwards_pushing_hand","name":"Leftwards Pushing Hand","keywords":["highfive","high","five","pressing","stop"],"skins":[{"unified":"1faf7","native":"🫷"},{"unified":"1faf7-1f3fb","native":"🫷🏻"},{"unified":"1faf7-1f3fc","native":"🫷🏼"},{"unified":"1faf7-1f3fd","native":"🫷🏽"},{"unified":"1faf7-1f3fe","native":"🫷🏾"},{"unified":"1faf7-1f3ff","native":"🫷🏿"}],"version":15},"rightwards_pushing_hand":{"id":"rightwards_pushing_hand","name":"Rightwards Pushing Hand","keywords":["highfive","high","five","pressing","stop"],"skins":[{"unified":"1faf8","native":"🫸"},{"unified":"1faf8-1f3fb","native":"🫸🏻"},{"unified":"1faf8-1f3fc","native":"🫸🏼"},{"unified":"1faf8-1f3fd","native":"🫸🏽"},{"unified":"1faf8-1f3fe","native":"🫸🏾"},{"unified":"1faf8-1f3ff","native":"🫸🏿"}],"version":15},"ok_hand":{"id":"ok_hand","name":"Ok Hand","keywords":["fingers","limbs","perfect","okay"],"skins":[{"unified":"1f44c","native":"👌"},{"unified":"1f44c-1f3fb","native":"👌🏻"},{"unified":"1f44c-1f3fc","native":"👌🏼"},{"unified":"1f44c-1f3fd","native":"👌🏽"},{"unified":"1f44c-1f3fe","native":"👌🏾"},{"unified":"1f44c-1f3ff","native":"👌🏿"}],"version":1},"pinched_fingers":{"id":"pinched_fingers","name":"Pinched Fingers","keywords":["size","tiny","small"],"skins":[{"unified":"1f90c","native":"🤌"},{"unified":"1f90c-1f3fb","native":"🤌🏻"},{"unified":"1f90c-1f3fc","native":"🤌🏼"},{"unified":"1f90c-1f3fd","native":"🤌🏽"},{"unified":"1f90c-1f3fe","native":"🤌🏾"},{"unified":"1f90c-1f3ff","native":"🤌🏿"}],"version":13},"pinching_hand":{"id":"pinching_hand","name":"Pinching Hand","keywords":["tiny","small","size"],"skins":[{"unified":"1f90f","native":"🤏"},{"unified":"1f90f-1f3fb","native":"🤏🏻"},{"unified":"1f90f-1f3fc","native":"🤏🏼"},{"unified":"1f90f-1f3fd","native":"🤏🏽"},{"unified":"1f90f-1f3fe","native":"🤏🏾"},{"unified":"1f90f-1f3ff","native":"🤏🏿"}],"version":12},"v":{"id":"v","name":"Victory Hand","keywords":["v","fingers","ohyeah","peace","two"],"skins":[{"unified":"270c-fe0f","native":"✌️"},{"unified":"270c-1f3fb","native":"✌🏻"},{"unified":"270c-1f3fc","native":"✌🏼"},{"unified":"270c-1f3fd","native":"✌🏽"},{"unified":"270c-1f3fe","native":"✌🏾"},{"unified":"270c-1f3ff","native":"✌🏿"}],"version":1},"crossed_fingers":{"id":"crossed_fingers","name":"Crossed Fingers","keywords":["hand","with","index","and","middle","good","lucky"],"skins":[{"unified":"1f91e","native":"🤞"},{"unified":"1f91e-1f3fb","native":"🤞🏻"},{"unified":"1f91e-1f3fc","native":"🤞🏼"},{"unified":"1f91e-1f3fd","native":"🤞🏽"},{"unified":"1f91e-1f3fe","native":"🤞🏾"},{"unified":"1f91e-1f3ff","native":"🤞🏿"}],"version":3},"hand_with_index_finger_and_thumb_crossed":{"id":"hand_with_index_finger_and_thumb_crossed","name":"Hand with Index Finger and Thumb Crossed","keywords":["heart","love","money","expensive"],"skins":[{"unified":"1faf0","native":"🫰"},{"unified":"1faf0-1f3fb","native":"🫰🏻"},{"unified":"1faf0-1f3fc","native":"🫰🏼"},{"unified":"1faf0-1f3fd","native":"🫰🏽"},{"unified":"1faf0-1f3fe","native":"🫰🏾"},{"unified":"1faf0-1f3ff","native":"🫰🏿"}],"version":14},"i_love_you_hand_sign":{"id":"i_love_you_hand_sign","name":"Love-You Gesture","keywords":["i","love","you","hand","sign","fingers"],"skins":[{"unified":"1f91f","native":"🤟"},{"unified":"1f91f-1f3fb","native":"🤟🏻"},{"unified":"1f91f-1f3fc","native":"🤟🏼"},{"unified":"1f91f-1f3fd","native":"🤟🏽"},{"unified":"1f91f-1f3fe","native":"🤟🏾"},{"unified":"1f91f-1f3ff","native":"🤟🏿"}],"version":5},"the_horns":{"id":"the_horns","name":"Sign of the Horns","keywords":["hand","fingers","evil","eye","rock","on"],"skins":[{"unified":"1f918","native":"🤘"},{"unified":"1f918-1f3fb","native":"🤘🏻"},{"unified":"1f918-1f3fc","native":"🤘🏼"},{"unified":"1f918-1f3fd","native":"🤘🏽"},{"unified":"1f918-1f3fe","native":"🤘🏾"},{"unified":"1f918-1f3ff","native":"🤘🏿"}],"version":1},"call_me_hand":{"id":"call_me_hand","name":"Call Me Hand","keywords":["hands","gesture","shaka"],"skins":[{"unified":"1f919","native":"🤙"},{"unified":"1f919-1f3fb","native":"🤙🏻"},{"unified":"1f919-1f3fc","native":"🤙🏼"},{"unified":"1f919-1f3fd","native":"🤙🏽"},{"unified":"1f919-1f3fe","native":"🤙🏾"},{"unified":"1f919-1f3ff","native":"🤙🏿"}],"version":3},"point_left":{"id":"point_left","name":"Backhand Index Pointing Left","keywords":["point","direction","fingers","hand"],"skins":[{"unified":"1f448","native":"👈"},{"unified":"1f448-1f3fb","native":"👈🏻"},{"unified":"1f448-1f3fc","native":"👈🏼"},{"unified":"1f448-1f3fd","native":"👈🏽"},{"unified":"1f448-1f3fe","native":"👈🏾"},{"unified":"1f448-1f3ff","native":"👈🏿"}],"version":1},"point_right":{"id":"point_right","name":"Backhand Index Pointing Right","keywords":["point","fingers","hand","direction"],"skins":[{"unified":"1f449","native":"👉"},{"unified":"1f449-1f3fb","native":"👉🏻"},{"unified":"1f449-1f3fc","native":"👉🏼"},{"unified":"1f449-1f3fd","native":"👉🏽"},{"unified":"1f449-1f3fe","native":"👉🏾"},{"unified":"1f449-1f3ff","native":"👉🏿"}],"version":1},"point_up_2":{"id":"point_up_2","name":"Backhand Index Pointing Up","keywords":["point","2","fingers","hand","direction"],"skins":[{"unified":"1f446","native":"👆"},{"unified":"1f446-1f3fb","native":"👆🏻"},{"unified":"1f446-1f3fc","native":"👆🏼"},{"unified":"1f446-1f3fd","native":"👆🏽"},{"unified":"1f446-1f3fe","native":"👆🏾"},{"unified":"1f446-1f3ff","native":"👆🏿"}],"version":1},"middle_finger":{"id":"middle_finger","name":"Middle Finger","keywords":["reversed","hand","with","extended","fingers","rude","flipping"],"skins":[{"unified":"1f595","native":"🖕"},{"unified":"1f595-1f3fb","native":"🖕🏻"},{"unified":"1f595-1f3fc","native":"🖕🏼"},{"unified":"1f595-1f3fd","native":"🖕🏽"},{"unified":"1f595-1f3fe","native":"🖕🏾"},{"unified":"1f595-1f3ff","native":"🖕🏿"}],"version":1},"point_down":{"id":"point_down","name":"Backhand Index Pointing Down","keywords":["point","fingers","hand","direction"],"skins":[{"unified":"1f447","native":"👇"},{"unified":"1f447-1f3fb","native":"👇🏻"},{"unified":"1f447-1f3fc","native":"👇🏼"},{"unified":"1f447-1f3fd","native":"👇🏽"},{"unified":"1f447-1f3fe","native":"👇🏾"},{"unified":"1f447-1f3ff","native":"👇🏿"}],"version":1},"point_up":{"id":"point_up","name":"Index Pointing Up","keywords":["point","hand","fingers","direction"],"skins":[{"unified":"261d-fe0f","native":"☝️"},{"unified":"261d-1f3fb","native":"☝🏻"},{"unified":"261d-1f3fc","native":"☝🏼"},{"unified":"261d-1f3fd","native":"☝🏽"},{"unified":"261d-1f3fe","native":"☝🏾"},{"unified":"261d-1f3ff","native":"☝🏿"}],"version":1},"index_pointing_at_the_viewer":{"id":"index_pointing_at_the_viewer","name":"Index Pointing at the Viewer","keywords":["you","recruit"],"skins":[{"unified":"1faf5","native":"🫵"},{"unified":"1faf5-1f3fb","native":"🫵🏻"},{"unified":"1faf5-1f3fc","native":"🫵🏼"},{"unified":"1faf5-1f3fd","native":"🫵🏽"},{"unified":"1faf5-1f3fe","native":"🫵🏾"},{"unified":"1faf5-1f3ff","native":"🫵🏿"}],"version":14},"+1":{"id":"+1","name":"Thumbs Up","keywords":["+1","thumbsup","yes","awesome","good","agree","accept","cool","hand","like"],"skins":[{"unified":"1f44d","native":"👍"},{"unified":"1f44d-1f3fb","native":"👍🏻"},{"unified":"1f44d-1f3fc","native":"👍🏼"},{"unified":"1f44d-1f3fd","native":"👍🏽"},{"unified":"1f44d-1f3fe","native":"👍🏾"},{"unified":"1f44d-1f3ff","native":"👍🏿"}],"version":1},"-1":{"id":"-1","name":"Thumbs Down","keywords":["-1","thumbsdown","no","dislike","hand"],"skins":[{"unified":"1f44e","native":"👎"},{"unified":"1f44e-1f3fb","native":"👎🏻"},{"unified":"1f44e-1f3fc","native":"👎🏼"},{"unified":"1f44e-1f3fd","native":"👎🏽"},{"unified":"1f44e-1f3fe","native":"👎🏾"},{"unified":"1f44e-1f3ff","native":"👎🏿"}],"version":1},"fist":{"id":"fist","name":"Raised Fist","keywords":["fingers","hand","grasp"],"skins":[{"unified":"270a","native":"✊"},{"unified":"270a-1f3fb","native":"✊🏻"},{"unified":"270a-1f3fc","native":"✊🏼"},{"unified":"270a-1f3fd","native":"✊🏽"},{"unified":"270a-1f3fe","native":"✊🏾"},{"unified":"270a-1f3ff","native":"✊🏿"}],"version":1},"facepunch":{"id":"facepunch","name":"Oncoming Fist","keywords":["facepunch","punch","angry","violence","hit","attack","hand"],"skins":[{"unified":"1f44a","native":"👊"},{"unified":"1f44a-1f3fb","native":"👊🏻"},{"unified":"1f44a-1f3fc","native":"👊🏼"},{"unified":"1f44a-1f3fd","native":"👊🏽"},{"unified":"1f44a-1f3fe","native":"👊🏾"},{"unified":"1f44a-1f3ff","native":"👊🏿"}],"version":1},"left-facing_fist":{"id":"left-facing_fist","name":"Left-Facing Fist","keywords":["left","facing","hand","fistbump"],"skins":[{"unified":"1f91b","native":"🤛"},{"unified":"1f91b-1f3fb","native":"🤛🏻"},{"unified":"1f91b-1f3fc","native":"🤛🏼"},{"unified":"1f91b-1f3fd","native":"🤛🏽"},{"unified":"1f91b-1f3fe","native":"🤛🏾"},{"unified":"1f91b-1f3ff","native":"🤛🏿"}],"version":3},"right-facing_fist":{"id":"right-facing_fist","name":"Right-Facing Fist","keywords":["right","facing","hand","fistbump"],"skins":[{"unified":"1f91c","native":"🤜"},{"unified":"1f91c-1f3fb","native":"🤜🏻"},{"unified":"1f91c-1f3fc","native":"🤜🏼"},{"unified":"1f91c-1f3fd","native":"🤜🏽"},{"unified":"1f91c-1f3fe","native":"🤜🏾"},{"unified":"1f91c-1f3ff","native":"🤜🏿"}],"version":3},"clap":{"id":"clap","name":"Clapping Hands","keywords":["clap","praise","applause","congrats","yay"],"skins":[{"unified":"1f44f","native":"👏"},{"unified":"1f44f-1f3fb","native":"👏🏻"},{"unified":"1f44f-1f3fc","native":"👏🏼"},{"unified":"1f44f-1f3fd","native":"👏🏽"},{"unified":"1f44f-1f3fe","native":"👏🏾"},{"unified":"1f44f-1f3ff","native":"👏🏿"}],"version":1},"raised_hands":{"id":"raised_hands","name":"Raising Hands","keywords":["raised","gesture","hooray","yea","celebration"],"skins":[{"unified":"1f64c","native":"🙌"},{"unified":"1f64c-1f3fb","native":"🙌🏻"},{"unified":"1f64c-1f3fc","native":"🙌🏼"},{"unified":"1f64c-1f3fd","native":"🙌🏽"},{"unified":"1f64c-1f3fe","native":"🙌🏾"},{"unified":"1f64c-1f3ff","native":"🙌🏿"}],"version":1},"heart_hands":{"id":"heart_hands","name":"Heart Hands","keywords":["love","appreciation","support"],"skins":[{"unified":"1faf6","native":"🫶"},{"unified":"1faf6-1f3fb","native":"🫶🏻"},{"unified":"1faf6-1f3fc","native":"🫶🏼"},{"unified":"1faf6-1f3fd","native":"🫶🏽"},{"unified":"1faf6-1f3fe","native":"🫶🏾"},{"unified":"1faf6-1f3ff","native":"🫶🏿"}],"version":14},"open_hands":{"id":"open_hands","name":"Open Hands","keywords":["fingers","butterfly"],"skins":[{"unified":"1f450","native":"👐"},{"unified":"1f450-1f3fb","native":"👐🏻"},{"unified":"1f450-1f3fc","native":"👐🏼"},{"unified":"1f450-1f3fd","native":"👐🏽"},{"unified":"1f450-1f3fe","native":"👐🏾"},{"unified":"1f450-1f3ff","native":"👐🏿"}],"version":1},"palms_up_together":{"id":"palms_up_together","name":"Palms Up Together","keywords":["hands","gesture","cupped","prayer"],"skins":[{"unified":"1f932","native":"🤲"},{"unified":"1f932-1f3fb","native":"🤲🏻"},{"unified":"1f932-1f3fc","native":"🤲🏼"},{"unified":"1f932-1f3fd","native":"🤲🏽"},{"unified":"1f932-1f3fe","native":"🤲🏾"},{"unified":"1f932-1f3ff","native":"🤲🏿"}],"version":5},"handshake":{"id":"handshake","name":"Handshake","keywords":["agreement","shake"],"skins":[{"unified":"1f91d","native":"🤝"},{"unified":"1f91d-1f3fb","native":"🤝🏻"},{"unified":"1f91d-1f3fc","native":"🤝🏼"},{"unified":"1f91d-1f3fd","native":"🤝🏽"},{"unified":"1f91d-1f3fe","native":"🤝🏾"},{"unified":"1f91d-1f3ff","native":"🤝🏿"}],"version":3},"pray":{"id":"pray","name":"Folded Hands","keywords":["pray","please","hope","wish","namaste","highfive","high","five","thank","you","thanks","appreciate"],"skins":[{"unified":"1f64f","native":"🙏"},{"unified":"1f64f-1f3fb","native":"🙏🏻"},{"unified":"1f64f-1f3fc","native":"🙏🏼"},{"unified":"1f64f-1f3fd","native":"🙏🏽"},{"unified":"1f64f-1f3fe","native":"🙏🏾"},{"unified":"1f64f-1f3ff","native":"🙏🏿"}],"version":1},"writing_hand":{"id":"writing_hand","name":"Writing Hand","keywords":["lower","left","ballpoint","pen","stationery","write","compose"],"skins":[{"unified":"270d-fe0f","native":"✍️"},{"unified":"270d-1f3fb","native":"✍🏻"},{"unified":"270d-1f3fc","native":"✍🏼"},{"unified":"270d-1f3fd","native":"✍🏽"},{"unified":"270d-1f3fe","native":"✍🏾"},{"unified":"270d-1f3ff","native":"✍🏿"}],"version":1},"nail_care":{"id":"nail_care","name":"Nail Polish","keywords":["care","beauty","manicure","finger","fashion"],"skins":[{"unified":"1f485","native":"💅"},{"unified":"1f485-1f3fb","native":"💅🏻"},{"unified":"1f485-1f3fc","native":"💅🏼"},{"unified":"1f485-1f3fd","native":"💅🏽"},{"unified":"1f485-1f3fe","native":"💅🏾"},{"unified":"1f485-1f3ff","native":"💅🏿"}],"version":1},"selfie":{"id":"selfie","name":"Selfie","keywords":["camera","phone"],"skins":[{"unified":"1f933","native":"🤳"},{"unified":"1f933-1f3fb","native":"🤳🏻"},{"unified":"1f933-1f3fc","native":"🤳🏼"},{"unified":"1f933-1f3fd","native":"🤳🏽"},{"unified":"1f933-1f3fe","native":"🤳🏾"},{"unified":"1f933-1f3ff","native":"🤳🏿"}],"version":3},"muscle":{"id":"muscle","name":"Flexed Biceps","keywords":["muscle","arm","flex","hand","summer","strong"],"skins":[{"unified":"1f4aa","native":"💪"},{"unified":"1f4aa-1f3fb","native":"💪🏻"},{"unified":"1f4aa-1f3fc","native":"💪🏼"},{"unified":"1f4aa-1f3fd","native":"💪🏽"},{"unified":"1f4aa-1f3fe","native":"💪🏾"},{"unified":"1f4aa-1f3ff","native":"💪🏿"}],"version":1},"mechanical_arm":{"id":"mechanical_arm","name":"Mechanical Arm","keywords":["accessibility"],"skins":[{"unified":"1f9be","native":"🦾"}],"version":12},"mechanical_leg":{"id":"mechanical_leg","name":"Mechanical Leg","keywords":["accessibility"],"skins":[{"unified":"1f9bf","native":"🦿"}],"version":12},"leg":{"id":"leg","name":"Leg","keywords":["kick","limb"],"skins":[{"unified":"1f9b5","native":"🦵"},{"unified":"1f9b5-1f3fb","native":"🦵🏻"},{"unified":"1f9b5-1f3fc","native":"🦵🏼"},{"unified":"1f9b5-1f3fd","native":"🦵🏽"},{"unified":"1f9b5-1f3fe","native":"🦵🏾"},{"unified":"1f9b5-1f3ff","native":"🦵🏿"}],"version":11},"foot":{"id":"foot","name":"Foot","keywords":["kick","stomp"],"skins":[{"unified":"1f9b6","native":"🦶"},{"unified":"1f9b6-1f3fb","native":"🦶🏻"},{"unified":"1f9b6-1f3fc","native":"🦶🏼"},{"unified":"1f9b6-1f3fd","native":"🦶🏽"},{"unified":"1f9b6-1f3fe","native":"🦶🏾"},{"unified":"1f9b6-1f3ff","native":"🦶🏿"}],"version":11},"ear":{"id":"ear","name":"Ear","keywords":["face","hear","sound","listen"],"skins":[{"unified":"1f442","native":"👂"},{"unified":"1f442-1f3fb","native":"👂🏻"},{"unified":"1f442-1f3fc","native":"👂🏼"},{"unified":"1f442-1f3fd","native":"👂🏽"},{"unified":"1f442-1f3fe","native":"👂🏾"},{"unified":"1f442-1f3ff","native":"👂🏿"}],"version":1},"ear_with_hearing_aid":{"id":"ear_with_hearing_aid","name":"Ear with Hearing Aid","keywords":["accessibility"],"skins":[{"unified":"1f9bb","native":"🦻"},{"unified":"1f9bb-1f3fb","native":"🦻🏻"},{"unified":"1f9bb-1f3fc","native":"🦻🏼"},{"unified":"1f9bb-1f3fd","native":"🦻🏽"},{"unified":"1f9bb-1f3fe","native":"🦻🏾"},{"unified":"1f9bb-1f3ff","native":"🦻🏿"}],"version":12},"nose":{"id":"nose","name":"Nose","keywords":["smell","sniff"],"skins":[{"unified":"1f443","native":"👃"},{"unified":"1f443-1f3fb","native":"👃🏻"},{"unified":"1f443-1f3fc","native":"👃🏼"},{"unified":"1f443-1f3fd","native":"👃🏽"},{"unified":"1f443-1f3fe","native":"👃🏾"},{"unified":"1f443-1f3ff","native":"👃🏿"}],"version":1},"brain":{"id":"brain","name":"Brain","keywords":["smart","intelligent"],"skins":[{"unified":"1f9e0","native":"🧠"}],"version":5},"anatomical_heart":{"id":"anatomical_heart","name":"Anatomical Heart","keywords":["health","heartbeat"],"skins":[{"unified":"1fac0","native":"🫀"}],"version":13},"lungs":{"id":"lungs","name":"Lungs","keywords":["breathe"],"skins":[{"unified":"1fac1","native":"🫁"}],"version":13},"tooth":{"id":"tooth","name":"Tooth","keywords":["teeth","dentist"],"skins":[{"unified":"1f9b7","native":"🦷"}],"version":11},"bone":{"id":"bone","name":"Bone","keywords":["skeleton"],"skins":[{"unified":"1f9b4","native":"🦴"}],"version":11},"eyes":{"id":"eyes","name":"Eyes","keywords":["look","watch","stalk","peek","see"],"skins":[{"unified":"1f440","native":"👀"}],"version":1},"eye":{"id":"eye","name":"Eye","keywords":["face","look","see","watch","stare"],"skins":[{"unified":"1f441-fe0f","native":"👁️"}],"version":1},"tongue":{"id":"tongue","name":"Tongue","keywords":["mouth","playful"],"skins":[{"unified":"1f445","native":"👅"}],"version":1},"lips":{"id":"lips","name":"Mouth","keywords":["lips","kiss"],"skins":[{"unified":"1f444","native":"👄"}],"version":1},"biting_lip":{"id":"biting_lip","name":"Biting Lip","keywords":["flirt","sexy","pain","worry"],"skins":[{"unified":"1fae6","native":"🫦"}],"version":14},"baby":{"id":"baby","name":"Baby","keywords":["child","boy","girl","toddler"],"skins":[{"unified":"1f476","native":"👶"},{"unified":"1f476-1f3fb","native":"👶🏻"},{"unified":"1f476-1f3fc","native":"👶🏼"},{"unified":"1f476-1f3fd","native":"👶🏽"},{"unified":"1f476-1f3fe","native":"👶🏾"},{"unified":"1f476-1f3ff","native":"👶🏿"}],"version":1},"child":{"id":"child","name":"Child","keywords":["gender","neutral","young"],"skins":[{"unified":"1f9d2","native":"🧒"},{"unified":"1f9d2-1f3fb","native":"🧒🏻"},{"unified":"1f9d2-1f3fc","native":"🧒🏼"},{"unified":"1f9d2-1f3fd","native":"🧒🏽"},{"unified":"1f9d2-1f3fe","native":"🧒🏾"},{"unified":"1f9d2-1f3ff","native":"🧒🏿"}],"version":5},"boy":{"id":"boy","name":"Boy","keywords":["man","male","guy","teenager"],"skins":[{"unified":"1f466","native":"👦"},{"unified":"1f466-1f3fb","native":"👦🏻"},{"unified":"1f466-1f3fc","native":"👦🏼"},{"unified":"1f466-1f3fd","native":"👦🏽"},{"unified":"1f466-1f3fe","native":"👦🏾"},{"unified":"1f466-1f3ff","native":"👦🏿"}],"version":1},"girl":{"id":"girl","name":"Girl","keywords":["female","woman","teenager"],"skins":[{"unified":"1f467","native":"👧"},{"unified":"1f467-1f3fb","native":"👧🏻"},{"unified":"1f467-1f3fc","native":"👧🏼"},{"unified":"1f467-1f3fd","native":"👧🏽"},{"unified":"1f467-1f3fe","native":"👧🏾"},{"unified":"1f467-1f3ff","native":"👧🏿"}],"version":1},"adult":{"id":"adult","name":"Adult","keywords":["person","gender","neutral"],"skins":[{"unified":"1f9d1","native":"🧑"},{"unified":"1f9d1-1f3fb","native":"🧑🏻"},{"unified":"1f9d1-1f3fc","native":"🧑🏼"},{"unified":"1f9d1-1f3fd","native":"🧑🏽"},{"unified":"1f9d1-1f3fe","native":"🧑🏾"},{"unified":"1f9d1-1f3ff","native":"🧑🏿"}],"version":5},"person_with_blond_hair":{"id":"person_with_blond_hair","name":"Person Blond Hair","keywords":["with","hairstyle"],"skins":[{"unified":"1f471","native":"👱"},{"unified":"1f471-1f3fb","native":"👱🏻"},{"unified":"1f471-1f3fc","native":"👱🏼"},{"unified":"1f471-1f3fd","native":"👱🏽"},{"unified":"1f471-1f3fe","native":"👱🏾"},{"unified":"1f471-1f3ff","native":"👱🏿"}],"version":1},"man":{"id":"man","name":"Man","keywords":["mustache","father","dad","guy","classy","sir","moustache"],"skins":[{"unified":"1f468","native":"👨"},{"unified":"1f468-1f3fb","native":"👨🏻"},{"unified":"1f468-1f3fc","native":"👨🏼"},{"unified":"1f468-1f3fd","native":"👨🏽"},{"unified":"1f468-1f3fe","native":"👨🏾"},{"unified":"1f468-1f3ff","native":"👨🏿"}],"version":1},"bearded_person":{"id":"bearded_person","name":"Person Beard","keywords":["bearded","man","bewhiskered"],"skins":[{"unified":"1f9d4","native":"🧔"},{"unified":"1f9d4-1f3fb","native":"🧔🏻"},{"unified":"1f9d4-1f3fc","native":"🧔🏼"},{"unified":"1f9d4-1f3fd","native":"🧔🏽"},{"unified":"1f9d4-1f3fe","native":"🧔🏾"},{"unified":"1f9d4-1f3ff","native":"🧔🏿"}],"version":5},"man_with_beard":{"id":"man_with_beard","name":"Man: Beard","keywords":["man","with","facial","hair"],"skins":[{"unified":"1f9d4-200d-2642-fe0f","native":"🧔‍♂️"},{"unified":"1f9d4-1f3fb-200d-2642-fe0f","native":"🧔🏻‍♂️"},{"unified":"1f9d4-1f3fc-200d-2642-fe0f","native":"🧔🏼‍♂️"},{"unified":"1f9d4-1f3fd-200d-2642-fe0f","native":"🧔🏽‍♂️"},{"unified":"1f9d4-1f3fe-200d-2642-fe0f","native":"🧔🏾‍♂️"},{"unified":"1f9d4-1f3ff-200d-2642-fe0f","native":"🧔🏿‍♂️"}],"version":13.1},"woman_with_beard":{"id":"woman_with_beard","name":"Woman: Beard","keywords":["woman","with","facial","hair"],"skins":[{"unified":"1f9d4-200d-2640-fe0f","native":"🧔‍♀️"},{"unified":"1f9d4-1f3fb-200d-2640-fe0f","native":"🧔🏻‍♀️"},{"unified":"1f9d4-1f3fc-200d-2640-fe0f","native":"🧔🏼‍♀️"},{"unified":"1f9d4-1f3fd-200d-2640-fe0f","native":"🧔🏽‍♀️"},{"unified":"1f9d4-1f3fe-200d-2640-fe0f","native":"🧔🏾‍♀️"},{"unified":"1f9d4-1f3ff-200d-2640-fe0f","native":"🧔🏿‍♀️"}],"version":13.1},"red_haired_man":{"id":"red_haired_man","name":"Man: Red Hair","keywords":["haired","man","hairstyle"],"skins":[{"unified":"1f468-200d-1f9b0","native":"👨‍🦰"},{"unified":"1f468-1f3fb-200d-1f9b0","native":"👨🏻‍🦰"},{"unified":"1f468-1f3fc-200d-1f9b0","native":"👨🏼‍🦰"},{"unified":"1f468-1f3fd-200d-1f9b0","native":"👨🏽‍🦰"},{"unified":"1f468-1f3fe-200d-1f9b0","native":"👨🏾‍🦰"},{"unified":"1f468-1f3ff-200d-1f9b0","native":"👨🏿‍🦰"}],"version":11},"curly_haired_man":{"id":"curly_haired_man","name":"Man: Curly Hair","keywords":["haired","man","hairstyle"],"skins":[{"unified":"1f468-200d-1f9b1","native":"👨‍🦱"},{"unified":"1f468-1f3fb-200d-1f9b1","native":"👨🏻‍🦱"},{"unified":"1f468-1f3fc-200d-1f9b1","native":"👨🏼‍🦱"},{"unified":"1f468-1f3fd-200d-1f9b1","native":"👨🏽‍🦱"},{"unified":"1f468-1f3fe-200d-1f9b1","native":"👨🏾‍🦱"},{"unified":"1f468-1f3ff-200d-1f9b1","native":"👨🏿‍🦱"}],"version":11},"white_haired_man":{"id":"white_haired_man","name":"Man: White Hair","keywords":["haired","man","old","elder"],"skins":[{"unified":"1f468-200d-1f9b3","native":"👨‍🦳"},{"unified":"1f468-1f3fb-200d-1f9b3","native":"👨🏻‍🦳"},{"unified":"1f468-1f3fc-200d-1f9b3","native":"👨🏼‍🦳"},{"unified":"1f468-1f3fd-200d-1f9b3","native":"👨🏽‍🦳"},{"unified":"1f468-1f3fe-200d-1f9b3","native":"👨🏾‍🦳"},{"unified":"1f468-1f3ff-200d-1f9b3","native":"👨🏿‍🦳"}],"version":11},"bald_man":{"id":"bald_man","name":"Man: Bald","keywords":["man","hairless"],"skins":[{"unified":"1f468-200d-1f9b2","native":"👨‍🦲"},{"unified":"1f468-1f3fb-200d-1f9b2","native":"👨🏻‍🦲"},{"unified":"1f468-1f3fc-200d-1f9b2","native":"👨🏼‍🦲"},{"unified":"1f468-1f3fd-200d-1f9b2","native":"👨🏽‍🦲"},{"unified":"1f468-1f3fe-200d-1f9b2","native":"👨🏾‍🦲"},{"unified":"1f468-1f3ff-200d-1f9b2","native":"👨🏿‍🦲"}],"version":11},"woman":{"id":"woman","name":"Woman","keywords":["female","girls","lady"],"skins":[{"unified":"1f469","native":"👩"},{"unified":"1f469-1f3fb","native":"👩🏻"},{"unified":"1f469-1f3fc","native":"👩🏼"},{"unified":"1f469-1f3fd","native":"👩🏽"},{"unified":"1f469-1f3fe","native":"👩🏾"},{"unified":"1f469-1f3ff","native":"👩🏿"}],"version":1},"red_haired_woman":{"id":"red_haired_woman","name":"Woman: Red Hair","keywords":["haired","woman","hairstyle"],"skins":[{"unified":"1f469-200d-1f9b0","native":"👩‍🦰"},{"unified":"1f469-1f3fb-200d-1f9b0","native":"👩🏻‍🦰"},{"unified":"1f469-1f3fc-200d-1f9b0","native":"👩🏼‍🦰"},{"unified":"1f469-1f3fd-200d-1f9b0","native":"👩🏽‍🦰"},{"unified":"1f469-1f3fe-200d-1f9b0","native":"👩🏾‍🦰"},{"unified":"1f469-1f3ff-200d-1f9b0","native":"👩🏿‍🦰"}],"version":11},"red_haired_person":{"id":"red_haired_person","name":"Person: Red Hair","keywords":["haired","person","hairstyle"],"skins":[{"unified":"1f9d1-200d-1f9b0","native":"🧑‍🦰"},{"unified":"1f9d1-1f3fb-200d-1f9b0","native":"🧑🏻‍🦰"},{"unified":"1f9d1-1f3fc-200d-1f9b0","native":"🧑🏼‍🦰"},{"unified":"1f9d1-1f3fd-200d-1f9b0","native":"🧑🏽‍🦰"},{"unified":"1f9d1-1f3fe-200d-1f9b0","native":"🧑🏾‍🦰"},{"unified":"1f9d1-1f3ff-200d-1f9b0","native":"🧑🏿‍🦰"}],"version":12.1},"curly_haired_woman":{"id":"curly_haired_woman","name":"Woman: Curly Hair","keywords":["haired","woman","hairstyle"],"skins":[{"unified":"1f469-200d-1f9b1","native":"👩‍🦱"},{"unified":"1f469-1f3fb-200d-1f9b1","native":"👩🏻‍🦱"},{"unified":"1f469-1f3fc-200d-1f9b1","native":"👩🏼‍🦱"},{"unified":"1f469-1f3fd-200d-1f9b1","native":"👩🏽‍🦱"},{"unified":"1f469-1f3fe-200d-1f9b1","native":"👩🏾‍🦱"},{"unified":"1f469-1f3ff-200d-1f9b1","native":"👩🏿‍🦱"}],"version":11},"curly_haired_person":{"id":"curly_haired_person","name":"Person: Curly Hair","keywords":["haired","person","hairstyle"],"skins":[{"unified":"1f9d1-200d-1f9b1","native":"🧑‍🦱"},{"unified":"1f9d1-1f3fb-200d-1f9b1","native":"🧑🏻‍🦱"},{"unified":"1f9d1-1f3fc-200d-1f9b1","native":"🧑🏼‍🦱"},{"unified":"1f9d1-1f3fd-200d-1f9b1","native":"🧑🏽‍🦱"},{"unified":"1f9d1-1f3fe-200d-1f9b1","native":"🧑🏾‍🦱"},{"unified":"1f9d1-1f3ff-200d-1f9b1","native":"🧑🏿‍🦱"}],"version":12.1},"white_haired_woman":{"id":"white_haired_woman","name":"Woman: White Hair","keywords":["haired","woman","old","elder"],"skins":[{"unified":"1f469-200d-1f9b3","native":"👩‍🦳"},{"unified":"1f469-1f3fb-200d-1f9b3","native":"👩🏻‍🦳"},{"unified":"1f469-1f3fc-200d-1f9b3","native":"👩🏼‍🦳"},{"unified":"1f469-1f3fd-200d-1f9b3","native":"👩🏽‍🦳"},{"unified":"1f469-1f3fe-200d-1f9b3","native":"👩🏾‍🦳"},{"unified":"1f469-1f3ff-200d-1f9b3","native":"👩🏿‍🦳"}],"version":11},"white_haired_person":{"id":"white_haired_person","name":"Person: White Hair","keywords":["haired","person","elder","old"],"skins":[{"unified":"1f9d1-200d-1f9b3","native":"🧑‍🦳"},{"unified":"1f9d1-1f3fb-200d-1f9b3","native":"🧑🏻‍🦳"},{"unified":"1f9d1-1f3fc-200d-1f9b3","native":"🧑🏼‍🦳"},{"unified":"1f9d1-1f3fd-200d-1f9b3","native":"🧑🏽‍🦳"},{"unified":"1f9d1-1f3fe-200d-1f9b3","native":"🧑🏾‍🦳"},{"unified":"1f9d1-1f3ff-200d-1f9b3","native":"🧑🏿‍🦳"}],"version":12.1},"bald_woman":{"id":"bald_woman","name":"Woman: Bald","keywords":["woman","hairless"],"skins":[{"unified":"1f469-200d-1f9b2","native":"👩‍🦲"},{"unified":"1f469-1f3fb-200d-1f9b2","native":"👩🏻‍🦲"},{"unified":"1f469-1f3fc-200d-1f9b2","native":"👩🏼‍🦲"},{"unified":"1f469-1f3fd-200d-1f9b2","native":"👩🏽‍🦲"},{"unified":"1f469-1f3fe-200d-1f9b2","native":"👩🏾‍🦲"},{"unified":"1f469-1f3ff-200d-1f9b2","native":"👩🏿‍🦲"}],"version":11},"bald_person":{"id":"bald_person","name":"Person: Bald","keywords":["person","hairless"],"skins":[{"unified":"1f9d1-200d-1f9b2","native":"🧑‍🦲"},{"unified":"1f9d1-1f3fb-200d-1f9b2","native":"🧑🏻‍🦲"},{"unified":"1f9d1-1f3fc-200d-1f9b2","native":"🧑🏼‍🦲"},{"unified":"1f9d1-1f3fd-200d-1f9b2","native":"🧑🏽‍🦲"},{"unified":"1f9d1-1f3fe-200d-1f9b2","native":"🧑🏾‍🦲"},{"unified":"1f9d1-1f3ff-200d-1f9b2","native":"🧑🏿‍🦲"}],"version":12.1},"blond-haired-woman":{"id":"blond-haired-woman","name":"Woman: Blond Hair","keywords":["haired-woman","woman","female","girl","blonde","person"],"skins":[{"unified":"1f471-200d-2640-fe0f","native":"👱‍♀️"},{"unified":"1f471-1f3fb-200d-2640-fe0f","native":"👱🏻‍♀️"},{"unified":"1f471-1f3fc-200d-2640-fe0f","native":"👱🏼‍♀️"},{"unified":"1f471-1f3fd-200d-2640-fe0f","native":"👱🏽‍♀️"},{"unified":"1f471-1f3fe-200d-2640-fe0f","native":"👱🏾‍♀️"},{"unified":"1f471-1f3ff-200d-2640-fe0f","native":"👱🏿‍♀️"}],"version":4},"blond-haired-man":{"id":"blond-haired-man","name":"Man: Blond Hair","keywords":["haired-man","man","male","boy","blonde","guy","person"],"skins":[{"unified":"1f471-200d-2642-fe0f","native":"👱‍♂️"},{"unified":"1f471-1f3fb-200d-2642-fe0f","native":"👱🏻‍♂️"},{"unified":"1f471-1f3fc-200d-2642-fe0f","native":"👱🏼‍♂️"},{"unified":"1f471-1f3fd-200d-2642-fe0f","native":"👱🏽‍♂️"},{"unified":"1f471-1f3fe-200d-2642-fe0f","native":"👱🏾‍♂️"},{"unified":"1f471-1f3ff-200d-2642-fe0f","native":"👱🏿‍♂️"}],"version":4},"older_adult":{"id":"older_adult","name":"Older Adult","keywords":["person","human","elder","senior","gender","neutral"],"skins":[{"unified":"1f9d3","native":"🧓"},{"unified":"1f9d3-1f3fb","native":"🧓🏻"},{"unified":"1f9d3-1f3fc","native":"🧓🏼"},{"unified":"1f9d3-1f3fd","native":"🧓🏽"},{"unified":"1f9d3-1f3fe","native":"🧓🏾"},{"unified":"1f9d3-1f3ff","native":"🧓🏿"}],"version":5},"older_man":{"id":"older_man","name":"Old Man","keywords":["older","human","male","men","elder","senior"],"skins":[{"unified":"1f474","native":"👴"},{"unified":"1f474-1f3fb","native":"👴🏻"},{"unified":"1f474-1f3fc","native":"👴🏼"},{"unified":"1f474-1f3fd","native":"👴🏽"},{"unified":"1f474-1f3fe","native":"👴🏾"},{"unified":"1f474-1f3ff","native":"👴🏿"}],"version":1},"older_woman":{"id":"older_woman","name":"Old Woman","keywords":["older","human","female","women","lady","elder","senior"],"skins":[{"unified":"1f475","native":"👵"},{"unified":"1f475-1f3fb","native":"👵🏻"},{"unified":"1f475-1f3fc","native":"👵🏼"},{"unified":"1f475-1f3fd","native":"👵🏽"},{"unified":"1f475-1f3fe","native":"👵🏾"},{"unified":"1f475-1f3ff","native":"👵🏿"}],"version":1},"person_frowning":{"id":"person_frowning","name":"Person Frowning","keywords":["worried"],"skins":[{"unified":"1f64d","native":"🙍"},{"unified":"1f64d-1f3fb","native":"🙍🏻"},{"unified":"1f64d-1f3fc","native":"🙍🏼"},{"unified":"1f64d-1f3fd","native":"🙍🏽"},{"unified":"1f64d-1f3fe","native":"🙍🏾"},{"unified":"1f64d-1f3ff","native":"🙍🏿"}],"version":1},"man-frowning":{"id":"man-frowning","name":"Man Frowning","keywords":["male","boy","sad","depressed","discouraged","unhappy"],"skins":[{"unified":"1f64d-200d-2642-fe0f","native":"🙍‍♂️"},{"unified":"1f64d-1f3fb-200d-2642-fe0f","native":"🙍🏻‍♂️"},{"unified":"1f64d-1f3fc-200d-2642-fe0f","native":"🙍🏼‍♂️"},{"unified":"1f64d-1f3fd-200d-2642-fe0f","native":"🙍🏽‍♂️"},{"unified":"1f64d-1f3fe-200d-2642-fe0f","native":"🙍🏾‍♂️"},{"unified":"1f64d-1f3ff-200d-2642-fe0f","native":"🙍🏿‍♂️"}],"version":4},"woman-frowning":{"id":"woman-frowning","name":"Woman Frowning","keywords":["female","girl","sad","depressed","discouraged","unhappy"],"skins":[{"unified":"1f64d-200d-2640-fe0f","native":"🙍‍♀️"},{"unified":"1f64d-1f3fb-200d-2640-fe0f","native":"🙍🏻‍♀️"},{"unified":"1f64d-1f3fc-200d-2640-fe0f","native":"🙍🏼‍♀️"},{"unified":"1f64d-1f3fd-200d-2640-fe0f","native":"🙍🏽‍♀️"},{"unified":"1f64d-1f3fe-200d-2640-fe0f","native":"🙍🏾‍♀️"},{"unified":"1f64d-1f3ff-200d-2640-fe0f","native":"🙍🏿‍♀️"}],"version":4},"person_with_pouting_face":{"id":"person_with_pouting_face","name":"Person Pouting","keywords":["with","face","upset"],"skins":[{"unified":"1f64e","native":"🙎"},{"unified":"1f64e-1f3fb","native":"🙎🏻"},{"unified":"1f64e-1f3fc","native":"🙎🏼"},{"unified":"1f64e-1f3fd","native":"🙎🏽"},{"unified":"1f64e-1f3fe","native":"🙎🏾"},{"unified":"1f64e-1f3ff","native":"🙎🏿"}],"version":1},"man-pouting":{"id":"man-pouting","name":"Man Pouting","keywords":["male","boy"],"skins":[{"unified":"1f64e-200d-2642-fe0f","native":"🙎‍♂️"},{"unified":"1f64e-1f3fb-200d-2642-fe0f","native":"🙎🏻‍♂️"},{"unified":"1f64e-1f3fc-200d-2642-fe0f","native":"🙎🏼‍♂️"},{"unified":"1f64e-1f3fd-200d-2642-fe0f","native":"🙎🏽‍♂️"},{"unified":"1f64e-1f3fe-200d-2642-fe0f","native":"🙎🏾‍♂️"},{"unified":"1f64e-1f3ff-200d-2642-fe0f","native":"🙎🏿‍♂️"}],"version":4},"woman-pouting":{"id":"woman-pouting","name":"Woman Pouting","keywords":["female","girl"],"skins":[{"unified":"1f64e-200d-2640-fe0f","native":"🙎‍♀️"},{"unified":"1f64e-1f3fb-200d-2640-fe0f","native":"🙎🏻‍♀️"},{"unified":"1f64e-1f3fc-200d-2640-fe0f","native":"🙎🏼‍♀️"},{"unified":"1f64e-1f3fd-200d-2640-fe0f","native":"🙎🏽‍♀️"},{"unified":"1f64e-1f3fe-200d-2640-fe0f","native":"🙎🏾‍♀️"},{"unified":"1f64e-1f3ff-200d-2640-fe0f","native":"🙎🏿‍♀️"}],"version":4},"no_good":{"id":"no_good","name":"Person Gesturing No","keywords":["good","decline"],"skins":[{"unified":"1f645","native":"🙅"},{"unified":"1f645-1f3fb","native":"🙅🏻"},{"unified":"1f645-1f3fc","native":"🙅🏼"},{"unified":"1f645-1f3fd","native":"🙅🏽"},{"unified":"1f645-1f3fe","native":"🙅🏾"},{"unified":"1f645-1f3ff","native":"🙅🏿"}],"version":1},"man-gesturing-no":{"id":"man-gesturing-no","name":"Man Gesturing No","keywords":["gesturing-no","male","boy","nope"],"skins":[{"unified":"1f645-200d-2642-fe0f","native":"🙅‍♂️"},{"unified":"1f645-1f3fb-200d-2642-fe0f","native":"🙅🏻‍♂️"},{"unified":"1f645-1f3fc-200d-2642-fe0f","native":"🙅🏼‍♂️"},{"unified":"1f645-1f3fd-200d-2642-fe0f","native":"🙅🏽‍♂️"},{"unified":"1f645-1f3fe-200d-2642-fe0f","native":"🙅🏾‍♂️"},{"unified":"1f645-1f3ff-200d-2642-fe0f","native":"🙅🏿‍♂️"}],"version":4},"woman-gesturing-no":{"id":"woman-gesturing-no","name":"Woman Gesturing No","keywords":["gesturing-no","female","girl","nope"],"skins":[{"unified":"1f645-200d-2640-fe0f","native":"🙅‍♀️"},{"unified":"1f645-1f3fb-200d-2640-fe0f","native":"🙅🏻‍♀️"},{"unified":"1f645-1f3fc-200d-2640-fe0f","native":"🙅🏼‍♀️"},{"unified":"1f645-1f3fd-200d-2640-fe0f","native":"🙅🏽‍♀️"},{"unified":"1f645-1f3fe-200d-2640-fe0f","native":"🙅🏾‍♀️"},{"unified":"1f645-1f3ff-200d-2640-fe0f","native":"🙅🏿‍♀️"}],"version":4},"ok_woman":{"id":"ok_woman","name":"Person Gesturing Ok","keywords":["woman","agree"],"skins":[{"unified":"1f646","native":"🙆"},{"unified":"1f646-1f3fb","native":"🙆🏻"},{"unified":"1f646-1f3fc","native":"🙆🏼"},{"unified":"1f646-1f3fd","native":"🙆🏽"},{"unified":"1f646-1f3fe","native":"🙆🏾"},{"unified":"1f646-1f3ff","native":"🙆🏿"}],"version":1},"man-gesturing-ok":{"id":"man-gesturing-ok","name":"Man Gesturing Ok","keywords":["gesturing-ok","men","boy","male","blue","human"],"skins":[{"unified":"1f646-200d-2642-fe0f","native":"🙆‍♂️"},{"unified":"1f646-1f3fb-200d-2642-fe0f","native":"🙆🏻‍♂️"},{"unified":"1f646-1f3fc-200d-2642-fe0f","native":"🙆🏼‍♂️"},{"unified":"1f646-1f3fd-200d-2642-fe0f","native":"🙆🏽‍♂️"},{"unified":"1f646-1f3fe-200d-2642-fe0f","native":"🙆🏾‍♂️"},{"unified":"1f646-1f3ff-200d-2642-fe0f","native":"🙆🏿‍♂️"}],"version":4},"woman-gesturing-ok":{"id":"woman-gesturing-ok","name":"Woman Gesturing Ok","keywords":["gesturing-ok","women","girl","female","pink","human"],"skins":[{"unified":"1f646-200d-2640-fe0f","native":"🙆‍♀️"},{"unified":"1f646-1f3fb-200d-2640-fe0f","native":"🙆🏻‍♀️"},{"unified":"1f646-1f3fc-200d-2640-fe0f","native":"🙆🏼‍♀️"},{"unified":"1f646-1f3fd-200d-2640-fe0f","native":"🙆🏽‍♀️"},{"unified":"1f646-1f3fe-200d-2640-fe0f","native":"🙆🏾‍♀️"},{"unified":"1f646-1f3ff-200d-2640-fe0f","native":"🙆🏿‍♀️"}],"version":4},"information_desk_person":{"id":"information_desk_person","name":"Person Tipping Hand","keywords":["information","desk"],"skins":[{"unified":"1f481","native":"💁"},{"unified":"1f481-1f3fb","native":"💁🏻"},{"unified":"1f481-1f3fc","native":"💁🏼"},{"unified":"1f481-1f3fd","native":"💁🏽"},{"unified":"1f481-1f3fe","native":"💁🏾"},{"unified":"1f481-1f3ff","native":"💁🏿"}],"version":1},"man-tipping-hand":{"id":"man-tipping-hand","name":"Man Tipping Hand","keywords":["tipping-hand","male","boy","human","information"],"skins":[{"unified":"1f481-200d-2642-fe0f","native":"💁‍♂️"},{"unified":"1f481-1f3fb-200d-2642-fe0f","native":"💁🏻‍♂️"},{"unified":"1f481-1f3fc-200d-2642-fe0f","native":"💁🏼‍♂️"},{"unified":"1f481-1f3fd-200d-2642-fe0f","native":"💁🏽‍♂️"},{"unified":"1f481-1f3fe-200d-2642-fe0f","native":"💁🏾‍♂️"},{"unified":"1f481-1f3ff-200d-2642-fe0f","native":"💁🏿‍♂️"}],"version":4},"woman-tipping-hand":{"id":"woman-tipping-hand","name":"Woman Tipping Hand","keywords":["tipping-hand","female","girl","human","information"],"skins":[{"unified":"1f481-200d-2640-fe0f","native":"💁‍♀️"},{"unified":"1f481-1f3fb-200d-2640-fe0f","native":"💁🏻‍♀️"},{"unified":"1f481-1f3fc-200d-2640-fe0f","native":"💁🏼‍♀️"},{"unified":"1f481-1f3fd-200d-2640-fe0f","native":"💁🏽‍♀️"},{"unified":"1f481-1f3fe-200d-2640-fe0f","native":"💁🏾‍♀️"},{"unified":"1f481-1f3ff-200d-2640-fe0f","native":"💁🏿‍♀️"}],"version":4},"raising_hand":{"id":"raising_hand","name":"Person Raising Hand","keywords":["question"],"skins":[{"unified":"1f64b","native":"🙋"},{"unified":"1f64b-1f3fb","native":"🙋🏻"},{"unified":"1f64b-1f3fc","native":"🙋🏼"},{"unified":"1f64b-1f3fd","native":"🙋🏽"},{"unified":"1f64b-1f3fe","native":"🙋🏾"},{"unified":"1f64b-1f3ff","native":"🙋🏿"}],"version":1},"man-raising-hand":{"id":"man-raising-hand","name":"Man Raising Hand","keywords":["raising-hand","male","boy"],"skins":[{"unified":"1f64b-200d-2642-fe0f","native":"🙋‍♂️"},{"unified":"1f64b-1f3fb-200d-2642-fe0f","native":"🙋🏻‍♂️"},{"unified":"1f64b-1f3fc-200d-2642-fe0f","native":"🙋🏼‍♂️"},{"unified":"1f64b-1f3fd-200d-2642-fe0f","native":"🙋🏽‍♂️"},{"unified":"1f64b-1f3fe-200d-2642-fe0f","native":"🙋🏾‍♂️"},{"unified":"1f64b-1f3ff-200d-2642-fe0f","native":"🙋🏿‍♂️"}],"version":4},"woman-raising-hand":{"id":"woman-raising-hand","name":"Woman Raising Hand","keywords":["raising-hand","female","girl"],"skins":[{"unified":"1f64b-200d-2640-fe0f","native":"🙋‍♀️"},{"unified":"1f64b-1f3fb-200d-2640-fe0f","native":"🙋🏻‍♀️"},{"unified":"1f64b-1f3fc-200d-2640-fe0f","native":"🙋🏼‍♀️"},{"unified":"1f64b-1f3fd-200d-2640-fe0f","native":"🙋🏽‍♀️"},{"unified":"1f64b-1f3fe-200d-2640-fe0f","native":"🙋🏾‍♀️"},{"unified":"1f64b-1f3ff-200d-2640-fe0f","native":"🙋🏿‍♀️"}],"version":4},"deaf_person":{"id":"deaf_person","name":"Deaf Person","keywords":["accessibility"],"skins":[{"unified":"1f9cf","native":"🧏"},{"unified":"1f9cf-1f3fb","native":"🧏🏻"},{"unified":"1f9cf-1f3fc","native":"🧏🏼"},{"unified":"1f9cf-1f3fd","native":"🧏🏽"},{"unified":"1f9cf-1f3fe","native":"🧏🏾"},{"unified":"1f9cf-1f3ff","native":"🧏🏿"}],"version":12},"deaf_man":{"id":"deaf_man","name":"Deaf Man","keywords":["accessibility"],"skins":[{"unified":"1f9cf-200d-2642-fe0f","native":"🧏‍♂️"},{"unified":"1f9cf-1f3fb-200d-2642-fe0f","native":"🧏🏻‍♂️"},{"unified":"1f9cf-1f3fc-200d-2642-fe0f","native":"🧏🏼‍♂️"},{"unified":"1f9cf-1f3fd-200d-2642-fe0f","native":"🧏🏽‍♂️"},{"unified":"1f9cf-1f3fe-200d-2642-fe0f","native":"🧏🏾‍♂️"},{"unified":"1f9cf-1f3ff-200d-2642-fe0f","native":"🧏🏿‍♂️"}],"version":12},"deaf_woman":{"id":"deaf_woman","name":"Deaf Woman","keywords":["accessibility"],"skins":[{"unified":"1f9cf-200d-2640-fe0f","native":"🧏‍♀️"},{"unified":"1f9cf-1f3fb-200d-2640-fe0f","native":"🧏🏻‍♀️"},{"unified":"1f9cf-1f3fc-200d-2640-fe0f","native":"🧏🏼‍♀️"},{"unified":"1f9cf-1f3fd-200d-2640-fe0f","native":"🧏🏽‍♀️"},{"unified":"1f9cf-1f3fe-200d-2640-fe0f","native":"🧏🏾‍♀️"},{"unified":"1f9cf-1f3ff-200d-2640-fe0f","native":"🧏🏿‍♀️"}],"version":12},"bow":{"id":"bow","name":"Person Bowing","keywords":["bow","respectiful"],"skins":[{"unified":"1f647","native":"🙇"},{"unified":"1f647-1f3fb","native":"🙇🏻"},{"unified":"1f647-1f3fc","native":"🙇🏼"},{"unified":"1f647-1f3fd","native":"🙇🏽"},{"unified":"1f647-1f3fe","native":"🙇🏾"},{"unified":"1f647-1f3ff","native":"🙇🏿"}],"version":1},"man-bowing":{"id":"man-bowing","name":"Man Bowing","keywords":["male","boy"],"skins":[{"unified":"1f647-200d-2642-fe0f","native":"🙇‍♂️"},{"unified":"1f647-1f3fb-200d-2642-fe0f","native":"🙇🏻‍♂️"},{"unified":"1f647-1f3fc-200d-2642-fe0f","native":"🙇🏼‍♂️"},{"unified":"1f647-1f3fd-200d-2642-fe0f","native":"🙇🏽‍♂️"},{"unified":"1f647-1f3fe-200d-2642-fe0f","native":"🙇🏾‍♂️"},{"unified":"1f647-1f3ff-200d-2642-fe0f","native":"🙇🏿‍♂️"}],"version":4},"woman-bowing":{"id":"woman-bowing","name":"Woman Bowing","keywords":["female","girl"],"skins":[{"unified":"1f647-200d-2640-fe0f","native":"🙇‍♀️"},{"unified":"1f647-1f3fb-200d-2640-fe0f","native":"🙇🏻‍♀️"},{"unified":"1f647-1f3fc-200d-2640-fe0f","native":"🙇🏼‍♀️"},{"unified":"1f647-1f3fd-200d-2640-fe0f","native":"🙇🏽‍♀️"},{"unified":"1f647-1f3fe-200d-2640-fe0f","native":"🙇🏾‍♀️"},{"unified":"1f647-1f3ff-200d-2640-fe0f","native":"🙇🏿‍♀️"}],"version":4},"face_palm":{"id":"face_palm","name":"Face Palm","keywords":["person","facepalming","disappointed"],"skins":[{"unified":"1f926","native":"🤦"},{"unified":"1f926-1f3fb","native":"🤦🏻"},{"unified":"1f926-1f3fc","native":"🤦🏼"},{"unified":"1f926-1f3fd","native":"🤦🏽"},{"unified":"1f926-1f3fe","native":"🤦🏾"},{"unified":"1f926-1f3ff","native":"🤦🏿"}],"version":3},"man-facepalming":{"id":"man-facepalming","name":"Man Facepalming","keywords":["male","boy","disbelief"],"skins":[{"unified":"1f926-200d-2642-fe0f","native":"🤦‍♂️"},{"unified":"1f926-1f3fb-200d-2642-fe0f","native":"🤦🏻‍♂️"},{"unified":"1f926-1f3fc-200d-2642-fe0f","native":"🤦🏼‍♂️"},{"unified":"1f926-1f3fd-200d-2642-fe0f","native":"🤦🏽‍♂️"},{"unified":"1f926-1f3fe-200d-2642-fe0f","native":"🤦🏾‍♂️"},{"unified":"1f926-1f3ff-200d-2642-fe0f","native":"🤦🏿‍♂️"}],"version":4},"woman-facepalming":{"id":"woman-facepalming","name":"Woman Facepalming","keywords":["female","girl","disbelief"],"skins":[{"unified":"1f926-200d-2640-fe0f","native":"🤦‍♀️"},{"unified":"1f926-1f3fb-200d-2640-fe0f","native":"🤦🏻‍♀️"},{"unified":"1f926-1f3fc-200d-2640-fe0f","native":"🤦🏼‍♀️"},{"unified":"1f926-1f3fd-200d-2640-fe0f","native":"🤦🏽‍♀️"},{"unified":"1f926-1f3fe-200d-2640-fe0f","native":"🤦🏾‍♀️"},{"unified":"1f926-1f3ff-200d-2640-fe0f","native":"🤦🏿‍♀️"}],"version":4},"shrug":{"id":"shrug","name":"Shrug","keywords":["person","shrugging","regardless"],"skins":[{"unified":"1f937","native":"🤷"},{"unified":"1f937-1f3fb","native":"🤷🏻"},{"unified":"1f937-1f3fc","native":"🤷🏼"},{"unified":"1f937-1f3fd","native":"🤷🏽"},{"unified":"1f937-1f3fe","native":"🤷🏾"},{"unified":"1f937-1f3ff","native":"🤷🏿"}],"version":3},"man-shrugging":{"id":"man-shrugging","name":"Man Shrugging","keywords":["male","boy","confused","indifferent","doubt"],"skins":[{"unified":"1f937-200d-2642-fe0f","native":"🤷‍♂️"},{"unified":"1f937-1f3fb-200d-2642-fe0f","native":"🤷🏻‍♂️"},{"unified":"1f937-1f3fc-200d-2642-fe0f","native":"🤷🏼‍♂️"},{"unified":"1f937-1f3fd-200d-2642-fe0f","native":"🤷🏽‍♂️"},{"unified":"1f937-1f3fe-200d-2642-fe0f","native":"🤷🏾‍♂️"},{"unified":"1f937-1f3ff-200d-2642-fe0f","native":"🤷🏿‍♂️"}],"version":4},"woman-shrugging":{"id":"woman-shrugging","name":"Woman Shrugging","keywords":["female","girl","confused","indifferent","doubt"],"skins":[{"unified":"1f937-200d-2640-fe0f","native":"🤷‍♀️"},{"unified":"1f937-1f3fb-200d-2640-fe0f","native":"🤷🏻‍♀️"},{"unified":"1f937-1f3fc-200d-2640-fe0f","native":"🤷🏼‍♀️"},{"unified":"1f937-1f3fd-200d-2640-fe0f","native":"🤷🏽‍♀️"},{"unified":"1f937-1f3fe-200d-2640-fe0f","native":"🤷🏾‍♀️"},{"unified":"1f937-1f3ff-200d-2640-fe0f","native":"🤷🏿‍♀️"}],"version":4},"health_worker":{"id":"health_worker","name":"Health Worker","keywords":["hospital"],"skins":[{"unified":"1f9d1-200d-2695-fe0f","native":"🧑‍⚕️"},{"unified":"1f9d1-1f3fb-200d-2695-fe0f","native":"🧑🏻‍⚕️"},{"unified":"1f9d1-1f3fc-200d-2695-fe0f","native":"🧑🏼‍⚕️"},{"unified":"1f9d1-1f3fd-200d-2695-fe0f","native":"🧑🏽‍⚕️"},{"unified":"1f9d1-1f3fe-200d-2695-fe0f","native":"🧑🏾‍⚕️"},{"unified":"1f9d1-1f3ff-200d-2695-fe0f","native":"🧑🏿‍⚕️"}],"version":12.1},"male-doctor":{"id":"male-doctor","name":"Man Health Worker","keywords":["male","doctor","nurse","therapist","healthcare","human"],"skins":[{"unified":"1f468-200d-2695-fe0f","native":"👨‍⚕️"},{"unified":"1f468-1f3fb-200d-2695-fe0f","native":"👨🏻‍⚕️"},{"unified":"1f468-1f3fc-200d-2695-fe0f","native":"👨🏼‍⚕️"},{"unified":"1f468-1f3fd-200d-2695-fe0f","native":"👨🏽‍⚕️"},{"unified":"1f468-1f3fe-200d-2695-fe0f","native":"👨🏾‍⚕️"},{"unified":"1f468-1f3ff-200d-2695-fe0f","native":"👨🏿‍⚕️"}],"version":4},"female-doctor":{"id":"female-doctor","name":"Woman Health Worker","keywords":["female","doctor","nurse","therapist","healthcare","human"],"skins":[{"unified":"1f469-200d-2695-fe0f","native":"👩‍⚕️"},{"unified":"1f469-1f3fb-200d-2695-fe0f","native":"👩🏻‍⚕️"},{"unified":"1f469-1f3fc-200d-2695-fe0f","native":"👩🏼‍⚕️"},{"unified":"1f469-1f3fd-200d-2695-fe0f","native":"👩🏽‍⚕️"},{"unified":"1f469-1f3fe-200d-2695-fe0f","native":"👩🏾‍⚕️"},{"unified":"1f469-1f3ff-200d-2695-fe0f","native":"👩🏿‍⚕️"}],"version":4},"student":{"id":"student","name":"Student","keywords":["learn"],"skins":[{"unified":"1f9d1-200d-1f393","native":"🧑‍🎓"},{"unified":"1f9d1-1f3fb-200d-1f393","native":"🧑🏻‍🎓"},{"unified":"1f9d1-1f3fc-200d-1f393","native":"🧑🏼‍🎓"},{"unified":"1f9d1-1f3fd-200d-1f393","native":"🧑🏽‍🎓"},{"unified":"1f9d1-1f3fe-200d-1f393","native":"🧑🏾‍🎓"},{"unified":"1f9d1-1f3ff-200d-1f393","native":"🧑🏿‍🎓"}],"version":12.1},"male-student":{"id":"male-student","name":"Man Student","keywords":["male","graduate","human"],"skins":[{"unified":"1f468-200d-1f393","native":"👨‍🎓"},{"unified":"1f468-1f3fb-200d-1f393","native":"👨🏻‍🎓"},{"unified":"1f468-1f3fc-200d-1f393","native":"👨🏼‍🎓"},{"unified":"1f468-1f3fd-200d-1f393","native":"👨🏽‍🎓"},{"unified":"1f468-1f3fe-200d-1f393","native":"👨🏾‍🎓"},{"unified":"1f468-1f3ff-200d-1f393","native":"👨🏿‍🎓"}],"version":4},"female-student":{"id":"female-student","name":"Woman Student","keywords":["female","graduate","human"],"skins":[{"unified":"1f469-200d-1f393","native":"👩‍🎓"},{"unified":"1f469-1f3fb-200d-1f393","native":"👩🏻‍🎓"},{"unified":"1f469-1f3fc-200d-1f393","native":"👩🏼‍🎓"},{"unified":"1f469-1f3fd-200d-1f393","native":"👩🏽‍🎓"},{"unified":"1f469-1f3fe-200d-1f393","native":"👩🏾‍🎓"},{"unified":"1f469-1f3ff-200d-1f393","native":"👩🏿‍🎓"}],"version":4},"teacher":{"id":"teacher","name":"Teacher","keywords":["professor"],"skins":[{"unified":"1f9d1-200d-1f3eb","native":"🧑‍🏫"},{"unified":"1f9d1-1f3fb-200d-1f3eb","native":"🧑🏻‍🏫"},{"unified":"1f9d1-1f3fc-200d-1f3eb","native":"🧑🏼‍🏫"},{"unified":"1f9d1-1f3fd-200d-1f3eb","native":"🧑🏽‍🏫"},{"unified":"1f9d1-1f3fe-200d-1f3eb","native":"🧑🏾‍🏫"},{"unified":"1f9d1-1f3ff-200d-1f3eb","native":"🧑🏿‍🏫"}],"version":12.1},"male-teacher":{"id":"male-teacher","name":"Man Teacher","keywords":["male","instructor","professor","human"],"skins":[{"unified":"1f468-200d-1f3eb","native":"👨‍🏫"},{"unified":"1f468-1f3fb-200d-1f3eb","native":"👨🏻‍🏫"},{"unified":"1f468-1f3fc-200d-1f3eb","native":"👨🏼‍🏫"},{"unified":"1f468-1f3fd-200d-1f3eb","native":"👨🏽‍🏫"},{"unified":"1f468-1f3fe-200d-1f3eb","native":"👨🏾‍🏫"},{"unified":"1f468-1f3ff-200d-1f3eb","native":"👨🏿‍🏫"}],"version":4},"female-teacher":{"id":"female-teacher","name":"Woman Teacher","keywords":["female","instructor","professor","human"],"skins":[{"unified":"1f469-200d-1f3eb","native":"👩‍🏫"},{"unified":"1f469-1f3fb-200d-1f3eb","native":"👩🏻‍🏫"},{"unified":"1f469-1f3fc-200d-1f3eb","native":"👩🏼‍🏫"},{"unified":"1f469-1f3fd-200d-1f3eb","native":"👩🏽‍🏫"},{"unified":"1f469-1f3fe-200d-1f3eb","native":"👩🏾‍🏫"},{"unified":"1f469-1f3ff-200d-1f3eb","native":"👩🏿‍🏫"}],"version":4},"judge":{"id":"judge","name":"Judge","keywords":["law"],"skins":[{"unified":"1f9d1-200d-2696-fe0f","native":"🧑‍⚖️"},{"unified":"1f9d1-1f3fb-200d-2696-fe0f","native":"🧑🏻‍⚖️"},{"unified":"1f9d1-1f3fc-200d-2696-fe0f","native":"🧑🏼‍⚖️"},{"unified":"1f9d1-1f3fd-200d-2696-fe0f","native":"🧑🏽‍⚖️"},{"unified":"1f9d1-1f3fe-200d-2696-fe0f","native":"🧑🏾‍⚖️"},{"unified":"1f9d1-1f3ff-200d-2696-fe0f","native":"🧑🏿‍⚖️"}],"version":12.1},"male-judge":{"id":"male-judge","name":"Man Judge","keywords":["male","justice","court","human"],"skins":[{"unified":"1f468-200d-2696-fe0f","native":"👨‍⚖️"},{"unified":"1f468-1f3fb-200d-2696-fe0f","native":"👨🏻‍⚖️"},{"unified":"1f468-1f3fc-200d-2696-fe0f","native":"👨🏼‍⚖️"},{"unified":"1f468-1f3fd-200d-2696-fe0f","native":"👨🏽‍⚖️"},{"unified":"1f468-1f3fe-200d-2696-fe0f","native":"👨🏾‍⚖️"},{"unified":"1f468-1f3ff-200d-2696-fe0f","native":"👨🏿‍⚖️"}],"version":4},"female-judge":{"id":"female-judge","name":"Woman Judge","keywords":["female","justice","court","human"],"skins":[{"unified":"1f469-200d-2696-fe0f","native":"👩‍⚖️"},{"unified":"1f469-1f3fb-200d-2696-fe0f","native":"👩🏻‍⚖️"},{"unified":"1f469-1f3fc-200d-2696-fe0f","native":"👩🏼‍⚖️"},{"unified":"1f469-1f3fd-200d-2696-fe0f","native":"👩🏽‍⚖️"},{"unified":"1f469-1f3fe-200d-2696-fe0f","native":"👩🏾‍⚖️"},{"unified":"1f469-1f3ff-200d-2696-fe0f","native":"👩🏿‍⚖️"}],"version":4},"farmer":{"id":"farmer","name":"Farmer","keywords":["crops"],"skins":[{"unified":"1f9d1-200d-1f33e","native":"🧑‍🌾"},{"unified":"1f9d1-1f3fb-200d-1f33e","native":"🧑🏻‍🌾"},{"unified":"1f9d1-1f3fc-200d-1f33e","native":"🧑🏼‍🌾"},{"unified":"1f9d1-1f3fd-200d-1f33e","native":"🧑🏽‍🌾"},{"unified":"1f9d1-1f3fe-200d-1f33e","native":"🧑🏾‍🌾"},{"unified":"1f9d1-1f3ff-200d-1f33e","native":"🧑🏿‍🌾"}],"version":12.1},"male-farmer":{"id":"male-farmer","name":"Man Farmer","keywords":["male","rancher","gardener","human"],"skins":[{"unified":"1f468-200d-1f33e","native":"👨‍🌾"},{"unified":"1f468-1f3fb-200d-1f33e","native":"👨🏻‍🌾"},{"unified":"1f468-1f3fc-200d-1f33e","native":"👨🏼‍🌾"},{"unified":"1f468-1f3fd-200d-1f33e","native":"👨🏽‍🌾"},{"unified":"1f468-1f3fe-200d-1f33e","native":"👨🏾‍🌾"},{"unified":"1f468-1f3ff-200d-1f33e","native":"👨🏿‍🌾"}],"version":4},"female-farmer":{"id":"female-farmer","name":"Woman Farmer","keywords":["female","rancher","gardener","human"],"skins":[{"unified":"1f469-200d-1f33e","native":"👩‍🌾"},{"unified":"1f469-1f3fb-200d-1f33e","native":"👩🏻‍🌾"},{"unified":"1f469-1f3fc-200d-1f33e","native":"👩🏼‍🌾"},{"unified":"1f469-1f3fd-200d-1f33e","native":"👩🏽‍🌾"},{"unified":"1f469-1f3fe-200d-1f33e","native":"👩🏾‍🌾"},{"unified":"1f469-1f3ff-200d-1f33e","native":"👩🏿‍🌾"}],"version":4},"cook":{"id":"cook","name":"Cook","keywords":["food","kitchen","culinary"],"skins":[{"unified":"1f9d1-200d-1f373","native":"🧑‍🍳"},{"unified":"1f9d1-1f3fb-200d-1f373","native":"🧑🏻‍🍳"},{"unified":"1f9d1-1f3fc-200d-1f373","native":"🧑🏼‍🍳"},{"unified":"1f9d1-1f3fd-200d-1f373","native":"🧑🏽‍🍳"},{"unified":"1f9d1-1f3fe-200d-1f373","native":"🧑🏾‍🍳"},{"unified":"1f9d1-1f3ff-200d-1f373","native":"🧑🏿‍🍳"}],"version":12.1},"male-cook":{"id":"male-cook","name":"Man Cook","keywords":["male","chef","human"],"skins":[{"unified":"1f468-200d-1f373","native":"👨‍🍳"},{"unified":"1f468-1f3fb-200d-1f373","native":"👨🏻‍🍳"},{"unified":"1f468-1f3fc-200d-1f373","native":"👨🏼‍🍳"},{"unified":"1f468-1f3fd-200d-1f373","native":"👨🏽‍🍳"},{"unified":"1f468-1f3fe-200d-1f373","native":"👨🏾‍🍳"},{"unified":"1f468-1f3ff-200d-1f373","native":"👨🏿‍🍳"}],"version":4},"female-cook":{"id":"female-cook","name":"Woman Cook","keywords":["female","chef","human"],"skins":[{"unified":"1f469-200d-1f373","native":"👩‍🍳"},{"unified":"1f469-1f3fb-200d-1f373","native":"👩🏻‍🍳"},{"unified":"1f469-1f3fc-200d-1f373","native":"👩🏼‍🍳"},{"unified":"1f469-1f3fd-200d-1f373","native":"👩🏽‍🍳"},{"unified":"1f469-1f3fe-200d-1f373","native":"👩🏾‍🍳"},{"unified":"1f469-1f3ff-200d-1f373","native":"👩🏿‍🍳"}],"version":4},"mechanic":{"id":"mechanic","name":"Mechanic","keywords":["worker","technician"],"skins":[{"unified":"1f9d1-200d-1f527","native":"🧑‍🔧"},{"unified":"1f9d1-1f3fb-200d-1f527","native":"🧑🏻‍🔧"},{"unified":"1f9d1-1f3fc-200d-1f527","native":"🧑🏼‍🔧"},{"unified":"1f9d1-1f3fd-200d-1f527","native":"🧑🏽‍🔧"},{"unified":"1f9d1-1f3fe-200d-1f527","native":"🧑🏾‍🔧"},{"unified":"1f9d1-1f3ff-200d-1f527","native":"🧑🏿‍🔧"}],"version":12.1},"male-mechanic":{"id":"male-mechanic","name":"Man Mechanic","keywords":["male","plumber","human","wrench"],"skins":[{"unified":"1f468-200d-1f527","native":"👨‍🔧"},{"unified":"1f468-1f3fb-200d-1f527","native":"👨🏻‍🔧"},{"unified":"1f468-1f3fc-200d-1f527","native":"👨🏼‍🔧"},{"unified":"1f468-1f3fd-200d-1f527","native":"👨🏽‍🔧"},{"unified":"1f468-1f3fe-200d-1f527","native":"👨🏾‍🔧"},{"unified":"1f468-1f3ff-200d-1f527","native":"👨🏿‍🔧"}],"version":4},"female-mechanic":{"id":"female-mechanic","name":"Woman Mechanic","keywords":["female","plumber","human","wrench"],"skins":[{"unified":"1f469-200d-1f527","native":"👩‍🔧"},{"unified":"1f469-1f3fb-200d-1f527","native":"👩🏻‍🔧"},{"unified":"1f469-1f3fc-200d-1f527","native":"👩🏼‍🔧"},{"unified":"1f469-1f3fd-200d-1f527","native":"👩🏽‍🔧"},{"unified":"1f469-1f3fe-200d-1f527","native":"👩🏾‍🔧"},{"unified":"1f469-1f3ff-200d-1f527","native":"👩🏿‍🔧"}],"version":4},"factory_worker":{"id":"factory_worker","name":"Factory Worker","keywords":["labor"],"skins":[{"unified":"1f9d1-200d-1f3ed","native":"🧑‍🏭"},{"unified":"1f9d1-1f3fb-200d-1f3ed","native":"🧑🏻‍🏭"},{"unified":"1f9d1-1f3fc-200d-1f3ed","native":"🧑🏼‍🏭"},{"unified":"1f9d1-1f3fd-200d-1f3ed","native":"🧑🏽‍🏭"},{"unified":"1f9d1-1f3fe-200d-1f3ed","native":"🧑🏾‍🏭"},{"unified":"1f9d1-1f3ff-200d-1f3ed","native":"🧑🏿‍🏭"}],"version":12.1},"male-factory-worker":{"id":"male-factory-worker","name":"Man Factory Worker","keywords":["male","factory-worker","assembly","industrial","human"],"skins":[{"unified":"1f468-200d-1f3ed","native":"👨‍🏭"},{"unified":"1f468-1f3fb-200d-1f3ed","native":"👨🏻‍🏭"},{"unified":"1f468-1f3fc-200d-1f3ed","native":"👨🏼‍🏭"},{"unified":"1f468-1f3fd-200d-1f3ed","native":"👨🏽‍🏭"},{"unified":"1f468-1f3fe-200d-1f3ed","native":"👨🏾‍🏭"},{"unified":"1f468-1f3ff-200d-1f3ed","native":"👨🏿‍🏭"}],"version":4},"female-factory-worker":{"id":"female-factory-worker","name":"Woman Factory Worker","keywords":["female","factory-worker","assembly","industrial","human"],"skins":[{"unified":"1f469-200d-1f3ed","native":"👩‍🏭"},{"unified":"1f469-1f3fb-200d-1f3ed","native":"👩🏻‍🏭"},{"unified":"1f469-1f3fc-200d-1f3ed","native":"👩🏼‍🏭"},{"unified":"1f469-1f3fd-200d-1f3ed","native":"👩🏽‍🏭"},{"unified":"1f469-1f3fe-200d-1f3ed","native":"👩🏾‍🏭"},{"unified":"1f469-1f3ff-200d-1f3ed","native":"👩🏿‍🏭"}],"version":4},"office_worker":{"id":"office_worker","name":"Office Worker","keywords":["business"],"skins":[{"unified":"1f9d1-200d-1f4bc","native":"🧑‍💼"},{"unified":"1f9d1-1f3fb-200d-1f4bc","native":"🧑🏻‍💼"},{"unified":"1f9d1-1f3fc-200d-1f4bc","native":"🧑🏼‍💼"},{"unified":"1f9d1-1f3fd-200d-1f4bc","native":"🧑🏽‍💼"},{"unified":"1f9d1-1f3fe-200d-1f4bc","native":"🧑🏾‍💼"},{"unified":"1f9d1-1f3ff-200d-1f4bc","native":"🧑🏿‍💼"}],"version":12.1},"male-office-worker":{"id":"male-office-worker","name":"Man Office Worker","keywords":["male","office-worker","business","manager","human"],"skins":[{"unified":"1f468-200d-1f4bc","native":"👨‍💼"},{"unified":"1f468-1f3fb-200d-1f4bc","native":"👨🏻‍💼"},{"unified":"1f468-1f3fc-200d-1f4bc","native":"👨🏼‍💼"},{"unified":"1f468-1f3fd-200d-1f4bc","native":"👨🏽‍💼"},{"unified":"1f468-1f3fe-200d-1f4bc","native":"👨🏾‍💼"},{"unified":"1f468-1f3ff-200d-1f4bc","native":"👨🏿‍💼"}],"version":4},"female-office-worker":{"id":"female-office-worker","name":"Woman Office Worker","keywords":["female","office-worker","business","manager","human"],"skins":[{"unified":"1f469-200d-1f4bc","native":"👩‍💼"},{"unified":"1f469-1f3fb-200d-1f4bc","native":"👩🏻‍💼"},{"unified":"1f469-1f3fc-200d-1f4bc","native":"👩🏼‍💼"},{"unified":"1f469-1f3fd-200d-1f4bc","native":"👩🏽‍💼"},{"unified":"1f469-1f3fe-200d-1f4bc","native":"👩🏾‍💼"},{"unified":"1f469-1f3ff-200d-1f4bc","native":"👩🏿‍💼"}],"version":4},"scientist":{"id":"scientist","name":"Scientist","keywords":["chemistry"],"skins":[{"unified":"1f9d1-200d-1f52c","native":"🧑‍🔬"},{"unified":"1f9d1-1f3fb-200d-1f52c","native":"🧑🏻‍🔬"},{"unified":"1f9d1-1f3fc-200d-1f52c","native":"🧑🏼‍🔬"},{"unified":"1f9d1-1f3fd-200d-1f52c","native":"🧑🏽‍🔬"},{"unified":"1f9d1-1f3fe-200d-1f52c","native":"🧑🏾‍🔬"},{"unified":"1f9d1-1f3ff-200d-1f52c","native":"🧑🏿‍🔬"}],"version":12.1},"male-scientist":{"id":"male-scientist","name":"Man Scientist","keywords":["male","biologist","chemist","engineer","physicist","human"],"skins":[{"unified":"1f468-200d-1f52c","native":"👨‍🔬"},{"unified":"1f468-1f3fb-200d-1f52c","native":"👨🏻‍🔬"},{"unified":"1f468-1f3fc-200d-1f52c","native":"👨🏼‍🔬"},{"unified":"1f468-1f3fd-200d-1f52c","native":"👨🏽‍🔬"},{"unified":"1f468-1f3fe-200d-1f52c","native":"👨🏾‍🔬"},{"unified":"1f468-1f3ff-200d-1f52c","native":"👨🏿‍🔬"}],"version":4},"female-scientist":{"id":"female-scientist","name":"Woman Scientist","keywords":["female","biologist","chemist","engineer","physicist","human"],"skins":[{"unified":"1f469-200d-1f52c","native":"👩‍🔬"},{"unified":"1f469-1f3fb-200d-1f52c","native":"👩🏻‍🔬"},{"unified":"1f469-1f3fc-200d-1f52c","native":"👩🏼‍🔬"},{"unified":"1f469-1f3fd-200d-1f52c","native":"👩🏽‍🔬"},{"unified":"1f469-1f3fe-200d-1f52c","native":"👩🏾‍🔬"},{"unified":"1f469-1f3ff-200d-1f52c","native":"👩🏿‍🔬"}],"version":4},"technologist":{"id":"technologist","name":"Technologist","keywords":["computer"],"skins":[{"unified":"1f9d1-200d-1f4bb","native":"🧑‍💻"},{"unified":"1f9d1-1f3fb-200d-1f4bb","native":"🧑🏻‍💻"},{"unified":"1f9d1-1f3fc-200d-1f4bb","native":"🧑🏼‍💻"},{"unified":"1f9d1-1f3fd-200d-1f4bb","native":"🧑🏽‍💻"},{"unified":"1f9d1-1f3fe-200d-1f4bb","native":"🧑🏾‍💻"},{"unified":"1f9d1-1f3ff-200d-1f4bb","native":"🧑🏿‍💻"}],"version":12.1},"male-technologist":{"id":"male-technologist","name":"Man Technologist","keywords":["male","coder","developer","engineer","programmer","software","human","laptop","computer"],"skins":[{"unified":"1f468-200d-1f4bb","native":"👨‍💻"},{"unified":"1f468-1f3fb-200d-1f4bb","native":"👨🏻‍💻"},{"unified":"1f468-1f3fc-200d-1f4bb","native":"👨🏼‍💻"},{"unified":"1f468-1f3fd-200d-1f4bb","native":"👨🏽‍💻"},{"unified":"1f468-1f3fe-200d-1f4bb","native":"👨🏾‍💻"},{"unified":"1f468-1f3ff-200d-1f4bb","native":"👨🏿‍💻"}],"version":4},"female-technologist":{"id":"female-technologist","name":"Woman Technologist","keywords":["female","coder","developer","engineer","programmer","software","human","laptop","computer"],"skins":[{"unified":"1f469-200d-1f4bb","native":"👩‍💻"},{"unified":"1f469-1f3fb-200d-1f4bb","native":"👩🏻‍💻"},{"unified":"1f469-1f3fc-200d-1f4bb","native":"👩🏼‍💻"},{"unified":"1f469-1f3fd-200d-1f4bb","native":"👩🏽‍💻"},{"unified":"1f469-1f3fe-200d-1f4bb","native":"👩🏾‍💻"},{"unified":"1f469-1f3ff-200d-1f4bb","native":"👩🏿‍💻"}],"version":4},"singer":{"id":"singer","name":"Singer","keywords":["song","artist","performer"],"skins":[{"unified":"1f9d1-200d-1f3a4","native":"🧑‍🎤"},{"unified":"1f9d1-1f3fb-200d-1f3a4","native":"🧑🏻‍🎤"},{"unified":"1f9d1-1f3fc-200d-1f3a4","native":"🧑🏼‍🎤"},{"unified":"1f9d1-1f3fd-200d-1f3a4","native":"🧑🏽‍🎤"},{"unified":"1f9d1-1f3fe-200d-1f3a4","native":"🧑🏾‍🎤"},{"unified":"1f9d1-1f3ff-200d-1f3a4","native":"🧑🏿‍🎤"}],"version":12.1},"male-singer":{"id":"male-singer","name":"Man Singer","keywords":["male","rockstar","entertainer","human"],"skins":[{"unified":"1f468-200d-1f3a4","native":"👨‍🎤"},{"unified":"1f468-1f3fb-200d-1f3a4","native":"👨🏻‍🎤"},{"unified":"1f468-1f3fc-200d-1f3a4","native":"👨🏼‍🎤"},{"unified":"1f468-1f3fd-200d-1f3a4","native":"👨🏽‍🎤"},{"unified":"1f468-1f3fe-200d-1f3a4","native":"👨🏾‍🎤"},{"unified":"1f468-1f3ff-200d-1f3a4","native":"👨🏿‍🎤"}],"version":4},"female-singer":{"id":"female-singer","name":"Woman Singer","keywords":["female","rockstar","entertainer","human"],"skins":[{"unified":"1f469-200d-1f3a4","native":"👩‍🎤"},{"unified":"1f469-1f3fb-200d-1f3a4","native":"👩🏻‍🎤"},{"unified":"1f469-1f3fc-200d-1f3a4","native":"👩🏼‍🎤"},{"unified":"1f469-1f3fd-200d-1f3a4","native":"👩🏽‍🎤"},{"unified":"1f469-1f3fe-200d-1f3a4","native":"👩🏾‍🎤"},{"unified":"1f469-1f3ff-200d-1f3a4","native":"👩🏿‍🎤"}],"version":4},"artist":{"id":"artist","name":"Artist","keywords":["painting","draw","creativity"],"skins":[{"unified":"1f9d1-200d-1f3a8","native":"🧑‍🎨"},{"unified":"1f9d1-1f3fb-200d-1f3a8","native":"🧑🏻‍🎨"},{"unified":"1f9d1-1f3fc-200d-1f3a8","native":"🧑🏼‍🎨"},{"unified":"1f9d1-1f3fd-200d-1f3a8","native":"🧑🏽‍🎨"},{"unified":"1f9d1-1f3fe-200d-1f3a8","native":"🧑🏾‍🎨"},{"unified":"1f9d1-1f3ff-200d-1f3a8","native":"🧑🏿‍🎨"}],"version":12.1},"male-artist":{"id":"male-artist","name":"Man Artist","keywords":["male","painter","human"],"skins":[{"unified":"1f468-200d-1f3a8","native":"👨‍🎨"},{"unified":"1f468-1f3fb-200d-1f3a8","native":"👨🏻‍🎨"},{"unified":"1f468-1f3fc-200d-1f3a8","native":"👨🏼‍🎨"},{"unified":"1f468-1f3fd-200d-1f3a8","native":"👨🏽‍🎨"},{"unified":"1f468-1f3fe-200d-1f3a8","native":"👨🏾‍🎨"},{"unified":"1f468-1f3ff-200d-1f3a8","native":"👨🏿‍🎨"}],"version":4},"female-artist":{"id":"female-artist","name":"Woman Artist","keywords":["female","painter","human"],"skins":[{"unified":"1f469-200d-1f3a8","native":"👩‍🎨"},{"unified":"1f469-1f3fb-200d-1f3a8","native":"👩🏻‍🎨"},{"unified":"1f469-1f3fc-200d-1f3a8","native":"👩🏼‍🎨"},{"unified":"1f469-1f3fd-200d-1f3a8","native":"👩🏽‍🎨"},{"unified":"1f469-1f3fe-200d-1f3a8","native":"👩🏾‍🎨"},{"unified":"1f469-1f3ff-200d-1f3a8","native":"👩🏿‍🎨"}],"version":4},"pilot":{"id":"pilot","name":"Pilot","keywords":["fly","plane","airplane"],"skins":[{"unified":"1f9d1-200d-2708-fe0f","native":"🧑‍✈️"},{"unified":"1f9d1-1f3fb-200d-2708-fe0f","native":"🧑🏻‍✈️"},{"unified":"1f9d1-1f3fc-200d-2708-fe0f","native":"🧑🏼‍✈️"},{"unified":"1f9d1-1f3fd-200d-2708-fe0f","native":"🧑🏽‍✈️"},{"unified":"1f9d1-1f3fe-200d-2708-fe0f","native":"🧑🏾‍✈️"},{"unified":"1f9d1-1f3ff-200d-2708-fe0f","native":"🧑🏿‍✈️"}],"version":12.1},"male-pilot":{"id":"male-pilot","name":"Man Pilot","keywords":["male","aviator","plane","human"],"skins":[{"unified":"1f468-200d-2708-fe0f","native":"👨‍✈️"},{"unified":"1f468-1f3fb-200d-2708-fe0f","native":"👨🏻‍✈️"},{"unified":"1f468-1f3fc-200d-2708-fe0f","native":"👨🏼‍✈️"},{"unified":"1f468-1f3fd-200d-2708-fe0f","native":"👨🏽‍✈️"},{"unified":"1f468-1f3fe-200d-2708-fe0f","native":"👨🏾‍✈️"},{"unified":"1f468-1f3ff-200d-2708-fe0f","native":"👨🏿‍✈️"}],"version":4},"female-pilot":{"id":"female-pilot","name":"Woman Pilot","keywords":["female","aviator","plane","human"],"skins":[{"unified":"1f469-200d-2708-fe0f","native":"👩‍✈️"},{"unified":"1f469-1f3fb-200d-2708-fe0f","native":"👩🏻‍✈️"},{"unified":"1f469-1f3fc-200d-2708-fe0f","native":"👩🏼‍✈️"},{"unified":"1f469-1f3fd-200d-2708-fe0f","native":"👩🏽‍✈️"},{"unified":"1f469-1f3fe-200d-2708-fe0f","native":"👩🏾‍✈️"},{"unified":"1f469-1f3ff-200d-2708-fe0f","native":"👩🏿‍✈️"}],"version":4},"astronaut":{"id":"astronaut","name":"Astronaut","keywords":["outerspace"],"skins":[{"unified":"1f9d1-200d-1f680","native":"🧑‍🚀"},{"unified":"1f9d1-1f3fb-200d-1f680","native":"🧑🏻‍🚀"},{"unified":"1f9d1-1f3fc-200d-1f680","native":"🧑🏼‍🚀"},{"unified":"1f9d1-1f3fd-200d-1f680","native":"🧑🏽‍🚀"},{"unified":"1f9d1-1f3fe-200d-1f680","native":"🧑🏾‍🚀"},{"unified":"1f9d1-1f3ff-200d-1f680","native":"🧑🏿‍🚀"}],"version":12.1},"male-astronaut":{"id":"male-astronaut","name":"Man Astronaut","keywords":["male","space","rocket","human"],"skins":[{"unified":"1f468-200d-1f680","native":"👨‍🚀"},{"unified":"1f468-1f3fb-200d-1f680","native":"👨🏻‍🚀"},{"unified":"1f468-1f3fc-200d-1f680","native":"👨🏼‍🚀"},{"unified":"1f468-1f3fd-200d-1f680","native":"👨🏽‍🚀"},{"unified":"1f468-1f3fe-200d-1f680","native":"👨🏾‍🚀"},{"unified":"1f468-1f3ff-200d-1f680","native":"👨🏿‍🚀"}],"version":4},"female-astronaut":{"id":"female-astronaut","name":"Woman Astronaut","keywords":["female","space","rocket","human"],"skins":[{"unified":"1f469-200d-1f680","native":"👩‍🚀"},{"unified":"1f469-1f3fb-200d-1f680","native":"👩🏻‍🚀"},{"unified":"1f469-1f3fc-200d-1f680","native":"👩🏼‍🚀"},{"unified":"1f469-1f3fd-200d-1f680","native":"👩🏽‍🚀"},{"unified":"1f469-1f3fe-200d-1f680","native":"👩🏾‍🚀"},{"unified":"1f469-1f3ff-200d-1f680","native":"👩🏿‍🚀"}],"version":4},"firefighter":{"id":"firefighter","name":"Firefighter","keywords":["fire"],"skins":[{"unified":"1f9d1-200d-1f692","native":"🧑‍🚒"},{"unified":"1f9d1-1f3fb-200d-1f692","native":"🧑🏻‍🚒"},{"unified":"1f9d1-1f3fc-200d-1f692","native":"🧑🏼‍🚒"},{"unified":"1f9d1-1f3fd-200d-1f692","native":"🧑🏽‍🚒"},{"unified":"1f9d1-1f3fe-200d-1f692","native":"🧑🏾‍🚒"},{"unified":"1f9d1-1f3ff-200d-1f692","native":"🧑🏿‍🚒"}],"version":12.1},"male-firefighter":{"id":"male-firefighter","name":"Man Firefighter","keywords":["male","fireman","human"],"skins":[{"unified":"1f468-200d-1f692","native":"👨‍🚒"},{"unified":"1f468-1f3fb-200d-1f692","native":"👨🏻‍🚒"},{"unified":"1f468-1f3fc-200d-1f692","native":"👨🏼‍🚒"},{"unified":"1f468-1f3fd-200d-1f692","native":"👨🏽‍🚒"},{"unified":"1f468-1f3fe-200d-1f692","native":"👨🏾‍🚒"},{"unified":"1f468-1f3ff-200d-1f692","native":"👨🏿‍🚒"}],"version":4},"female-firefighter":{"id":"female-firefighter","name":"Woman Firefighter","keywords":["female","fireman","human"],"skins":[{"unified":"1f469-200d-1f692","native":"👩‍🚒"},{"unified":"1f469-1f3fb-200d-1f692","native":"👩🏻‍🚒"},{"unified":"1f469-1f3fc-200d-1f692","native":"👩🏼‍🚒"},{"unified":"1f469-1f3fd-200d-1f692","native":"👩🏽‍🚒"},{"unified":"1f469-1f3fe-200d-1f692","native":"👩🏾‍🚒"},{"unified":"1f469-1f3ff-200d-1f692","native":"👩🏿‍🚒"}],"version":4},"cop":{"id":"cop","name":"Police Officer","keywords":["cop"],"skins":[{"unified":"1f46e","native":"👮"},{"unified":"1f46e-1f3fb","native":"👮🏻"},{"unified":"1f46e-1f3fc","native":"👮🏼"},{"unified":"1f46e-1f3fd","native":"👮🏽"},{"unified":"1f46e-1f3fe","native":"👮🏾"},{"unified":"1f46e-1f3ff","native":"👮🏿"}],"version":1},"male-police-officer":{"id":"male-police-officer","name":"Man Police Officer","keywords":["male","police-officer","law","legal","enforcement","arrest","911"],"skins":[{"unified":"1f46e-200d-2642-fe0f","native":"👮‍♂️"},{"unified":"1f46e-1f3fb-200d-2642-fe0f","native":"👮🏻‍♂️"},{"unified":"1f46e-1f3fc-200d-2642-fe0f","native":"👮🏼‍♂️"},{"unified":"1f46e-1f3fd-200d-2642-fe0f","native":"👮🏽‍♂️"},{"unified":"1f46e-1f3fe-200d-2642-fe0f","native":"👮🏾‍♂️"},{"unified":"1f46e-1f3ff-200d-2642-fe0f","native":"👮🏿‍♂️"}],"version":4},"female-police-officer":{"id":"female-police-officer","name":"Woman Police Officer","keywords":["female","police-officer","law","legal","enforcement","arrest","911"],"skins":[{"unified":"1f46e-200d-2640-fe0f","native":"👮‍♀️"},{"unified":"1f46e-1f3fb-200d-2640-fe0f","native":"👮🏻‍♀️"},{"unified":"1f46e-1f3fc-200d-2640-fe0f","native":"👮🏼‍♀️"},{"unified":"1f46e-1f3fd-200d-2640-fe0f","native":"👮🏽‍♀️"},{"unified":"1f46e-1f3fe-200d-2640-fe0f","native":"👮🏾‍♀️"},{"unified":"1f46e-1f3ff-200d-2640-fe0f","native":"👮🏿‍♀️"}],"version":4},"sleuth_or_spy":{"id":"sleuth_or_spy","name":"Detective","keywords":["sleuth","or","spy","human"],"skins":[{"unified":"1f575-fe0f","native":"🕵️"},{"unified":"1f575-1f3fb","native":"🕵🏻"},{"unified":"1f575-1f3fc","native":"🕵🏼"},{"unified":"1f575-1f3fd","native":"🕵🏽"},{"unified":"1f575-1f3fe","native":"🕵🏾"},{"unified":"1f575-1f3ff","native":"🕵🏿"}],"version":1},"male-detective":{"id":"male-detective","name":"Man Detective","keywords":["male","crime"],"skins":[{"unified":"1f575-fe0f-200d-2642-fe0f","native":"🕵️‍♂️"},{"unified":"1f575-1f3fb-200d-2642-fe0f","native":"🕵🏻‍♂️"},{"unified":"1f575-1f3fc-200d-2642-fe0f","native":"🕵🏼‍♂️"},{"unified":"1f575-1f3fd-200d-2642-fe0f","native":"🕵🏽‍♂️"},{"unified":"1f575-1f3fe-200d-2642-fe0f","native":"🕵🏾‍♂️"},{"unified":"1f575-1f3ff-200d-2642-fe0f","native":"🕵🏿‍♂️"}],"version":4},"female-detective":{"id":"female-detective","name":"Woman Detective","keywords":["female","human","spy"],"skins":[{"unified":"1f575-fe0f-200d-2640-fe0f","native":"🕵️‍♀️"},{"unified":"1f575-1f3fb-200d-2640-fe0f","native":"🕵🏻‍♀️"},{"unified":"1f575-1f3fc-200d-2640-fe0f","native":"🕵🏼‍♀️"},{"unified":"1f575-1f3fd-200d-2640-fe0f","native":"🕵🏽‍♀️"},{"unified":"1f575-1f3fe-200d-2640-fe0f","native":"🕵🏾‍♀️"},{"unified":"1f575-1f3ff-200d-2640-fe0f","native":"🕵🏿‍♀️"}],"version":4},"guardsman":{"id":"guardsman","name":"Guard","keywords":["guardsman","protect"],"skins":[{"unified":"1f482","native":"💂"},{"unified":"1f482-1f3fb","native":"💂🏻"},{"unified":"1f482-1f3fc","native":"💂🏼"},{"unified":"1f482-1f3fd","native":"💂🏽"},{"unified":"1f482-1f3fe","native":"💂🏾"},{"unified":"1f482-1f3ff","native":"💂🏿"}],"version":1},"male-guard":{"id":"male-guard","name":"Man Guard","keywords":["male","uk","gb","british","guy","royal"],"skins":[{"unified":"1f482-200d-2642-fe0f","native":"💂‍♂️"},{"unified":"1f482-1f3fb-200d-2642-fe0f","native":"💂🏻‍♂️"},{"unified":"1f482-1f3fc-200d-2642-fe0f","native":"💂🏼‍♂️"},{"unified":"1f482-1f3fd-200d-2642-fe0f","native":"💂🏽‍♂️"},{"unified":"1f482-1f3fe-200d-2642-fe0f","native":"💂🏾‍♂️"},{"unified":"1f482-1f3ff-200d-2642-fe0f","native":"💂🏿‍♂️"}],"version":4},"female-guard":{"id":"female-guard","name":"Woman Guard","keywords":["female","uk","gb","british","royal"],"skins":[{"unified":"1f482-200d-2640-fe0f","native":"💂‍♀️"},{"unified":"1f482-1f3fb-200d-2640-fe0f","native":"💂🏻‍♀️"},{"unified":"1f482-1f3fc-200d-2640-fe0f","native":"💂🏼‍♀️"},{"unified":"1f482-1f3fd-200d-2640-fe0f","native":"💂🏽‍♀️"},{"unified":"1f482-1f3fe-200d-2640-fe0f","native":"💂🏾‍♀️"},{"unified":"1f482-1f3ff-200d-2640-fe0f","native":"💂🏿‍♀️"}],"version":4},"ninja":{"id":"ninja","name":"Ninja","keywords":["ninjutsu","skills","japanese"],"skins":[{"unified":"1f977","native":"🥷"},{"unified":"1f977-1f3fb","native":"🥷🏻"},{"unified":"1f977-1f3fc","native":"🥷🏼"},{"unified":"1f977-1f3fd","native":"🥷🏽"},{"unified":"1f977-1f3fe","native":"🥷🏾"},{"unified":"1f977-1f3ff","native":"🥷🏿"}],"version":13},"construction_worker":{"id":"construction_worker","name":"Construction Worker","keywords":["labor","build"],"skins":[{"unified":"1f477","native":"👷"},{"unified":"1f477-1f3fb","native":"👷🏻"},{"unified":"1f477-1f3fc","native":"👷🏼"},{"unified":"1f477-1f3fd","native":"👷🏽"},{"unified":"1f477-1f3fe","native":"👷🏾"},{"unified":"1f477-1f3ff","native":"👷🏿"}],"version":1},"male-construction-worker":{"id":"male-construction-worker","name":"Man Construction Worker","keywords":["male","construction-worker","human","wip","guy","build","labor"],"skins":[{"unified":"1f477-200d-2642-fe0f","native":"👷‍♂️"},{"unified":"1f477-1f3fb-200d-2642-fe0f","native":"👷🏻‍♂️"},{"unified":"1f477-1f3fc-200d-2642-fe0f","native":"👷🏼‍♂️"},{"unified":"1f477-1f3fd-200d-2642-fe0f","native":"👷🏽‍♂️"},{"unified":"1f477-1f3fe-200d-2642-fe0f","native":"👷🏾‍♂️"},{"unified":"1f477-1f3ff-200d-2642-fe0f","native":"👷🏿‍♂️"}],"version":4},"female-construction-worker":{"id":"female-construction-worker","name":"Woman Construction Worker","keywords":["female","construction-worker","human","wip","build","labor"],"skins":[{"unified":"1f477-200d-2640-fe0f","native":"👷‍♀️"},{"unified":"1f477-1f3fb-200d-2640-fe0f","native":"👷🏻‍♀️"},{"unified":"1f477-1f3fc-200d-2640-fe0f","native":"👷🏼‍♀️"},{"unified":"1f477-1f3fd-200d-2640-fe0f","native":"👷🏽‍♀️"},{"unified":"1f477-1f3fe-200d-2640-fe0f","native":"👷🏾‍♀️"},{"unified":"1f477-1f3ff-200d-2640-fe0f","native":"👷🏿‍♀️"}],"version":4},"person_with_crown":{"id":"person_with_crown","name":"Person with Crown","keywords":["royalty","power"],"skins":[{"unified":"1fac5","native":"🫅"},{"unified":"1fac5-1f3fb","native":"🫅🏻"},{"unified":"1fac5-1f3fc","native":"🫅🏼"},{"unified":"1fac5-1f3fd","native":"🫅🏽"},{"unified":"1fac5-1f3fe","native":"🫅🏾"},{"unified":"1fac5-1f3ff","native":"🫅🏿"}],"version":14},"prince":{"id":"prince","name":"Prince","keywords":["boy","man","male","crown","royal","king"],"skins":[{"unified":"1f934","native":"🤴"},{"unified":"1f934-1f3fb","native":"🤴🏻"},{"unified":"1f934-1f3fc","native":"🤴🏼"},{"unified":"1f934-1f3fd","native":"🤴🏽"},{"unified":"1f934-1f3fe","native":"🤴🏾"},{"unified":"1f934-1f3ff","native":"🤴🏿"}],"version":3},"princess":{"id":"princess","name":"Princess","keywords":["girl","woman","female","blond","crown","royal","queen"],"skins":[{"unified":"1f478","native":"👸"},{"unified":"1f478-1f3fb","native":"👸🏻"},{"unified":"1f478-1f3fc","native":"👸🏼"},{"unified":"1f478-1f3fd","native":"👸🏽"},{"unified":"1f478-1f3fe","native":"👸🏾"},{"unified":"1f478-1f3ff","native":"👸🏿"}],"version":1},"man_with_turban":{"id":"man_with_turban","name":"Man with Turban","keywords":["person","wearing","headdress"],"skins":[{"unified":"1f473","native":"👳"},{"unified":"1f473-1f3fb","native":"👳🏻"},{"unified":"1f473-1f3fc","native":"👳🏼"},{"unified":"1f473-1f3fd","native":"👳🏽"},{"unified":"1f473-1f3fe","native":"👳🏾"},{"unified":"1f473-1f3ff","native":"👳🏿"}],"version":1},"man-wearing-turban":{"id":"man-wearing-turban","name":"Man Wearing Turban","keywords":["wearing-turban","male","indian","hinduism","arabs"],"skins":[{"unified":"1f473-200d-2642-fe0f","native":"👳‍♂️"},{"unified":"1f473-1f3fb-200d-2642-fe0f","native":"👳🏻‍♂️"},{"unified":"1f473-1f3fc-200d-2642-fe0f","native":"👳🏼‍♂️"},{"unified":"1f473-1f3fd-200d-2642-fe0f","native":"👳🏽‍♂️"},{"unified":"1f473-1f3fe-200d-2642-fe0f","native":"👳🏾‍♂️"},{"unified":"1f473-1f3ff-200d-2642-fe0f","native":"👳🏿‍♂️"}],"version":4},"woman-wearing-turban":{"id":"woman-wearing-turban","name":"Woman Wearing Turban","keywords":["wearing-turban","female","indian","hinduism","arabs"],"skins":[{"unified":"1f473-200d-2640-fe0f","native":"👳‍♀️"},{"unified":"1f473-1f3fb-200d-2640-fe0f","native":"👳🏻‍♀️"},{"unified":"1f473-1f3fc-200d-2640-fe0f","native":"👳🏼‍♀️"},{"unified":"1f473-1f3fd-200d-2640-fe0f","native":"👳🏽‍♀️"},{"unified":"1f473-1f3fe-200d-2640-fe0f","native":"👳🏾‍♀️"},{"unified":"1f473-1f3ff-200d-2640-fe0f","native":"👳🏿‍♀️"}],"version":4},"man_with_gua_pi_mao":{"id":"man_with_gua_pi_mao","name":"Man with Gua Pi Mao","keywords":["skullcap","male","boy","chinese"],"skins":[{"unified":"1f472","native":"👲"},{"unified":"1f472-1f3fb","native":"👲🏻"},{"unified":"1f472-1f3fc","native":"👲🏼"},{"unified":"1f472-1f3fd","native":"👲🏽"},{"unified":"1f472-1f3fe","native":"👲🏾"},{"unified":"1f472-1f3ff","native":"👲🏿"}],"version":1},"person_with_headscarf":{"id":"person_with_headscarf","name":"Woman with Headscarf","keywords":["person","female","hijab","mantilla","tichel"],"skins":[{"unified":"1f9d5","native":"🧕"},{"unified":"1f9d5-1f3fb","native":"🧕🏻"},{"unified":"1f9d5-1f3fc","native":"🧕🏼"},{"unified":"1f9d5-1f3fd","native":"🧕🏽"},{"unified":"1f9d5-1f3fe","native":"🧕🏾"},{"unified":"1f9d5-1f3ff","native":"🧕🏿"}],"version":5},"person_in_tuxedo":{"id":"person_in_tuxedo","name":"Man in Tuxedo","keywords":["person","couple","marriage","wedding","groom"],"skins":[{"unified":"1f935","native":"🤵"},{"unified":"1f935-1f3fb","native":"🤵🏻"},{"unified":"1f935-1f3fc","native":"🤵🏼"},{"unified":"1f935-1f3fd","native":"🤵🏽"},{"unified":"1f935-1f3fe","native":"🤵🏾"},{"unified":"1f935-1f3ff","native":"🤵🏿"}],"version":3},"man_in_tuxedo":{"id":"man_in_tuxedo","name":"Man in Tuxedo","keywords":["formal","fashion"],"skins":[{"unified":"1f935-200d-2642-fe0f","native":"🤵‍♂️"},{"unified":"1f935-1f3fb-200d-2642-fe0f","native":"🤵🏻‍♂️"},{"unified":"1f935-1f3fc-200d-2642-fe0f","native":"🤵🏼‍♂️"},{"unified":"1f935-1f3fd-200d-2642-fe0f","native":"🤵🏽‍♂️"},{"unified":"1f935-1f3fe-200d-2642-fe0f","native":"🤵🏾‍♂️"},{"unified":"1f935-1f3ff-200d-2642-fe0f","native":"🤵🏿‍♂️"}],"version":13},"woman_in_tuxedo":{"id":"woman_in_tuxedo","name":"Woman in Tuxedo","keywords":["formal","fashion"],"skins":[{"unified":"1f935-200d-2640-fe0f","native":"🤵‍♀️"},{"unified":"1f935-1f3fb-200d-2640-fe0f","native":"🤵🏻‍♀️"},{"unified":"1f935-1f3fc-200d-2640-fe0f","native":"🤵🏼‍♀️"},{"unified":"1f935-1f3fd-200d-2640-fe0f","native":"🤵🏽‍♀️"},{"unified":"1f935-1f3fe-200d-2640-fe0f","native":"🤵🏾‍♀️"},{"unified":"1f935-1f3ff-200d-2640-fe0f","native":"🤵🏿‍♀️"}],"version":13},"bride_with_veil":{"id":"bride_with_veil","name":"Bride with Veil","keywords":["couple","marriage","wedding","woman"],"skins":[{"unified":"1f470","native":"👰"},{"unified":"1f470-1f3fb","native":"👰🏻"},{"unified":"1f470-1f3fc","native":"👰🏼"},{"unified":"1f470-1f3fd","native":"👰🏽"},{"unified":"1f470-1f3fe","native":"👰🏾"},{"unified":"1f470-1f3ff","native":"👰🏿"}],"version":1},"man_with_veil":{"id":"man_with_veil","name":"Man with Veil","keywords":["wedding","marriage"],"skins":[{"unified":"1f470-200d-2642-fe0f","native":"👰‍♂️"},{"unified":"1f470-1f3fb-200d-2642-fe0f","native":"👰🏻‍♂️"},{"unified":"1f470-1f3fc-200d-2642-fe0f","native":"👰🏼‍♂️"},{"unified":"1f470-1f3fd-200d-2642-fe0f","native":"👰🏽‍♂️"},{"unified":"1f470-1f3fe-200d-2642-fe0f","native":"👰🏾‍♂️"},{"unified":"1f470-1f3ff-200d-2642-fe0f","native":"👰🏿‍♂️"}],"version":13},"woman_with_veil":{"id":"woman_with_veil","name":"Woman with Veil","keywords":["wedding","marriage"],"skins":[{"unified":"1f470-200d-2640-fe0f","native":"👰‍♀️"},{"unified":"1f470-1f3fb-200d-2640-fe0f","native":"👰🏻‍♀️"},{"unified":"1f470-1f3fc-200d-2640-fe0f","native":"👰🏼‍♀️"},{"unified":"1f470-1f3fd-200d-2640-fe0f","native":"👰🏽‍♀️"},{"unified":"1f470-1f3fe-200d-2640-fe0f","native":"👰🏾‍♀️"},{"unified":"1f470-1f3ff-200d-2640-fe0f","native":"👰🏿‍♀️"}],"version":13},"pregnant_woman":{"id":"pregnant_woman","name":"Pregnant Woman","keywords":["baby"],"skins":[{"unified":"1f930","native":"🤰"},{"unified":"1f930-1f3fb","native":"🤰🏻"},{"unified":"1f930-1f3fc","native":"🤰🏼"},{"unified":"1f930-1f3fd","native":"🤰🏽"},{"unified":"1f930-1f3fe","native":"🤰🏾"},{"unified":"1f930-1f3ff","native":"🤰🏿"}],"version":3},"pregnant_man":{"id":"pregnant_man","name":"Pregnant Man","keywords":["baby","belly"],"skins":[{"unified":"1fac3","native":"🫃"},{"unified":"1fac3-1f3fb","native":"🫃🏻"},{"unified":"1fac3-1f3fc","native":"🫃🏼"},{"unified":"1fac3-1f3fd","native":"🫃🏽"},{"unified":"1fac3-1f3fe","native":"🫃🏾"},{"unified":"1fac3-1f3ff","native":"🫃🏿"}],"version":14},"pregnant_person":{"id":"pregnant_person","name":"Pregnant Person","keywords":["baby","belly"],"skins":[{"unified":"1fac4","native":"🫄"},{"unified":"1fac4-1f3fb","native":"🫄🏻"},{"unified":"1fac4-1f3fc","native":"🫄🏼"},{"unified":"1fac4-1f3fd","native":"🫄🏽"},{"unified":"1fac4-1f3fe","native":"🫄🏾"},{"unified":"1fac4-1f3ff","native":"🫄🏿"}],"version":14},"breast-feeding":{"id":"breast-feeding","name":"Breast-Feeding","keywords":["breast","feeding","nursing","baby"],"skins":[{"unified":"1f931","native":"🤱"},{"unified":"1f931-1f3fb","native":"🤱🏻"},{"unified":"1f931-1f3fc","native":"🤱🏼"},{"unified":"1f931-1f3fd","native":"🤱🏽"},{"unified":"1f931-1f3fe","native":"🤱🏾"},{"unified":"1f931-1f3ff","native":"🤱🏿"}],"version":5},"woman_feeding_baby":{"id":"woman_feeding_baby","name":"Woman Feeding Baby","keywords":["birth","food"],"skins":[{"unified":"1f469-200d-1f37c","native":"👩‍🍼"},{"unified":"1f469-1f3fb-200d-1f37c","native":"👩🏻‍🍼"},{"unified":"1f469-1f3fc-200d-1f37c","native":"👩🏼‍🍼"},{"unified":"1f469-1f3fd-200d-1f37c","native":"👩🏽‍🍼"},{"unified":"1f469-1f3fe-200d-1f37c","native":"👩🏾‍🍼"},{"unified":"1f469-1f3ff-200d-1f37c","native":"👩🏿‍🍼"}],"version":13},"man_feeding_baby":{"id":"man_feeding_baby","name":"Man Feeding Baby","keywords":["birth","food"],"skins":[{"unified":"1f468-200d-1f37c","native":"👨‍🍼"},{"unified":"1f468-1f3fb-200d-1f37c","native":"👨🏻‍🍼"},{"unified":"1f468-1f3fc-200d-1f37c","native":"👨🏼‍🍼"},{"unified":"1f468-1f3fd-200d-1f37c","native":"👨🏽‍🍼"},{"unified":"1f468-1f3fe-200d-1f37c","native":"👨🏾‍🍼"},{"unified":"1f468-1f3ff-200d-1f37c","native":"👨🏿‍🍼"}],"version":13},"person_feeding_baby":{"id":"person_feeding_baby","name":"Person Feeding Baby","keywords":["birth","food"],"skins":[{"unified":"1f9d1-200d-1f37c","native":"🧑‍🍼"},{"unified":"1f9d1-1f3fb-200d-1f37c","native":"🧑🏻‍🍼"},{"unified":"1f9d1-1f3fc-200d-1f37c","native":"🧑🏼‍🍼"},{"unified":"1f9d1-1f3fd-200d-1f37c","native":"🧑🏽‍🍼"},{"unified":"1f9d1-1f3fe-200d-1f37c","native":"🧑🏾‍🍼"},{"unified":"1f9d1-1f3ff-200d-1f37c","native":"🧑🏿‍🍼"}],"version":13},"angel":{"id":"angel","name":"Baby Angel","keywords":["heaven","wings","halo"],"skins":[{"unified":"1f47c","native":"👼"},{"unified":"1f47c-1f3fb","native":"👼🏻"},{"unified":"1f47c-1f3fc","native":"👼🏼"},{"unified":"1f47c-1f3fd","native":"👼🏽"},{"unified":"1f47c-1f3fe","native":"👼🏾"},{"unified":"1f47c-1f3ff","native":"👼🏿"}],"version":1},"santa":{"id":"santa","name":"Santa Claus","keywords":["festival","man","male","xmas","father","christmas"],"skins":[{"unified":"1f385","native":"🎅"},{"unified":"1f385-1f3fb","native":"🎅🏻"},{"unified":"1f385-1f3fc","native":"🎅🏼"},{"unified":"1f385-1f3fd","native":"🎅🏽"},{"unified":"1f385-1f3fe","native":"🎅🏾"},{"unified":"1f385-1f3ff","native":"🎅🏿"}],"version":1},"mrs_claus":{"id":"mrs_claus","name":"Mrs. Claus","keywords":["mrs","mother","christmas","woman","female","xmas"],"skins":[{"unified":"1f936","native":"🤶"},{"unified":"1f936-1f3fb","native":"🤶🏻"},{"unified":"1f936-1f3fc","native":"🤶🏼"},{"unified":"1f936-1f3fd","native":"🤶🏽"},{"unified":"1f936-1f3fe","native":"🤶🏾"},{"unified":"1f936-1f3ff","native":"🤶🏿"}],"version":3},"mx_claus":{"id":"mx_claus","name":"Mx Claus","keywords":["christmas"],"skins":[{"unified":"1f9d1-200d-1f384","native":"🧑‍🎄"},{"unified":"1f9d1-1f3fb-200d-1f384","native":"🧑🏻‍🎄"},{"unified":"1f9d1-1f3fc-200d-1f384","native":"🧑🏼‍🎄"},{"unified":"1f9d1-1f3fd-200d-1f384","native":"🧑🏽‍🎄"},{"unified":"1f9d1-1f3fe-200d-1f384","native":"🧑🏾‍🎄"},{"unified":"1f9d1-1f3ff-200d-1f384","native":"🧑🏿‍🎄"}],"version":13},"superhero":{"id":"superhero","name":"Superhero","keywords":["marvel"],"skins":[{"unified":"1f9b8","native":"🦸"},{"unified":"1f9b8-1f3fb","native":"🦸🏻"},{"unified":"1f9b8-1f3fc","native":"🦸🏼"},{"unified":"1f9b8-1f3fd","native":"🦸🏽"},{"unified":"1f9b8-1f3fe","native":"🦸🏾"},{"unified":"1f9b8-1f3ff","native":"🦸🏿"}],"version":11},"male_superhero":{"id":"male_superhero","name":"Man Superhero","keywords":["male","good","hero","superpowers"],"skins":[{"unified":"1f9b8-200d-2642-fe0f","native":"🦸‍♂️"},{"unified":"1f9b8-1f3fb-200d-2642-fe0f","native":"🦸🏻‍♂️"},{"unified":"1f9b8-1f3fc-200d-2642-fe0f","native":"🦸🏼‍♂️"},{"unified":"1f9b8-1f3fd-200d-2642-fe0f","native":"🦸🏽‍♂️"},{"unified":"1f9b8-1f3fe-200d-2642-fe0f","native":"🦸🏾‍♂️"},{"unified":"1f9b8-1f3ff-200d-2642-fe0f","native":"🦸🏿‍♂️"}],"version":11},"female_superhero":{"id":"female_superhero","name":"Woman Superhero","keywords":["female","good","heroine","superpowers"],"skins":[{"unified":"1f9b8-200d-2640-fe0f","native":"🦸‍♀️"},{"unified":"1f9b8-1f3fb-200d-2640-fe0f","native":"🦸🏻‍♀️"},{"unified":"1f9b8-1f3fc-200d-2640-fe0f","native":"🦸🏼‍♀️"},{"unified":"1f9b8-1f3fd-200d-2640-fe0f","native":"🦸🏽‍♀️"},{"unified":"1f9b8-1f3fe-200d-2640-fe0f","native":"🦸🏾‍♀️"},{"unified":"1f9b8-1f3ff-200d-2640-fe0f","native":"🦸🏿‍♀️"}],"version":11},"supervillain":{"id":"supervillain","name":"Supervillain","keywords":["marvel"],"skins":[{"unified":"1f9b9","native":"🦹"},{"unified":"1f9b9-1f3fb","native":"🦹🏻"},{"unified":"1f9b9-1f3fc","native":"🦹🏼"},{"unified":"1f9b9-1f3fd","native":"🦹🏽"},{"unified":"1f9b9-1f3fe","native":"🦹🏾"},{"unified":"1f9b9-1f3ff","native":"🦹🏿"}],"version":11},"male_supervillain":{"id":"male_supervillain","name":"Man Supervillain","keywords":["male","evil","bad","criminal","hero","superpowers"],"skins":[{"unified":"1f9b9-200d-2642-fe0f","native":"🦹‍♂️"},{"unified":"1f9b9-1f3fb-200d-2642-fe0f","native":"🦹🏻‍♂️"},{"unified":"1f9b9-1f3fc-200d-2642-fe0f","native":"🦹🏼‍♂️"},{"unified":"1f9b9-1f3fd-200d-2642-fe0f","native":"🦹🏽‍♂️"},{"unified":"1f9b9-1f3fe-200d-2642-fe0f","native":"🦹🏾‍♂️"},{"unified":"1f9b9-1f3ff-200d-2642-fe0f","native":"🦹🏿‍♂️"}],"version":11},"female_supervillain":{"id":"female_supervillain","name":"Woman Supervillain","keywords":["female","evil","bad","criminal","heroine","superpowers"],"skins":[{"unified":"1f9b9-200d-2640-fe0f","native":"🦹‍♀️"},{"unified":"1f9b9-1f3fb-200d-2640-fe0f","native":"🦹🏻‍♀️"},{"unified":"1f9b9-1f3fc-200d-2640-fe0f","native":"🦹🏼‍♀️"},{"unified":"1f9b9-1f3fd-200d-2640-fe0f","native":"🦹🏽‍♀️"},{"unified":"1f9b9-1f3fe-200d-2640-fe0f","native":"🦹🏾‍♀️"},{"unified":"1f9b9-1f3ff-200d-2640-fe0f","native":"🦹🏿‍♀️"}],"version":11},"mage":{"id":"mage","name":"Mage","keywords":["magic"],"skins":[{"unified":"1f9d9","native":"🧙"},{"unified":"1f9d9-1f3fb","native":"🧙🏻"},{"unified":"1f9d9-1f3fc","native":"🧙🏼"},{"unified":"1f9d9-1f3fd","native":"🧙🏽"},{"unified":"1f9d9-1f3fe","native":"🧙🏾"},{"unified":"1f9d9-1f3ff","native":"🧙🏿"}],"version":5},"male_mage":{"id":"male_mage","name":"Man Mage","keywords":["male","sorcerer"],"skins":[{"unified":"1f9d9-200d-2642-fe0f","native":"🧙‍♂️"},{"unified":"1f9d9-1f3fb-200d-2642-fe0f","native":"🧙🏻‍♂️"},{"unified":"1f9d9-1f3fc-200d-2642-fe0f","native":"🧙🏼‍♂️"},{"unified":"1f9d9-1f3fd-200d-2642-fe0f","native":"🧙🏽‍♂️"},{"unified":"1f9d9-1f3fe-200d-2642-fe0f","native":"🧙🏾‍♂️"},{"unified":"1f9d9-1f3ff-200d-2642-fe0f","native":"🧙🏿‍♂️"}],"version":5},"female_mage":{"id":"female_mage","name":"Woman Mage","keywords":["female","witch"],"skins":[{"unified":"1f9d9-200d-2640-fe0f","native":"🧙‍♀️"},{"unified":"1f9d9-1f3fb-200d-2640-fe0f","native":"🧙🏻‍♀️"},{"unified":"1f9d9-1f3fc-200d-2640-fe0f","native":"🧙🏼‍♀️"},{"unified":"1f9d9-1f3fd-200d-2640-fe0f","native":"🧙🏽‍♀️"},{"unified":"1f9d9-1f3fe-200d-2640-fe0f","native":"🧙🏾‍♀️"},{"unified":"1f9d9-1f3ff-200d-2640-fe0f","native":"🧙🏿‍♀️"}],"version":5},"fairy":{"id":"fairy","name":"Fairy","keywords":["wings","magical"],"skins":[{"unified":"1f9da","native":"🧚"},{"unified":"1f9da-1f3fb","native":"🧚🏻"},{"unified":"1f9da-1f3fc","native":"🧚🏼"},{"unified":"1f9da-1f3fd","native":"🧚🏽"},{"unified":"1f9da-1f3fe","native":"🧚🏾"},{"unified":"1f9da-1f3ff","native":"🧚🏿"}],"version":5},"male_fairy":{"id":"male_fairy","name":"Man Fairy","keywords":["male"],"skins":[{"unified":"1f9da-200d-2642-fe0f","native":"🧚‍♂️"},{"unified":"1f9da-1f3fb-200d-2642-fe0f","native":"🧚🏻‍♂️"},{"unified":"1f9da-1f3fc-200d-2642-fe0f","native":"🧚🏼‍♂️"},{"unified":"1f9da-1f3fd-200d-2642-fe0f","native":"🧚🏽‍♂️"},{"unified":"1f9da-1f3fe-200d-2642-fe0f","native":"🧚🏾‍♂️"},{"unified":"1f9da-1f3ff-200d-2642-fe0f","native":"🧚🏿‍♂️"}],"version":5},"female_fairy":{"id":"female_fairy","name":"Woman Fairy","keywords":["female"],"skins":[{"unified":"1f9da-200d-2640-fe0f","native":"🧚‍♀️"},{"unified":"1f9da-1f3fb-200d-2640-fe0f","native":"🧚🏻‍♀️"},{"unified":"1f9da-1f3fc-200d-2640-fe0f","native":"🧚🏼‍♀️"},{"unified":"1f9da-1f3fd-200d-2640-fe0f","native":"🧚🏽‍♀️"},{"unified":"1f9da-1f3fe-200d-2640-fe0f","native":"🧚🏾‍♀️"},{"unified":"1f9da-1f3ff-200d-2640-fe0f","native":"🧚🏿‍♀️"}],"version":5},"vampire":{"id":"vampire","name":"Vampire","keywords":["blood","twilight"],"skins":[{"unified":"1f9db","native":"🧛"},{"unified":"1f9db-1f3fb","native":"🧛🏻"},{"unified":"1f9db-1f3fc","native":"🧛🏼"},{"unified":"1f9db-1f3fd","native":"🧛🏽"},{"unified":"1f9db-1f3fe","native":"🧛🏾"},{"unified":"1f9db-1f3ff","native":"🧛🏿"}],"version":5},"male_vampire":{"id":"male_vampire","name":"Man Vampire","keywords":["male","dracula"],"skins":[{"unified":"1f9db-200d-2642-fe0f","native":"🧛‍♂️"},{"unified":"1f9db-1f3fb-200d-2642-fe0f","native":"🧛🏻‍♂️"},{"unified":"1f9db-1f3fc-200d-2642-fe0f","native":"🧛🏼‍♂️"},{"unified":"1f9db-1f3fd-200d-2642-fe0f","native":"🧛🏽‍♂️"},{"unified":"1f9db-1f3fe-200d-2642-fe0f","native":"🧛🏾‍♂️"},{"unified":"1f9db-1f3ff-200d-2642-fe0f","native":"🧛🏿‍♂️"}],"version":5},"female_vampire":{"id":"female_vampire","name":"Woman Vampire","keywords":["female"],"skins":[{"unified":"1f9db-200d-2640-fe0f","native":"🧛‍♀️"},{"unified":"1f9db-1f3fb-200d-2640-fe0f","native":"🧛🏻‍♀️"},{"unified":"1f9db-1f3fc-200d-2640-fe0f","native":"🧛🏼‍♀️"},{"unified":"1f9db-1f3fd-200d-2640-fe0f","native":"🧛🏽‍♀️"},{"unified":"1f9db-1f3fe-200d-2640-fe0f","native":"🧛🏾‍♀️"},{"unified":"1f9db-1f3ff-200d-2640-fe0f","native":"🧛🏿‍♀️"}],"version":5},"merperson":{"id":"merperson","name":"Merperson","keywords":["sea"],"skins":[{"unified":"1f9dc","native":"🧜"},{"unified":"1f9dc-1f3fb","native":"🧜🏻"},{"unified":"1f9dc-1f3fc","native":"🧜🏼"},{"unified":"1f9dc-1f3fd","native":"🧜🏽"},{"unified":"1f9dc-1f3fe","native":"🧜🏾"},{"unified":"1f9dc-1f3ff","native":"🧜🏿"}],"version":5},"merman":{"id":"merman","name":"Merman","keywords":["man","male","triton"],"skins":[{"unified":"1f9dc-200d-2642-fe0f","native":"🧜‍♂️"},{"unified":"1f9dc-1f3fb-200d-2642-fe0f","native":"🧜🏻‍♂️"},{"unified":"1f9dc-1f3fc-200d-2642-fe0f","native":"🧜🏼‍♂️"},{"unified":"1f9dc-1f3fd-200d-2642-fe0f","native":"🧜🏽‍♂️"},{"unified":"1f9dc-1f3fe-200d-2642-fe0f","native":"🧜🏾‍♂️"},{"unified":"1f9dc-1f3ff-200d-2642-fe0f","native":"🧜🏿‍♂️"}],"version":5},"mermaid":{"id":"mermaid","name":"Mermaid","keywords":["woman","female","merwoman","ariel"],"skins":[{"unified":"1f9dc-200d-2640-fe0f","native":"🧜‍♀️"},{"unified":"1f9dc-1f3fb-200d-2640-fe0f","native":"🧜🏻‍♀️"},{"unified":"1f9dc-1f3fc-200d-2640-fe0f","native":"🧜🏼‍♀️"},{"unified":"1f9dc-1f3fd-200d-2640-fe0f","native":"🧜🏽‍♀️"},{"unified":"1f9dc-1f3fe-200d-2640-fe0f","native":"🧜🏾‍♀️"},{"unified":"1f9dc-1f3ff-200d-2640-fe0f","native":"🧜🏿‍♀️"}],"version":5},"elf":{"id":"elf","name":"Elf","keywords":["magical"],"skins":[{"unified":"1f9dd","native":"🧝"},{"unified":"1f9dd-1f3fb","native":"🧝🏻"},{"unified":"1f9dd-1f3fc","native":"🧝🏼"},{"unified":"1f9dd-1f3fd","native":"🧝🏽"},{"unified":"1f9dd-1f3fe","native":"🧝🏾"},{"unified":"1f9dd-1f3ff","native":"🧝🏿"}],"version":5},"male_elf":{"id":"male_elf","name":"Man Elf","keywords":["male"],"skins":[{"unified":"1f9dd-200d-2642-fe0f","native":"🧝‍♂️"},{"unified":"1f9dd-1f3fb-200d-2642-fe0f","native":"🧝🏻‍♂️"},{"unified":"1f9dd-1f3fc-200d-2642-fe0f","native":"🧝🏼‍♂️"},{"unified":"1f9dd-1f3fd-200d-2642-fe0f","native":"🧝🏽‍♂️"},{"unified":"1f9dd-1f3fe-200d-2642-fe0f","native":"🧝🏾‍♂️"},{"unified":"1f9dd-1f3ff-200d-2642-fe0f","native":"🧝🏿‍♂️"}],"version":5},"female_elf":{"id":"female_elf","name":"Woman Elf","keywords":["female"],"skins":[{"unified":"1f9dd-200d-2640-fe0f","native":"🧝‍♀️"},{"unified":"1f9dd-1f3fb-200d-2640-fe0f","native":"🧝🏻‍♀️"},{"unified":"1f9dd-1f3fc-200d-2640-fe0f","native":"🧝🏼‍♀️"},{"unified":"1f9dd-1f3fd-200d-2640-fe0f","native":"🧝🏽‍♀️"},{"unified":"1f9dd-1f3fe-200d-2640-fe0f","native":"🧝🏾‍♀️"},{"unified":"1f9dd-1f3ff-200d-2640-fe0f","native":"🧝🏿‍♀️"}],"version":5},"genie":{"id":"genie","name":"Genie","keywords":["magical","wishes"],"skins":[{"unified":"1f9de","native":"🧞"}],"version":5},"male_genie":{"id":"male_genie","name":"Man Genie","keywords":["male"],"skins":[{"unified":"1f9de-200d-2642-fe0f","native":"🧞‍♂️"}],"version":5},"female_genie":{"id":"female_genie","name":"Woman Genie","keywords":["female"],"skins":[{"unified":"1f9de-200d-2640-fe0f","native":"🧞‍♀️"}],"version":5},"zombie":{"id":"zombie","name":"Zombie","keywords":["dead"],"skins":[{"unified":"1f9df","native":"🧟"}],"version":5},"male_zombie":{"id":"male_zombie","name":"Man Zombie","keywords":["male","dracula","undead","walking","dead"],"skins":[{"unified":"1f9df-200d-2642-fe0f","native":"🧟‍♂️"}],"version":5},"female_zombie":{"id":"female_zombie","name":"Woman Zombie","keywords":["female","undead","walking","dead"],"skins":[{"unified":"1f9df-200d-2640-fe0f","native":"🧟‍♀️"}],"version":5},"troll":{"id":"troll","name":"Troll","keywords":["mystical","monster"],"skins":[{"unified":"1f9cc","native":"🧌"}],"version":14},"massage":{"id":"massage","name":"Face Massage","keywords":["person","getting","relax"],"skins":[{"unified":"1f486","native":"💆"},{"unified":"1f486-1f3fb","native":"💆🏻"},{"unified":"1f486-1f3fc","native":"💆🏼"},{"unified":"1f486-1f3fd","native":"💆🏽"},{"unified":"1f486-1f3fe","native":"💆🏾"},{"unified":"1f486-1f3ff","native":"💆🏿"}],"version":1},"man-getting-massage":{"id":"man-getting-massage","name":"Man Getting Massage","keywords":["getting-massage","male","boy","head"],"skins":[{"unified":"1f486-200d-2642-fe0f","native":"💆‍♂️"},{"unified":"1f486-1f3fb-200d-2642-fe0f","native":"💆🏻‍♂️"},{"unified":"1f486-1f3fc-200d-2642-fe0f","native":"💆🏼‍♂️"},{"unified":"1f486-1f3fd-200d-2642-fe0f","native":"💆🏽‍♂️"},{"unified":"1f486-1f3fe-200d-2642-fe0f","native":"💆🏾‍♂️"},{"unified":"1f486-1f3ff-200d-2642-fe0f","native":"💆🏿‍♂️"}],"version":4},"woman-getting-massage":{"id":"woman-getting-massage","name":"Woman Getting Massage","keywords":["getting-massage","female","girl","head"],"skins":[{"unified":"1f486-200d-2640-fe0f","native":"💆‍♀️"},{"unified":"1f486-1f3fb-200d-2640-fe0f","native":"💆🏻‍♀️"},{"unified":"1f486-1f3fc-200d-2640-fe0f","native":"💆🏼‍♀️"},{"unified":"1f486-1f3fd-200d-2640-fe0f","native":"💆🏽‍♀️"},{"unified":"1f486-1f3fe-200d-2640-fe0f","native":"💆🏾‍♀️"},{"unified":"1f486-1f3ff-200d-2640-fe0f","native":"💆🏿‍♀️"}],"version":4},"haircut":{"id":"haircut","name":"Haircut","keywords":["person","getting","hairstyle"],"skins":[{"unified":"1f487","native":"💇"},{"unified":"1f487-1f3fb","native":"💇🏻"},{"unified":"1f487-1f3fc","native":"💇🏼"},{"unified":"1f487-1f3fd","native":"💇🏽"},{"unified":"1f487-1f3fe","native":"💇🏾"},{"unified":"1f487-1f3ff","native":"💇🏿"}],"version":1},"man-getting-haircut":{"id":"man-getting-haircut","name":"Man Getting Haircut","keywords":["getting-haircut","male","boy"],"skins":[{"unified":"1f487-200d-2642-fe0f","native":"💇‍♂️"},{"unified":"1f487-1f3fb-200d-2642-fe0f","native":"💇🏻‍♂️"},{"unified":"1f487-1f3fc-200d-2642-fe0f","native":"💇🏼‍♂️"},{"unified":"1f487-1f3fd-200d-2642-fe0f","native":"💇🏽‍♂️"},{"unified":"1f487-1f3fe-200d-2642-fe0f","native":"💇🏾‍♂️"},{"unified":"1f487-1f3ff-200d-2642-fe0f","native":"💇🏿‍♂️"}],"version":4},"woman-getting-haircut":{"id":"woman-getting-haircut","name":"Woman Getting Haircut","keywords":["getting-haircut","female","girl"],"skins":[{"unified":"1f487-200d-2640-fe0f","native":"💇‍♀️"},{"unified":"1f487-1f3fb-200d-2640-fe0f","native":"💇🏻‍♀️"},{"unified":"1f487-1f3fc-200d-2640-fe0f","native":"💇🏼‍♀️"},{"unified":"1f487-1f3fd-200d-2640-fe0f","native":"💇🏽‍♀️"},{"unified":"1f487-1f3fe-200d-2640-fe0f","native":"💇🏾‍♀️"},{"unified":"1f487-1f3ff-200d-2640-fe0f","native":"💇🏿‍♀️"}],"version":4},"walking":{"id":"walking","name":"Pedestrian","keywords":["walking","person","move"],"skins":[{"unified":"1f6b6","native":"🚶"},{"unified":"1f6b6-1f3fb","native":"🚶🏻"},{"unified":"1f6b6-1f3fc","native":"🚶🏼"},{"unified":"1f6b6-1f3fd","native":"🚶🏽"},{"unified":"1f6b6-1f3fe","native":"🚶🏾"},{"unified":"1f6b6-1f3ff","native":"🚶🏿"}],"version":1},"man-walking":{"id":"man-walking","name":"Man Walking","keywords":["human","feet","steps"],"skins":[{"unified":"1f6b6-200d-2642-fe0f","native":"🚶‍♂️"},{"unified":"1f6b6-1f3fb-200d-2642-fe0f","native":"🚶🏻‍♂️"},{"unified":"1f6b6-1f3fc-200d-2642-fe0f","native":"🚶🏼‍♂️"},{"unified":"1f6b6-1f3fd-200d-2642-fe0f","native":"🚶🏽‍♂️"},{"unified":"1f6b6-1f3fe-200d-2642-fe0f","native":"🚶🏾‍♂️"},{"unified":"1f6b6-1f3ff-200d-2642-fe0f","native":"🚶🏿‍♂️"}],"version":4},"woman-walking":{"id":"woman-walking","name":"Woman Walking","keywords":["human","feet","steps","female"],"skins":[{"unified":"1f6b6-200d-2640-fe0f","native":"🚶‍♀️"},{"unified":"1f6b6-1f3fb-200d-2640-fe0f","native":"🚶🏻‍♀️"},{"unified":"1f6b6-1f3fc-200d-2640-fe0f","native":"🚶🏼‍♀️"},{"unified":"1f6b6-1f3fd-200d-2640-fe0f","native":"🚶🏽‍♀️"},{"unified":"1f6b6-1f3fe-200d-2640-fe0f","native":"🚶🏾‍♀️"},{"unified":"1f6b6-1f3ff-200d-2640-fe0f","native":"🚶🏿‍♀️"}],"version":4},"standing_person":{"id":"standing_person","name":"Standing Person","keywords":["still"],"skins":[{"unified":"1f9cd","native":"🧍"},{"unified":"1f9cd-1f3fb","native":"🧍🏻"},{"unified":"1f9cd-1f3fc","native":"🧍🏼"},{"unified":"1f9cd-1f3fd","native":"🧍🏽"},{"unified":"1f9cd-1f3fe","native":"🧍🏾"},{"unified":"1f9cd-1f3ff","native":"🧍🏿"}],"version":12},"man_standing":{"id":"man_standing","name":"Man Standing","keywords":["still"],"skins":[{"unified":"1f9cd-200d-2642-fe0f","native":"🧍‍♂️"},{"unified":"1f9cd-1f3fb-200d-2642-fe0f","native":"🧍🏻‍♂️"},{"unified":"1f9cd-1f3fc-200d-2642-fe0f","native":"🧍🏼‍♂️"},{"unified":"1f9cd-1f3fd-200d-2642-fe0f","native":"🧍🏽‍♂️"},{"unified":"1f9cd-1f3fe-200d-2642-fe0f","native":"🧍🏾‍♂️"},{"unified":"1f9cd-1f3ff-200d-2642-fe0f","native":"🧍🏿‍♂️"}],"version":12},"woman_standing":{"id":"woman_standing","name":"Woman Standing","keywords":["still"],"skins":[{"unified":"1f9cd-200d-2640-fe0f","native":"🧍‍♀️"},{"unified":"1f9cd-1f3fb-200d-2640-fe0f","native":"🧍🏻‍♀️"},{"unified":"1f9cd-1f3fc-200d-2640-fe0f","native":"🧍🏼‍♀️"},{"unified":"1f9cd-1f3fd-200d-2640-fe0f","native":"🧍🏽‍♀️"},{"unified":"1f9cd-1f3fe-200d-2640-fe0f","native":"🧍🏾‍♀️"},{"unified":"1f9cd-1f3ff-200d-2640-fe0f","native":"🧍🏿‍♀️"}],"version":12},"kneeling_person":{"id":"kneeling_person","name":"Kneeling Person","keywords":["pray","respectful"],"skins":[{"unified":"1f9ce","native":"🧎"},{"unified":"1f9ce-1f3fb","native":"🧎🏻"},{"unified":"1f9ce-1f3fc","native":"🧎🏼"},{"unified":"1f9ce-1f3fd","native":"🧎🏽"},{"unified":"1f9ce-1f3fe","native":"🧎🏾"},{"unified":"1f9ce-1f3ff","native":"🧎🏿"}],"version":12},"man_kneeling":{"id":"man_kneeling","name":"Man Kneeling","keywords":["pray","respectful"],"skins":[{"unified":"1f9ce-200d-2642-fe0f","native":"🧎‍♂️"},{"unified":"1f9ce-1f3fb-200d-2642-fe0f","native":"🧎🏻‍♂️"},{"unified":"1f9ce-1f3fc-200d-2642-fe0f","native":"🧎🏼‍♂️"},{"unified":"1f9ce-1f3fd-200d-2642-fe0f","native":"🧎🏽‍♂️"},{"unified":"1f9ce-1f3fe-200d-2642-fe0f","native":"🧎🏾‍♂️"},{"unified":"1f9ce-1f3ff-200d-2642-fe0f","native":"🧎🏿‍♂️"}],"version":12},"woman_kneeling":{"id":"woman_kneeling","name":"Woman Kneeling","keywords":["respectful","pray"],"skins":[{"unified":"1f9ce-200d-2640-fe0f","native":"🧎‍♀️"},{"unified":"1f9ce-1f3fb-200d-2640-fe0f","native":"🧎🏻‍♀️"},{"unified":"1f9ce-1f3fc-200d-2640-fe0f","native":"🧎🏼‍♀️"},{"unified":"1f9ce-1f3fd-200d-2640-fe0f","native":"🧎🏽‍♀️"},{"unified":"1f9ce-1f3fe-200d-2640-fe0f","native":"🧎🏾‍♀️"},{"unified":"1f9ce-1f3ff-200d-2640-fe0f","native":"🧎🏿‍♀️"}],"version":12},"person_with_probing_cane":{"id":"person_with_probing_cane","name":"Person with White Cane","keywords":["probing","blind"],"skins":[{"unified":"1f9d1-200d-1f9af","native":"🧑‍🦯"},{"unified":"1f9d1-1f3fb-200d-1f9af","native":"🧑🏻‍🦯"},{"unified":"1f9d1-1f3fc-200d-1f9af","native":"🧑🏼‍🦯"},{"unified":"1f9d1-1f3fd-200d-1f9af","native":"🧑🏽‍🦯"},{"unified":"1f9d1-1f3fe-200d-1f9af","native":"🧑🏾‍🦯"},{"unified":"1f9d1-1f3ff-200d-1f9af","native":"🧑🏿‍🦯"}],"version":12.1},"man_with_probing_cane":{"id":"man_with_probing_cane","name":"Man with White Cane","keywords":["probing","blind"],"skins":[{"unified":"1f468-200d-1f9af","native":"👨‍🦯"},{"unified":"1f468-1f3fb-200d-1f9af","native":"👨🏻‍🦯"},{"unified":"1f468-1f3fc-200d-1f9af","native":"👨🏼‍🦯"},{"unified":"1f468-1f3fd-200d-1f9af","native":"👨🏽‍🦯"},{"unified":"1f468-1f3fe-200d-1f9af","native":"👨🏾‍🦯"},{"unified":"1f468-1f3ff-200d-1f9af","native":"👨🏿‍🦯"}],"version":12},"woman_with_probing_cane":{"id":"woman_with_probing_cane","name":"Woman with White Cane","keywords":["probing","blind"],"skins":[{"unified":"1f469-200d-1f9af","native":"👩‍🦯"},{"unified":"1f469-1f3fb-200d-1f9af","native":"👩🏻‍🦯"},{"unified":"1f469-1f3fc-200d-1f9af","native":"👩🏼‍🦯"},{"unified":"1f469-1f3fd-200d-1f9af","native":"👩🏽‍🦯"},{"unified":"1f469-1f3fe-200d-1f9af","native":"👩🏾‍🦯"},{"unified":"1f469-1f3ff-200d-1f9af","native":"👩🏿‍🦯"}],"version":12},"person_in_motorized_wheelchair":{"id":"person_in_motorized_wheelchair","name":"Person in Motorized Wheelchair","keywords":["disability","accessibility"],"skins":[{"unified":"1f9d1-200d-1f9bc","native":"🧑‍🦼"},{"unified":"1f9d1-1f3fb-200d-1f9bc","native":"🧑🏻‍🦼"},{"unified":"1f9d1-1f3fc-200d-1f9bc","native":"🧑🏼‍🦼"},{"unified":"1f9d1-1f3fd-200d-1f9bc","native":"🧑🏽‍🦼"},{"unified":"1f9d1-1f3fe-200d-1f9bc","native":"🧑🏾‍🦼"},{"unified":"1f9d1-1f3ff-200d-1f9bc","native":"🧑🏿‍🦼"}],"version":12.1},"man_in_motorized_wheelchair":{"id":"man_in_motorized_wheelchair","name":"Man in Motorized Wheelchair","keywords":["disability","accessibility"],"skins":[{"unified":"1f468-200d-1f9bc","native":"👨‍🦼"},{"unified":"1f468-1f3fb-200d-1f9bc","native":"👨🏻‍🦼"},{"unified":"1f468-1f3fc-200d-1f9bc","native":"👨🏼‍🦼"},{"unified":"1f468-1f3fd-200d-1f9bc","native":"👨🏽‍🦼"},{"unified":"1f468-1f3fe-200d-1f9bc","native":"👨🏾‍🦼"},{"unified":"1f468-1f3ff-200d-1f9bc","native":"👨🏿‍🦼"}],"version":12},"woman_in_motorized_wheelchair":{"id":"woman_in_motorized_wheelchair","name":"Woman in Motorized Wheelchair","keywords":["disability","accessibility"],"skins":[{"unified":"1f469-200d-1f9bc","native":"👩‍🦼"},{"unified":"1f469-1f3fb-200d-1f9bc","native":"👩🏻‍🦼"},{"unified":"1f469-1f3fc-200d-1f9bc","native":"👩🏼‍🦼"},{"unified":"1f469-1f3fd-200d-1f9bc","native":"👩🏽‍🦼"},{"unified":"1f469-1f3fe-200d-1f9bc","native":"👩🏾‍🦼"},{"unified":"1f469-1f3ff-200d-1f9bc","native":"👩🏿‍🦼"}],"version":12},"person_in_manual_wheelchair":{"id":"person_in_manual_wheelchair","name":"Person in Manual Wheelchair","keywords":["disability","accessibility"],"skins":[{"unified":"1f9d1-200d-1f9bd","native":"🧑‍🦽"},{"unified":"1f9d1-1f3fb-200d-1f9bd","native":"🧑🏻‍🦽"},{"unified":"1f9d1-1f3fc-200d-1f9bd","native":"🧑🏼‍🦽"},{"unified":"1f9d1-1f3fd-200d-1f9bd","native":"🧑🏽‍🦽"},{"unified":"1f9d1-1f3fe-200d-1f9bd","native":"🧑🏾‍🦽"},{"unified":"1f9d1-1f3ff-200d-1f9bd","native":"🧑🏿‍🦽"}],"version":12.1},"man_in_manual_wheelchair":{"id":"man_in_manual_wheelchair","name":"Man in Manual Wheelchair","keywords":["disability","accessibility"],"skins":[{"unified":"1f468-200d-1f9bd","native":"👨‍🦽"},{"unified":"1f468-1f3fb-200d-1f9bd","native":"👨🏻‍🦽"},{"unified":"1f468-1f3fc-200d-1f9bd","native":"👨🏼‍🦽"},{"unified":"1f468-1f3fd-200d-1f9bd","native":"👨🏽‍🦽"},{"unified":"1f468-1f3fe-200d-1f9bd","native":"👨🏾‍🦽"},{"unified":"1f468-1f3ff-200d-1f9bd","native":"👨🏿‍🦽"}],"version":12},"woman_in_manual_wheelchair":{"id":"woman_in_manual_wheelchair","name":"Woman in Manual Wheelchair","keywords":["disability","accessibility"],"skins":[{"unified":"1f469-200d-1f9bd","native":"👩‍🦽"},{"unified":"1f469-1f3fb-200d-1f9bd","native":"👩🏻‍🦽"},{"unified":"1f469-1f3fc-200d-1f9bd","native":"👩🏼‍🦽"},{"unified":"1f469-1f3fd-200d-1f9bd","native":"👩🏽‍🦽"},{"unified":"1f469-1f3fe-200d-1f9bd","native":"👩🏾‍🦽"},{"unified":"1f469-1f3ff-200d-1f9bd","native":"👩🏿‍🦽"}],"version":12},"runner":{"id":"runner","name":"Runner","keywords":["running","person","move"],"skins":[{"unified":"1f3c3","native":"🏃"},{"unified":"1f3c3-1f3fb","native":"🏃🏻"},{"unified":"1f3c3-1f3fc","native":"🏃🏼"},{"unified":"1f3c3-1f3fd","native":"🏃🏽"},{"unified":"1f3c3-1f3fe","native":"🏃🏾"},{"unified":"1f3c3-1f3ff","native":"🏃🏿"}],"version":1},"man-running":{"id":"man-running","name":"Man Running","keywords":["walking","exercise","race"],"skins":[{"unified":"1f3c3-200d-2642-fe0f","native":"🏃‍♂️"},{"unified":"1f3c3-1f3fb-200d-2642-fe0f","native":"🏃🏻‍♂️"},{"unified":"1f3c3-1f3fc-200d-2642-fe0f","native":"🏃🏼‍♂️"},{"unified":"1f3c3-1f3fd-200d-2642-fe0f","native":"🏃🏽‍♂️"},{"unified":"1f3c3-1f3fe-200d-2642-fe0f","native":"🏃🏾‍♂️"},{"unified":"1f3c3-1f3ff-200d-2642-fe0f","native":"🏃🏿‍♂️"}],"version":4},"woman-running":{"id":"woman-running","name":"Woman Running","keywords":["walking","exercise","race","female"],"skins":[{"unified":"1f3c3-200d-2640-fe0f","native":"🏃‍♀️"},{"unified":"1f3c3-1f3fb-200d-2640-fe0f","native":"🏃🏻‍♀️"},{"unified":"1f3c3-1f3fc-200d-2640-fe0f","native":"🏃🏼‍♀️"},{"unified":"1f3c3-1f3fd-200d-2640-fe0f","native":"🏃🏽‍♀️"},{"unified":"1f3c3-1f3fe-200d-2640-fe0f","native":"🏃🏾‍♀️"},{"unified":"1f3c3-1f3ff-200d-2640-fe0f","native":"🏃🏿‍♀️"}],"version":4},"dancer":{"id":"dancer","name":"Dancer","keywords":["woman","dancing","female","girl","fun"],"skins":[{"unified":"1f483","native":"💃"},{"unified":"1f483-1f3fb","native":"💃🏻"},{"unified":"1f483-1f3fc","native":"💃🏼"},{"unified":"1f483-1f3fd","native":"💃🏽"},{"unified":"1f483-1f3fe","native":"💃🏾"},{"unified":"1f483-1f3ff","native":"💃🏿"}],"version":1},"man_dancing":{"id":"man_dancing","name":"Man Dancing","keywords":["male","boy","fun","dancer"],"skins":[{"unified":"1f57a","native":"🕺"},{"unified":"1f57a-1f3fb","native":"🕺🏻"},{"unified":"1f57a-1f3fc","native":"🕺🏼"},{"unified":"1f57a-1f3fd","native":"🕺🏽"},{"unified":"1f57a-1f3fe","native":"🕺🏾"},{"unified":"1f57a-1f3ff","native":"🕺🏿"}],"version":3},"man_in_business_suit_levitating":{"id":"man_in_business_suit_levitating","name":"Person in Suit Levitating","keywords":["man","business","levitate","hover","jump"],"skins":[{"unified":"1f574-fe0f","native":"🕴️"},{"unified":"1f574-1f3fb","native":"🕴🏻"},{"unified":"1f574-1f3fc","native":"🕴🏼"},{"unified":"1f574-1f3fd","native":"🕴🏽"},{"unified":"1f574-1f3fe","native":"🕴🏾"},{"unified":"1f574-1f3ff","native":"🕴🏿"}],"version":1},"dancers":{"id":"dancers","name":"Woman with Bunny Ears","keywords":["dancers","people","perform","costume"],"skins":[{"unified":"1f46f","native":"👯"}],"version":1},"men-with-bunny-ears-partying":{"id":"men-with-bunny-ears-partying","name":"Men with Bunny Ears","keywords":["with-bunny-ears-partying","man","male","boys"],"skins":[{"unified":"1f46f-200d-2642-fe0f","native":"👯‍♂️"}],"version":4},"women-with-bunny-ears-partying":{"id":"women-with-bunny-ears-partying","name":"Women with Bunny Ears","keywords":["with-bunny-ears-partying","woman","female","girls"],"skins":[{"unified":"1f46f-200d-2640-fe0f","native":"👯‍♀️"}],"version":4},"person_in_steamy_room":{"id":"person_in_steamy_room","name":"Person in Steamy Room","keywords":["relax","spa"],"skins":[{"unified":"1f9d6","native":"🧖"},{"unified":"1f9d6-1f3fb","native":"🧖🏻"},{"unified":"1f9d6-1f3fc","native":"🧖🏼"},{"unified":"1f9d6-1f3fd","native":"🧖🏽"},{"unified":"1f9d6-1f3fe","native":"🧖🏾"},{"unified":"1f9d6-1f3ff","native":"🧖🏿"}],"version":5},"man_in_steamy_room":{"id":"man_in_steamy_room","name":"Man in Steamy Room","keywords":["male","spa","steamroom","sauna"],"skins":[{"unified":"1f9d6-200d-2642-fe0f","native":"🧖‍♂️"},{"unified":"1f9d6-1f3fb-200d-2642-fe0f","native":"🧖🏻‍♂️"},{"unified":"1f9d6-1f3fc-200d-2642-fe0f","native":"🧖🏼‍♂️"},{"unified":"1f9d6-1f3fd-200d-2642-fe0f","native":"🧖🏽‍♂️"},{"unified":"1f9d6-1f3fe-200d-2642-fe0f","native":"🧖🏾‍♂️"},{"unified":"1f9d6-1f3ff-200d-2642-fe0f","native":"🧖🏿‍♂️"}],"version":5},"woman_in_steamy_room":{"id":"woman_in_steamy_room","name":"Woman in Steamy Room","keywords":["female","spa","steamroom","sauna"],"skins":[{"unified":"1f9d6-200d-2640-fe0f","native":"🧖‍♀️"},{"unified":"1f9d6-1f3fb-200d-2640-fe0f","native":"🧖🏻‍♀️"},{"unified":"1f9d6-1f3fc-200d-2640-fe0f","native":"🧖🏼‍♀️"},{"unified":"1f9d6-1f3fd-200d-2640-fe0f","native":"🧖🏽‍♀️"},{"unified":"1f9d6-1f3fe-200d-2640-fe0f","native":"🧖🏾‍♀️"},{"unified":"1f9d6-1f3ff-200d-2640-fe0f","native":"🧖🏿‍♀️"}],"version":5},"person_climbing":{"id":"person_climbing","name":"Person Climbing","keywords":["sport"],"skins":[{"unified":"1f9d7","native":"🧗"},{"unified":"1f9d7-1f3fb","native":"🧗🏻"},{"unified":"1f9d7-1f3fc","native":"🧗🏼"},{"unified":"1f9d7-1f3fd","native":"🧗🏽"},{"unified":"1f9d7-1f3fe","native":"🧗🏾"},{"unified":"1f9d7-1f3ff","native":"🧗🏿"}],"version":5},"man_climbing":{"id":"man_climbing","name":"Man Climbing","keywords":["sports","hobby","male","rock"],"skins":[{"unified":"1f9d7-200d-2642-fe0f","native":"🧗‍♂️"},{"unified":"1f9d7-1f3fb-200d-2642-fe0f","native":"🧗🏻‍♂️"},{"unified":"1f9d7-1f3fc-200d-2642-fe0f","native":"🧗🏼‍♂️"},{"unified":"1f9d7-1f3fd-200d-2642-fe0f","native":"🧗🏽‍♂️"},{"unified":"1f9d7-1f3fe-200d-2642-fe0f","native":"🧗🏾‍♂️"},{"unified":"1f9d7-1f3ff-200d-2642-fe0f","native":"🧗🏿‍♂️"}],"version":5},"woman_climbing":{"id":"woman_climbing","name":"Woman Climbing","keywords":["sports","hobby","female","rock"],"skins":[{"unified":"1f9d7-200d-2640-fe0f","native":"🧗‍♀️"},{"unified":"1f9d7-1f3fb-200d-2640-fe0f","native":"🧗🏻‍♀️"},{"unified":"1f9d7-1f3fc-200d-2640-fe0f","native":"🧗🏼‍♀️"},{"unified":"1f9d7-1f3fd-200d-2640-fe0f","native":"🧗🏽‍♀️"},{"unified":"1f9d7-1f3fe-200d-2640-fe0f","native":"🧗🏾‍♀️"},{"unified":"1f9d7-1f3ff-200d-2640-fe0f","native":"🧗🏿‍♀️"}],"version":5},"fencer":{"id":"fencer","name":"Fencer","keywords":["person","fencing","sports","sword"],"skins":[{"unified":"1f93a","native":"🤺"}],"version":3},"horse_racing":{"id":"horse_racing","name":"Horse Racing","keywords":["animal","betting","competition","gambling","luck"],"skins":[{"unified":"1f3c7","native":"🏇"},{"unified":"1f3c7-1f3fb","native":"🏇🏻"},{"unified":"1f3c7-1f3fc","native":"🏇🏼"},{"unified":"1f3c7-1f3fd","native":"🏇🏽"},{"unified":"1f3c7-1f3fe","native":"🏇🏾"},{"unified":"1f3c7-1f3ff","native":"🏇🏿"}],"version":1},"skier":{"id":"skier","name":"Skier","keywords":["sports","winter","snow"],"skins":[{"unified":"26f7-fe0f","native":"⛷️"}],"version":1},"snowboarder":{"id":"snowboarder","name":"Snowboarder","keywords":["sports","winter"],"skins":[{"unified":"1f3c2","native":"🏂"},{"unified":"1f3c2-1f3fb","native":"🏂🏻"},{"unified":"1f3c2-1f3fc","native":"🏂🏼"},{"unified":"1f3c2-1f3fd","native":"🏂🏽"},{"unified":"1f3c2-1f3fe","native":"🏂🏾"},{"unified":"1f3c2-1f3ff","native":"🏂🏿"}],"version":1},"golfer":{"id":"golfer","name":"Person Golfing","keywords":["golfer","sports","business"],"skins":[{"unified":"1f3cc-fe0f","native":"🏌️"},{"unified":"1f3cc-1f3fb","native":"🏌🏻"},{"unified":"1f3cc-1f3fc","native":"🏌🏼"},{"unified":"1f3cc-1f3fd","native":"🏌🏽"},{"unified":"1f3cc-1f3fe","native":"🏌🏾"},{"unified":"1f3cc-1f3ff","native":"🏌🏿"}],"version":1},"man-golfing":{"id":"man-golfing","name":"Man Golfing","keywords":["sport"],"skins":[{"unified":"1f3cc-fe0f-200d-2642-fe0f","native":"🏌️‍♂️"},{"unified":"1f3cc-1f3fb-200d-2642-fe0f","native":"🏌🏻‍♂️"},{"unified":"1f3cc-1f3fc-200d-2642-fe0f","native":"🏌🏼‍♂️"},{"unified":"1f3cc-1f3fd-200d-2642-fe0f","native":"🏌🏽‍♂️"},{"unified":"1f3cc-1f3fe-200d-2642-fe0f","native":"🏌🏾‍♂️"},{"unified":"1f3cc-1f3ff-200d-2642-fe0f","native":"🏌🏿‍♂️"}],"version":4},"woman-golfing":{"id":"woman-golfing","name":"Woman Golfing","keywords":["sports","business","female"],"skins":[{"unified":"1f3cc-fe0f-200d-2640-fe0f","native":"🏌️‍♀️"},{"unified":"1f3cc-1f3fb-200d-2640-fe0f","native":"🏌🏻‍♀️"},{"unified":"1f3cc-1f3fc-200d-2640-fe0f","native":"🏌🏼‍♀️"},{"unified":"1f3cc-1f3fd-200d-2640-fe0f","native":"🏌🏽‍♀️"},{"unified":"1f3cc-1f3fe-200d-2640-fe0f","native":"🏌🏾‍♀️"},{"unified":"1f3cc-1f3ff-200d-2640-fe0f","native":"🏌🏿‍♀️"}],"version":4},"surfer":{"id":"surfer","name":"Surfer","keywords":["person","surfing","sport","sea"],"skins":[{"unified":"1f3c4","native":"🏄"},{"unified":"1f3c4-1f3fb","native":"🏄🏻"},{"unified":"1f3c4-1f3fc","native":"🏄🏼"},{"unified":"1f3c4-1f3fd","native":"🏄🏽"},{"unified":"1f3c4-1f3fe","native":"🏄🏾"},{"unified":"1f3c4-1f3ff","native":"🏄🏿"}],"version":1},"man-surfing":{"id":"man-surfing","name":"Man Surfing","keywords":["sports","ocean","sea","summer","beach"],"skins":[{"unified":"1f3c4-200d-2642-fe0f","native":"🏄‍♂️"},{"unified":"1f3c4-1f3fb-200d-2642-fe0f","native":"🏄🏻‍♂️"},{"unified":"1f3c4-1f3fc-200d-2642-fe0f","native":"🏄🏼‍♂️"},{"unified":"1f3c4-1f3fd-200d-2642-fe0f","native":"🏄🏽‍♂️"},{"unified":"1f3c4-1f3fe-200d-2642-fe0f","native":"🏄🏾‍♂️"},{"unified":"1f3c4-1f3ff-200d-2642-fe0f","native":"🏄🏿‍♂️"}],"version":4},"woman-surfing":{"id":"woman-surfing","name":"Woman Surfing","keywords":["sports","ocean","sea","summer","beach","female"],"skins":[{"unified":"1f3c4-200d-2640-fe0f","native":"🏄‍♀️"},{"unified":"1f3c4-1f3fb-200d-2640-fe0f","native":"🏄🏻‍♀️"},{"unified":"1f3c4-1f3fc-200d-2640-fe0f","native":"🏄🏼‍♀️"},{"unified":"1f3c4-1f3fd-200d-2640-fe0f","native":"🏄🏽‍♀️"},{"unified":"1f3c4-1f3fe-200d-2640-fe0f","native":"🏄🏾‍♀️"},{"unified":"1f3c4-1f3ff-200d-2640-fe0f","native":"🏄🏿‍♀️"}],"version":4},"rowboat":{"id":"rowboat","name":"Rowboat","keywords":["person","rowing","boat","sport","move"],"skins":[{"unified":"1f6a3","native":"🚣"},{"unified":"1f6a3-1f3fb","native":"🚣🏻"},{"unified":"1f6a3-1f3fc","native":"🚣🏼"},{"unified":"1f6a3-1f3fd","native":"🚣🏽"},{"unified":"1f6a3-1f3fe","native":"🚣🏾"},{"unified":"1f6a3-1f3ff","native":"🚣🏿"}],"version":1},"man-rowing-boat":{"id":"man-rowing-boat","name":"Man Rowing Boat","keywords":["rowing-boat","sports","hobby","water","ship"],"skins":[{"unified":"1f6a3-200d-2642-fe0f","native":"🚣‍♂️"},{"unified":"1f6a3-1f3fb-200d-2642-fe0f","native":"🚣🏻‍♂️"},{"unified":"1f6a3-1f3fc-200d-2642-fe0f","native":"🚣🏼‍♂️"},{"unified":"1f6a3-1f3fd-200d-2642-fe0f","native":"🚣🏽‍♂️"},{"unified":"1f6a3-1f3fe-200d-2642-fe0f","native":"🚣🏾‍♂️"},{"unified":"1f6a3-1f3ff-200d-2642-fe0f","native":"🚣🏿‍♂️"}],"version":4},"woman-rowing-boat":{"id":"woman-rowing-boat","name":"Woman Rowing Boat","keywords":["rowing-boat","sports","hobby","water","ship","female"],"skins":[{"unified":"1f6a3-200d-2640-fe0f","native":"🚣‍♀️"},{"unified":"1f6a3-1f3fb-200d-2640-fe0f","native":"🚣🏻‍♀️"},{"unified":"1f6a3-1f3fc-200d-2640-fe0f","native":"🚣🏼‍♀️"},{"unified":"1f6a3-1f3fd-200d-2640-fe0f","native":"🚣🏽‍♀️"},{"unified":"1f6a3-1f3fe-200d-2640-fe0f","native":"🚣🏾‍♀️"},{"unified":"1f6a3-1f3ff-200d-2640-fe0f","native":"🚣🏿‍♀️"}],"version":4},"swimmer":{"id":"swimmer","name":"Swimmer","keywords":["person","swimming","sport","pool"],"skins":[{"unified":"1f3ca","native":"🏊"},{"unified":"1f3ca-1f3fb","native":"🏊🏻"},{"unified":"1f3ca-1f3fc","native":"🏊🏼"},{"unified":"1f3ca-1f3fd","native":"🏊🏽"},{"unified":"1f3ca-1f3fe","native":"🏊🏾"},{"unified":"1f3ca-1f3ff","native":"🏊🏿"}],"version":1},"man-swimming":{"id":"man-swimming","name":"Man Swimming","keywords":["sports","exercise","human","athlete","water","summer"],"skins":[{"unified":"1f3ca-200d-2642-fe0f","native":"🏊‍♂️"},{"unified":"1f3ca-1f3fb-200d-2642-fe0f","native":"🏊🏻‍♂️"},{"unified":"1f3ca-1f3fc-200d-2642-fe0f","native":"🏊🏼‍♂️"},{"unified":"1f3ca-1f3fd-200d-2642-fe0f","native":"🏊🏽‍♂️"},{"unified":"1f3ca-1f3fe-200d-2642-fe0f","native":"🏊🏾‍♂️"},{"unified":"1f3ca-1f3ff-200d-2642-fe0f","native":"🏊🏿‍♂️"}],"version":4},"woman-swimming":{"id":"woman-swimming","name":"Woman Swimming","keywords":["sports","exercise","human","athlete","water","summer","female"],"skins":[{"unified":"1f3ca-200d-2640-fe0f","native":"🏊‍♀️"},{"unified":"1f3ca-1f3fb-200d-2640-fe0f","native":"🏊🏻‍♀️"},{"unified":"1f3ca-1f3fc-200d-2640-fe0f","native":"🏊🏼‍♀️"},{"unified":"1f3ca-1f3fd-200d-2640-fe0f","native":"🏊🏽‍♀️"},{"unified":"1f3ca-1f3fe-200d-2640-fe0f","native":"🏊🏾‍♀️"},{"unified":"1f3ca-1f3ff-200d-2640-fe0f","native":"🏊🏿‍♀️"}],"version":4},"person_with_ball":{"id":"person_with_ball","name":"Person Bouncing Ball","keywords":["with","sports","human"],"skins":[{"unified":"26f9-fe0f","native":"⛹️"},{"unified":"26f9-1f3fb","native":"⛹🏻"},{"unified":"26f9-1f3fc","native":"⛹🏼"},{"unified":"26f9-1f3fd","native":"⛹🏽"},{"unified":"26f9-1f3fe","native":"⛹🏾"},{"unified":"26f9-1f3ff","native":"⛹🏿"}],"version":1},"man-bouncing-ball":{"id":"man-bouncing-ball","name":"Man Bouncing Ball","keywords":["bouncing-ball","sport"],"skins":[{"unified":"26f9-fe0f-200d-2642-fe0f","native":"⛹️‍♂️"},{"unified":"26f9-1f3fb-200d-2642-fe0f","native":"⛹🏻‍♂️"},{"unified":"26f9-1f3fc-200d-2642-fe0f","native":"⛹🏼‍♂️"},{"unified":"26f9-1f3fd-200d-2642-fe0f","native":"⛹🏽‍♂️"},{"unified":"26f9-1f3fe-200d-2642-fe0f","native":"⛹🏾‍♂️"},{"unified":"26f9-1f3ff-200d-2642-fe0f","native":"⛹🏿‍♂️"}],"version":4},"woman-bouncing-ball":{"id":"woman-bouncing-ball","name":"Woman Bouncing Ball","keywords":["bouncing-ball","sports","human","female"],"skins":[{"unified":"26f9-fe0f-200d-2640-fe0f","native":"⛹️‍♀️"},{"unified":"26f9-1f3fb-200d-2640-fe0f","native":"⛹🏻‍♀️"},{"unified":"26f9-1f3fc-200d-2640-fe0f","native":"⛹🏼‍♀️"},{"unified":"26f9-1f3fd-200d-2640-fe0f","native":"⛹🏽‍♀️"},{"unified":"26f9-1f3fe-200d-2640-fe0f","native":"⛹🏾‍♀️"},{"unified":"26f9-1f3ff-200d-2640-fe0f","native":"⛹🏿‍♀️"}],"version":4},"weight_lifter":{"id":"weight_lifter","name":"Person Lifting Weights","keywords":["weight","lifter","sports","training","exercise"],"skins":[{"unified":"1f3cb-fe0f","native":"🏋️"},{"unified":"1f3cb-1f3fb","native":"🏋🏻"},{"unified":"1f3cb-1f3fc","native":"🏋🏼"},{"unified":"1f3cb-1f3fd","native":"🏋🏽"},{"unified":"1f3cb-1f3fe","native":"🏋🏾"},{"unified":"1f3cb-1f3ff","native":"🏋🏿"}],"version":1},"man-lifting-weights":{"id":"man-lifting-weights","name":"Man Lifting Weights","keywords":["lifting-weights","sport"],"skins":[{"unified":"1f3cb-fe0f-200d-2642-fe0f","native":"🏋️‍♂️"},{"unified":"1f3cb-1f3fb-200d-2642-fe0f","native":"🏋🏻‍♂️"},{"unified":"1f3cb-1f3fc-200d-2642-fe0f","native":"🏋🏼‍♂️"},{"unified":"1f3cb-1f3fd-200d-2642-fe0f","native":"🏋🏽‍♂️"},{"unified":"1f3cb-1f3fe-200d-2642-fe0f","native":"🏋🏾‍♂️"},{"unified":"1f3cb-1f3ff-200d-2642-fe0f","native":"🏋🏿‍♂️"}],"version":4},"woman-lifting-weights":{"id":"woman-lifting-weights","name":"Woman Lifting Weights","keywords":["lifting-weights","sports","training","exercise","female"],"skins":[{"unified":"1f3cb-fe0f-200d-2640-fe0f","native":"🏋️‍♀️"},{"unified":"1f3cb-1f3fb-200d-2640-fe0f","native":"🏋🏻‍♀️"},{"unified":"1f3cb-1f3fc-200d-2640-fe0f","native":"🏋🏼‍♀️"},{"unified":"1f3cb-1f3fd-200d-2640-fe0f","native":"🏋🏽‍♀️"},{"unified":"1f3cb-1f3fe-200d-2640-fe0f","native":"🏋🏾‍♀️"},{"unified":"1f3cb-1f3ff-200d-2640-fe0f","native":"🏋🏿‍♀️"}],"version":4},"bicyclist":{"id":"bicyclist","name":"Bicyclist","keywords":["person","biking","sport","move"],"skins":[{"unified":"1f6b4","native":"🚴"},{"unified":"1f6b4-1f3fb","native":"🚴🏻"},{"unified":"1f6b4-1f3fc","native":"🚴🏼"},{"unified":"1f6b4-1f3fd","native":"🚴🏽"},{"unified":"1f6b4-1f3fe","native":"🚴🏾"},{"unified":"1f6b4-1f3ff","native":"🚴🏿"}],"version":1},"man-biking":{"id":"man-biking","name":"Man Biking","keywords":["sports","bike","exercise","hipster"],"skins":[{"unified":"1f6b4-200d-2642-fe0f","native":"🚴‍♂️"},{"unified":"1f6b4-1f3fb-200d-2642-fe0f","native":"🚴🏻‍♂️"},{"unified":"1f6b4-1f3fc-200d-2642-fe0f","native":"🚴🏼‍♂️"},{"unified":"1f6b4-1f3fd-200d-2642-fe0f","native":"🚴🏽‍♂️"},{"unified":"1f6b4-1f3fe-200d-2642-fe0f","native":"🚴🏾‍♂️"},{"unified":"1f6b4-1f3ff-200d-2642-fe0f","native":"🚴🏿‍♂️"}],"version":4},"woman-biking":{"id":"woman-biking","name":"Woman Biking","keywords":["sports","bike","exercise","hipster","female"],"skins":[{"unified":"1f6b4-200d-2640-fe0f","native":"🚴‍♀️"},{"unified":"1f6b4-1f3fb-200d-2640-fe0f","native":"🚴🏻‍♀️"},{"unified":"1f6b4-1f3fc-200d-2640-fe0f","native":"🚴🏼‍♀️"},{"unified":"1f6b4-1f3fd-200d-2640-fe0f","native":"🚴🏽‍♀️"},{"unified":"1f6b4-1f3fe-200d-2640-fe0f","native":"🚴🏾‍♀️"},{"unified":"1f6b4-1f3ff-200d-2640-fe0f","native":"🚴🏿‍♀️"}],"version":4},"mountain_bicyclist":{"id":"mountain_bicyclist","name":"Mountain Bicyclist","keywords":["person","biking","sport","move"],"skins":[{"unified":"1f6b5","native":"🚵"},{"unified":"1f6b5-1f3fb","native":"🚵🏻"},{"unified":"1f6b5-1f3fc","native":"🚵🏼"},{"unified":"1f6b5-1f3fd","native":"🚵🏽"},{"unified":"1f6b5-1f3fe","native":"🚵🏾"},{"unified":"1f6b5-1f3ff","native":"🚵🏿"}],"version":1},"man-mountain-biking":{"id":"man-mountain-biking","name":"Man Mountain Biking","keywords":["mountain-biking","transportation","sports","human","race","bike"],"skins":[{"unified":"1f6b5-200d-2642-fe0f","native":"🚵‍♂️"},{"unified":"1f6b5-1f3fb-200d-2642-fe0f","native":"🚵🏻‍♂️"},{"unified":"1f6b5-1f3fc-200d-2642-fe0f","native":"🚵🏼‍♂️"},{"unified":"1f6b5-1f3fd-200d-2642-fe0f","native":"🚵🏽‍♂️"},{"unified":"1f6b5-1f3fe-200d-2642-fe0f","native":"🚵🏾‍♂️"},{"unified":"1f6b5-1f3ff-200d-2642-fe0f","native":"🚵🏿‍♂️"}],"version":4},"woman-mountain-biking":{"id":"woman-mountain-biking","name":"Woman Mountain Biking","keywords":["mountain-biking","transportation","sports","human","race","bike","female"],"skins":[{"unified":"1f6b5-200d-2640-fe0f","native":"🚵‍♀️"},{"unified":"1f6b5-1f3fb-200d-2640-fe0f","native":"🚵🏻‍♀️"},{"unified":"1f6b5-1f3fc-200d-2640-fe0f","native":"🚵🏼‍♀️"},{"unified":"1f6b5-1f3fd-200d-2640-fe0f","native":"🚵🏽‍♀️"},{"unified":"1f6b5-1f3fe-200d-2640-fe0f","native":"🚵🏾‍♀️"},{"unified":"1f6b5-1f3ff-200d-2640-fe0f","native":"🚵🏿‍♀️"}],"version":4},"person_doing_cartwheel":{"id":"person_doing_cartwheel","name":"Person Cartwheeling","keywords":["doing","cartwheel","sport","gymnastic"],"skins":[{"unified":"1f938","native":"🤸"},{"unified":"1f938-1f3fb","native":"🤸🏻"},{"unified":"1f938-1f3fc","native":"🤸🏼"},{"unified":"1f938-1f3fd","native":"🤸🏽"},{"unified":"1f938-1f3fe","native":"🤸🏾"},{"unified":"1f938-1f3ff","native":"🤸🏿"}],"version":3},"man-cartwheeling":{"id":"man-cartwheeling","name":"Man Cartwheeling","keywords":["gymnastics"],"skins":[{"unified":"1f938-200d-2642-fe0f","native":"🤸‍♂️"},{"unified":"1f938-1f3fb-200d-2642-fe0f","native":"🤸🏻‍♂️"},{"unified":"1f938-1f3fc-200d-2642-fe0f","native":"🤸🏼‍♂️"},{"unified":"1f938-1f3fd-200d-2642-fe0f","native":"🤸🏽‍♂️"},{"unified":"1f938-1f3fe-200d-2642-fe0f","native":"🤸🏾‍♂️"},{"unified":"1f938-1f3ff-200d-2642-fe0f","native":"🤸🏿‍♂️"}],"version":4},"woman-cartwheeling":{"id":"woman-cartwheeling","name":"Woman Cartwheeling","keywords":["gymnastics"],"skins":[{"unified":"1f938-200d-2640-fe0f","native":"🤸‍♀️"},{"unified":"1f938-1f3fb-200d-2640-fe0f","native":"🤸🏻‍♀️"},{"unified":"1f938-1f3fc-200d-2640-fe0f","native":"🤸🏼‍♀️"},{"unified":"1f938-1f3fd-200d-2640-fe0f","native":"🤸🏽‍♀️"},{"unified":"1f938-1f3fe-200d-2640-fe0f","native":"🤸🏾‍♀️"},{"unified":"1f938-1f3ff-200d-2640-fe0f","native":"🤸🏿‍♀️"}],"version":4},"wrestlers":{"id":"wrestlers","name":"Wrestlers","keywords":["people","wrestling","sport"],"skins":[{"unified":"1f93c","native":"🤼"}],"version":3},"man-wrestling":{"id":"man-wrestling","name":"Men Wrestling","keywords":["man","sports","wrestlers"],"skins":[{"unified":"1f93c-200d-2642-fe0f","native":"🤼‍♂️"}],"version":4},"woman-wrestling":{"id":"woman-wrestling","name":"Women Wrestling","keywords":["woman","sports","wrestlers"],"skins":[{"unified":"1f93c-200d-2640-fe0f","native":"🤼‍♀️"}],"version":4},"water_polo":{"id":"water_polo","name":"Water Polo","keywords":["person","playing","sport"],"skins":[{"unified":"1f93d","native":"🤽"},{"unified":"1f93d-1f3fb","native":"🤽🏻"},{"unified":"1f93d-1f3fc","native":"🤽🏼"},{"unified":"1f93d-1f3fd","native":"🤽🏽"},{"unified":"1f93d-1f3fe","native":"🤽🏾"},{"unified":"1f93d-1f3ff","native":"🤽🏿"}],"version":3},"man-playing-water-polo":{"id":"man-playing-water-polo","name":"Man Playing Water Polo","keywords":["playing-water-polo","sports","pool"],"skins":[{"unified":"1f93d-200d-2642-fe0f","native":"🤽‍♂️"},{"unified":"1f93d-1f3fb-200d-2642-fe0f","native":"🤽🏻‍♂️"},{"unified":"1f93d-1f3fc-200d-2642-fe0f","native":"🤽🏼‍♂️"},{"unified":"1f93d-1f3fd-200d-2642-fe0f","native":"🤽🏽‍♂️"},{"unified":"1f93d-1f3fe-200d-2642-fe0f","native":"🤽🏾‍♂️"},{"unified":"1f93d-1f3ff-200d-2642-fe0f","native":"🤽🏿‍♂️"}],"version":4},"woman-playing-water-polo":{"id":"woman-playing-water-polo","name":"Woman Playing Water Polo","keywords":["playing-water-polo","sports","pool"],"skins":[{"unified":"1f93d-200d-2640-fe0f","native":"🤽‍♀️"},{"unified":"1f93d-1f3fb-200d-2640-fe0f","native":"🤽🏻‍♀️"},{"unified":"1f93d-1f3fc-200d-2640-fe0f","native":"🤽🏼‍♀️"},{"unified":"1f93d-1f3fd-200d-2640-fe0f","native":"🤽🏽‍♀️"},{"unified":"1f93d-1f3fe-200d-2640-fe0f","native":"🤽🏾‍♀️"},{"unified":"1f93d-1f3ff-200d-2640-fe0f","native":"🤽🏿‍♀️"}],"version":4},"handball":{"id":"handball","name":"Handball","keywords":["person","playing","sport"],"skins":[{"unified":"1f93e","native":"🤾"},{"unified":"1f93e-1f3fb","native":"🤾🏻"},{"unified":"1f93e-1f3fc","native":"🤾🏼"},{"unified":"1f93e-1f3fd","native":"🤾🏽"},{"unified":"1f93e-1f3fe","native":"🤾🏾"},{"unified":"1f93e-1f3ff","native":"🤾🏿"}],"version":3},"man-playing-handball":{"id":"man-playing-handball","name":"Man Playing Handball","keywords":["playing-handball","sports"],"skins":[{"unified":"1f93e-200d-2642-fe0f","native":"🤾‍♂️"},{"unified":"1f93e-1f3fb-200d-2642-fe0f","native":"🤾🏻‍♂️"},{"unified":"1f93e-1f3fc-200d-2642-fe0f","native":"🤾🏼‍♂️"},{"unified":"1f93e-1f3fd-200d-2642-fe0f","native":"🤾🏽‍♂️"},{"unified":"1f93e-1f3fe-200d-2642-fe0f","native":"🤾🏾‍♂️"},{"unified":"1f93e-1f3ff-200d-2642-fe0f","native":"🤾🏿‍♂️"}],"version":4},"woman-playing-handball":{"id":"woman-playing-handball","name":"Woman Playing Handball","keywords":["playing-handball","sports"],"skins":[{"unified":"1f93e-200d-2640-fe0f","native":"🤾‍♀️"},{"unified":"1f93e-1f3fb-200d-2640-fe0f","native":"🤾🏻‍♀️"},{"unified":"1f93e-1f3fc-200d-2640-fe0f","native":"🤾🏼‍♀️"},{"unified":"1f93e-1f3fd-200d-2640-fe0f","native":"🤾🏽‍♀️"},{"unified":"1f93e-1f3fe-200d-2640-fe0f","native":"🤾🏾‍♀️"},{"unified":"1f93e-1f3ff-200d-2640-fe0f","native":"🤾🏿‍♀️"}],"version":4},"juggling":{"id":"juggling","name":"Juggling","keywords":["person","performance","balance"],"skins":[{"unified":"1f939","native":"🤹"},{"unified":"1f939-1f3fb","native":"🤹🏻"},{"unified":"1f939-1f3fc","native":"🤹🏼"},{"unified":"1f939-1f3fd","native":"🤹🏽"},{"unified":"1f939-1f3fe","native":"🤹🏾"},{"unified":"1f939-1f3ff","native":"🤹🏿"}],"version":3},"man-juggling":{"id":"man-juggling","name":"Man Juggling","keywords":["juggle","balance","skill","multitask"],"skins":[{"unified":"1f939-200d-2642-fe0f","native":"🤹‍♂️"},{"unified":"1f939-1f3fb-200d-2642-fe0f","native":"🤹🏻‍♂️"},{"unified":"1f939-1f3fc-200d-2642-fe0f","native":"🤹🏼‍♂️"},{"unified":"1f939-1f3fd-200d-2642-fe0f","native":"🤹🏽‍♂️"},{"unified":"1f939-1f3fe-200d-2642-fe0f","native":"🤹🏾‍♂️"},{"unified":"1f939-1f3ff-200d-2642-fe0f","native":"🤹🏿‍♂️"}],"version":4},"woman-juggling":{"id":"woman-juggling","name":"Woman Juggling","keywords":["juggle","balance","skill","multitask"],"skins":[{"unified":"1f939-200d-2640-fe0f","native":"🤹‍♀️"},{"unified":"1f939-1f3fb-200d-2640-fe0f","native":"🤹🏻‍♀️"},{"unified":"1f939-1f3fc-200d-2640-fe0f","native":"🤹🏼‍♀️"},{"unified":"1f939-1f3fd-200d-2640-fe0f","native":"🤹🏽‍♀️"},{"unified":"1f939-1f3fe-200d-2640-fe0f","native":"🤹🏾‍♀️"},{"unified":"1f939-1f3ff-200d-2640-fe0f","native":"🤹🏿‍♀️"}],"version":4},"person_in_lotus_position":{"id":"person_in_lotus_position","name":"Person in Lotus Position","keywords":["meditate"],"skins":[{"unified":"1f9d8","native":"🧘"},{"unified":"1f9d8-1f3fb","native":"🧘🏻"},{"unified":"1f9d8-1f3fc","native":"🧘🏼"},{"unified":"1f9d8-1f3fd","native":"🧘🏽"},{"unified":"1f9d8-1f3fe","native":"🧘🏾"},{"unified":"1f9d8-1f3ff","native":"🧘🏿"}],"version":5},"man_in_lotus_position":{"id":"man_in_lotus_position","name":"Man in Lotus Position","keywords":["male","meditation","yoga","serenity","zen","mindfulness"],"skins":[{"unified":"1f9d8-200d-2642-fe0f","native":"🧘‍♂️"},{"unified":"1f9d8-1f3fb-200d-2642-fe0f","native":"🧘🏻‍♂️"},{"unified":"1f9d8-1f3fc-200d-2642-fe0f","native":"🧘🏼‍♂️"},{"unified":"1f9d8-1f3fd-200d-2642-fe0f","native":"🧘🏽‍♂️"},{"unified":"1f9d8-1f3fe-200d-2642-fe0f","native":"🧘🏾‍♂️"},{"unified":"1f9d8-1f3ff-200d-2642-fe0f","native":"🧘🏿‍♂️"}],"version":5},"woman_in_lotus_position":{"id":"woman_in_lotus_position","name":"Woman in Lotus Position","keywords":["female","meditation","yoga","serenity","zen","mindfulness"],"skins":[{"unified":"1f9d8-200d-2640-fe0f","native":"🧘‍♀️"},{"unified":"1f9d8-1f3fb-200d-2640-fe0f","native":"🧘🏻‍♀️"},{"unified":"1f9d8-1f3fc-200d-2640-fe0f","native":"🧘🏼‍♀️"},{"unified":"1f9d8-1f3fd-200d-2640-fe0f","native":"🧘🏽‍♀️"},{"unified":"1f9d8-1f3fe-200d-2640-fe0f","native":"🧘🏾‍♀️"},{"unified":"1f9d8-1f3ff-200d-2640-fe0f","native":"🧘🏿‍♀️"}],"version":5},"bath":{"id":"bath","name":"Bath","keywords":["person","taking","clean","shower","bathroom"],"skins":[{"unified":"1f6c0","native":"🛀"},{"unified":"1f6c0-1f3fb","native":"🛀🏻"},{"unified":"1f6c0-1f3fc","native":"🛀🏼"},{"unified":"1f6c0-1f3fd","native":"🛀🏽"},{"unified":"1f6c0-1f3fe","native":"🛀🏾"},{"unified":"1f6c0-1f3ff","native":"🛀🏿"}],"version":1},"sleeping_accommodation":{"id":"sleeping_accommodation","name":"Person in Bed","keywords":["sleeping","accommodation","rest"],"skins":[{"unified":"1f6cc","native":"🛌"},{"unified":"1f6cc-1f3fb","native":"🛌🏻"},{"unified":"1f6cc-1f3fc","native":"🛌🏼"},{"unified":"1f6cc-1f3fd","native":"🛌🏽"},{"unified":"1f6cc-1f3fe","native":"🛌🏾"},{"unified":"1f6cc-1f3ff","native":"🛌🏿"}],"version":1},"people_holding_hands":{"id":"people_holding_hands","name":"People Holding Hands","keywords":["friendship"],"skins":[{"unified":"1f9d1-200d-1f91d-200d-1f9d1","native":"🧑‍🤝‍🧑"},{"unified":"1f9d1-1f3fb-200d-1f91d-200d-1f9d1-1f3fb","native":"🧑🏻‍🤝‍🧑🏻"},{"unified":"1f9d1-1f3fc-200d-1f91d-200d-1f9d1-1f3fc","native":"🧑🏼‍🤝‍🧑🏼"},{"unified":"1f9d1-1f3fd-200d-1f91d-200d-1f9d1-1f3fd","native":"🧑🏽‍🤝‍🧑🏽"},{"unified":"1f9d1-1f3fe-200d-1f91d-200d-1f9d1-1f3fe","native":"🧑🏾‍🤝‍🧑🏾"},{"unified":"1f9d1-1f3ff-200d-1f91d-200d-1f9d1-1f3ff","native":"🧑🏿‍🤝‍🧑🏿"}],"version":12},"two_women_holding_hands":{"id":"two_women_holding_hands","name":"Women Holding Hands","keywords":["two","pair","friendship","couple","love","like","female","people","human"],"skins":[{"unified":"1f46d","native":"👭"},{"unified":"1f46d-1f3fb","native":"👭🏻"},{"unified":"1f46d-1f3fc","native":"👭🏼"},{"unified":"1f46d-1f3fd","native":"👭🏽"},{"unified":"1f46d-1f3fe","native":"👭🏾"},{"unified":"1f46d-1f3ff","native":"👭🏿"}],"version":1},"man_and_woman_holding_hands":{"id":"man_and_woman_holding_hands","name":"Man and Woman Holding Hands","keywords":["couple","pair","people","human","love","date","dating","like","affection","valentines","marriage"],"skins":[{"unified":"1f46b","native":"👫"},{"unified":"1f46b-1f3fb","native":"👫🏻"},{"unified":"1f46b-1f3fc","native":"👫🏼"},{"unified":"1f46b-1f3fd","native":"👫🏽"},{"unified":"1f46b-1f3fe","native":"👫🏾"},{"unified":"1f46b-1f3ff","native":"👫🏿"}],"version":1},"two_men_holding_hands":{"id":"two_men_holding_hands","name":"Men Holding Hands","keywords":["two","pair","couple","love","like","bromance","friendship","people","human"],"skins":[{"unified":"1f46c","native":"👬"},{"unified":"1f46c-1f3fb","native":"👬🏻"},{"unified":"1f46c-1f3fc","native":"👬🏼"},{"unified":"1f46c-1f3fd","native":"👬🏽"},{"unified":"1f46c-1f3fe","native":"👬🏾"},{"unified":"1f46c-1f3ff","native":"👬🏿"}],"version":1},"couplekiss":{"id":"couplekiss","name":"Kiss","keywords":["couplekiss","pair","valentines","love","like","dating","marriage"],"skins":[{"unified":"1f48f","native":"💏"},{"unified":"1f48f-1f3fb","native":"💏🏻"},{"unified":"1f48f-1f3fc","native":"💏🏼"},{"unified":"1f48f-1f3fd","native":"💏🏽"},{"unified":"1f48f-1f3fe","native":"💏🏾"},{"unified":"1f48f-1f3ff","native":"💏🏿"}],"version":1},"woman-kiss-man":{"id":"woman-kiss-man","name":"Kiss: Woman, Man","keywords":["woman","kiss-man","kiss","love"],"skins":[{"unified":"1f469-200d-2764-fe0f-200d-1f48b-200d-1f468","native":"👩‍❤️‍💋‍👨"},{"unified":"1f469-1f3fb-200d-2764-fe0f-200d-1f48b-200d-1f468-1f3fb","native":"👩🏻‍❤️‍💋‍👨🏻"},{"unified":"1f469-1f3fc-200d-2764-fe0f-200d-1f48b-200d-1f468-1f3fc","native":"👩🏼‍❤️‍💋‍👨🏼"},{"unified":"1f469-1f3fd-200d-2764-fe0f-200d-1f48b-200d-1f468-1f3fd","native":"👩🏽‍❤️‍💋‍👨🏽"},{"unified":"1f469-1f3fe-200d-2764-fe0f-200d-1f48b-200d-1f468-1f3fe","native":"👩🏾‍❤️‍💋‍👨🏾"},{"unified":"1f469-1f3ff-200d-2764-fe0f-200d-1f48b-200d-1f468-1f3ff","native":"👩🏿‍❤️‍💋‍👨🏿"}],"version":2},"man-kiss-man":{"id":"man-kiss-man","name":"Kiss: Man, Man","keywords":["kiss-man","kiss","pair","valentines","love","like","dating","marriage"],"skins":[{"unified":"1f468-200d-2764-fe0f-200d-1f48b-200d-1f468","native":"👨‍❤️‍💋‍👨"},{"unified":"1f468-1f3fb-200d-2764-fe0f-200d-1f48b-200d-1f468-1f3fb","native":"👨🏻‍❤️‍💋‍👨🏻"},{"unified":"1f468-1f3fc-200d-2764-fe0f-200d-1f48b-200d-1f468-1f3fc","native":"👨🏼‍❤️‍💋‍👨🏼"},{"unified":"1f468-1f3fd-200d-2764-fe0f-200d-1f48b-200d-1f468-1f3fd","native":"👨🏽‍❤️‍💋‍👨🏽"},{"unified":"1f468-1f3fe-200d-2764-fe0f-200d-1f48b-200d-1f468-1f3fe","native":"👨🏾‍❤️‍💋‍👨🏾"},{"unified":"1f468-1f3ff-200d-2764-fe0f-200d-1f48b-200d-1f468-1f3ff","native":"👨🏿‍❤️‍💋‍👨🏿"}],"version":2},"woman-kiss-woman":{"id":"woman-kiss-woman","name":"Kiss: Woman, Woman","keywords":["kiss-woman","kiss","pair","valentines","love","like","dating","marriage"],"skins":[{"unified":"1f469-200d-2764-fe0f-200d-1f48b-200d-1f469","native":"👩‍❤️‍💋‍👩"},{"unified":"1f469-1f3fb-200d-2764-fe0f-200d-1f48b-200d-1f469-1f3fb","native":"👩🏻‍❤️‍💋‍👩🏻"},{"unified":"1f469-1f3fc-200d-2764-fe0f-200d-1f48b-200d-1f469-1f3fc","native":"👩🏼‍❤️‍💋‍👩🏼"},{"unified":"1f469-1f3fd-200d-2764-fe0f-200d-1f48b-200d-1f469-1f3fd","native":"👩🏽‍❤️‍💋‍👩🏽"},{"unified":"1f469-1f3fe-200d-2764-fe0f-200d-1f48b-200d-1f469-1f3fe","native":"👩🏾‍❤️‍💋‍👩🏾"},{"unified":"1f469-1f3ff-200d-2764-fe0f-200d-1f48b-200d-1f469-1f3ff","native":"👩🏿‍❤️‍💋‍👩🏿"}],"version":2},"couple_with_heart":{"id":"couple_with_heart","name":"Couple with Heart","keywords":["pair","love","like","affection","human","dating","valentines","marriage"],"skins":[{"unified":"1f491","native":"💑"},{"unified":"1f491-1f3fb","native":"💑🏻"},{"unified":"1f491-1f3fc","native":"💑🏼"},{"unified":"1f491-1f3fd","native":"💑🏽"},{"unified":"1f491-1f3fe","native":"💑🏾"},{"unified":"1f491-1f3ff","native":"💑🏿"}],"version":1},"woman-heart-man":{"id":"woman-heart-man","name":"Couple with Heart: Woman, Man","keywords":["woman","heart-man","heart","love"],"skins":[{"unified":"1f469-200d-2764-fe0f-200d-1f468","native":"👩‍❤️‍👨"},{"unified":"1f469-1f3fb-200d-2764-fe0f-200d-1f468-1f3fb","native":"👩🏻‍❤️‍👨🏻"},{"unified":"1f469-1f3fc-200d-2764-fe0f-200d-1f468-1f3fc","native":"👩🏼‍❤️‍👨🏼"},{"unified":"1f469-1f3fd-200d-2764-fe0f-200d-1f468-1f3fd","native":"👩🏽‍❤️‍👨🏽"},{"unified":"1f469-1f3fe-200d-2764-fe0f-200d-1f468-1f3fe","native":"👩🏾‍❤️‍👨🏾"},{"unified":"1f469-1f3ff-200d-2764-fe0f-200d-1f468-1f3ff","native":"👩🏿‍❤️‍👨🏿"}],"version":2},"man-heart-man":{"id":"man-heart-man","name":"Couple with Heart: Man, Man","keywords":["heart-man","heart","pair","love","like","affection","human","dating","valentines","marriage"],"skins":[{"unified":"1f468-200d-2764-fe0f-200d-1f468","native":"👨‍❤️‍👨"},{"unified":"1f468-1f3fb-200d-2764-fe0f-200d-1f468-1f3fb","native":"👨🏻‍❤️‍👨🏻"},{"unified":"1f468-1f3fc-200d-2764-fe0f-200d-1f468-1f3fc","native":"👨🏼‍❤️‍👨🏼"},{"unified":"1f468-1f3fd-200d-2764-fe0f-200d-1f468-1f3fd","native":"👨🏽‍❤️‍👨🏽"},{"unified":"1f468-1f3fe-200d-2764-fe0f-200d-1f468-1f3fe","native":"👨🏾‍❤️‍👨🏾"},{"unified":"1f468-1f3ff-200d-2764-fe0f-200d-1f468-1f3ff","native":"👨🏿‍❤️‍👨🏿"}],"version":2},"woman-heart-woman":{"id":"woman-heart-woman","name":"Couple with Heart: Woman, Woman","keywords":["heart-woman","heart","pair","love","like","affection","human","dating","valentines","marriage"],"skins":[{"unified":"1f469-200d-2764-fe0f-200d-1f469","native":"👩‍❤️‍👩"},{"unified":"1f469-1f3fb-200d-2764-fe0f-200d-1f469-1f3fb","native":"👩🏻‍❤️‍👩🏻"},{"unified":"1f469-1f3fc-200d-2764-fe0f-200d-1f469-1f3fc","native":"👩🏼‍❤️‍👩🏼"},{"unified":"1f469-1f3fd-200d-2764-fe0f-200d-1f469-1f3fd","native":"👩🏽‍❤️‍👩🏽"},{"unified":"1f469-1f3fe-200d-2764-fe0f-200d-1f469-1f3fe","native":"👩🏾‍❤️‍👩🏾"},{"unified":"1f469-1f3ff-200d-2764-fe0f-200d-1f469-1f3ff","native":"👩🏿‍❤️‍👩🏿"}],"version":2},"family":{"id":"family","name":"Family","keywords":["home","parents","child","mom","dad","father","mother","people","human"],"skins":[{"unified":"1f46a","native":"👪"}],"version":1},"man-woman-boy":{"id":"man-woman-boy","name":"Family: Man, Woman, Boy","keywords":["man","woman-boy","family","woman","love"],"skins":[{"unified":"1f468-200d-1f469-200d-1f466","native":"👨‍👩‍👦"}],"version":2},"man-woman-girl":{"id":"man-woman-girl","name":"Family: Man, Woman, Girl","keywords":["man","woman-girl","family","woman","home","parents","people","human","child"],"skins":[{"unified":"1f468-200d-1f469-200d-1f467","native":"👨‍👩‍👧"}],"version":2},"man-woman-girl-boy":{"id":"man-woman-girl-boy","name":"Family: Man, Woman, Girl, Boy","keywords":["man","woman-girl-boy","family","woman","girl","home","parents","people","human","children"],"skins":[{"unified":"1f468-200d-1f469-200d-1f467-200d-1f466","native":"👨‍👩‍👧‍👦"}],"version":2},"man-woman-boy-boy":{"id":"man-woman-boy-boy","name":"Family: Man, Woman, Boy, Boy","keywords":["man","woman-boy-boy","family","woman","home","parents","people","human","children"],"skins":[{"unified":"1f468-200d-1f469-200d-1f466-200d-1f466","native":"👨‍👩‍👦‍👦"}],"version":2},"man-woman-girl-girl":{"id":"man-woman-girl-girl","name":"Family: Man, Woman, Girl, Girl","keywords":["man","woman-girl-girl","family","woman","home","parents","people","human","children"],"skins":[{"unified":"1f468-200d-1f469-200d-1f467-200d-1f467","native":"👨‍👩‍👧‍👧"}],"version":2},"man-man-boy":{"id":"man-man-boy","name":"Family: Man, Man, Boy","keywords":["man","man-boy","family","home","parents","people","human","children"],"skins":[{"unified":"1f468-200d-1f468-200d-1f466","native":"👨‍👨‍👦"}],"version":2},"man-man-girl":{"id":"man-man-girl","name":"Family: Man, Man, Girl","keywords":["man","man-girl","family","home","parents","people","human","children"],"skins":[{"unified":"1f468-200d-1f468-200d-1f467","native":"👨‍👨‍👧"}],"version":2},"man-man-girl-boy":{"id":"man-man-girl-boy","name":"Family: Man, Man, Girl, Boy","keywords":["man","man-girl-boy","family","girl","home","parents","people","human","children"],"skins":[{"unified":"1f468-200d-1f468-200d-1f467-200d-1f466","native":"👨‍👨‍👧‍👦"}],"version":2},"man-man-boy-boy":{"id":"man-man-boy-boy","name":"Family: Man, Man, Boy, Boy","keywords":["man","man-boy-boy","family","home","parents","people","human","children"],"skins":[{"unified":"1f468-200d-1f468-200d-1f466-200d-1f466","native":"👨‍👨‍👦‍👦"}],"version":2},"man-man-girl-girl":{"id":"man-man-girl-girl","name":"Family: Man, Man, Girl, Girl","keywords":["man","man-girl-girl","family","home","parents","people","human","children"],"skins":[{"unified":"1f468-200d-1f468-200d-1f467-200d-1f467","native":"👨‍👨‍👧‍👧"}],"version":2},"woman-woman-boy":{"id":"woman-woman-boy","name":"Family: Woman, Woman, Boy","keywords":["woman","woman-boy","family","home","parents","people","human","children"],"skins":[{"unified":"1f469-200d-1f469-200d-1f466","native":"👩‍👩‍👦"}],"version":2},"woman-woman-girl":{"id":"woman-woman-girl","name":"Family: Woman, Woman, Girl","keywords":["woman","woman-girl","family","home","parents","people","human","children"],"skins":[{"unified":"1f469-200d-1f469-200d-1f467","native":"👩‍👩‍👧"}],"version":2},"woman-woman-girl-boy":{"id":"woman-woman-girl-boy","name":"Family: Woman, Woman, Girl, Boy","keywords":["woman","woman-girl-boy","family","girl","home","parents","people","human","children"],"skins":[{"unified":"1f469-200d-1f469-200d-1f467-200d-1f466","native":"👩‍👩‍👧‍👦"}],"version":2},"woman-woman-boy-boy":{"id":"woman-woman-boy-boy","name":"Family: Woman, Woman, Boy, Boy","keywords":["woman","woman-boy-boy","family","home","parents","people","human","children"],"skins":[{"unified":"1f469-200d-1f469-200d-1f466-200d-1f466","native":"👩‍👩‍👦‍👦"}],"version":2},"woman-woman-girl-girl":{"id":"woman-woman-girl-girl","name":"Family: Woman, Woman, Girl, Girl","keywords":["woman","woman-girl-girl","family","home","parents","people","human","children"],"skins":[{"unified":"1f469-200d-1f469-200d-1f467-200d-1f467","native":"👩‍👩‍👧‍👧"}],"version":2},"man-boy":{"id":"man-boy","name":"Family: Man, Boy","keywords":["man","family","home","parent","people","human","child"],"skins":[{"unified":"1f468-200d-1f466","native":"👨‍👦"}],"version":4},"man-boy-boy":{"id":"man-boy-boy","name":"Family: Man, Boy, Boy","keywords":["man","boy-boy","family","home","parent","people","human","children"],"skins":[{"unified":"1f468-200d-1f466-200d-1f466","native":"👨‍👦‍👦"}],"version":4},"man-girl":{"id":"man-girl","name":"Family: Man, Girl","keywords":["man","family","home","parent","people","human","child"],"skins":[{"unified":"1f468-200d-1f467","native":"👨‍👧"}],"version":4},"man-girl-boy":{"id":"man-girl-boy","name":"Family: Man, Girl, Boy","keywords":["man","girl-boy","family","girl","home","parent","people","human","children"],"skins":[{"unified":"1f468-200d-1f467-200d-1f466","native":"👨‍👧‍👦"}],"version":4},"man-girl-girl":{"id":"man-girl-girl","name":"Family: Man, Girl, Girl","keywords":["man","girl-girl","family","home","parent","people","human","children"],"skins":[{"unified":"1f468-200d-1f467-200d-1f467","native":"👨‍👧‍👧"}],"version":4},"woman-boy":{"id":"woman-boy","name":"Family: Woman, Boy","keywords":["woman","family","home","parent","people","human","child"],"skins":[{"unified":"1f469-200d-1f466","native":"👩‍👦"}],"version":4},"woman-boy-boy":{"id":"woman-boy-boy","name":"Family: Woman, Boy, Boy","keywords":["woman","boy-boy","family","home","parent","people","human","children"],"skins":[{"unified":"1f469-200d-1f466-200d-1f466","native":"👩‍👦‍👦"}],"version":4},"woman-girl":{"id":"woman-girl","name":"Family: Woman, Girl","keywords":["woman","family","home","parent","people","human","child"],"skins":[{"unified":"1f469-200d-1f467","native":"👩‍👧"}],"version":4},"woman-girl-boy":{"id":"woman-girl-boy","name":"Family: Woman, Girl, Boy","keywords":["woman","girl-boy","family","girl","home","parent","people","human","children"],"skins":[{"unified":"1f469-200d-1f467-200d-1f466","native":"👩‍👧‍👦"}],"version":4},"woman-girl-girl":{"id":"woman-girl-girl","name":"Family: Woman, Girl, Girl","keywords":["woman","girl-girl","family","home","parent","people","human","children"],"skins":[{"unified":"1f469-200d-1f467-200d-1f467","native":"👩‍👧‍👧"}],"version":4},"speaking_head_in_silhouette":{"id":"speaking_head_in_silhouette","name":"Speaking Head","keywords":["in","silhouette","user","person","human","sing","say","talk"],"skins":[{"unified":"1f5e3-fe0f","native":"🗣️"}],"version":1},"bust_in_silhouette":{"id":"bust_in_silhouette","name":"Bust in Silhouette","keywords":["user","person","human"],"skins":[{"unified":"1f464","native":"👤"}],"version":1},"busts_in_silhouette":{"id":"busts_in_silhouette","name":"Busts in Silhouette","keywords":["user","person","human","group","team"],"skins":[{"unified":"1f465","native":"👥"}],"version":1},"people_hugging":{"id":"people_hugging","name":"People Hugging","keywords":["care"],"skins":[{"unified":"1fac2","native":"🫂"}],"version":13},"footprints":{"id":"footprints","name":"Footprints","keywords":["feet","tracking","walking","beach"],"skins":[{"unified":"1f463","native":"👣"}],"version":1},"monkey_face":{"id":"monkey_face","name":"Monkey Face","emoticons":[":o)"],"keywords":["animal","nature","circus"],"skins":[{"unified":"1f435","native":"🐵"}],"version":1},"monkey":{"id":"monkey","name":"Monkey","keywords":["animal","nature","banana","circus"],"skins":[{"unified":"1f412","native":"🐒"}],"version":1},"gorilla":{"id":"gorilla","name":"Gorilla","keywords":["animal","nature","circus"],"skins":[{"unified":"1f98d","native":"🦍"}],"version":3},"orangutan":{"id":"orangutan","name":"Orangutan","keywords":["animal"],"skins":[{"unified":"1f9a7","native":"🦧"}],"version":12},"dog":{"id":"dog","name":"Dog Face","keywords":["animal","friend","nature","woof","puppy","pet","faithful"],"skins":[{"unified":"1f436","native":"🐶"}],"version":1},"dog2":{"id":"dog2","name":"Dog","keywords":["dog2","animal","nature","friend","doge","pet","faithful"],"skins":[{"unified":"1f415","native":"🐕"}],"version":1},"guide_dog":{"id":"guide_dog","name":"Guide Dog","keywords":["animal","blind"],"skins":[{"unified":"1f9ae","native":"🦮"}],"version":12},"service_dog":{"id":"service_dog","name":"Service Dog","keywords":["blind","animal"],"skins":[{"unified":"1f415-200d-1f9ba","native":"🐕‍🦺"}],"version":12},"poodle":{"id":"poodle","name":"Poodle","keywords":["dog","animal","101","nature","pet"],"skins":[{"unified":"1f429","native":"🐩"}],"version":1},"wolf":{"id":"wolf","name":"Wolf","keywords":["animal","nature","wild"],"skins":[{"unified":"1f43a","native":"🐺"}],"version":1},"fox_face":{"id":"fox_face","name":"Fox","keywords":["face","animal","nature"],"skins":[{"unified":"1f98a","native":"🦊"}],"version":3},"raccoon":{"id":"raccoon","name":"Raccoon","keywords":["animal","nature"],"skins":[{"unified":"1f99d","native":"🦝"}],"version":11},"cat":{"id":"cat","name":"Cat Face","keywords":["animal","meow","nature","pet","kitten"],"skins":[{"unified":"1f431","native":"🐱"}],"version":1},"cat2":{"id":"cat2","name":"Cat","keywords":["cat2","animal","meow","pet","cats"],"skins":[{"unified":"1f408","native":"🐈"}],"version":1},"black_cat":{"id":"black_cat","name":"Black Cat","keywords":["superstition","luck"],"skins":[{"unified":"1f408-200d-2b1b","native":"🐈‍⬛"}],"version":13},"lion_face":{"id":"lion_face","name":"Lion","keywords":["face","animal","nature"],"skins":[{"unified":"1f981","native":"🦁"}],"version":1},"tiger":{"id":"tiger","name":"Tiger Face","keywords":["animal","cat","danger","wild","nature","roar"],"skins":[{"unified":"1f42f","native":"🐯"}],"version":1},"tiger2":{"id":"tiger2","name":"Tiger","keywords":["tiger2","animal","nature","roar"],"skins":[{"unified":"1f405","native":"🐅"}],"version":1},"leopard":{"id":"leopard","name":"Leopard","keywords":["animal","nature"],"skins":[{"unified":"1f406","native":"🐆"}],"version":1},"horse":{"id":"horse","name":"Horse Face","keywords":["animal","brown","nature"],"skins":[{"unified":"1f434","native":"🐴"}],"version":1},"moose":{"id":"moose","name":"Moose","keywords":["shrek","canada","sweden","sven","cool"],"skins":[{"unified":"1face","native":"🫎"}],"version":15},"donkey":{"id":"donkey","name":"Donkey","keywords":["eeyore","mule"],"skins":[{"unified":"1facf","native":"🫏"}],"version":15},"racehorse":{"id":"racehorse","name":"Horse","keywords":["racehorse","animal","gamble","luck"],"skins":[{"unified":"1f40e","native":"🐎"}],"version":1},"unicorn_face":{"id":"unicorn_face","name":"Unicorn","keywords":["face","animal","nature","mystical"],"skins":[{"unified":"1f984","native":"🦄"}],"version":1},"zebra_face":{"id":"zebra_face","name":"Zebra","keywords":["face","animal","nature","stripes","safari"],"skins":[{"unified":"1f993","native":"🦓"}],"version":5},"deer":{"id":"deer","name":"Deer","keywords":["animal","nature","horns","venison"],"skins":[{"unified":"1f98c","native":"🦌"}],"version":3},"bison":{"id":"bison","name":"Bison","keywords":["ox"],"skins":[{"unified":"1f9ac","native":"🦬"}],"version":13},"cow":{"id":"cow","name":"Cow Face","keywords":["beef","ox","animal","nature","moo","milk"],"skins":[{"unified":"1f42e","native":"🐮"}],"version":1},"ox":{"id":"ox","name":"Ox","keywords":["animal","cow","beef"],"skins":[{"unified":"1f402","native":"🐂"}],"version":1},"water_buffalo":{"id":"water_buffalo","name":"Water Buffalo","keywords":["animal","nature","ox","cow"],"skins":[{"unified":"1f403","native":"🐃"}],"version":1},"cow2":{"id":"cow2","name":"Cow","keywords":["cow2","beef","ox","animal","nature","moo","milk"],"skins":[{"unified":"1f404","native":"🐄"}],"version":1},"pig":{"id":"pig","name":"Pig Face","keywords":["animal","oink","nature"],"skins":[{"unified":"1f437","native":"🐷"}],"version":1},"pig2":{"id":"pig2","name":"Pig","keywords":["pig2","animal","nature"],"skins":[{"unified":"1f416","native":"🐖"}],"version":1},"boar":{"id":"boar","name":"Boar","keywords":["animal","nature"],"skins":[{"unified":"1f417","native":"🐗"}],"version":1},"pig_nose":{"id":"pig_nose","name":"Pig Nose","keywords":["animal","oink"],"skins":[{"unified":"1f43d","native":"🐽"}],"version":1},"ram":{"id":"ram","name":"Ram","keywords":["animal","sheep","nature"],"skins":[{"unified":"1f40f","native":"🐏"}],"version":1},"sheep":{"id":"sheep","name":"Ewe","keywords":["sheep","animal","nature","wool","shipit"],"skins":[{"unified":"1f411","native":"🐑"}],"version":1},"goat":{"id":"goat","name":"Goat","keywords":["animal","nature"],"skins":[{"unified":"1f410","native":"🐐"}],"version":1},"dromedary_camel":{"id":"dromedary_camel","name":"Camel","keywords":["dromedary","animal","hot","desert","hump"],"skins":[{"unified":"1f42a","native":"🐪"}],"version":1},"camel":{"id":"camel","name":"Bactrian Camel","keywords":["two","hump","animal","nature","hot","desert"],"skins":[{"unified":"1f42b","native":"🐫"}],"version":1},"llama":{"id":"llama","name":"Llama","keywords":["animal","nature","alpaca"],"skins":[{"unified":"1f999","native":"🦙"}],"version":11},"giraffe_face":{"id":"giraffe_face","name":"Giraffe","keywords":["face","animal","nature","spots","safari"],"skins":[{"unified":"1f992","native":"🦒"}],"version":5},"elephant":{"id":"elephant","name":"Elephant","keywords":["animal","nature","nose","th","circus"],"skins":[{"unified":"1f418","native":"🐘"}],"version":1},"mammoth":{"id":"mammoth","name":"Mammoth","keywords":["elephant","tusks"],"skins":[{"unified":"1f9a3","native":"🦣"}],"version":13},"rhinoceros":{"id":"rhinoceros","name":"Rhinoceros","keywords":["animal","nature","horn"],"skins":[{"unified":"1f98f","native":"🦏"}],"version":3},"hippopotamus":{"id":"hippopotamus","name":"Hippopotamus","keywords":["animal","nature"],"skins":[{"unified":"1f99b","native":"🦛"}],"version":11},"mouse":{"id":"mouse","name":"Mouse Face","keywords":["animal","nature","cheese","wedge","rodent"],"skins":[{"unified":"1f42d","native":"🐭"}],"version":1},"mouse2":{"id":"mouse2","name":"Mouse","keywords":["mouse2","animal","nature","rodent"],"skins":[{"unified":"1f401","native":"🐁"}],"version":1},"rat":{"id":"rat","name":"Rat","keywords":["animal","mouse","rodent"],"skins":[{"unified":"1f400","native":"🐀"}],"version":1},"hamster":{"id":"hamster","name":"Hamster","keywords":["animal","nature"],"skins":[{"unified":"1f439","native":"🐹"}],"version":1},"rabbit":{"id":"rabbit","name":"Rabbit Face","keywords":["animal","nature","pet","spring","magic","bunny"],"skins":[{"unified":"1f430","native":"🐰"}],"version":1},"rabbit2":{"id":"rabbit2","name":"Rabbit","keywords":["rabbit2","animal","nature","pet","magic","spring"],"skins":[{"unified":"1f407","native":"🐇"}],"version":1},"chipmunk":{"id":"chipmunk","name":"Chipmunk","keywords":["animal","nature","rodent","squirrel"],"skins":[{"unified":"1f43f-fe0f","native":"🐿️"}],"version":1},"beaver":{"id":"beaver","name":"Beaver","keywords":["animal","rodent"],"skins":[{"unified":"1f9ab","native":"🦫"}],"version":13},"hedgehog":{"id":"hedgehog","name":"Hedgehog","keywords":["animal","nature","spiny"],"skins":[{"unified":"1f994","native":"🦔"}],"version":5},"bat":{"id":"bat","name":"Bat","keywords":["animal","nature","blind","vampire"],"skins":[{"unified":"1f987","native":"🦇"}],"version":3},"bear":{"id":"bear","name":"Bear","keywords":["animal","nature","wild"],"skins":[{"unified":"1f43b","native":"🐻"}],"version":1},"polar_bear":{"id":"polar_bear","name":"Polar Bear","keywords":["animal","arctic"],"skins":[{"unified":"1f43b-200d-2744-fe0f","native":"🐻‍❄️"}],"version":13},"koala":{"id":"koala","name":"Koala","keywords":["animal","nature"],"skins":[{"unified":"1f428","native":"🐨"}],"version":1},"panda_face":{"id":"panda_face","name":"Panda","keywords":["face","animal","nature"],"skins":[{"unified":"1f43c","native":"🐼"}],"version":1},"sloth":{"id":"sloth","name":"Sloth","keywords":["animal"],"skins":[{"unified":"1f9a5","native":"🦥"}],"version":12},"otter":{"id":"otter","name":"Otter","keywords":["animal"],"skins":[{"unified":"1f9a6","native":"🦦"}],"version":12},"skunk":{"id":"skunk","name":"Skunk","keywords":["animal"],"skins":[{"unified":"1f9a8","native":"🦨"}],"version":12},"kangaroo":{"id":"kangaroo","name":"Kangaroo","keywords":["animal","nature","australia","joey","hop","marsupial"],"skins":[{"unified":"1f998","native":"🦘"}],"version":11},"badger":{"id":"badger","name":"Badger","keywords":["animal","nature","honey"],"skins":[{"unified":"1f9a1","native":"🦡"}],"version":11},"feet":{"id":"feet","name":"Paw Prints","keywords":["feet","animal","tracking","footprints","dog","cat","pet"],"skins":[{"unified":"1f43e","native":"🐾"}],"version":1},"turkey":{"id":"turkey","name":"Turkey","keywords":["animal","bird"],"skins":[{"unified":"1f983","native":"🦃"}],"version":1},"chicken":{"id":"chicken","name":"Chicken","keywords":["animal","cluck","nature","bird"],"skins":[{"unified":"1f414","native":"🐔"}],"version":1},"rooster":{"id":"rooster","name":"Rooster","keywords":["animal","nature","chicken"],"skins":[{"unified":"1f413","native":"🐓"}],"version":1},"hatching_chick":{"id":"hatching_chick","name":"Hatching Chick","keywords":["animal","chicken","egg","born","baby","bird"],"skins":[{"unified":"1f423","native":"🐣"}],"version":1},"baby_chick":{"id":"baby_chick","name":"Baby Chick","keywords":["animal","chicken","bird"],"skins":[{"unified":"1f424","native":"🐤"}],"version":1},"hatched_chick":{"id":"hatched_chick","name":"Front-Facing Baby Chick","keywords":["hatched","front","facing","animal","chicken","bird"],"skins":[{"unified":"1f425","native":"🐥"}],"version":1},"bird":{"id":"bird","name":"Bird","keywords":["animal","nature","fly","tweet","spring"],"skins":[{"unified":"1f426","native":"🐦"}],"version":1},"penguin":{"id":"penguin","name":"Penguin","keywords":["animal","nature"],"skins":[{"unified":"1f427","native":"🐧"}],"version":1},"dove_of_peace":{"id":"dove_of_peace","name":"Dove","keywords":["of","peace","animal","bird"],"skins":[{"unified":"1f54a-fe0f","native":"🕊️"}],"version":1},"eagle":{"id":"eagle","name":"Eagle","keywords":["animal","nature","bird"],"skins":[{"unified":"1f985","native":"🦅"}],"version":3},"duck":{"id":"duck","name":"Duck","keywords":["animal","nature","bird","mallard"],"skins":[{"unified":"1f986","native":"🦆"}],"version":3},"swan":{"id":"swan","name":"Swan","keywords":["animal","nature","bird"],"skins":[{"unified":"1f9a2","native":"🦢"}],"version":11},"owl":{"id":"owl","name":"Owl","keywords":["animal","nature","bird","hoot"],"skins":[{"unified":"1f989","native":"🦉"}],"version":3},"dodo":{"id":"dodo","name":"Dodo","keywords":["animal","bird"],"skins":[{"unified":"1f9a4","native":"🦤"}],"version":13},"feather":{"id":"feather","name":"Feather","keywords":["bird","fly"],"skins":[{"unified":"1fab6","native":"🪶"}],"version":13},"flamingo":{"id":"flamingo","name":"Flamingo","keywords":["animal"],"skins":[{"unified":"1f9a9","native":"🦩"}],"version":12},"peacock":{"id":"peacock","name":"Peacock","keywords":["animal","nature","peahen","bird"],"skins":[{"unified":"1f99a","native":"🦚"}],"version":11},"parrot":{"id":"parrot","name":"Parrot","keywords":["animal","nature","bird","pirate","talk"],"skins":[{"unified":"1f99c","native":"🦜"}],"version":11},"wing":{"id":"wing","name":"Wing","keywords":["angel","birds","flying"],"skins":[{"unified":"1fabd","native":"🪽"}],"version":15},"black_bird":{"id":"black_bird","name":"Black Bird","keywords":["crow"],"skins":[{"unified":"1f426-200d-2b1b","native":"🐦‍⬛"}],"version":15},"goose":{"id":"goose","name":"Goose","keywords":["silly","jemima","goosebumps"],"skins":[{"unified":"1fabf","native":"🪿"}],"version":15},"frog":{"id":"frog","name":"Frog","keywords":["animal","nature","croak","toad"],"skins":[{"unified":"1f438","native":"🐸"}],"version":1},"crocodile":{"id":"crocodile","name":"Crocodile","keywords":["animal","nature","reptile","lizard","alligator"],"skins":[{"unified":"1f40a","native":"🐊"}],"version":1},"turtle":{"id":"turtle","name":"Turtle","keywords":["animal","slow","nature","tortoise"],"skins":[{"unified":"1f422","native":"🐢"}],"version":1},"lizard":{"id":"lizard","name":"Lizard","keywords":["animal","nature","reptile"],"skins":[{"unified":"1f98e","native":"🦎"}],"version":3},"snake":{"id":"snake","name":"Snake","keywords":["animal","evil","nature","hiss","python"],"skins":[{"unified":"1f40d","native":"🐍"}],"version":1},"dragon_face":{"id":"dragon_face","name":"Dragon Face","keywords":["animal","myth","nature","chinese","green"],"skins":[{"unified":"1f432","native":"🐲"}],"version":1},"dragon":{"id":"dragon","name":"Dragon","keywords":["animal","myth","nature","chinese","green"],"skins":[{"unified":"1f409","native":"🐉"}],"version":1},"sauropod":{"id":"sauropod","name":"Sauropod","keywords":["animal","nature","dinosaur","brachiosaurus","brontosaurus","diplodocus","extinct"],"skins":[{"unified":"1f995","native":"🦕"}],"version":5},"t-rex":{"id":"t-rex","name":"T-Rex","keywords":["t","rex","animal","nature","dinosaur","tyrannosaurus","extinct"],"skins":[{"unified":"1f996","native":"🦖"}],"version":5},"whale":{"id":"whale","name":"Spouting Whale","keywords":["animal","nature","sea","ocean"],"skins":[{"unified":"1f433","native":"🐳"}],"version":1},"whale2":{"id":"whale2","name":"Whale","keywords":["whale2","animal","nature","sea","ocean"],"skins":[{"unified":"1f40b","native":"🐋"}],"version":1},"dolphin":{"id":"dolphin","name":"Dolphin","keywords":["flipper","animal","nature","fish","sea","ocean","fins","beach"],"skins":[{"unified":"1f42c","native":"🐬"}],"version":1},"seal":{"id":"seal","name":"Seal","keywords":["animal","creature","sea"],"skins":[{"unified":"1f9ad","native":"🦭"}],"version":13},"fish":{"id":"fish","name":"Fish","keywords":["animal","food","nature"],"skins":[{"unified":"1f41f","native":"🐟"}],"version":1},"tropical_fish":{"id":"tropical_fish","name":"Tropical Fish","keywords":["animal","swim","ocean","beach","nemo"],"skins":[{"unified":"1f420","native":"🐠"}],"version":1},"blowfish":{"id":"blowfish","name":"Blowfish","keywords":["animal","nature","food","sea","ocean"],"skins":[{"unified":"1f421","native":"🐡"}],"version":1},"shark":{"id":"shark","name":"Shark","keywords":["animal","nature","fish","sea","ocean","jaws","fins","beach"],"skins":[{"unified":"1f988","native":"🦈"}],"version":3},"octopus":{"id":"octopus","name":"Octopus","keywords":["animal","creature","ocean","sea","nature","beach"],"skins":[{"unified":"1f419","native":"🐙"}],"version":1},"shell":{"id":"shell","name":"Spiral Shell","keywords":["nature","sea","beach"],"skins":[{"unified":"1f41a","native":"🐚"}],"version":1},"coral":{"id":"coral","name":"Coral","keywords":["ocean","sea","reef"],"skins":[{"unified":"1fab8","native":"🪸"}],"version":14},"jellyfish":{"id":"jellyfish","name":"Jellyfish","keywords":["sting","tentacles"],"skins":[{"unified":"1fabc","native":"🪼"}],"version":15},"snail":{"id":"snail","name":"Snail","keywords":["slow","animal","shell"],"skins":[{"unified":"1f40c","native":"🐌"}],"version":1},"butterfly":{"id":"butterfly","name":"Butterfly","keywords":["animal","insect","nature","caterpillar"],"skins":[{"unified":"1f98b","native":"🦋"}],"version":3},"bug":{"id":"bug","name":"Bug","keywords":["animal","insect","nature","worm"],"skins":[{"unified":"1f41b","native":"🐛"}],"version":1},"ant":{"id":"ant","name":"Ant","keywords":["animal","insect","nature","bug"],"skins":[{"unified":"1f41c","native":"🐜"}],"version":1},"bee":{"id":"bee","name":"Honeybee","keywords":["bee","animal","insect","nature","bug","spring","honey"],"skins":[{"unified":"1f41d","native":"🐝"}],"version":1},"beetle":{"id":"beetle","name":"Beetle","keywords":["insect"],"skins":[{"unified":"1fab2","native":"🪲"}],"version":13},"ladybug":{"id":"ladybug","name":"Lady Beetle","keywords":["ladybug","animal","insect","nature"],"skins":[{"unified":"1f41e","native":"🐞"}],"version":1},"cricket":{"id":"cricket","name":"Cricket","keywords":["animal","chirp"],"skins":[{"unified":"1f997","native":"🦗"}],"version":5},"cockroach":{"id":"cockroach","name":"Cockroach","keywords":["insect","pests"],"skins":[{"unified":"1fab3","native":"🪳"}],"version":13},"spider":{"id":"spider","name":"Spider","keywords":["animal","arachnid"],"skins":[{"unified":"1f577-fe0f","native":"🕷️"}],"version":1},"spider_web":{"id":"spider_web","name":"Spider Web","keywords":["animal","insect","arachnid","silk"],"skins":[{"unified":"1f578-fe0f","native":"🕸️"}],"version":1},"scorpion":{"id":"scorpion","name":"Scorpion","keywords":["animal","arachnid"],"skins":[{"unified":"1f982","native":"🦂"}],"version":1},"mosquito":{"id":"mosquito","name":"Mosquito","keywords":["animal","nature","insect","malaria"],"skins":[{"unified":"1f99f","native":"🦟"}],"version":11},"fly":{"id":"fly","name":"Fly","keywords":["insect"],"skins":[{"unified":"1fab0","native":"🪰"}],"version":13},"worm":{"id":"worm","name":"Worm","keywords":["animal"],"skins":[{"unified":"1fab1","native":"🪱"}],"version":13},"microbe":{"id":"microbe","name":"Microbe","keywords":["amoeba","bacteria","germs","virus","covid"],"skins":[{"unified":"1f9a0","native":"🦠"}],"version":11},"bouquet":{"id":"bouquet","name":"Bouquet","keywords":["flowers","nature","spring"],"skins":[{"unified":"1f490","native":"💐"}],"version":1},"cherry_blossom":{"id":"cherry_blossom","name":"Cherry Blossom","keywords":["nature","plant","spring","flower"],"skins":[{"unified":"1f338","native":"🌸"}],"version":1},"white_flower":{"id":"white_flower","name":"White Flower","keywords":["japanese","spring"],"skins":[{"unified":"1f4ae","native":"💮"}],"version":1},"lotus":{"id":"lotus","name":"Lotus","keywords":["flower","calm","meditation"],"skins":[{"unified":"1fab7","native":"🪷"}],"version":14},"rosette":{"id":"rosette","name":"Rosette","keywords":["flower","decoration","military"],"skins":[{"unified":"1f3f5-fe0f","native":"🏵️"}],"version":1},"rose":{"id":"rose","name":"Rose","keywords":["flowers","valentines","love","spring"],"skins":[{"unified":"1f339","native":"🌹"}],"version":1},"wilted_flower":{"id":"wilted_flower","name":"Wilted Flower","keywords":["plant","nature","rose"],"skins":[{"unified":"1f940","native":"🥀"}],"version":3},"hibiscus":{"id":"hibiscus","name":"Hibiscus","keywords":["plant","vegetable","flowers","beach"],"skins":[{"unified":"1f33a","native":"🌺"}],"version":1},"sunflower":{"id":"sunflower","name":"Sunflower","keywords":["nature","plant","fall"],"skins":[{"unified":"1f33b","native":"🌻"}],"version":1},"blossom":{"id":"blossom","name":"Blossom","keywords":["nature","flowers","yellow"],"skins":[{"unified":"1f33c","native":"🌼"}],"version":1},"tulip":{"id":"tulip","name":"Tulip","keywords":["flowers","plant","nature","summer","spring"],"skins":[{"unified":"1f337","native":"🌷"}],"version":1},"hyacinth":{"id":"hyacinth","name":"Hyacinth","keywords":["flower","lavender"],"skins":[{"unified":"1fabb","native":"🪻"}],"version":15},"seedling":{"id":"seedling","name":"Seedling","keywords":["plant","nature","grass","lawn","spring"],"skins":[{"unified":"1f331","native":"🌱"}],"version":1},"potted_plant":{"id":"potted_plant","name":"Potted Plant","keywords":["greenery","house"],"skins":[{"unified":"1fab4","native":"🪴"}],"version":13},"evergreen_tree":{"id":"evergreen_tree","name":"Evergreen Tree","keywords":["plant","nature"],"skins":[{"unified":"1f332","native":"🌲"}],"version":1},"deciduous_tree":{"id":"deciduous_tree","name":"Deciduous Tree","keywords":["plant","nature"],"skins":[{"unified":"1f333","native":"🌳"}],"version":1},"palm_tree":{"id":"palm_tree","name":"Palm Tree","keywords":["plant","vegetable","nature","summer","beach","mojito","tropical"],"skins":[{"unified":"1f334","native":"🌴"}],"version":1},"cactus":{"id":"cactus","name":"Cactus","keywords":["vegetable","plant","nature"],"skins":[{"unified":"1f335","native":"🌵"}],"version":1},"ear_of_rice":{"id":"ear_of_rice","name":"Ear of Rice","keywords":["sheaf","nature","plant"],"skins":[{"unified":"1f33e","native":"🌾"}],"version":1},"herb":{"id":"herb","name":"Herb","keywords":["vegetable","plant","medicine","weed","grass","lawn"],"skins":[{"unified":"1f33f","native":"🌿"}],"version":1},"shamrock":{"id":"shamrock","name":"Shamrock","keywords":["vegetable","plant","nature","irish","clover"],"skins":[{"unified":"2618-fe0f","native":"☘️"}],"version":1},"four_leaf_clover":{"id":"four_leaf_clover","name":"Four Leaf Clover","keywords":["vegetable","plant","nature","lucky","irish"],"skins":[{"unified":"1f340","native":"🍀"}],"version":1},"maple_leaf":{"id":"maple_leaf","name":"Maple Leaf","keywords":["nature","plant","vegetable","ca","fall"],"skins":[{"unified":"1f341","native":"🍁"}],"version":1},"fallen_leaf":{"id":"fallen_leaf","name":"Fallen Leaf","keywords":["nature","plant","vegetable","leaves"],"skins":[{"unified":"1f342","native":"🍂"}],"version":1},"leaves":{"id":"leaves","name":"Leaf Fluttering in Wind","keywords":["leaves","nature","plant","tree","vegetable","grass","lawn","spring"],"skins":[{"unified":"1f343","native":"🍃"}],"version":1},"empty_nest":{"id":"empty_nest","name":"Empty Nest","keywords":["bird"],"skins":[{"unified":"1fab9","native":"🪹"}],"version":14},"nest_with_eggs":{"id":"nest_with_eggs","name":"Nest with Eggs","keywords":["bird"],"skins":[{"unified":"1faba","native":"🪺"}],"version":14},"mushroom":{"id":"mushroom","name":"Mushroom","keywords":["plant","vegetable"],"skins":[{"unified":"1f344","native":"🍄"}],"version":1},"grapes":{"id":"grapes","name":"Grapes","keywords":["fruit","food","wine"],"skins":[{"unified":"1f347","native":"🍇"}],"version":1},"melon":{"id":"melon","name":"Melon","keywords":["fruit","nature","food"],"skins":[{"unified":"1f348","native":"🍈"}],"version":1},"watermelon":{"id":"watermelon","name":"Watermelon","keywords":["fruit","food","picnic","summer"],"skins":[{"unified":"1f349","native":"🍉"}],"version":1},"tangerine":{"id":"tangerine","name":"Tangerine","keywords":["food","fruit","nature","orange"],"skins":[{"unified":"1f34a","native":"🍊"}],"version":1},"lemon":{"id":"lemon","name":"Lemon","keywords":["fruit","nature"],"skins":[{"unified":"1f34b","native":"🍋"}],"version":1},"banana":{"id":"banana","name":"Banana","keywords":["fruit","food","monkey"],"skins":[{"unified":"1f34c","native":"🍌"}],"version":1},"pineapple":{"id":"pineapple","name":"Pineapple","keywords":["fruit","nature","food"],"skins":[{"unified":"1f34d","native":"🍍"}],"version":1},"mango":{"id":"mango","name":"Mango","keywords":["fruit","food","tropical"],"skins":[{"unified":"1f96d","native":"🥭"}],"version":11},"apple":{"id":"apple","name":"Red Apple","keywords":["fruit","mac","school"],"skins":[{"unified":"1f34e","native":"🍎"}],"version":1},"green_apple":{"id":"green_apple","name":"Green Apple","keywords":["fruit","nature"],"skins":[{"unified":"1f34f","native":"🍏"}],"version":1},"pear":{"id":"pear","name":"Pear","keywords":["fruit","nature","food"],"skins":[{"unified":"1f350","native":"🍐"}],"version":1},"peach":{"id":"peach","name":"Peach","keywords":["fruit","nature","food"],"skins":[{"unified":"1f351","native":"🍑"}],"version":1},"cherries":{"id":"cherries","name":"Cherries","keywords":["food","fruit"],"skins":[{"unified":"1f352","native":"🍒"}],"version":1},"strawberry":{"id":"strawberry","name":"Strawberry","keywords":["fruit","food","nature"],"skins":[{"unified":"1f353","native":"🍓"}],"version":1},"blueberries":{"id":"blueberries","name":"Blueberries","keywords":["fruit"],"skins":[{"unified":"1fad0","native":"🫐"}],"version":13},"kiwifruit":{"id":"kiwifruit","name":"Kiwifruit","keywords":["kiwi","fruit","food"],"skins":[{"unified":"1f95d","native":"🥝"}],"version":3},"tomato":{"id":"tomato","name":"Tomato","keywords":["fruit","vegetable","nature","food"],"skins":[{"unified":"1f345","native":"🍅"}],"version":1},"olive":{"id":"olive","name":"Olive","keywords":["fruit"],"skins":[{"unified":"1fad2","native":"🫒"}],"version":13},"coconut":{"id":"coconut","name":"Coconut","keywords":["fruit","nature","food","palm"],"skins":[{"unified":"1f965","native":"🥥"}],"version":5},"avocado":{"id":"avocado","name":"Avocado","keywords":["fruit","food"],"skins":[{"unified":"1f951","native":"🥑"}],"version":3},"eggplant":{"id":"eggplant","name":"Eggplant","keywords":["vegetable","nature","food","aubergine"],"skins":[{"unified":"1f346","native":"🍆"}],"version":1},"potato":{"id":"potato","name":"Potato","keywords":["food","tuber","vegatable","starch"],"skins":[{"unified":"1f954","native":"🥔"}],"version":3},"carrot":{"id":"carrot","name":"Carrot","keywords":["vegetable","food","orange"],"skins":[{"unified":"1f955","native":"🥕"}],"version":3},"corn":{"id":"corn","name":"Ear of Corn","keywords":["food","vegetable","plant"],"skins":[{"unified":"1f33d","native":"🌽"}],"version":1},"hot_pepper":{"id":"hot_pepper","name":"Hot Pepper","keywords":["food","spicy","chilli","chili"],"skins":[{"unified":"1f336-fe0f","native":"🌶️"}],"version":1},"bell_pepper":{"id":"bell_pepper","name":"Bell Pepper","keywords":["fruit","plant"],"skins":[{"unified":"1fad1","native":"🫑"}],"version":13},"cucumber":{"id":"cucumber","name":"Cucumber","keywords":["fruit","food","pickle"],"skins":[{"unified":"1f952","native":"🥒"}],"version":3},"leafy_green":{"id":"leafy_green","name":"Leafy Green","keywords":["food","vegetable","plant","bok","choy","cabbage","kale","lettuce"],"skins":[{"unified":"1f96c","native":"🥬"}],"version":11},"broccoli":{"id":"broccoli","name":"Broccoli","keywords":["fruit","food","vegetable"],"skins":[{"unified":"1f966","native":"🥦"}],"version":5},"garlic":{"id":"garlic","name":"Garlic","keywords":["food","spice","cook"],"skins":[{"unified":"1f9c4","native":"🧄"}],"version":12},"onion":{"id":"onion","name":"Onion","keywords":["cook","food","spice"],"skins":[{"unified":"1f9c5","native":"🧅"}],"version":12},"peanuts":{"id":"peanuts","name":"Peanuts","keywords":["food","nut"],"skins":[{"unified":"1f95c","native":"🥜"}],"version":3},"beans":{"id":"beans","name":"Beans","keywords":["food"],"skins":[{"unified":"1fad8","native":"🫘"}],"version":14},"chestnut":{"id":"chestnut","name":"Chestnut","keywords":["food","squirrel"],"skins":[{"unified":"1f330","native":"🌰"}],"version":1},"ginger_root":{"id":"ginger_root","name":"Ginger Root","keywords":["spice","yellow","cooking","gingerbread"],"skins":[{"unified":"1fada","native":"🫚"}],"version":15},"pea_pod":{"id":"pea_pod","name":"Pea Pod","keywords":["cozy","green"],"skins":[{"unified":"1fadb","native":"🫛"}],"version":15},"bread":{"id":"bread","name":"Bread","keywords":["food","wheat","breakfast","toast"],"skins":[{"unified":"1f35e","native":"🍞"}],"version":1},"croissant":{"id":"croissant","name":"Croissant","keywords":["food","bread","french"],"skins":[{"unified":"1f950","native":"🥐"}],"version":3},"baguette_bread":{"id":"baguette_bread","name":"Baguette Bread","keywords":["food","french","france","bakery"],"skins":[{"unified":"1f956","native":"🥖"}],"version":3},"flatbread":{"id":"flatbread","name":"Flatbread","keywords":["flour","food","bakery"],"skins":[{"unified":"1fad3","native":"🫓"}],"version":13},"pretzel":{"id":"pretzel","name":"Pretzel","keywords":["food","bread","twisted","germany","bakery"],"skins":[{"unified":"1f968","native":"🥨"}],"version":5},"bagel":{"id":"bagel","name":"Bagel","keywords":["food","bread","bakery","schmear","jewish"],"skins":[{"unified":"1f96f","native":"🥯"}],"version":11},"pancakes":{"id":"pancakes","name":"Pancakes","keywords":["food","breakfast","flapjacks","hotcakes","brunch"],"skins":[{"unified":"1f95e","native":"🥞"}],"version":3},"waffle":{"id":"waffle","name":"Waffle","keywords":["food","breakfast","brunch"],"skins":[{"unified":"1f9c7","native":"🧇"}],"version":12},"cheese_wedge":{"id":"cheese_wedge","name":"Cheese Wedge","keywords":["food","chadder","swiss"],"skins":[{"unified":"1f9c0","native":"🧀"}],"version":1},"meat_on_bone":{"id":"meat_on_bone","name":"Meat on Bone","keywords":["good","food","drumstick"],"skins":[{"unified":"1f356","native":"🍖"}],"version":1},"poultry_leg":{"id":"poultry_leg","name":"Poultry Leg","keywords":["food","meat","drumstick","bird","chicken","turkey"],"skins":[{"unified":"1f357","native":"🍗"}],"version":1},"cut_of_meat":{"id":"cut_of_meat","name":"Cut of Meat","keywords":["food","cow","chop","lambchop","porkchop"],"skins":[{"unified":"1f969","native":"🥩"}],"version":5},"bacon":{"id":"bacon","name":"Bacon","keywords":["food","breakfast","pork","pig","meat","brunch"],"skins":[{"unified":"1f953","native":"🥓"}],"version":3},"hamburger":{"id":"hamburger","name":"Hamburger","keywords":["meat","fast","food","beef","cheeseburger","mcdonalds","burger","king"],"skins":[{"unified":"1f354","native":"🍔"}],"version":1},"fries":{"id":"fries","name":"French Fries","keywords":["chips","snack","fast","food","potato"],"skins":[{"unified":"1f35f","native":"🍟"}],"version":1},"pizza":{"id":"pizza","name":"Pizza","keywords":["food","party","italy"],"skins":[{"unified":"1f355","native":"🍕"}],"version":1},"hotdog":{"id":"hotdog","name":"Hot Dog","keywords":["hotdog","food","frankfurter","america"],"skins":[{"unified":"1f32d","native":"🌭"}],"version":1},"sandwich":{"id":"sandwich","name":"Sandwich","keywords":["food","lunch","bread","toast","bakery"],"skins":[{"unified":"1f96a","native":"🥪"}],"version":5},"taco":{"id":"taco","name":"Taco","keywords":["food","mexican"],"skins":[{"unified":"1f32e","native":"🌮"}],"version":1},"burrito":{"id":"burrito","name":"Burrito","keywords":["food","mexican"],"skins":[{"unified":"1f32f","native":"🌯"}],"version":1},"tamale":{"id":"tamale","name":"Tamale","keywords":["food","masa"],"skins":[{"unified":"1fad4","native":"🫔"}],"version":13},"stuffed_flatbread":{"id":"stuffed_flatbread","name":"Stuffed Flatbread","keywords":["food","gyro","mediterranean"],"skins":[{"unified":"1f959","native":"🥙"}],"version":3},"falafel":{"id":"falafel","name":"Falafel","keywords":["food","mediterranean"],"skins":[{"unified":"1f9c6","native":"🧆"}],"version":12},"egg":{"id":"egg","name":"Egg","keywords":["food","chicken","breakfast"],"skins":[{"unified":"1f95a","native":"🥚"}],"version":3},"fried_egg":{"id":"fried_egg","name":"Cooking","keywords":["fried","egg","food","breakfast","kitchen","skillet"],"skins":[{"unified":"1f373","native":"🍳"}],"version":1},"shallow_pan_of_food":{"id":"shallow_pan_of_food","name":"Shallow Pan of Food","keywords":["cooking","casserole","paella","skillet"],"skins":[{"unified":"1f958","native":"🥘"}],"version":3},"stew":{"id":"stew","name":"Pot of Food","keywords":["stew","meat","soup","hot"],"skins":[{"unified":"1f372","native":"🍲"}],"version":1},"fondue":{"id":"fondue","name":"Fondue","keywords":["cheese","pot","food"],"skins":[{"unified":"1fad5","native":"🫕"}],"version":13},"bowl_with_spoon":{"id":"bowl_with_spoon","name":"Bowl with Spoon","keywords":["food","breakfast","cereal","oatmeal","porridge"],"skins":[{"unified":"1f963","native":"🥣"}],"version":5},"green_salad":{"id":"green_salad","name":"Green Salad","keywords":["food","healthy","lettuce","vegetable"],"skins":[{"unified":"1f957","native":"🥗"}],"version":3},"popcorn":{"id":"popcorn","name":"Popcorn","keywords":["food","movie","theater","films","snack","drama"],"skins":[{"unified":"1f37f","native":"🍿"}],"version":1},"butter":{"id":"butter","name":"Butter","keywords":["food","cook"],"skins":[{"unified":"1f9c8","native":"🧈"}],"version":12},"salt":{"id":"salt","name":"Salt","keywords":["condiment","shaker"],"skins":[{"unified":"1f9c2","native":"🧂"}],"version":11},"canned_food":{"id":"canned_food","name":"Canned Food","keywords":["soup","tomatoes"],"skins":[{"unified":"1f96b","native":"🥫"}],"version":5},"bento":{"id":"bento","name":"Bento Box","keywords":["food","japanese","lunch"],"skins":[{"unified":"1f371","native":"🍱"}],"version":1},"rice_cracker":{"id":"rice_cracker","name":"Rice Cracker","keywords":["food","japanese","snack"],"skins":[{"unified":"1f358","native":"🍘"}],"version":1},"rice_ball":{"id":"rice_ball","name":"Rice Ball","keywords":["food","japanese"],"skins":[{"unified":"1f359","native":"🍙"}],"version":1},"rice":{"id":"rice","name":"Cooked Rice","keywords":["food","asian"],"skins":[{"unified":"1f35a","native":"🍚"}],"version":1},"curry":{"id":"curry","name":"Curry Rice","keywords":["food","spicy","hot","indian"],"skins":[{"unified":"1f35b","native":"🍛"}],"version":1},"ramen":{"id":"ramen","name":"Steaming Bowl","keywords":["ramen","food","japanese","noodle","chopsticks"],"skins":[{"unified":"1f35c","native":"🍜"}],"version":1},"spaghetti":{"id":"spaghetti","name":"Spaghetti","keywords":["food","italian","pasta","noodle"],"skins":[{"unified":"1f35d","native":"🍝"}],"version":1},"sweet_potato":{"id":"sweet_potato","name":"Roasted Sweet Potato","keywords":["food","nature","plant"],"skins":[{"unified":"1f360","native":"🍠"}],"version":1},"oden":{"id":"oden","name":"Oden","keywords":["food","japanese"],"skins":[{"unified":"1f362","native":"🍢"}],"version":1},"sushi":{"id":"sushi","name":"Sushi","keywords":["food","fish","japanese","rice"],"skins":[{"unified":"1f363","native":"🍣"}],"version":1},"fried_shrimp":{"id":"fried_shrimp","name":"Fried Shrimp","keywords":["food","animal","appetizer","summer"],"skins":[{"unified":"1f364","native":"🍤"}],"version":1},"fish_cake":{"id":"fish_cake","name":"Fish Cake with Swirl","keywords":["food","japan","sea","beach","narutomaki","pink","kamaboko","surimi","ramen"],"skins":[{"unified":"1f365","native":"🍥"}],"version":1},"moon_cake":{"id":"moon_cake","name":"Moon Cake","keywords":["food","autumn","dessert"],"skins":[{"unified":"1f96e","native":"🥮"}],"version":11},"dango":{"id":"dango","name":"Dango","keywords":["food","dessert","sweet","japanese","barbecue","meat"],"skins":[{"unified":"1f361","native":"🍡"}],"version":1},"dumpling":{"id":"dumpling","name":"Dumpling","keywords":["food","empanada","pierogi","potsticker","gyoza"],"skins":[{"unified":"1f95f","native":"🥟"}],"version":5},"fortune_cookie":{"id":"fortune_cookie","name":"Fortune Cookie","keywords":["food","prophecy","dessert"],"skins":[{"unified":"1f960","native":"🥠"}],"version":5},"takeout_box":{"id":"takeout_box","name":"Takeout Box","keywords":["food","leftovers"],"skins":[{"unified":"1f961","native":"🥡"}],"version":5},"crab":{"id":"crab","name":"Crab","keywords":["animal","crustacean"],"skins":[{"unified":"1f980","native":"🦀"}],"version":1},"lobster":{"id":"lobster","name":"Lobster","keywords":["animal","nature","bisque","claws","seafood"],"skins":[{"unified":"1f99e","native":"🦞"}],"version":11},"shrimp":{"id":"shrimp","name":"Shrimp","keywords":["animal","ocean","nature","seafood"],"skins":[{"unified":"1f990","native":"🦐"}],"version":3},"squid":{"id":"squid","name":"Squid","keywords":["animal","nature","ocean","sea"],"skins":[{"unified":"1f991","native":"🦑"}],"version":3},"oyster":{"id":"oyster","name":"Oyster","keywords":["food"],"skins":[{"unified":"1f9aa","native":"🦪"}],"version":12},"icecream":{"id":"icecream","name":"Soft Ice Cream","keywords":["icecream","food","hot","dessert","summer"],"skins":[{"unified":"1f366","native":"🍦"}],"version":1},"shaved_ice":{"id":"shaved_ice","name":"Shaved Ice","keywords":["hot","dessert","summer"],"skins":[{"unified":"1f367","native":"🍧"}],"version":1},"ice_cream":{"id":"ice_cream","name":"Ice Cream","keywords":["food","hot","dessert"],"skins":[{"unified":"1f368","native":"🍨"}],"version":1},"doughnut":{"id":"doughnut","name":"Doughnut","keywords":["food","dessert","snack","sweet","donut"],"skins":[{"unified":"1f369","native":"🍩"}],"version":1},"cookie":{"id":"cookie","name":"Cookie","keywords":["food","snack","oreo","chocolate","sweet","dessert"],"skins":[{"unified":"1f36a","native":"🍪"}],"version":1},"birthday":{"id":"birthday","name":"Birthday Cake","keywords":["food","dessert"],"skins":[{"unified":"1f382","native":"🎂"}],"version":1},"cake":{"id":"cake","name":"Shortcake","keywords":["cake","food","dessert"],"skins":[{"unified":"1f370","native":"🍰"}],"version":1},"cupcake":{"id":"cupcake","name":"Cupcake","keywords":["food","dessert","bakery","sweet"],"skins":[{"unified":"1f9c1","native":"🧁"}],"version":11},"pie":{"id":"pie","name":"Pie","keywords":["food","dessert","pastry"],"skins":[{"unified":"1f967","native":"🥧"}],"version":5},"chocolate_bar":{"id":"chocolate_bar","name":"Chocolate Bar","keywords":["food","snack","dessert","sweet"],"skins":[{"unified":"1f36b","native":"🍫"}],"version":1},"candy":{"id":"candy","name":"Candy","keywords":["snack","dessert","sweet","lolly"],"skins":[{"unified":"1f36c","native":"🍬"}],"version":1},"lollipop":{"id":"lollipop","name":"Lollipop","keywords":["food","snack","candy","sweet"],"skins":[{"unified":"1f36d","native":"🍭"}],"version":1},"custard":{"id":"custard","name":"Custard","keywords":["dessert","food"],"skins":[{"unified":"1f36e","native":"🍮"}],"version":1},"honey_pot":{"id":"honey_pot","name":"Honey Pot","keywords":["bees","sweet","kitchen"],"skins":[{"unified":"1f36f","native":"🍯"}],"version":1},"baby_bottle":{"id":"baby_bottle","name":"Baby Bottle","keywords":["food","container","milk"],"skins":[{"unified":"1f37c","native":"🍼"}],"version":1},"glass_of_milk":{"id":"glass_of_milk","name":"Glass of Milk","keywords":["beverage","drink","cow"],"skins":[{"unified":"1f95b","native":"🥛"}],"version":3},"coffee":{"id":"coffee","name":"Hot Beverage","keywords":["coffee","caffeine","latte","espresso","mug"],"skins":[{"unified":"2615","native":"☕"}],"version":1},"teapot":{"id":"teapot","name":"Teapot","keywords":["drink","hot"],"skins":[{"unified":"1fad6","native":"🫖"}],"version":13},"tea":{"id":"tea","name":"Teacup Without Handle","keywords":["tea","drink","bowl","breakfast","green","british"],"skins":[{"unified":"1f375","native":"🍵"}],"version":1},"sake":{"id":"sake","name":"Sake","keywords":["wine","drink","drunk","beverage","japanese","alcohol","booze"],"skins":[{"unified":"1f376","native":"🍶"}],"version":1},"champagne":{"id":"champagne","name":"Bottle with Popping Cork","keywords":["champagne","drink","wine","celebration"],"skins":[{"unified":"1f37e","native":"🍾"}],"version":1},"wine_glass":{"id":"wine_glass","name":"Wine Glass","keywords":["drink","beverage","drunk","alcohol","booze"],"skins":[{"unified":"1f377","native":"🍷"}],"version":1},"cocktail":{"id":"cocktail","name":"Cocktail Glass","keywords":["drink","drunk","alcohol","beverage","booze","mojito"],"skins":[{"unified":"1f378","native":"🍸"}],"version":1},"tropical_drink":{"id":"tropical_drink","name":"Tropical Drink","keywords":["beverage","cocktail","summer","beach","alcohol","booze","mojito"],"skins":[{"unified":"1f379","native":"🍹"}],"version":1},"beer":{"id":"beer","name":"Beer Mug","keywords":["relax","beverage","drink","drunk","party","pub","summer","alcohol","booze"],"skins":[{"unified":"1f37a","native":"🍺"}],"version":1},"beers":{"id":"beers","name":"Clinking Beer Mugs","keywords":["beers","relax","beverage","drink","drunk","party","pub","summer","alcohol","booze"],"skins":[{"unified":"1f37b","native":"🍻"}],"version":1},"clinking_glasses":{"id":"clinking_glasses","name":"Clinking Glasses","keywords":["beverage","drink","party","alcohol","celebrate","cheers","wine","champagne","toast"],"skins":[{"unified":"1f942","native":"🥂"}],"version":3},"tumbler_glass":{"id":"tumbler_glass","name":"Tumbler Glass","keywords":["drink","beverage","drunk","alcohol","liquor","booze","bourbon","scotch","whisky","shot"],"skins":[{"unified":"1f943","native":"🥃"}],"version":3},"pouring_liquid":{"id":"pouring_liquid","name":"Pouring Liquid","keywords":["cup","water"],"skins":[{"unified":"1fad7","native":"🫗"}],"version":14},"cup_with_straw":{"id":"cup_with_straw","name":"Cup with Straw","keywords":["drink","soda"],"skins":[{"unified":"1f964","native":"🥤"}],"version":5},"bubble_tea":{"id":"bubble_tea","name":"Bubble Tea","keywords":["taiwan","boba","milk","straw"],"skins":[{"unified":"1f9cb","native":"🧋"}],"version":13},"beverage_box":{"id":"beverage_box","name":"Beverage Box","keywords":["drink"],"skins":[{"unified":"1f9c3","native":"🧃"}],"version":12},"mate_drink":{"id":"mate_drink","name":"Mate","keywords":["drink","tea","beverage"],"skins":[{"unified":"1f9c9","native":"🧉"}],"version":12},"ice_cube":{"id":"ice_cube","name":"Ice","keywords":["cube","water","cold"],"skins":[{"unified":"1f9ca","native":"🧊"}],"version":12},"chopsticks":{"id":"chopsticks","name":"Chopsticks","keywords":["food"],"skins":[{"unified":"1f962","native":"🥢"}],"version":5},"knife_fork_plate":{"id":"knife_fork_plate","name":"Fork and Knife with Plate","keywords":["food","eat","meal","lunch","dinner","restaurant"],"skins":[{"unified":"1f37d-fe0f","native":"🍽️"}],"version":1},"fork_and_knife":{"id":"fork_and_knife","name":"Fork and Knife","keywords":["cutlery","kitchen"],"skins":[{"unified":"1f374","native":"🍴"}],"version":1},"spoon":{"id":"spoon","name":"Spoon","keywords":["cutlery","kitchen","tableware"],"skins":[{"unified":"1f944","native":"🥄"}],"version":3},"hocho":{"id":"hocho","name":"Hocho","keywords":["knife","kitchen","blade","cutlery","weapon"],"skins":[{"unified":"1f52a","native":"🔪"}],"version":1},"jar":{"id":"jar","name":"Jar","keywords":["container","sauce"],"skins":[{"unified":"1fad9","native":"🫙"}],"version":14},"amphora":{"id":"amphora","name":"Amphora","keywords":["vase","jar"],"skins":[{"unified":"1f3fa","native":"🏺"}],"version":1},"earth_africa":{"id":"earth_africa","name":"Earth Globe Europe-Africa","keywords":["africa","showing","europe","world","international"],"skins":[{"unified":"1f30d","native":"🌍"}],"version":1},"earth_americas":{"id":"earth_americas","name":"Earth Globe Americas","keywords":["showing","world","USA","international"],"skins":[{"unified":"1f30e","native":"🌎"}],"version":1},"earth_asia":{"id":"earth_asia","name":"Earth Globe Asia-Australia","keywords":["asia","showing","australia","world","east","international"],"skins":[{"unified":"1f30f","native":"🌏"}],"version":1},"globe_with_meridians":{"id":"globe_with_meridians","name":"Globe with Meridians","keywords":["earth","international","world","internet","interweb","i18n"],"skins":[{"unified":"1f310","native":"🌐"}],"version":1},"world_map":{"id":"world_map","name":"World Map","keywords":["location","direction"],"skins":[{"unified":"1f5fa-fe0f","native":"🗺️"}],"version":1},"japan":{"id":"japan","name":"Map of Japan","keywords":["nation","country","japanese","asia"],"skins":[{"unified":"1f5fe","native":"🗾"}],"version":1},"compass":{"id":"compass","name":"Compass","keywords":["magnetic","navigation","orienteering"],"skins":[{"unified":"1f9ed","native":"🧭"}],"version":11},"snow_capped_mountain":{"id":"snow_capped_mountain","name":"Snow-Capped Mountain","keywords":["snow","capped","photo","nature","environment","winter","cold"],"skins":[{"unified":"1f3d4-fe0f","native":"🏔️"}],"version":1},"mountain":{"id":"mountain","name":"Mountain","keywords":["photo","nature","environment"],"skins":[{"unified":"26f0-fe0f","native":"⛰️"}],"version":1},"volcano":{"id":"volcano","name":"Volcano","keywords":["photo","nature","disaster"],"skins":[{"unified":"1f30b","native":"🌋"}],"version":1},"mount_fuji":{"id":"mount_fuji","name":"Mount Fuji","keywords":["photo","mountain","nature","japanese"],"skins":[{"unified":"1f5fb","native":"🗻"}],"version":1},"camping":{"id":"camping","name":"Camping","keywords":["photo","outdoors","tent"],"skins":[{"unified":"1f3d5-fe0f","native":"🏕️"}],"version":1},"beach_with_umbrella":{"id":"beach_with_umbrella","name":"Beach with Umbrella","keywords":["weather","summer","sunny","sand","mojito"],"skins":[{"unified":"1f3d6-fe0f","native":"🏖️"}],"version":1},"desert":{"id":"desert","name":"Desert","keywords":["photo","warm","saharah"],"skins":[{"unified":"1f3dc-fe0f","native":"🏜️"}],"version":1},"desert_island":{"id":"desert_island","name":"Desert Island","keywords":["photo","tropical","mojito"],"skins":[{"unified":"1f3dd-fe0f","native":"🏝️"}],"version":1},"national_park":{"id":"national_park","name":"National Park","keywords":["photo","environment","nature"],"skins":[{"unified":"1f3de-fe0f","native":"🏞️"}],"version":1},"stadium":{"id":"stadium","name":"Stadium","keywords":["photo","place","sports","concert","venue"],"skins":[{"unified":"1f3df-fe0f","native":"🏟️"}],"version":1},"classical_building":{"id":"classical_building","name":"Classical Building","keywords":["art","culture","history"],"skins":[{"unified":"1f3db-fe0f","native":"🏛️"}],"version":1},"building_construction":{"id":"building_construction","name":"Building Construction","keywords":["wip","working","progress"],"skins":[{"unified":"1f3d7-fe0f","native":"🏗️"}],"version":1},"bricks":{"id":"bricks","name":"Brick","keywords":["bricks"],"skins":[{"unified":"1f9f1","native":"🧱"}],"version":11},"rock":{"id":"rock","name":"Rock","keywords":["stone"],"skins":[{"unified":"1faa8","native":"🪨"}],"version":13},"wood":{"id":"wood","name":"Wood","keywords":["nature","timber","trunk"],"skins":[{"unified":"1fab5","native":"🪵"}],"version":13},"hut":{"id":"hut","name":"Hut","keywords":["house","structure"],"skins":[{"unified":"1f6d6","native":"🛖"}],"version":13},"house_buildings":{"id":"house_buildings","name":"Houses","keywords":["house","buildings","photo"],"skins":[{"unified":"1f3d8-fe0f","native":"🏘️"}],"version":1},"derelict_house_building":{"id":"derelict_house_building","name":"Derelict House","keywords":["building","abandon","evict","broken"],"skins":[{"unified":"1f3da-fe0f","native":"🏚️"}],"version":1},"house":{"id":"house","name":"House","keywords":["building","home"],"skins":[{"unified":"1f3e0","native":"🏠"}],"version":1},"house_with_garden":{"id":"house_with_garden","name":"House with Garden","keywords":["home","plant","nature"],"skins":[{"unified":"1f3e1","native":"🏡"}],"version":1},"office":{"id":"office","name":"Office Building","keywords":["bureau","work"],"skins":[{"unified":"1f3e2","native":"🏢"}],"version":1},"post_office":{"id":"post_office","name":"Japanese Post Office","keywords":["building","envelope","communication"],"skins":[{"unified":"1f3e3","native":"🏣"}],"version":1},"european_post_office":{"id":"european_post_office","name":"Post Office","keywords":["european","building","email"],"skins":[{"unified":"1f3e4","native":"🏤"}],"version":1},"hospital":{"id":"hospital","name":"Hospital","keywords":["building","health","surgery","doctor"],"skins":[{"unified":"1f3e5","native":"🏥"}],"version":1},"bank":{"id":"bank","name":"Bank","keywords":["building","money","sales","cash","business","enterprise"],"skins":[{"unified":"1f3e6","native":"🏦"}],"version":1},"hotel":{"id":"hotel","name":"Hotel","keywords":["building","accomodation","checkin"],"skins":[{"unified":"1f3e8","native":"🏨"}],"version":1},"love_hotel":{"id":"love_hotel","name":"Love Hotel","keywords":["like","affection","dating"],"skins":[{"unified":"1f3e9","native":"🏩"}],"version":1},"convenience_store":{"id":"convenience_store","name":"Convenience Store","keywords":["building","shopping","groceries"],"skins":[{"unified":"1f3ea","native":"🏪"}],"version":1},"school":{"id":"school","name":"School","keywords":["building","student","education","learn","teach"],"skins":[{"unified":"1f3eb","native":"🏫"}],"version":1},"department_store":{"id":"department_store","name":"Department Store","keywords":["building","shopping","mall"],"skins":[{"unified":"1f3ec","native":"🏬"}],"version":1},"factory":{"id":"factory","name":"Factory","keywords":["building","industry","pollution","smoke"],"skins":[{"unified":"1f3ed","native":"🏭"}],"version":1},"japanese_castle":{"id":"japanese_castle","name":"Japanese Castle","keywords":["photo","building"],"skins":[{"unified":"1f3ef","native":"🏯"}],"version":1},"european_castle":{"id":"european_castle","name":"Castle","keywords":["european","building","royalty","history"],"skins":[{"unified":"1f3f0","native":"🏰"}],"version":1},"wedding":{"id":"wedding","name":"Wedding","keywords":["love","like","affection","couple","marriage","bride","groom"],"skins":[{"unified":"1f492","native":"💒"}],"version":1},"tokyo_tower":{"id":"tokyo_tower","name":"Tokyo Tower","keywords":["photo","japanese"],"skins":[{"unified":"1f5fc","native":"🗼"}],"version":1},"statue_of_liberty":{"id":"statue_of_liberty","name":"Statue of Liberty","keywords":["american","newyork"],"skins":[{"unified":"1f5fd","native":"🗽"}],"version":1},"church":{"id":"church","name":"Church","keywords":["building","religion","christ"],"skins":[{"unified":"26ea","native":"⛪"}],"version":1},"mosque":{"id":"mosque","name":"Mosque","keywords":["islam","worship","minaret"],"skins":[{"unified":"1f54c","native":"🕌"}],"version":1},"hindu_temple":{"id":"hindu_temple","name":"Hindu Temple","keywords":["religion"],"skins":[{"unified":"1f6d5","native":"🛕"}],"version":12},"synagogue":{"id":"synagogue","name":"Synagogue","keywords":["judaism","worship","temple","jewish"],"skins":[{"unified":"1f54d","native":"🕍"}],"version":1},"shinto_shrine":{"id":"shinto_shrine","name":"Shinto Shrine","keywords":["temple","japan","kyoto"],"skins":[{"unified":"26e9-fe0f","native":"⛩️"}],"version":1},"kaaba":{"id":"kaaba","name":"Kaaba","keywords":["mecca","mosque","islam"],"skins":[{"unified":"1f54b","native":"🕋"}],"version":1},"fountain":{"id":"fountain","name":"Fountain","keywords":["photo","summer","water","fresh"],"skins":[{"unified":"26f2","native":"⛲"}],"version":1},"tent":{"id":"tent","name":"Tent","keywords":["photo","camping","outdoors"],"skins":[{"unified":"26fa","native":"⛺"}],"version":1},"foggy":{"id":"foggy","name":"Foggy","keywords":["photo","mountain"],"skins":[{"unified":"1f301","native":"🌁"}],"version":1},"night_with_stars":{"id":"night_with_stars","name":"Night with Stars","keywords":["evening","city","downtown"],"skins":[{"unified":"1f303","native":"🌃"}],"version":1},"cityscape":{"id":"cityscape","name":"Cityscape","keywords":["photo","night","life","urban"],"skins":[{"unified":"1f3d9-fe0f","native":"🏙️"}],"version":1},"sunrise_over_mountains":{"id":"sunrise_over_mountains","name":"Sunrise over Mountains","keywords":["view","vacation","photo"],"skins":[{"unified":"1f304","native":"🌄"}],"version":1},"sunrise":{"id":"sunrise","name":"Sunrise","keywords":["morning","view","vacation","photo"],"skins":[{"unified":"1f305","native":"🌅"}],"version":1},"city_sunset":{"id":"city_sunset","name":"Cityscape at Dusk","keywords":["city","sunset","photo","evening","sky","buildings"],"skins":[{"unified":"1f306","native":"🌆"}],"version":1},"city_sunrise":{"id":"city_sunrise","name":"Sunset","keywords":["city","sunrise","photo","good","morning","dawn"],"skins":[{"unified":"1f307","native":"🌇"}],"version":1},"bridge_at_night":{"id":"bridge_at_night","name":"Bridge at Night","keywords":["photo","sanfrancisco"],"skins":[{"unified":"1f309","native":"🌉"}],"version":1},"hotsprings":{"id":"hotsprings","name":"Hot Springs","keywords":["hotsprings","bath","warm","relax"],"skins":[{"unified":"2668-fe0f","native":"♨️"}],"version":1},"carousel_horse":{"id":"carousel_horse","name":"Carousel Horse","keywords":["photo","carnival"],"skins":[{"unified":"1f3a0","native":"🎠"}],"version":1},"playground_slide":{"id":"playground_slide","name":"Playground Slide","keywords":["fun","park"],"skins":[{"unified":"1f6dd","native":"🛝"}],"version":14},"ferris_wheel":{"id":"ferris_wheel","name":"Ferris Wheel","keywords":["photo","carnival","londoneye"],"skins":[{"unified":"1f3a1","native":"🎡"}],"version":1},"roller_coaster":{"id":"roller_coaster","name":"Roller Coaster","keywords":["carnival","playground","photo","fun"],"skins":[{"unified":"1f3a2","native":"🎢"}],"version":1},"barber":{"id":"barber","name":"Barber Pole","keywords":["hair","salon","style"],"skins":[{"unified":"1f488","native":"💈"}],"version":1},"circus_tent":{"id":"circus_tent","name":"Circus Tent","keywords":["festival","carnival","party"],"skins":[{"unified":"1f3aa","native":"🎪"}],"version":1},"steam_locomotive":{"id":"steam_locomotive","name":"Locomotive","keywords":["steam","transportation","vehicle","train"],"skins":[{"unified":"1f682","native":"🚂"}],"version":1},"railway_car":{"id":"railway_car","name":"Railway Car","keywords":["transportation","vehicle"],"skins":[{"unified":"1f683","native":"🚃"}],"version":1},"bullettrain_side":{"id":"bullettrain_side","name":"High-Speed Train","keywords":["bullettrain","side","high","speed","transportation","vehicle"],"skins":[{"unified":"1f684","native":"🚄"}],"version":1},"bullettrain_front":{"id":"bullettrain_front","name":"Bullet Train","keywords":["bullettrain","front","transportation","vehicle","speed","fast","public","travel"],"skins":[{"unified":"1f685","native":"🚅"}],"version":1},"train2":{"id":"train2","name":"Train","keywords":["train2","transportation","vehicle"],"skins":[{"unified":"1f686","native":"🚆"}],"version":1},"metro":{"id":"metro","name":"Metro","keywords":["transportation","blue","square","mrt","underground","tube"],"skins":[{"unified":"1f687","native":"🚇"}],"version":1},"light_rail":{"id":"light_rail","name":"Light Rail","keywords":["transportation","vehicle"],"skins":[{"unified":"1f688","native":"🚈"}],"version":1},"station":{"id":"station","name":"Station","keywords":["transportation","vehicle","public"],"skins":[{"unified":"1f689","native":"🚉"}],"version":1},"tram":{"id":"tram","name":"Tram","keywords":["transportation","vehicle"],"skins":[{"unified":"1f68a","native":"🚊"}],"version":1},"monorail":{"id":"monorail","name":"Monorail","keywords":["transportation","vehicle"],"skins":[{"unified":"1f69d","native":"🚝"}],"version":1},"mountain_railway":{"id":"mountain_railway","name":"Mountain Railway","keywords":["transportation","vehicle"],"skins":[{"unified":"1f69e","native":"🚞"}],"version":1},"train":{"id":"train","name":"Tram Car","keywords":["train","transportation","vehicle","carriage","public","travel"],"skins":[{"unified":"1f68b","native":"🚋"}],"version":1},"bus":{"id":"bus","name":"Bus","keywords":["car","vehicle","transportation"],"skins":[{"unified":"1f68c","native":"🚌"}],"version":1},"oncoming_bus":{"id":"oncoming_bus","name":"Oncoming Bus","keywords":["vehicle","transportation"],"skins":[{"unified":"1f68d","native":"🚍"}],"version":1},"trolleybus":{"id":"trolleybus","name":"Trolleybus","keywords":["bart","transportation","vehicle"],"skins":[{"unified":"1f68e","native":"🚎"}],"version":1},"minibus":{"id":"minibus","name":"Minibus","keywords":["vehicle","car","transportation"],"skins":[{"unified":"1f690","native":"🚐"}],"version":1},"ambulance":{"id":"ambulance","name":"Ambulance","keywords":["health","911","hospital"],"skins":[{"unified":"1f691","native":"🚑"}],"version":1},"fire_engine":{"id":"fire_engine","name":"Fire Engine","keywords":["transportation","cars","vehicle"],"skins":[{"unified":"1f692","native":"🚒"}],"version":1},"police_car":{"id":"police_car","name":"Police Car","keywords":["vehicle","cars","transportation","law","legal","enforcement"],"skins":[{"unified":"1f693","native":"🚓"}],"version":1},"oncoming_police_car":{"id":"oncoming_police_car","name":"Oncoming Police Car","keywords":["vehicle","law","legal","enforcement","911"],"skins":[{"unified":"1f694","native":"🚔"}],"version":1},"taxi":{"id":"taxi","name":"Taxi","keywords":["uber","vehicle","cars","transportation"],"skins":[{"unified":"1f695","native":"🚕"}],"version":1},"oncoming_taxi":{"id":"oncoming_taxi","name":"Oncoming Taxi","keywords":["vehicle","cars","uber"],"skins":[{"unified":"1f696","native":"🚖"}],"version":1},"car":{"id":"car","name":"Automobile","keywords":["car","red","transportation","vehicle"],"skins":[{"unified":"1f697","native":"🚗"}],"version":1},"oncoming_automobile":{"id":"oncoming_automobile","name":"Oncoming Automobile","keywords":["car","vehicle","transportation"],"skins":[{"unified":"1f698","native":"🚘"}],"version":1},"blue_car":{"id":"blue_car","name":"Recreational Vehicle","keywords":["blue","car","sport","utility","transportation"],"skins":[{"unified":"1f699","native":"🚙"}],"version":1},"pickup_truck":{"id":"pickup_truck","name":"Pickup Truck","keywords":["car","transportation"],"skins":[{"unified":"1f6fb","native":"🛻"}],"version":13},"truck":{"id":"truck","name":"Delivery Truck","keywords":["cars","transportation"],"skins":[{"unified":"1f69a","native":"🚚"}],"version":1},"articulated_lorry":{"id":"articulated_lorry","name":"Articulated Lorry","keywords":["vehicle","cars","transportation","express"],"skins":[{"unified":"1f69b","native":"🚛"}],"version":1},"tractor":{"id":"tractor","name":"Tractor","keywords":["vehicle","car","farming","agriculture"],"skins":[{"unified":"1f69c","native":"🚜"}],"version":1},"racing_car":{"id":"racing_car","name":"Racing Car","keywords":["sports","race","fast","formula","f1"],"skins":[{"unified":"1f3ce-fe0f","native":"🏎️"}],"version":1},"racing_motorcycle":{"id":"racing_motorcycle","name":"Motorcycle","keywords":["racing","race","sports","fast"],"skins":[{"unified":"1f3cd-fe0f","native":"🏍️"}],"version":1},"motor_scooter":{"id":"motor_scooter","name":"Motor Scooter","keywords":["vehicle","vespa","sasha"],"skins":[{"unified":"1f6f5","native":"🛵"}],"version":3},"manual_wheelchair":{"id":"manual_wheelchair","name":"Manual Wheelchair","keywords":["accessibility"],"skins":[{"unified":"1f9bd","native":"🦽"}],"version":12},"motorized_wheelchair":{"id":"motorized_wheelchair","name":"Motorized Wheelchair","keywords":["accessibility"],"skins":[{"unified":"1f9bc","native":"🦼"}],"version":12},"auto_rickshaw":{"id":"auto_rickshaw","name":"Auto Rickshaw","keywords":["move","transportation"],"skins":[{"unified":"1f6fa","native":"🛺"}],"version":12},"bike":{"id":"bike","name":"Bicycle","keywords":["bike","sports","exercise","hipster"],"skins":[{"unified":"1f6b2","native":"🚲"}],"version":1},"scooter":{"id":"scooter","name":"Scooter","keywords":["kick","vehicle","razor"],"skins":[{"unified":"1f6f4","native":"🛴"}],"version":3},"skateboard":{"id":"skateboard","name":"Skateboard","keywords":["board"],"skins":[{"unified":"1f6f9","native":"🛹"}],"version":11},"roller_skate":{"id":"roller_skate","name":"Roller Skate","keywords":["footwear","sports"],"skins":[{"unified":"1f6fc","native":"🛼"}],"version":13},"busstop":{"id":"busstop","name":"Bus Stop","keywords":["busstop","transportation","wait"],"skins":[{"unified":"1f68f","native":"🚏"}],"version":1},"motorway":{"id":"motorway","name":"Motorway","keywords":["road","cupertino","interstate","highway"],"skins":[{"unified":"1f6e3-fe0f","native":"🛣️"}],"version":1},"railway_track":{"id":"railway_track","name":"Railway Track","keywords":["train","transportation"],"skins":[{"unified":"1f6e4-fe0f","native":"🛤️"}],"version":1},"oil_drum":{"id":"oil_drum","name":"Oil Drum","keywords":["barrell"],"skins":[{"unified":"1f6e2-fe0f","native":"🛢️"}],"version":1},"fuelpump":{"id":"fuelpump","name":"Fuel Pump","keywords":["fuelpump","gas","station","petroleum"],"skins":[{"unified":"26fd","native":"⛽"}],"version":1},"wheel":{"id":"wheel","name":"Wheel","keywords":["car","transport"],"skins":[{"unified":"1f6de","native":"🛞"}],"version":14},"rotating_light":{"id":"rotating_light","name":"Police Car Light","keywords":["rotating","ambulance","911","emergency","alert","error","pinged","law","legal"],"skins":[{"unified":"1f6a8","native":"🚨"}],"version":1},"traffic_light":{"id":"traffic_light","name":"Horizontal Traffic Light","keywords":["transportation","signal"],"skins":[{"unified":"1f6a5","native":"🚥"}],"version":1},"vertical_traffic_light":{"id":"vertical_traffic_light","name":"Vertical Traffic Light","keywords":["transportation","driving"],"skins":[{"unified":"1f6a6","native":"🚦"}],"version":1},"octagonal_sign":{"id":"octagonal_sign","name":"Stop Sign","keywords":["octagonal"],"skins":[{"unified":"1f6d1","native":"🛑"}],"version":3},"construction":{"id":"construction","name":"Construction","keywords":["wip","progress","caution","warning"],"skins":[{"unified":"1f6a7","native":"🚧"}],"version":1},"anchor":{"id":"anchor","name":"Anchor","keywords":["ship","ferry","sea","boat"],"skins":[{"unified":"2693","native":"⚓"}],"version":1},"ring_buoy":{"id":"ring_buoy","name":"Ring Buoy","keywords":["life","saver","preserver"],"skins":[{"unified":"1f6df","native":"🛟"}],"version":14},"boat":{"id":"boat","name":"Sailboat","keywords":["boat","ship","summer","transportation","water","sailing"],"skins":[{"unified":"26f5","native":"⛵"}],"version":1},"canoe":{"id":"canoe","name":"Canoe","keywords":["boat","paddle","water","ship"],"skins":[{"unified":"1f6f6","native":"🛶"}],"version":3},"speedboat":{"id":"speedboat","name":"Speedboat","keywords":["ship","transportation","vehicle","summer"],"skins":[{"unified":"1f6a4","native":"🚤"}],"version":1},"passenger_ship":{"id":"passenger_ship","name":"Passenger Ship","keywords":["yacht","cruise","ferry"],"skins":[{"unified":"1f6f3-fe0f","native":"🛳️"}],"version":1},"ferry":{"id":"ferry","name":"Ferry","keywords":["boat","ship","yacht"],"skins":[{"unified":"26f4-fe0f","native":"⛴️"}],"version":1},"motor_boat":{"id":"motor_boat","name":"Motor Boat","keywords":["ship"],"skins":[{"unified":"1f6e5-fe0f","native":"🛥️"}],"version":1},"ship":{"id":"ship","name":"Ship","keywords":["transportation","titanic","deploy"],"skins":[{"unified":"1f6a2","native":"🚢"}],"version":1},"airplane":{"id":"airplane","name":"Airplane","keywords":["vehicle","transportation","flight","fly"],"skins":[{"unified":"2708-fe0f","native":"✈️"}],"version":1},"small_airplane":{"id":"small_airplane","name":"Small Airplane","keywords":["flight","transportation","fly","vehicle"],"skins":[{"unified":"1f6e9-fe0f","native":"🛩️"}],"version":1},"airplane_departure":{"id":"airplane_departure","name":"Airplane Departure","keywords":["airport","flight","landing"],"skins":[{"unified":"1f6eb","native":"🛫"}],"version":1},"airplane_arriving":{"id":"airplane_arriving","name":"Airplane Arrival","keywords":["arriving","airport","flight","boarding"],"skins":[{"unified":"1f6ec","native":"🛬"}],"version":1},"parachute":{"id":"parachute","name":"Parachute","keywords":["fly","glide"],"skins":[{"unified":"1fa82","native":"🪂"}],"version":12},"seat":{"id":"seat","name":"Seat","keywords":["sit","airplane","transport","bus","flight","fly"],"skins":[{"unified":"1f4ba","native":"💺"}],"version":1},"helicopter":{"id":"helicopter","name":"Helicopter","keywords":["transportation","vehicle","fly"],"skins":[{"unified":"1f681","native":"🚁"}],"version":1},"suspension_railway":{"id":"suspension_railway","name":"Suspension Railway","keywords":["vehicle","transportation"],"skins":[{"unified":"1f69f","native":"🚟"}],"version":1},"mountain_cableway":{"id":"mountain_cableway","name":"Mountain Cableway","keywords":["transportation","vehicle","ski"],"skins":[{"unified":"1f6a0","native":"🚠"}],"version":1},"aerial_tramway":{"id":"aerial_tramway","name":"Aerial Tramway","keywords":["transportation","vehicle","ski"],"skins":[{"unified":"1f6a1","native":"🚡"}],"version":1},"satellite":{"id":"satellite","name":"Satellite","keywords":["communication","gps","orbit","spaceflight","NASA","ISS"],"skins":[{"unified":"1f6f0-fe0f","native":"🛰️"}],"version":1},"rocket":{"id":"rocket","name":"Rocket","keywords":["launch","ship","staffmode","NASA","outer","space","fly"],"skins":[{"unified":"1f680","native":"🚀"}],"version":1},"flying_saucer":{"id":"flying_saucer","name":"Flying Saucer","keywords":["transportation","vehicle","ufo"],"skins":[{"unified":"1f6f8","native":"🛸"}],"version":5},"bellhop_bell":{"id":"bellhop_bell","name":"Bellhop Bell","keywords":["service"],"skins":[{"unified":"1f6ce-fe0f","native":"🛎️"}],"version":1},"luggage":{"id":"luggage","name":"Luggage","keywords":["packing","travel"],"skins":[{"unified":"1f9f3","native":"🧳"}],"version":11},"hourglass":{"id":"hourglass","name":"Hourglass","keywords":["done","time","clock","oldschool","limit","exam","quiz","test"],"skins":[{"unified":"231b","native":"⌛"}],"version":1},"hourglass_flowing_sand":{"id":"hourglass_flowing_sand","name":"Hourglass Not Done","keywords":["flowing","sand","oldschool","time","countdown"],"skins":[{"unified":"23f3","native":"⏳"}],"version":1},"watch":{"id":"watch","name":"Watch","keywords":["time","accessories"],"skins":[{"unified":"231a","native":"⌚"}],"version":1},"alarm_clock":{"id":"alarm_clock","name":"Alarm Clock","keywords":["time","wake"],"skins":[{"unified":"23f0","native":"⏰"}],"version":1},"stopwatch":{"id":"stopwatch","name":"Stopwatch","keywords":["time","deadline"],"skins":[{"unified":"23f1-fe0f","native":"⏱️"}],"version":1},"timer_clock":{"id":"timer_clock","name":"Timer Clock","keywords":["alarm"],"skins":[{"unified":"23f2-fe0f","native":"⏲️"}],"version":1},"mantelpiece_clock":{"id":"mantelpiece_clock","name":"Mantelpiece Clock","keywords":["time"],"skins":[{"unified":"1f570-fe0f","native":"🕰️"}],"version":1},"clock12":{"id":"clock12","name":"Twelve O’clock","keywords":["clock12","o","clock","12","00:00","0000","12:00","1200","time","noon","midnight","midday","late","early","schedule"],"skins":[{"unified":"1f55b","native":"🕛"}],"version":1},"clock1230":{"id":"clock1230","name":"Twelve-Thirty","keywords":["clock1230","twelve","thirty","00:30","0030","12:30","1230","time","late","early","schedule"],"skins":[{"unified":"1f567","native":"🕧"}],"version":1},"clock1":{"id":"clock1","name":"One O’clock","keywords":["clock1","o","clock","1","1:00","100","13:00","1300","time","late","early","schedule"],"skins":[{"unified":"1f550","native":"🕐"}],"version":1},"clock130":{"id":"clock130","name":"One-Thirty","keywords":["clock130","one","thirty","1:30","130","13:30","1330","time","late","early","schedule"],"skins":[{"unified":"1f55c","native":"🕜"}],"version":1},"clock2":{"id":"clock2","name":"Two O’clock","keywords":["clock2","o","clock","2","2:00","200","14:00","1400","time","late","early","schedule"],"skins":[{"unified":"1f551","native":"🕑"}],"version":1},"clock230":{"id":"clock230","name":"Two-Thirty","keywords":["clock230","two","thirty","2:30","230","14:30","1430","time","late","early","schedule"],"skins":[{"unified":"1f55d","native":"🕝"}],"version":1},"clock3":{"id":"clock3","name":"Three O’clock","keywords":["clock3","o","clock","3","3:00","300","15:00","1500","time","late","early","schedule"],"skins":[{"unified":"1f552","native":"🕒"}],"version":1},"clock330":{"id":"clock330","name":"Three-Thirty","keywords":["clock330","three","thirty","3:30","330","15:30","1530","time","late","early","schedule"],"skins":[{"unified":"1f55e","native":"🕞"}],"version":1},"clock4":{"id":"clock4","name":"Four O’clock","keywords":["clock4","o","clock","4","4:00","400","16:00","1600","time","late","early","schedule"],"skins":[{"unified":"1f553","native":"🕓"}],"version":1},"clock430":{"id":"clock430","name":"Four-Thirty","keywords":["clock430","four","thirty","4:30","430","16:30","1630","time","late","early","schedule"],"skins":[{"unified":"1f55f","native":"🕟"}],"version":1},"clock5":{"id":"clock5","name":"Five O’clock","keywords":["clock5","o","clock","5","5:00","500","17:00","1700","time","late","early","schedule"],"skins":[{"unified":"1f554","native":"🕔"}],"version":1},"clock530":{"id":"clock530","name":"Five-Thirty","keywords":["clock530","five","thirty","5:30","530","17:30","1730","time","late","early","schedule"],"skins":[{"unified":"1f560","native":"🕠"}],"version":1},"clock6":{"id":"clock6","name":"Six O’clock","keywords":["clock6","o","clock","6","6:00","600","18:00","1800","time","late","early","schedule","dawn","dusk"],"skins":[{"unified":"1f555","native":"🕕"}],"version":1},"clock630":{"id":"clock630","name":"Six-Thirty","keywords":["clock630","six","thirty","6:30","630","18:30","1830","time","late","early","schedule"],"skins":[{"unified":"1f561","native":"🕡"}],"version":1},"clock7":{"id":"clock7","name":"Seven O’clock","keywords":["clock7","o","clock","7","7:00","700","19:00","1900","time","late","early","schedule"],"skins":[{"unified":"1f556","native":"🕖"}],"version":1},"clock730":{"id":"clock730","name":"Seven-Thirty","keywords":["clock730","seven","thirty","7:30","730","19:30","1930","time","late","early","schedule"],"skins":[{"unified":"1f562","native":"🕢"}],"version":1},"clock8":{"id":"clock8","name":"Eight O’clock","keywords":["clock8","o","clock","8","8:00","800","20:00","2000","time","late","early","schedule"],"skins":[{"unified":"1f557","native":"🕗"}],"version":1},"clock830":{"id":"clock830","name":"Eight-Thirty","keywords":["clock830","eight","thirty","8:30","830","20:30","2030","time","late","early","schedule"],"skins":[{"unified":"1f563","native":"🕣"}],"version":1},"clock9":{"id":"clock9","name":"Nine O’clock","keywords":["clock9","o","clock","9","9:00","900","21:00","2100","time","late","early","schedule"],"skins":[{"unified":"1f558","native":"🕘"}],"version":1},"clock930":{"id":"clock930","name":"Nine-Thirty","keywords":["clock930","nine","thirty","9:30","930","21:30","2130","time","late","early","schedule"],"skins":[{"unified":"1f564","native":"🕤"}],"version":1},"clock10":{"id":"clock10","name":"Ten O’clock","keywords":["clock10","o","clock","10","10:00","1000","22:00","2200","time","late","early","schedule"],"skins":[{"unified":"1f559","native":"🕙"}],"version":1},"clock1030":{"id":"clock1030","name":"Ten-Thirty","keywords":["clock1030","ten","thirty","10:30","1030","22:30","2230","time","late","early","schedule"],"skins":[{"unified":"1f565","native":"🕥"}],"version":1},"clock11":{"id":"clock11","name":"Eleven O’clock","keywords":["clock11","o","clock","11","11:00","1100","23:00","2300","time","late","early","schedule"],"skins":[{"unified":"1f55a","native":"🕚"}],"version":1},"clock1130":{"id":"clock1130","name":"Eleven-Thirty","keywords":["clock1130","eleven","thirty","11:30","1130","23:30","2330","time","late","early","schedule"],"skins":[{"unified":"1f566","native":"🕦"}],"version":1},"new_moon":{"id":"new_moon","name":"New Moon","keywords":["nature","twilight","planet","space","night","evening","sleep"],"skins":[{"unified":"1f311","native":"🌑"}],"version":1},"waxing_crescent_moon":{"id":"waxing_crescent_moon","name":"Waxing Crescent Moon","keywords":["nature","twilight","planet","space","night","evening","sleep"],"skins":[{"unified":"1f312","native":"🌒"}],"version":1},"first_quarter_moon":{"id":"first_quarter_moon","name":"First Quarter Moon","keywords":["nature","twilight","planet","space","night","evening","sleep"],"skins":[{"unified":"1f313","native":"🌓"}],"version":1},"moon":{"id":"moon","name":"Waxing Gibbous Moon","keywords":["nature","night","sky","gray","twilight","planet","space","evening","sleep"],"skins":[{"unified":"1f314","native":"🌔"}],"version":1},"full_moon":{"id":"full_moon","name":"Full Moon","keywords":["nature","yellow","twilight","planet","space","night","evening","sleep"],"skins":[{"unified":"1f315","native":"🌕"}],"version":1},"waning_gibbous_moon":{"id":"waning_gibbous_moon","name":"Waning Gibbous Moon","keywords":["nature","twilight","planet","space","night","evening","sleep","waxing"],"skins":[{"unified":"1f316","native":"🌖"}],"version":1},"last_quarter_moon":{"id":"last_quarter_moon","name":"Last Quarter Moon","keywords":["nature","twilight","planet","space","night","evening","sleep"],"skins":[{"unified":"1f317","native":"🌗"}],"version":1},"waning_crescent_moon":{"id":"waning_crescent_moon","name":"Waning Crescent Moon","keywords":["nature","twilight","planet","space","night","evening","sleep"],"skins":[{"unified":"1f318","native":"🌘"}],"version":1},"crescent_moon":{"id":"crescent_moon","name":"Crescent Moon","keywords":["night","sleep","sky","evening","magic"],"skins":[{"unified":"1f319","native":"🌙"}],"version":1},"new_moon_with_face":{"id":"new_moon_with_face","name":"New Moon Face","keywords":["with","nature","twilight","planet","space","night","evening","sleep"],"skins":[{"unified":"1f31a","native":"🌚"}],"version":1},"first_quarter_moon_with_face":{"id":"first_quarter_moon_with_face","name":"First Quarter Moon Face","keywords":["with","nature","twilight","planet","space","night","evening","sleep"],"skins":[{"unified":"1f31b","native":"🌛"}],"version":1},"last_quarter_moon_with_face":{"id":"last_quarter_moon_with_face","name":"Last Quarter Moon Face","keywords":["with","nature","twilight","planet","space","night","evening","sleep"],"skins":[{"unified":"1f31c","native":"🌜"}],"version":1},"thermometer":{"id":"thermometer","name":"Thermometer","keywords":["weather","temperature","hot","cold"],"skins":[{"unified":"1f321-fe0f","native":"🌡️"}],"version":1},"sunny":{"id":"sunny","name":"Sun","keywords":["sunny","weather","nature","brightness","summer","beach","spring"],"skins":[{"unified":"2600-fe0f","native":"☀️"}],"version":1},"full_moon_with_face":{"id":"full_moon_with_face","name":"Full Moon Face","keywords":["with","nature","twilight","planet","space","night","evening","sleep"],"skins":[{"unified":"1f31d","native":"🌝"}],"version":1},"sun_with_face":{"id":"sun_with_face","name":"Sun with Face","keywords":["nature","morning","sky"],"skins":[{"unified":"1f31e","native":"🌞"}],"version":1},"ringed_planet":{"id":"ringed_planet","name":"Ringed Planet","keywords":["outerspace"],"skins":[{"unified":"1fa90","native":"🪐"}],"version":12},"star":{"id":"star","name":"Star","keywords":["night","yellow"],"skins":[{"unified":"2b50","native":"⭐"}],"version":1},"star2":{"id":"star2","name":"Glowing Star","keywords":["star2","night","sparkle","awesome","good","magic"],"skins":[{"unified":"1f31f","native":"🌟"}],"version":1},"stars":{"id":"stars","name":"Shooting Star","keywords":["stars","night","photo"],"skins":[{"unified":"1f320","native":"🌠"}],"version":1},"milky_way":{"id":"milky_way","name":"Milky Way","keywords":["photo","space","stars"],"skins":[{"unified":"1f30c","native":"🌌"}],"version":1},"cloud":{"id":"cloud","name":"Cloud","keywords":["weather","sky"],"skins":[{"unified":"2601-fe0f","native":"☁️"}],"version":1},"partly_sunny":{"id":"partly_sunny","name":"Sun Behind Cloud","keywords":["partly","sunny","weather","nature","cloudy","morning","fall","spring"],"skins":[{"unified":"26c5","native":"⛅"}],"version":1},"thunder_cloud_and_rain":{"id":"thunder_cloud_and_rain","name":"Cloud with Lightning and Rain","keywords":["thunder","weather"],"skins":[{"unified":"26c8-fe0f","native":"⛈️"}],"version":1},"mostly_sunny":{"id":"mostly_sunny","name":"Sun Behind Small Cloud","keywords":["mostly","sunny","weather"],"skins":[{"unified":"1f324-fe0f","native":"🌤️"}],"version":1},"barely_sunny":{"id":"barely_sunny","name":"Sun Behind Large Cloud","keywords":["barely","sunny","weather"],"skins":[{"unified":"1f325-fe0f","native":"🌥️"}],"version":1},"partly_sunny_rain":{"id":"partly_sunny_rain","name":"Sun Behind Rain Cloud","keywords":["partly","sunny","weather"],"skins":[{"unified":"1f326-fe0f","native":"🌦️"}],"version":1},"rain_cloud":{"id":"rain_cloud","name":"Cloud with Rain","keywords":["weather"],"skins":[{"unified":"1f327-fe0f","native":"🌧️"}],"version":1},"snow_cloud":{"id":"snow_cloud","name":"Cloud with Snow","keywords":["weather"],"skins":[{"unified":"1f328-fe0f","native":"🌨️"}],"version":1},"lightning":{"id":"lightning","name":"Cloud with Lightning","keywords":["weather","thunder"],"skins":[{"unified":"1f329-fe0f","native":"🌩️"}],"version":1},"tornado":{"id":"tornado","name":"Tornado","keywords":["cloud","weather","cyclone","twister"],"skins":[{"unified":"1f32a-fe0f","native":"🌪️"}],"version":1},"fog":{"id":"fog","name":"Fog","keywords":["weather"],"skins":[{"unified":"1f32b-fe0f","native":"🌫️"}],"version":1},"wind_blowing_face":{"id":"wind_blowing_face","name":"Wind Face","keywords":["blowing","gust","air"],"skins":[{"unified":"1f32c-fe0f","native":"🌬️"}],"version":1},"cyclone":{"id":"cyclone","name":"Cyclone","keywords":["weather","swirl","blue","cloud","vortex","spiral","whirlpool","spin","tornado","hurricane","typhoon"],"skins":[{"unified":"1f300","native":"🌀"}],"version":1},"rainbow":{"id":"rainbow","name":"Rainbow","keywords":["nature","happy","unicorn","face","photo","sky","spring"],"skins":[{"unified":"1f308","native":"🌈"}],"version":1},"closed_umbrella":{"id":"closed_umbrella","name":"Closed Umbrella","keywords":["weather","rain","drizzle"],"skins":[{"unified":"1f302","native":"🌂"}],"version":1},"umbrella":{"id":"umbrella","name":"Umbrella","keywords":["weather","spring"],"skins":[{"unified":"2602-fe0f","native":"☂️"}],"version":1},"umbrella_with_rain_drops":{"id":"umbrella_with_rain_drops","name":"Umbrella with Rain Drops","keywords":["rainy","weather","spring"],"skins":[{"unified":"2614","native":"☔"}],"version":1},"umbrella_on_ground":{"id":"umbrella_on_ground","name":"Umbrella on Ground","keywords":["weather","summer"],"skins":[{"unified":"26f1-fe0f","native":"⛱️"}],"version":1},"zap":{"id":"zap","name":"High Voltage","keywords":["zap","thunder","weather","lightning","bolt","fast"],"skins":[{"unified":"26a1","native":"⚡"}],"version":1},"snowflake":{"id":"snowflake","name":"Snowflake","keywords":["winter","season","cold","weather","christmas","xmas"],"skins":[{"unified":"2744-fe0f","native":"❄️"}],"version":1},"snowman":{"id":"snowman","name":"Snowman","keywords":["winter","season","cold","weather","christmas","xmas","frozen"],"skins":[{"unified":"2603-fe0f","native":"☃️"}],"version":1},"snowman_without_snow":{"id":"snowman_without_snow","name":"Snowman Without Snow","keywords":["winter","season","cold","weather","christmas","xmas","frozen"],"skins":[{"unified":"26c4","native":"⛄"}],"version":1},"comet":{"id":"comet","name":"Comet","keywords":["space"],"skins":[{"unified":"2604-fe0f","native":"☄️"}],"version":1},"fire":{"id":"fire","name":"Fire","keywords":["hot","cook","flame"],"skins":[{"unified":"1f525","native":"🔥"}],"version":1},"droplet":{"id":"droplet","name":"Droplet","keywords":["water","drip","faucet","spring"],"skins":[{"unified":"1f4a7","native":"💧"}],"version":1},"ocean":{"id":"ocean","name":"Water Wave","keywords":["ocean","sea","nature","tsunami","disaster"],"skins":[{"unified":"1f30a","native":"🌊"}],"version":1},"jack_o_lantern":{"id":"jack_o_lantern","name":"Jack-O-Lantern","keywords":["jack","o","lantern","halloween","light","pumpkin","creepy","fall"],"skins":[{"unified":"1f383","native":"🎃"}],"version":1},"christmas_tree":{"id":"christmas_tree","name":"Christmas Tree","keywords":["festival","vacation","december","xmas","celebration"],"skins":[{"unified":"1f384","native":"🎄"}],"version":1},"fireworks":{"id":"fireworks","name":"Fireworks","keywords":["photo","festival","carnival","congratulations"],"skins":[{"unified":"1f386","native":"🎆"}],"version":1},"sparkler":{"id":"sparkler","name":"Sparkler","keywords":["stars","night","shine"],"skins":[{"unified":"1f387","native":"🎇"}],"version":1},"firecracker":{"id":"firecracker","name":"Firecracker","keywords":["dynamite","boom","explode","explosion","explosive"],"skins":[{"unified":"1f9e8","native":"🧨"}],"version":11},"sparkles":{"id":"sparkles","name":"Sparkles","keywords":["stars","shine","shiny","cool","awesome","good","magic"],"skins":[{"unified":"2728","native":"✨"}],"version":1},"balloon":{"id":"balloon","name":"Balloon","keywords":["party","celebration","birthday","circus"],"skins":[{"unified":"1f388","native":"🎈"}],"version":1},"tada":{"id":"tada","name":"Party Popper","keywords":["tada","congratulations","birthday","magic","circus","celebration"],"skins":[{"unified":"1f389","native":"🎉"}],"version":1},"confetti_ball":{"id":"confetti_ball","name":"Confetti Ball","keywords":["festival","party","birthday","circus"],"skins":[{"unified":"1f38a","native":"🎊"}],"version":1},"tanabata_tree":{"id":"tanabata_tree","name":"Tanabata Tree","keywords":["plant","nature","branch","summer","bamboo","wish","star","festival","tanzaku"],"skins":[{"unified":"1f38b","native":"🎋"}],"version":1},"bamboo":{"id":"bamboo","name":"Pine Decoration","keywords":["bamboo","japanese","plant","nature","vegetable","panda","new","years"],"skins":[{"unified":"1f38d","native":"🎍"}],"version":1},"dolls":{"id":"dolls","name":"Japanese Dolls","keywords":["toy","kimono"],"skins":[{"unified":"1f38e","native":"🎎"}],"version":1},"flags":{"id":"flags","name":"Carp Streamer","keywords":["flags","fish","japanese","koinobori","banner"],"skins":[{"unified":"1f38f","native":"🎏"}],"version":1},"wind_chime":{"id":"wind_chime","name":"Wind Chime","keywords":["nature","ding","spring","bell"],"skins":[{"unified":"1f390","native":"🎐"}],"version":1},"rice_scene":{"id":"rice_scene","name":"Moon Viewing Ceremony","keywords":["rice","scene","photo","japan","asia","tsukimi"],"skins":[{"unified":"1f391","native":"🎑"}],"version":1},"red_envelope":{"id":"red_envelope","name":"Red Envelope","keywords":["gift"],"skins":[{"unified":"1f9e7","native":"🧧"}],"version":11},"ribbon":{"id":"ribbon","name":"Ribbon","keywords":["decoration","pink","girl","bowtie"],"skins":[{"unified":"1f380","native":"🎀"}],"version":1},"gift":{"id":"gift","name":"Wrapped Gift","keywords":["present","birthday","christmas","xmas"],"skins":[{"unified":"1f381","native":"🎁"}],"version":1},"reminder_ribbon":{"id":"reminder_ribbon","name":"Reminder Ribbon","keywords":["sports","cause","support","awareness"],"skins":[{"unified":"1f397-fe0f","native":"🎗️"}],"version":1},"admission_tickets":{"id":"admission_tickets","name":"Admission Tickets","keywords":["sports","concert","entrance"],"skins":[{"unified":"1f39f-fe0f","native":"🎟️"}],"version":1},"ticket":{"id":"ticket","name":"Ticket","keywords":["event","concert","pass"],"skins":[{"unified":"1f3ab","native":"🎫"}],"version":1},"medal":{"id":"medal","name":"Military Medal","keywords":["award","winning","army"],"skins":[{"unified":"1f396-fe0f","native":"🎖️"}],"version":1},"trophy":{"id":"trophy","name":"Trophy","keywords":["win","award","contest","place","ftw","ceremony"],"skins":[{"unified":"1f3c6","native":"🏆"}],"version":1},"sports_medal":{"id":"sports_medal","name":"Sports Medal","keywords":["award","winning"],"skins":[{"unified":"1f3c5","native":"🏅"}],"version":1},"first_place_medal":{"id":"first_place_medal","name":"1st Place Medal","keywords":["first","award","winning"],"skins":[{"unified":"1f947","native":"🥇"}],"version":3},"second_place_medal":{"id":"second_place_medal","name":"2nd Place Medal","keywords":["second","award"],"skins":[{"unified":"1f948","native":"🥈"}],"version":3},"third_place_medal":{"id":"third_place_medal","name":"3rd Place Medal","keywords":["third","award"],"skins":[{"unified":"1f949","native":"🥉"}],"version":3},"soccer":{"id":"soccer","name":"Soccer Ball","keywords":["sports","football"],"skins":[{"unified":"26bd","native":"⚽"}],"version":1},"baseball":{"id":"baseball","name":"Baseball","keywords":["sports","balls"],"skins":[{"unified":"26be","native":"⚾"}],"version":1},"softball":{"id":"softball","name":"Softball","keywords":["sports","balls"],"skins":[{"unified":"1f94e","native":"🥎"}],"version":11},"basketball":{"id":"basketball","name":"Basketball","keywords":["sports","balls","NBA"],"skins":[{"unified":"1f3c0","native":"🏀"}],"version":1},"volleyball":{"id":"volleyball","name":"Volleyball","keywords":["sports","balls"],"skins":[{"unified":"1f3d0","native":"🏐"}],"version":1},"football":{"id":"football","name":"American Football","keywords":["sports","balls","NFL"],"skins":[{"unified":"1f3c8","native":"🏈"}],"version":1},"rugby_football":{"id":"rugby_football","name":"Rugby Football","keywords":["sports","team"],"skins":[{"unified":"1f3c9","native":"🏉"}],"version":1},"tennis":{"id":"tennis","name":"Tennis","keywords":["sports","balls","green"],"skins":[{"unified":"1f3be","native":"🎾"}],"version":1},"flying_disc":{"id":"flying_disc","name":"Flying Disc","keywords":["sports","frisbee","ultimate"],"skins":[{"unified":"1f94f","native":"🥏"}],"version":11},"bowling":{"id":"bowling","name":"Bowling","keywords":["sports","fun","play"],"skins":[{"unified":"1f3b3","native":"🎳"}],"version":1},"cricket_bat_and_ball":{"id":"cricket_bat_and_ball","name":"Cricket Game","keywords":["bat","and","ball","sports"],"skins":[{"unified":"1f3cf","native":"🏏"}],"version":1},"field_hockey_stick_and_ball":{"id":"field_hockey_stick_and_ball","name":"Field Hockey","keywords":["stick","and","ball","sports"],"skins":[{"unified":"1f3d1","native":"🏑"}],"version":1},"ice_hockey_stick_and_puck":{"id":"ice_hockey_stick_and_puck","name":"Ice Hockey","keywords":["stick","and","puck","sports"],"skins":[{"unified":"1f3d2","native":"🏒"}],"version":1},"lacrosse":{"id":"lacrosse","name":"Lacrosse","keywords":["sports","ball","stick"],"skins":[{"unified":"1f94d","native":"🥍"}],"version":11},"table_tennis_paddle_and_ball":{"id":"table_tennis_paddle_and_ball","name":"Ping Pong","keywords":["table","tennis","paddle","and","ball","sports","pingpong"],"skins":[{"unified":"1f3d3","native":"🏓"}],"version":1},"badminton_racquet_and_shuttlecock":{"id":"badminton_racquet_and_shuttlecock","name":"Badminton","keywords":["racquet","and","shuttlecock","sports"],"skins":[{"unified":"1f3f8","native":"🏸"}],"version":1},"boxing_glove":{"id":"boxing_glove","name":"Boxing Glove","keywords":["sports","fighting"],"skins":[{"unified":"1f94a","native":"🥊"}],"version":3},"martial_arts_uniform":{"id":"martial_arts_uniform","name":"Martial Arts Uniform","keywords":["judo","karate","taekwondo"],"skins":[{"unified":"1f94b","native":"🥋"}],"version":3},"goal_net":{"id":"goal_net","name":"Goal Net","keywords":["sports"],"skins":[{"unified":"1f945","native":"🥅"}],"version":3},"golf":{"id":"golf","name":"Flag in Hole","keywords":["golf","sports","business","summer"],"skins":[{"unified":"26f3","native":"⛳"}],"version":1},"ice_skate":{"id":"ice_skate","name":"Ice Skate","keywords":["sports"],"skins":[{"unified":"26f8-fe0f","native":"⛸️"}],"version":1},"fishing_pole_and_fish":{"id":"fishing_pole_and_fish","name":"Fishing Pole","keywords":["and","fish","food","hobby","summer"],"skins":[{"unified":"1f3a3","native":"🎣"}],"version":1},"diving_mask":{"id":"diving_mask","name":"Diving Mask","keywords":["sport","ocean"],"skins":[{"unified":"1f93f","native":"🤿"}],"version":12},"running_shirt_with_sash":{"id":"running_shirt_with_sash","name":"Running Shirt","keywords":["with","sash","play","pageant"],"skins":[{"unified":"1f3bd","native":"🎽"}],"version":1},"ski":{"id":"ski","name":"Skis","keywords":["ski","sports","winter","cold","snow"],"skins":[{"unified":"1f3bf","native":"🎿"}],"version":1},"sled":{"id":"sled","name":"Sled","keywords":["sleigh","luge","toboggan"],"skins":[{"unified":"1f6f7","native":"🛷"}],"version":5},"curling_stone":{"id":"curling_stone","name":"Curling Stone","keywords":["sports"],"skins":[{"unified":"1f94c","native":"🥌"}],"version":5},"dart":{"id":"dart","name":"Bullseye","keywords":["dart","direct","hit","game","play","bar","target"],"skins":[{"unified":"1f3af","native":"🎯"}],"version":1},"yo-yo":{"id":"yo-yo","name":"Yo-Yo","keywords":["yo","toy"],"skins":[{"unified":"1fa80","native":"🪀"}],"version":12},"kite":{"id":"kite","name":"Kite","keywords":["wind","fly"],"skins":[{"unified":"1fa81","native":"🪁"}],"version":12},"gun":{"id":"gun","name":"Pistol","keywords":["gun","violence","weapon","revolver"],"skins":[{"unified":"1f52b","native":"🔫"}],"version":1},"8ball":{"id":"8ball","name":"Billiards","keywords":["8ball","pool","8","ball","hobby","game","luck","magic"],"skins":[{"unified":"1f3b1","native":"🎱"}],"version":1},"crystal_ball":{"id":"crystal_ball","name":"Crystal Ball","keywords":["disco","party","magic","circus","fortune","teller"],"skins":[{"unified":"1f52e","native":"🔮"}],"version":1},"magic_wand":{"id":"magic_wand","name":"Magic Wand","keywords":["supernature","power"],"skins":[{"unified":"1fa84","native":"🪄"}],"version":13},"video_game":{"id":"video_game","name":"Video Game","keywords":["play","console","PS4","controller"],"skins":[{"unified":"1f3ae","native":"🎮"}],"version":1},"joystick":{"id":"joystick","name":"Joystick","keywords":["game","play"],"skins":[{"unified":"1f579-fe0f","native":"🕹️"}],"version":1},"slot_machine":{"id":"slot_machine","name":"Slot Machine","keywords":["bet","gamble","vegas","fruit","luck","casino"],"skins":[{"unified":"1f3b0","native":"🎰"}],"version":1},"game_die":{"id":"game_die","name":"Game Die","keywords":["dice","random","tabletop","play","luck"],"skins":[{"unified":"1f3b2","native":"🎲"}],"version":1},"jigsaw":{"id":"jigsaw","name":"Puzzle Piece","keywords":["jigsaw","interlocking"],"skins":[{"unified":"1f9e9","native":"🧩"}],"version":11},"teddy_bear":{"id":"teddy_bear","name":"Teddy Bear","keywords":["plush","stuffed"],"skins":[{"unified":"1f9f8","native":"🧸"}],"version":11},"pinata":{"id":"pinata","name":"Pinata","keywords":["mexico","candy","celebration"],"skins":[{"unified":"1fa85","native":"🪅"}],"version":13},"mirror_ball":{"id":"mirror_ball","name":"Mirror Ball","keywords":["disco","dance","party"],"skins":[{"unified":"1faa9","native":"🪩"}],"version":14},"nesting_dolls":{"id":"nesting_dolls","name":"Nesting Dolls","keywords":["matryoshka","toy"],"skins":[{"unified":"1fa86","native":"🪆"}],"version":13},"spades":{"id":"spades","name":"Spade Suit","keywords":["spades","poker","cards","suits","magic"],"skins":[{"unified":"2660-fe0f","native":"♠️"}],"version":1},"hearts":{"id":"hearts","name":"Heart Suit","keywords":["hearts","poker","cards","magic","suits"],"skins":[{"unified":"2665-fe0f","native":"♥️"}],"version":1},"diamonds":{"id":"diamonds","name":"Diamond Suit","keywords":["diamonds","poker","cards","magic","suits"],"skins":[{"unified":"2666-fe0f","native":"♦️"}],"version":1},"clubs":{"id":"clubs","name":"Club Suit","keywords":["clubs","poker","cards","magic","suits"],"skins":[{"unified":"2663-fe0f","native":"♣️"}],"version":1},"chess_pawn":{"id":"chess_pawn","name":"Chess Pawn","keywords":["expendable"],"skins":[{"unified":"265f-fe0f","native":"♟️"}],"version":11},"black_joker":{"id":"black_joker","name":"Joker","keywords":["black","poker","cards","game","play","magic"],"skins":[{"unified":"1f0cf","native":"🃏"}],"version":1},"mahjong":{"id":"mahjong","name":"Mahjong Red Dragon","keywords":["game","play","chinese","kanji"],"skins":[{"unified":"1f004","native":"🀄"}],"version":1},"flower_playing_cards":{"id":"flower_playing_cards","name":"Flower Playing Cards","keywords":["game","sunset","red"],"skins":[{"unified":"1f3b4","native":"🎴"}],"version":1},"performing_arts":{"id":"performing_arts","name":"Performing Arts","keywords":["acting","theater","drama"],"skins":[{"unified":"1f3ad","native":"🎭"}],"version":1},"frame_with_picture":{"id":"frame_with_picture","name":"Framed Picture","keywords":["frame","with","photography"],"skins":[{"unified":"1f5bc-fe0f","native":"🖼️"}],"version":1},"art":{"id":"art","name":"Artist Palette","keywords":["art","design","paint","draw","colors"],"skins":[{"unified":"1f3a8","native":"🎨"}],"version":1},"thread":{"id":"thread","name":"Thread","keywords":["needle","sewing","spool","string"],"skins":[{"unified":"1f9f5","native":"🧵"}],"version":11},"sewing_needle":{"id":"sewing_needle","name":"Sewing Needle","keywords":["stitches"],"skins":[{"unified":"1faa1","native":"🪡"}],"version":13},"yarn":{"id":"yarn","name":"Yarn","keywords":["ball","crochet","knit"],"skins":[{"unified":"1f9f6","native":"🧶"}],"version":11},"knot":{"id":"knot","name":"Knot","keywords":["rope","scout"],"skins":[{"unified":"1faa2","native":"🪢"}],"version":13},"eyeglasses":{"id":"eyeglasses","name":"Glasses","keywords":["eyeglasses","fashion","accessories","eyesight","nerdy","dork","geek"],"skins":[{"unified":"1f453","native":"👓"}],"version":1},"dark_sunglasses":{"id":"dark_sunglasses","name":"Sunglasses","keywords":["dark","face","cool","accessories"],"skins":[{"unified":"1f576-fe0f","native":"🕶️"}],"version":1},"goggles":{"id":"goggles","name":"Goggles","keywords":["eyes","protection","safety"],"skins":[{"unified":"1f97d","native":"🥽"}],"version":11},"lab_coat":{"id":"lab_coat","name":"Lab Coat","keywords":["doctor","experiment","scientist","chemist"],"skins":[{"unified":"1f97c","native":"🥼"}],"version":11},"safety_vest":{"id":"safety_vest","name":"Safety Vest","keywords":["protection"],"skins":[{"unified":"1f9ba","native":"🦺"}],"version":12},"necktie":{"id":"necktie","name":"Necktie","keywords":["shirt","suitup","formal","fashion","cloth","business"],"skins":[{"unified":"1f454","native":"👔"}],"version":1},"shirt":{"id":"shirt","name":"T-Shirt","keywords":["shirt","tshirt","t","fashion","cloth","casual","tee"],"skins":[{"unified":"1f455","native":"👕"}],"version":1},"jeans":{"id":"jeans","name":"Jeans","keywords":["fashion","shopping"],"skins":[{"unified":"1f456","native":"👖"}],"version":1},"scarf":{"id":"scarf","name":"Scarf","keywords":["neck","winter","clothes"],"skins":[{"unified":"1f9e3","native":"🧣"}],"version":5},"gloves":{"id":"gloves","name":"Gloves","keywords":["hands","winter","clothes"],"skins":[{"unified":"1f9e4","native":"🧤"}],"version":5},"coat":{"id":"coat","name":"Coat","keywords":["jacket"],"skins":[{"unified":"1f9e5","native":"🧥"}],"version":5},"socks":{"id":"socks","name":"Socks","keywords":["stockings","clothes"],"skins":[{"unified":"1f9e6","native":"🧦"}],"version":5},"dress":{"id":"dress","name":"Dress","keywords":["clothes","fashion","shopping"],"skins":[{"unified":"1f457","native":"👗"}],"version":1},"kimono":{"id":"kimono","name":"Kimono","keywords":["dress","fashion","women","female","japanese"],"skins":[{"unified":"1f458","native":"👘"}],"version":1},"sari":{"id":"sari","name":"Sari","keywords":["dress"],"skins":[{"unified":"1f97b","native":"🥻"}],"version":12},"one-piece_swimsuit":{"id":"one-piece_swimsuit","name":"One-Piece Swimsuit","keywords":["one","piece","fashion"],"skins":[{"unified":"1fa71","native":"🩱"}],"version":12},"briefs":{"id":"briefs","name":"Briefs","keywords":["clothing"],"skins":[{"unified":"1fa72","native":"🩲"}],"version":12},"shorts":{"id":"shorts","name":"Shorts","keywords":["clothing"],"skins":[{"unified":"1fa73","native":"🩳"}],"version":12},"bikini":{"id":"bikini","name":"Bikini","keywords":["swimming","female","woman","girl","fashion","beach","summer"],"skins":[{"unified":"1f459","native":"👙"}],"version":1},"womans_clothes":{"id":"womans_clothes","name":"Womans Clothes","keywords":["woman","s","fashion","shopping","bags","female"],"skins":[{"unified":"1f45a","native":"👚"}],"version":1},"folding_hand_fan":{"id":"folding_hand_fan","name":"Folding Hand Fan","keywords":["flamenco","hot"],"skins":[{"unified":"1faad","native":"🪭"}],"version":15},"purse":{"id":"purse","name":"Purse","keywords":["fashion","accessories","money","sales","shopping"],"skins":[{"unified":"1f45b","native":"👛"}],"version":1},"handbag":{"id":"handbag","name":"Handbag","keywords":["fashion","accessory","accessories","shopping"],"skins":[{"unified":"1f45c","native":"👜"}],"version":1},"pouch":{"id":"pouch","name":"Pouch","keywords":["clutch","bag","accessories","shopping"],"skins":[{"unified":"1f45d","native":"👝"}],"version":1},"shopping_bags":{"id":"shopping_bags","name":"Shopping Bags","keywords":["mall","buy","purchase"],"skins":[{"unified":"1f6cd-fe0f","native":"🛍️"}],"version":1},"school_satchel":{"id":"school_satchel","name":"Backpack","keywords":["school","satchel","student","education","bag"],"skins":[{"unified":"1f392","native":"🎒"}],"version":1},"thong_sandal":{"id":"thong_sandal","name":"Thong Sandal","keywords":["footwear","summer"],"skins":[{"unified":"1fa74","native":"🩴"}],"version":13},"mans_shoe":{"id":"mans_shoe","name":"Mans Shoe","keywords":["man","s","fashion","male"],"skins":[{"unified":"1f45e","native":"👞"}],"version":1},"athletic_shoe":{"id":"athletic_shoe","name":"Running Shoe","keywords":["athletic","shoes","sports","sneakers"],"skins":[{"unified":"1f45f","native":"👟"}],"version":1},"hiking_boot":{"id":"hiking_boot","name":"Hiking Boot","keywords":["backpacking","camping"],"skins":[{"unified":"1f97e","native":"🥾"}],"version":11},"womans_flat_shoe":{"id":"womans_flat_shoe","name":"Flat Shoe","keywords":["womans","ballet","slip","on","slipper"],"skins":[{"unified":"1f97f","native":"🥿"}],"version":11},"high_heel":{"id":"high_heel","name":"High-Heeled Shoe","keywords":["high","heel","heeled","fashion","shoes","female","pumps","stiletto"],"skins":[{"unified":"1f460","native":"👠"}],"version":1},"sandal":{"id":"sandal","name":"Womans Sandal","keywords":["woman","s","shoes","fashion","flip","flops"],"skins":[{"unified":"1f461","native":"👡"}],"version":1},"ballet_shoes":{"id":"ballet_shoes","name":"Ballet Shoes","keywords":["dance"],"skins":[{"unified":"1fa70","native":"🩰"}],"version":12},"boot":{"id":"boot","name":"Womans Boots","keywords":["boot","woman","s","shoes","fashion"],"skins":[{"unified":"1f462","native":"👢"}],"version":1},"hair_pick":{"id":"hair_pick","name":"Hair Pick","keywords":["afro","comb"],"skins":[{"unified":"1faae","native":"🪮"}],"version":15},"crown":{"id":"crown","name":"Crown","keywords":["king","kod","leader","royalty","lord"],"skins":[{"unified":"1f451","native":"👑"}],"version":1},"womans_hat":{"id":"womans_hat","name":"Womans Hat","keywords":["woman","s","fashion","accessories","female","lady","spring"],"skins":[{"unified":"1f452","native":"👒"}],"version":1},"tophat":{"id":"tophat","name":"Top Hat","keywords":["tophat","magic","gentleman","classy","circus"],"skins":[{"unified":"1f3a9","native":"🎩"}],"version":1},"mortar_board":{"id":"mortar_board","name":"Graduation Cap","keywords":["mortar","board","school","college","degree","university","hat","legal","learn","education"],"skins":[{"unified":"1f393","native":"🎓"}],"version":1},"billed_cap":{"id":"billed_cap","name":"Billed Cap","keywords":["baseball"],"skins":[{"unified":"1f9e2","native":"🧢"}],"version":5},"military_helmet":{"id":"military_helmet","name":"Military Helmet","keywords":["army","protection"],"skins":[{"unified":"1fa96","native":"🪖"}],"version":13},"helmet_with_white_cross":{"id":"helmet_with_white_cross","name":"Rescue Worker’s Helmet","keywords":["with","white","cross","worker","s","construction","build"],"skins":[{"unified":"26d1-fe0f","native":"⛑️"}],"version":1},"prayer_beads":{"id":"prayer_beads","name":"Prayer Beads","keywords":["dhikr","religious"],"skins":[{"unified":"1f4ff","native":"📿"}],"version":1},"lipstick":{"id":"lipstick","name":"Lipstick","keywords":["female","girl","fashion","woman"],"skins":[{"unified":"1f484","native":"💄"}],"version":1},"ring":{"id":"ring","name":"Ring","keywords":["wedding","propose","marriage","valentines","diamond","fashion","jewelry","gem","engagement"],"skins":[{"unified":"1f48d","native":"💍"}],"version":1},"gem":{"id":"gem","name":"Gem Stone","keywords":["blue","ruby","diamond","jewelry"],"skins":[{"unified":"1f48e","native":"💎"}],"version":1},"mute":{"id":"mute","name":"Muted Speaker","keywords":["mute","sound","volume","silence","quiet"],"skins":[{"unified":"1f507","native":"🔇"}],"version":1},"speaker":{"id":"speaker","name":"Speaker","keywords":["low","volume","sound","silence","broadcast"],"skins":[{"unified":"1f508","native":"🔈"}],"version":1},"sound":{"id":"sound","name":"Speaker Medium Volume","keywords":["sound","broadcast"],"skins":[{"unified":"1f509","native":"🔉"}],"version":1},"loud_sound":{"id":"loud_sound","name":"Speaker High Volume","keywords":["loud","sound","noise","noisy","broadcast"],"skins":[{"unified":"1f50a","native":"🔊"}],"version":1},"loudspeaker":{"id":"loudspeaker","name":"Loudspeaker","keywords":["volume","sound"],"skins":[{"unified":"1f4e2","native":"📢"}],"version":1},"mega":{"id":"mega","name":"Megaphone","keywords":["mega","sound","speaker","volume"],"skins":[{"unified":"1f4e3","native":"📣"}],"version":1},"postal_horn":{"id":"postal_horn","name":"Postal Horn","keywords":["instrument","music"],"skins":[{"unified":"1f4ef","native":"📯"}],"version":1},"bell":{"id":"bell","name":"Bell","keywords":["sound","notification","christmas","xmas","chime"],"skins":[{"unified":"1f514","native":"🔔"}],"version":1},"no_bell":{"id":"no_bell","name":"Bell with Slash","keywords":["no","sound","volume","mute","quiet","silent"],"skins":[{"unified":"1f515","native":"🔕"}],"version":1},"musical_score":{"id":"musical_score","name":"Musical Score","keywords":["treble","clef","compose"],"skins":[{"unified":"1f3bc","native":"🎼"}],"version":1},"musical_note":{"id":"musical_note","name":"Musical Note","keywords":["score","tone","sound"],"skins":[{"unified":"1f3b5","native":"🎵"}],"version":1},"notes":{"id":"notes","name":"Musical Notes","keywords":["music","score"],"skins":[{"unified":"1f3b6","native":"🎶"}],"version":1},"studio_microphone":{"id":"studio_microphone","name":"Studio Microphone","keywords":["sing","recording","artist","talkshow"],"skins":[{"unified":"1f399-fe0f","native":"🎙️"}],"version":1},"level_slider":{"id":"level_slider","name":"Level Slider","keywords":["scale"],"skins":[{"unified":"1f39a-fe0f","native":"🎚️"}],"version":1},"control_knobs":{"id":"control_knobs","name":"Control Knobs","keywords":["dial"],"skins":[{"unified":"1f39b-fe0f","native":"🎛️"}],"version":1},"microphone":{"id":"microphone","name":"Microphone","keywords":["sound","music","PA","sing","talkshow"],"skins":[{"unified":"1f3a4","native":"🎤"}],"version":1},"headphones":{"id":"headphones","name":"Headphone","keywords":["headphones","music","score","gadgets"],"skins":[{"unified":"1f3a7","native":"🎧"}],"version":1},"radio":{"id":"radio","name":"Radio","keywords":["communication","music","podcast","program"],"skins":[{"unified":"1f4fb","native":"📻"}],"version":1},"saxophone":{"id":"saxophone","name":"Saxophone","keywords":["music","instrument","jazz","blues"],"skins":[{"unified":"1f3b7","native":"🎷"}],"version":1},"accordion":{"id":"accordion","name":"Accordion","keywords":["music"],"skins":[{"unified":"1fa97","native":"🪗"}],"version":13},"guitar":{"id":"guitar","name":"Guitar","keywords":["music","instrument"],"skins":[{"unified":"1f3b8","native":"🎸"}],"version":1},"musical_keyboard":{"id":"musical_keyboard","name":"Musical Keyboard","keywords":["piano","instrument","compose"],"skins":[{"unified":"1f3b9","native":"🎹"}],"version":1},"trumpet":{"id":"trumpet","name":"Trumpet","keywords":["music","brass"],"skins":[{"unified":"1f3ba","native":"🎺"}],"version":1},"violin":{"id":"violin","name":"Violin","keywords":["music","instrument","orchestra","symphony"],"skins":[{"unified":"1f3bb","native":"🎻"}],"version":1},"banjo":{"id":"banjo","name":"Banjo","keywords":["music","instructment"],"skins":[{"unified":"1fa95","native":"🪕"}],"version":12},"drum_with_drumsticks":{"id":"drum_with_drumsticks","name":"Drum","keywords":["with","drumsticks","music","instrument","snare"],"skins":[{"unified":"1f941","native":"🥁"}],"version":3},"long_drum":{"id":"long_drum","name":"Long Drum","keywords":["music"],"skins":[{"unified":"1fa98","native":"🪘"}],"version":13},"maracas":{"id":"maracas","name":"Maracas","keywords":["music","instrument","percussion"],"skins":[{"unified":"1fa87","native":"🪇"}],"version":15},"flute":{"id":"flute","name":"Flute","keywords":["bamboo","music","instrument","pied","piper"],"skins":[{"unified":"1fa88","native":"🪈"}],"version":15},"iphone":{"id":"iphone","name":"Mobile Phone","keywords":["iphone","technology","apple","gadgets","dial"],"skins":[{"unified":"1f4f1","native":"📱"}],"version":1},"calling":{"id":"calling","name":"Mobile Phone with Arrow","keywords":["calling","iphone","incoming"],"skins":[{"unified":"1f4f2","native":"📲"}],"version":1},"phone":{"id":"phone","name":"Telephone","keywords":["phone","technology","communication","dial"],"skins":[{"unified":"260e-fe0f","native":"☎️"}],"version":1},"telephone_receiver":{"id":"telephone_receiver","name":"Telephone Receiver","keywords":["technology","communication","dial"],"skins":[{"unified":"1f4de","native":"📞"}],"version":1},"pager":{"id":"pager","name":"Pager","keywords":["bbcall","oldschool","90s"],"skins":[{"unified":"1f4df","native":"📟"}],"version":1},"fax":{"id":"fax","name":"Fax Machine","keywords":["communication","technology"],"skins":[{"unified":"1f4e0","native":"📠"}],"version":1},"battery":{"id":"battery","name":"Battery","keywords":["power","energy","sustain"],"skins":[{"unified":"1f50b","native":"🔋"}],"version":1},"low_battery":{"id":"low_battery","name":"Low Battery","keywords":["drained","dead"],"skins":[{"unified":"1faab","native":"🪫"}],"version":14},"electric_plug":{"id":"electric_plug","name":"Electric Plug","keywords":["charger","power"],"skins":[{"unified":"1f50c","native":"🔌"}],"version":1},"computer":{"id":"computer","name":"Laptop","keywords":["computer","technology","screen","display","monitor"],"skins":[{"unified":"1f4bb","native":"💻"}],"version":1},"desktop_computer":{"id":"desktop_computer","name":"Desktop Computer","keywords":["technology","computing","screen"],"skins":[{"unified":"1f5a5-fe0f","native":"🖥️"}],"version":1},"printer":{"id":"printer","name":"Printer","keywords":["paper","ink"],"skins":[{"unified":"1f5a8-fe0f","native":"🖨️"}],"version":1},"keyboard":{"id":"keyboard","name":"Keyboard","keywords":["technology","computer","type","input","text"],"skins":[{"unified":"2328-fe0f","native":"⌨️"}],"version":1},"three_button_mouse":{"id":"three_button_mouse","name":"Computer Mouse","keywords":["three","button","click"],"skins":[{"unified":"1f5b1-fe0f","native":"🖱️"}],"version":1},"trackball":{"id":"trackball","name":"Trackball","keywords":["technology","trackpad"],"skins":[{"unified":"1f5b2-fe0f","native":"🖲️"}],"version":1},"minidisc":{"id":"minidisc","name":"Minidisc","keywords":["computer","disk","technology","record","data","90s"],"skins":[{"unified":"1f4bd","native":"💽"}],"version":1},"floppy_disk":{"id":"floppy_disk","name":"Floppy Disk","keywords":["oldschool","technology","save","90s","80s"],"skins":[{"unified":"1f4be","native":"💾"}],"version":1},"cd":{"id":"cd","name":"Optical Disc","keywords":["cd","disk","technology","dvd","90s"],"skins":[{"unified":"1f4bf","native":"💿"}],"version":1},"dvd":{"id":"dvd","name":"Dvd","keywords":["cd","disk","disc"],"skins":[{"unified":"1f4c0","native":"📀"}],"version":1},"abacus":{"id":"abacus","name":"Abacus","keywords":["calculation"],"skins":[{"unified":"1f9ee","native":"🧮"}],"version":11},"movie_camera":{"id":"movie_camera","name":"Movie Camera","keywords":["film","record"],"skins":[{"unified":"1f3a5","native":"🎥"}],"version":1},"film_frames":{"id":"film_frames","name":"Film Frames","keywords":["movie"],"skins":[{"unified":"1f39e-fe0f","native":"🎞️"}],"version":1},"film_projector":{"id":"film_projector","name":"Film Projector","keywords":["video","tape","record","movie"],"skins":[{"unified":"1f4fd-fe0f","native":"📽️"}],"version":1},"clapper":{"id":"clapper","name":"Clapper Board","keywords":["movie","film","record"],"skins":[{"unified":"1f3ac","native":"🎬"}],"version":1},"tv":{"id":"tv","name":"Television","keywords":["tv","technology","program","oldschool","show"],"skins":[{"unified":"1f4fa","native":"📺"}],"version":1},"camera":{"id":"camera","name":"Camera","keywords":["gadgets","photography"],"skins":[{"unified":"1f4f7","native":"📷"}],"version":1},"camera_with_flash":{"id":"camera_with_flash","name":"Camera with Flash","keywords":["photography","gadgets"],"skins":[{"unified":"1f4f8","native":"📸"}],"version":1},"video_camera":{"id":"video_camera","name":"Video Camera","keywords":["film","record"],"skins":[{"unified":"1f4f9","native":"📹"}],"version":1},"vhs":{"id":"vhs","name":"Videocassette","keywords":["vhs","record","video","oldschool","90s","80s"],"skins":[{"unified":"1f4fc","native":"📼"}],"version":1},"mag":{"id":"mag","name":"Magnifying Glass Tilted Left","keywords":["mag","search","zoom","find","detective"],"skins":[{"unified":"1f50d","native":"🔍"}],"version":1},"mag_right":{"id":"mag_right","name":"Magnifying Glass Tilted Right","keywords":["mag","search","zoom","find","detective"],"skins":[{"unified":"1f50e","native":"🔎"}],"version":1},"candle":{"id":"candle","name":"Candle","keywords":["fire","wax"],"skins":[{"unified":"1f56f-fe0f","native":"🕯️"}],"version":1},"bulb":{"id":"bulb","name":"Light Bulb","keywords":["electricity","idea"],"skins":[{"unified":"1f4a1","native":"💡"}],"version":1},"flashlight":{"id":"flashlight","name":"Flashlight","keywords":["dark","camping","sight","night"],"skins":[{"unified":"1f526","native":"🔦"}],"version":1},"izakaya_lantern":{"id":"izakaya_lantern","name":"Izakaya Lantern","keywords":["red","paper","light","halloween","spooky"],"skins":[{"unified":"1f3ee","native":"🏮"}],"version":1},"diya_lamp":{"id":"diya_lamp","name":"Diya Lamp","keywords":["lighting"],"skins":[{"unified":"1fa94","native":"🪔"}],"version":12},"notebook_with_decorative_cover":{"id":"notebook_with_decorative_cover","name":"Notebook with Decorative Cover","keywords":["classroom","notes","record","paper","study"],"skins":[{"unified":"1f4d4","native":"📔"}],"version":1},"closed_book":{"id":"closed_book","name":"Closed Book","keywords":["read","library","knowledge","textbook","learn"],"skins":[{"unified":"1f4d5","native":"📕"}],"version":1},"book":{"id":"book","name":"Open Book","keywords":["read","library","knowledge","literature","learn","study"],"skins":[{"unified":"1f4d6","native":"📖"}],"version":1},"green_book":{"id":"green_book","name":"Green Book","keywords":["read","library","knowledge","study"],"skins":[{"unified":"1f4d7","native":"📗"}],"version":1},"blue_book":{"id":"blue_book","name":"Blue Book","keywords":["read","library","knowledge","learn","study"],"skins":[{"unified":"1f4d8","native":"📘"}],"version":1},"orange_book":{"id":"orange_book","name":"Orange Book","keywords":["read","library","knowledge","textbook","study"],"skins":[{"unified":"1f4d9","native":"📙"}],"version":1},"books":{"id":"books","name":"Books","keywords":["literature","library","study"],"skins":[{"unified":"1f4da","native":"📚"}],"version":1},"notebook":{"id":"notebook","name":"Notebook","keywords":["stationery","record","notes","paper","study"],"skins":[{"unified":"1f4d3","native":"📓"}],"version":1},"ledger":{"id":"ledger","name":"Ledger","keywords":["notes","paper"],"skins":[{"unified":"1f4d2","native":"📒"}],"version":1},"page_with_curl":{"id":"page_with_curl","name":"Page with Curl","keywords":["documents","office","paper"],"skins":[{"unified":"1f4c3","native":"📃"}],"version":1},"scroll":{"id":"scroll","name":"Scroll","keywords":["documents","ancient","history","paper"],"skins":[{"unified":"1f4dc","native":"📜"}],"version":1},"page_facing_up":{"id":"page_facing_up","name":"Page Facing Up","keywords":["documents","office","paper","information"],"skins":[{"unified":"1f4c4","native":"📄"}],"version":1},"newspaper":{"id":"newspaper","name":"Newspaper","keywords":["press","headline"],"skins":[{"unified":"1f4f0","native":"📰"}],"version":1},"rolled_up_newspaper":{"id":"rolled_up_newspaper","name":"Rolled-Up Newspaper","keywords":["rolled","up","press","headline"],"skins":[{"unified":"1f5de-fe0f","native":"🗞️"}],"version":1},"bookmark_tabs":{"id":"bookmark_tabs","name":"Bookmark Tabs","keywords":["favorite","save","order","tidy"],"skins":[{"unified":"1f4d1","native":"📑"}],"version":1},"bookmark":{"id":"bookmark","name":"Bookmark","keywords":["favorite","label","save"],"skins":[{"unified":"1f516","native":"🔖"}],"version":1},"label":{"id":"label","name":"Label","keywords":["sale","tag"],"skins":[{"unified":"1f3f7-fe0f","native":"🏷️"}],"version":1},"moneybag":{"id":"moneybag","name":"Money Bag","keywords":["moneybag","dollar","payment","coins","sale"],"skins":[{"unified":"1f4b0","native":"💰"}],"version":1},"coin":{"id":"coin","name":"Coin","keywords":["money","currency"],"skins":[{"unified":"1fa99","native":"🪙"}],"version":13},"yen":{"id":"yen","name":"Yen Banknote","keywords":["money","sales","japanese","dollar","currency"],"skins":[{"unified":"1f4b4","native":"💴"}],"version":1},"dollar":{"id":"dollar","name":"Dollar Banknote","keywords":["money","sales","bill","currency"],"skins":[{"unified":"1f4b5","native":"💵"}],"version":1},"euro":{"id":"euro","name":"Euro Banknote","keywords":["money","sales","dollar","currency"],"skins":[{"unified":"1f4b6","native":"💶"}],"version":1},"pound":{"id":"pound","name":"Pound Banknote","keywords":["british","sterling","money","sales","bills","uk","england","currency"],"skins":[{"unified":"1f4b7","native":"💷"}],"version":1},"money_with_wings":{"id":"money_with_wings","name":"Money with Wings","keywords":["dollar","bills","payment","sale"],"skins":[{"unified":"1f4b8","native":"💸"}],"version":1},"credit_card":{"id":"credit_card","name":"Credit Card","keywords":["money","sales","dollar","bill","payment","shopping"],"skins":[{"unified":"1f4b3","native":"💳"}],"version":1},"receipt":{"id":"receipt","name":"Receipt","keywords":["accounting","expenses"],"skins":[{"unified":"1f9fe","native":"🧾"}],"version":11},"chart":{"id":"chart","name":"Chart Increasing with Yen","keywords":["green","square","graph","presentation","stats"],"skins":[{"unified":"1f4b9","native":"💹"}],"version":1},"email":{"id":"email","name":"Envelope","keywords":["email","letter","postal","inbox","communication"],"skins":[{"unified":"2709-fe0f","native":"✉️"}],"version":1},"e-mail":{"id":"e-mail","name":"E-Mail","keywords":["e","mail","communication","inbox"],"skins":[{"unified":"1f4e7","native":"📧"}],"version":1},"incoming_envelope":{"id":"incoming_envelope","name":"Incoming Envelope","keywords":["email","inbox"],"skins":[{"unified":"1f4e8","native":"📨"}],"version":1},"envelope_with_arrow":{"id":"envelope_with_arrow","name":"Envelope with Arrow","keywords":["email","communication"],"skins":[{"unified":"1f4e9","native":"📩"}],"version":1},"outbox_tray":{"id":"outbox_tray","name":"Outbox Tray","keywords":["inbox","email"],"skins":[{"unified":"1f4e4","native":"📤"}],"version":1},"inbox_tray":{"id":"inbox_tray","name":"Inbox Tray","keywords":["email","documents"],"skins":[{"unified":"1f4e5","native":"📥"}],"version":1},"package":{"id":"package","name":"Package","keywords":["mail","gift","cardboard","box","moving"],"skins":[{"unified":"1f4e6","native":"📦"}],"version":1},"mailbox":{"id":"mailbox","name":"Closed Mailbox with Raised Flag","keywords":["email","inbox","communication"],"skins":[{"unified":"1f4eb","native":"📫"}],"version":1},"mailbox_closed":{"id":"mailbox_closed","name":"Closed Mailbox with Lowered Flag","keywords":["email","communication","inbox"],"skins":[{"unified":"1f4ea","native":"📪"}],"version":1},"mailbox_with_mail":{"id":"mailbox_with_mail","name":"Open Mailbox with Raised Flag","keywords":["mail","email","inbox","communication"],"skins":[{"unified":"1f4ec","native":"📬"}],"version":1},"mailbox_with_no_mail":{"id":"mailbox_with_no_mail","name":"Open Mailbox with Lowered Flag","keywords":["no","mail","email","inbox"],"skins":[{"unified":"1f4ed","native":"📭"}],"version":1},"postbox":{"id":"postbox","name":"Postbox","keywords":["email","letter","envelope"],"skins":[{"unified":"1f4ee","native":"📮"}],"version":1},"ballot_box_with_ballot":{"id":"ballot_box_with_ballot","name":"Ballot Box with Ballot","keywords":["election","vote"],"skins":[{"unified":"1f5f3-fe0f","native":"🗳️"}],"version":1},"pencil2":{"id":"pencil2","name":"Pencil","keywords":["pencil2","stationery","write","paper","writing","school","study"],"skins":[{"unified":"270f-fe0f","native":"✏️"}],"version":1},"black_nib":{"id":"black_nib","name":"Black Nib","keywords":["pen","stationery","writing","write"],"skins":[{"unified":"2712-fe0f","native":"✒️"}],"version":1},"lower_left_fountain_pen":{"id":"lower_left_fountain_pen","name":"Fountain Pen","keywords":["lower","left","stationery","writing","write"],"skins":[{"unified":"1f58b-fe0f","native":"🖋️"}],"version":1},"lower_left_ballpoint_pen":{"id":"lower_left_ballpoint_pen","name":"Pen","keywords":["lower","left","ballpoint","stationery","writing","write"],"skins":[{"unified":"1f58a-fe0f","native":"🖊️"}],"version":1},"lower_left_paintbrush":{"id":"lower_left_paintbrush","name":"Paintbrush","keywords":["lower","left","drawing","creativity","art"],"skins":[{"unified":"1f58c-fe0f","native":"🖌️"}],"version":1},"lower_left_crayon":{"id":"lower_left_crayon","name":"Crayon","keywords":["lower","left","drawing","creativity"],"skins":[{"unified":"1f58d-fe0f","native":"🖍️"}],"version":1},"memo":{"id":"memo","name":"Memo","keywords":["pencil","write","documents","stationery","paper","writing","legal","exam","quiz","test","study","compose"],"skins":[{"unified":"1f4dd","native":"📝"}],"version":1},"briefcase":{"id":"briefcase","name":"Briefcase","keywords":["business","documents","work","law","legal","job","career"],"skins":[{"unified":"1f4bc","native":"💼"}],"version":1},"file_folder":{"id":"file_folder","name":"File Folder","keywords":["documents","business","office"],"skins":[{"unified":"1f4c1","native":"📁"}],"version":1},"open_file_folder":{"id":"open_file_folder","name":"Open File Folder","keywords":["documents","load"],"skins":[{"unified":"1f4c2","native":"📂"}],"version":1},"card_index_dividers":{"id":"card_index_dividers","name":"Card Index Dividers","keywords":["organizing","business","stationery"],"skins":[{"unified":"1f5c2-fe0f","native":"🗂️"}],"version":1},"date":{"id":"date","name":"Calendar","keywords":["date","schedule"],"skins":[{"unified":"1f4c5","native":"📅"}],"version":1},"calendar":{"id":"calendar","name":"Tear-off Calendar","keywords":["tear","off","schedule","date","planning"],"skins":[{"unified":"1f4c6","native":"📆"}],"version":1},"spiral_note_pad":{"id":"spiral_note_pad","name":"Spiral Notepad","keywords":["note","pad","memo","stationery"],"skins":[{"unified":"1f5d2-fe0f","native":"🗒️"}],"version":1},"spiral_calendar_pad":{"id":"spiral_calendar_pad","name":"Spiral Calendar","keywords":["pad","date","schedule","planning"],"skins":[{"unified":"1f5d3-fe0f","native":"🗓️"}],"version":1},"card_index":{"id":"card_index","name":"Card Index","keywords":["business","stationery"],"skins":[{"unified":"1f4c7","native":"📇"}],"version":1},"chart_with_upwards_trend":{"id":"chart_with_upwards_trend","name":"Chart Increasing","keywords":["with","upwards","trend","graph","presentation","stats","recovery","business","economics","money","sales","good","success"],"skins":[{"unified":"1f4c8","native":"📈"}],"version":1},"chart_with_downwards_trend":{"id":"chart_with_downwards_trend","name":"Chart Decreasing","keywords":["with","downwards","trend","graph","presentation","stats","recession","business","economics","money","sales","bad","failure"],"skins":[{"unified":"1f4c9","native":"📉"}],"version":1},"bar_chart":{"id":"bar_chart","name":"Bar Chart","keywords":["graph","presentation","stats"],"skins":[{"unified":"1f4ca","native":"📊"}],"version":1},"clipboard":{"id":"clipboard","name":"Clipboard","keywords":["stationery","documents"],"skins":[{"unified":"1f4cb","native":"📋"}],"version":1},"pushpin":{"id":"pushpin","name":"Pushpin","keywords":["stationery","mark","here"],"skins":[{"unified":"1f4cc","native":"📌"}],"version":1},"round_pushpin":{"id":"round_pushpin","name":"Round Pushpin","keywords":["stationery","location","map","here"],"skins":[{"unified":"1f4cd","native":"📍"}],"version":1},"paperclip":{"id":"paperclip","name":"Paperclip","keywords":["documents","stationery"],"skins":[{"unified":"1f4ce","native":"📎"}],"version":1},"linked_paperclips":{"id":"linked_paperclips","name":"Linked Paperclips","keywords":["documents","stationery"],"skins":[{"unified":"1f587-fe0f","native":"🖇️"}],"version":1},"straight_ruler":{"id":"straight_ruler","name":"Straight Ruler","keywords":["stationery","calculate","length","math","school","drawing","architect","sketch"],"skins":[{"unified":"1f4cf","native":"📏"}],"version":1},"triangular_ruler":{"id":"triangular_ruler","name":"Triangular Ruler","keywords":["stationery","math","architect","sketch"],"skins":[{"unified":"1f4d0","native":"📐"}],"version":1},"scissors":{"id":"scissors","name":"Scissors","keywords":["stationery","cut"],"skins":[{"unified":"2702-fe0f","native":"✂️"}],"version":1},"card_file_box":{"id":"card_file_box","name":"Card File Box","keywords":["business","stationery"],"skins":[{"unified":"1f5c3-fe0f","native":"🗃️"}],"version":1},"file_cabinet":{"id":"file_cabinet","name":"File Cabinet","keywords":["filing","organizing"],"skins":[{"unified":"1f5c4-fe0f","native":"🗄️"}],"version":1},"wastebasket":{"id":"wastebasket","name":"Wastebasket","keywords":["bin","trash","rubbish","garbage","toss"],"skins":[{"unified":"1f5d1-fe0f","native":"🗑️"}],"version":1},"lock":{"id":"lock","name":"Lock","keywords":["locked","security","password","padlock"],"skins":[{"unified":"1f512","native":"🔒"}],"version":1},"unlock":{"id":"unlock","name":"Unlocked","keywords":["unlock","privacy","security"],"skins":[{"unified":"1f513","native":"🔓"}],"version":1},"lock_with_ink_pen":{"id":"lock_with_ink_pen","name":"Locked with Pen","keywords":["lock","ink","security","secret"],"skins":[{"unified":"1f50f","native":"🔏"}],"version":1},"closed_lock_with_key":{"id":"closed_lock_with_key","name":"Locked with Key","keywords":["closed","lock","security","privacy"],"skins":[{"unified":"1f510","native":"🔐"}],"version":1},"key":{"id":"key","name":"Key","keywords":["lock","door","password"],"skins":[{"unified":"1f511","native":"🔑"}],"version":1},"old_key":{"id":"old_key","name":"Old Key","keywords":["lock","door","password"],"skins":[{"unified":"1f5dd-fe0f","native":"🗝️"}],"version":1},"hammer":{"id":"hammer","name":"Hammer","keywords":["tools","build","create"],"skins":[{"unified":"1f528","native":"🔨"}],"version":1},"axe":{"id":"axe","name":"Axe","keywords":["tool","chop","cut"],"skins":[{"unified":"1fa93","native":"🪓"}],"version":12},"pick":{"id":"pick","name":"Pick","keywords":["tools","dig"],"skins":[{"unified":"26cf-fe0f","native":"⛏️"}],"version":1},"hammer_and_pick":{"id":"hammer_and_pick","name":"Hammer and Pick","keywords":["tools","build","create"],"skins":[{"unified":"2692-fe0f","native":"⚒️"}],"version":1},"hammer_and_wrench":{"id":"hammer_and_wrench","name":"Hammer and Wrench","keywords":["tools","build","create"],"skins":[{"unified":"1f6e0-fe0f","native":"🛠️"}],"version":1},"dagger_knife":{"id":"dagger_knife","name":"Dagger","keywords":["knife","weapon"],"skins":[{"unified":"1f5e1-fe0f","native":"🗡️"}],"version":1},"crossed_swords":{"id":"crossed_swords","name":"Crossed Swords","keywords":["weapon"],"skins":[{"unified":"2694-fe0f","native":"⚔️"}],"version":1},"bomb":{"id":"bomb","name":"Bomb","keywords":["boom","explode","explosion","terrorism"],"skins":[{"unified":"1f4a3","native":"💣"}],"version":1},"boomerang":{"id":"boomerang","name":"Boomerang","keywords":["weapon"],"skins":[{"unified":"1fa83","native":"🪃"}],"version":13},"bow_and_arrow":{"id":"bow_and_arrow","name":"Bow and Arrow","keywords":["sports"],"skins":[{"unified":"1f3f9","native":"🏹"}],"version":1},"shield":{"id":"shield","name":"Shield","keywords":["protection","security"],"skins":[{"unified":"1f6e1-fe0f","native":"🛡️"}],"version":1},"carpentry_saw":{"id":"carpentry_saw","name":"Carpentry Saw","keywords":["cut","chop"],"skins":[{"unified":"1fa9a","native":"🪚"}],"version":13},"wrench":{"id":"wrench","name":"Wrench","keywords":["tools","diy","ikea","fix","maintainer"],"skins":[{"unified":"1f527","native":"🔧"}],"version":1},"screwdriver":{"id":"screwdriver","name":"Screwdriver","keywords":["tools"],"skins":[{"unified":"1fa9b","native":"🪛"}],"version":13},"nut_and_bolt":{"id":"nut_and_bolt","name":"Nut and Bolt","keywords":["handy","tools","fix"],"skins":[{"unified":"1f529","native":"🔩"}],"version":1},"gear":{"id":"gear","name":"Gear","keywords":["cog"],"skins":[{"unified":"2699-fe0f","native":"⚙️"}],"version":1},"compression":{"id":"compression","name":"Clamp","keywords":["compression","tool"],"skins":[{"unified":"1f5dc-fe0f","native":"🗜️"}],"version":1},"scales":{"id":"scales","name":"Balance Scale","keywords":["scales","law","fairness","weight"],"skins":[{"unified":"2696-fe0f","native":"⚖️"}],"version":1},"probing_cane":{"id":"probing_cane","name":"White Cane","keywords":["probing","accessibility"],"skins":[{"unified":"1f9af","native":"🦯"}],"version":12},"link":{"id":"link","name":"Link","keywords":["rings","url"],"skins":[{"unified":"1f517","native":"🔗"}],"version":1},"chains":{"id":"chains","name":"Chains","keywords":["lock","arrest"],"skins":[{"unified":"26d3-fe0f","native":"⛓️"}],"version":1},"hook":{"id":"hook","name":"Hook","keywords":["tools"],"skins":[{"unified":"1fa9d","native":"🪝"}],"version":13},"toolbox":{"id":"toolbox","name":"Toolbox","keywords":["tools","diy","fix","maintainer","mechanic"],"skins":[{"unified":"1f9f0","native":"🧰"}],"version":11},"magnet":{"id":"magnet","name":"Magnet","keywords":["attraction","magnetic"],"skins":[{"unified":"1f9f2","native":"🧲"}],"version":11},"ladder":{"id":"ladder","name":"Ladder","keywords":["tools"],"skins":[{"unified":"1fa9c","native":"🪜"}],"version":13},"alembic":{"id":"alembic","name":"Alembic","keywords":["distilling","science","experiment","chemistry"],"skins":[{"unified":"2697-fe0f","native":"⚗️"}],"version":1},"test_tube":{"id":"test_tube","name":"Test Tube","keywords":["chemistry","experiment","lab","science"],"skins":[{"unified":"1f9ea","native":"🧪"}],"version":11},"petri_dish":{"id":"petri_dish","name":"Petri Dish","keywords":["bacteria","biology","culture","lab"],"skins":[{"unified":"1f9eb","native":"🧫"}],"version":11},"dna":{"id":"dna","name":"Dna","keywords":["biologist","genetics","life"],"skins":[{"unified":"1f9ec","native":"🧬"}],"version":11},"microscope":{"id":"microscope","name":"Microscope","keywords":["laboratory","experiment","zoomin","science","study"],"skins":[{"unified":"1f52c","native":"🔬"}],"version":1},"telescope":{"id":"telescope","name":"Telescope","keywords":["stars","space","zoom","science","astronomy"],"skins":[{"unified":"1f52d","native":"🔭"}],"version":1},"satellite_antenna":{"id":"satellite_antenna","name":"Satellite Antenna","keywords":["communication","future","radio","space"],"skins":[{"unified":"1f4e1","native":"📡"}],"version":1},"syringe":{"id":"syringe","name":"Syringe","keywords":["health","hospital","drugs","blood","medicine","needle","doctor","nurse"],"skins":[{"unified":"1f489","native":"💉"}],"version":1},"drop_of_blood":{"id":"drop_of_blood","name":"Drop of Blood","keywords":["period","hurt","harm","wound"],"skins":[{"unified":"1fa78","native":"🩸"}],"version":12},"pill":{"id":"pill","name":"Pill","keywords":["health","medicine","doctor","pharmacy","drug"],"skins":[{"unified":"1f48a","native":"💊"}],"version":1},"adhesive_bandage":{"id":"adhesive_bandage","name":"Adhesive Bandage","keywords":["heal"],"skins":[{"unified":"1fa79","native":"🩹"}],"version":12},"crutch":{"id":"crutch","name":"Crutch","keywords":["accessibility","assist"],"skins":[{"unified":"1fa7c","native":"🩼"}],"version":14},"stethoscope":{"id":"stethoscope","name":"Stethoscope","keywords":["health"],"skins":[{"unified":"1fa7a","native":"🩺"}],"version":12},"x-ray":{"id":"x-ray","name":"X-Ray","keywords":["x","ray","skeleton","medicine"],"skins":[{"unified":"1fa7b","native":"🩻"}],"version":14},"door":{"id":"door","name":"Door","keywords":["house","entry","exit"],"skins":[{"unified":"1f6aa","native":"🚪"}],"version":1},"elevator":{"id":"elevator","name":"Elevator","keywords":["lift"],"skins":[{"unified":"1f6d7","native":"🛗"}],"version":13},"mirror":{"id":"mirror","name":"Mirror","keywords":["reflection"],"skins":[{"unified":"1fa9e","native":"🪞"}],"version":13},"window":{"id":"window","name":"Window","keywords":["scenery"],"skins":[{"unified":"1fa9f","native":"🪟"}],"version":13},"bed":{"id":"bed","name":"Bed","keywords":["sleep","rest"],"skins":[{"unified":"1f6cf-fe0f","native":"🛏️"}],"version":1},"couch_and_lamp":{"id":"couch_and_lamp","name":"Couch and Lamp","keywords":["read","chill"],"skins":[{"unified":"1f6cb-fe0f","native":"🛋️"}],"version":1},"chair":{"id":"chair","name":"Chair","keywords":["sit","furniture"],"skins":[{"unified":"1fa91","native":"🪑"}],"version":12},"toilet":{"id":"toilet","name":"Toilet","keywords":["restroom","wc","washroom","bathroom","potty"],"skins":[{"unified":"1f6bd","native":"🚽"}],"version":1},"plunger":{"id":"plunger","name":"Plunger","keywords":["toilet"],"skins":[{"unified":"1faa0","native":"🪠"}],"version":13},"shower":{"id":"shower","name":"Shower","keywords":["clean","water","bathroom"],"skins":[{"unified":"1f6bf","native":"🚿"}],"version":1},"bathtub":{"id":"bathtub","name":"Bathtub","keywords":["clean","shower","bathroom"],"skins":[{"unified":"1f6c1","native":"🛁"}],"version":1},"mouse_trap":{"id":"mouse_trap","name":"Mouse Trap","keywords":["cheese"],"skins":[{"unified":"1faa4","native":"🪤"}],"version":13},"razor":{"id":"razor","name":"Razor","keywords":["cut"],"skins":[{"unified":"1fa92","native":"🪒"}],"version":12},"lotion_bottle":{"id":"lotion_bottle","name":"Lotion Bottle","keywords":["moisturizer","sunscreen"],"skins":[{"unified":"1f9f4","native":"🧴"}],"version":11},"safety_pin":{"id":"safety_pin","name":"Safety Pin","keywords":["diaper"],"skins":[{"unified":"1f9f7","native":"🧷"}],"version":11},"broom":{"id":"broom","name":"Broom","keywords":["cleaning","sweeping","witch"],"skins":[{"unified":"1f9f9","native":"🧹"}],"version":11},"basket":{"id":"basket","name":"Basket","keywords":["laundry"],"skins":[{"unified":"1f9fa","native":"🧺"}],"version":11},"roll_of_paper":{"id":"roll_of_paper","name":"Roll of Paper","keywords":[],"skins":[{"unified":"1f9fb","native":"🧻"}],"version":11},"bucket":{"id":"bucket","name":"Bucket","keywords":["water","container"],"skins":[{"unified":"1faa3","native":"🪣"}],"version":13},"soap":{"id":"soap","name":"Soap","keywords":["bar","bathing","cleaning","lather"],"skins":[{"unified":"1f9fc","native":"🧼"}],"version":11},"bubbles":{"id":"bubbles","name":"Bubbles","keywords":["soap","fun","carbonation","sparkling"],"skins":[{"unified":"1fae7","native":"🫧"}],"version":14},"toothbrush":{"id":"toothbrush","name":"Toothbrush","keywords":["hygiene","dental"],"skins":[{"unified":"1faa5","native":"🪥"}],"version":13},"sponge":{"id":"sponge","name":"Sponge","keywords":["absorbing","cleaning","porous"],"skins":[{"unified":"1f9fd","native":"🧽"}],"version":11},"fire_extinguisher":{"id":"fire_extinguisher","name":"Fire Extinguisher","keywords":["quench"],"skins":[{"unified":"1f9ef","native":"🧯"}],"version":11},"shopping_trolley":{"id":"shopping_trolley","name":"Shopping Cart","keywords":["trolley"],"skins":[{"unified":"1f6d2","native":"🛒"}],"version":3},"smoking":{"id":"smoking","name":"Cigarette","keywords":["smoking","kills","tobacco","joint","smoke"],"skins":[{"unified":"1f6ac","native":"🚬"}],"version":1},"coffin":{"id":"coffin","name":"Coffin","keywords":["vampire","dead","die","death","rip","graveyard","cemetery","casket","funeral","box"],"skins":[{"unified":"26b0-fe0f","native":"⚰️"}],"version":1},"headstone":{"id":"headstone","name":"Headstone","keywords":["death","rip","grave"],"skins":[{"unified":"1faa6","native":"🪦"}],"version":13},"funeral_urn":{"id":"funeral_urn","name":"Funeral Urn","keywords":["dead","die","death","rip","ashes"],"skins":[{"unified":"26b1-fe0f","native":"⚱️"}],"version":1},"nazar_amulet":{"id":"nazar_amulet","name":"Nazar Amulet","keywords":["bead","charm"],"skins":[{"unified":"1f9ff","native":"🧿"}],"version":11},"hamsa":{"id":"hamsa","name":"Hamsa","keywords":["religion","protection"],"skins":[{"unified":"1faac","native":"🪬"}],"version":14},"moyai":{"id":"moyai","name":"Moai","keywords":["moyai","rock","easter","island"],"skins":[{"unified":"1f5ff","native":"🗿"}],"version":1},"placard":{"id":"placard","name":"Placard","keywords":["announcement"],"skins":[{"unified":"1faa7","native":"🪧"}],"version":13},"identification_card":{"id":"identification_card","name":"Identification Card","keywords":["document"],"skins":[{"unified":"1faaa","native":"🪪"}],"version":14},"atm":{"id":"atm","name":"Atm Sign","keywords":["money","sales","cash","blue","square","payment","bank"],"skins":[{"unified":"1f3e7","native":"🏧"}],"version":1},"put_litter_in_its_place":{"id":"put_litter_in_its_place","name":"Litter in Bin Sign","keywords":["put","its","place","blue","square","human","info"],"skins":[{"unified":"1f6ae","native":"🚮"}],"version":1},"potable_water":{"id":"potable_water","name":"Potable Water","keywords":["blue","square","liquid","restroom","cleaning","faucet"],"skins":[{"unified":"1f6b0","native":"🚰"}],"version":1},"wheelchair":{"id":"wheelchair","name":"Wheelchair Symbol","keywords":["blue","square","disabled","accessibility"],"skins":[{"unified":"267f","native":"♿"}],"version":1},"mens":{"id":"mens","name":"Men’s Room","keywords":["mens","men","s","toilet","restroom","wc","blue","square","gender","male"],"skins":[{"unified":"1f6b9","native":"🚹"}],"version":1},"womens":{"id":"womens","name":"Women’s Room","keywords":["womens","women","s","purple","square","woman","female","toilet","loo","restroom","gender"],"skins":[{"unified":"1f6ba","native":"🚺"}],"version":1},"restroom":{"id":"restroom","name":"Restroom","keywords":["blue","square","toilet","refresh","wc","gender"],"skins":[{"unified":"1f6bb","native":"🚻"}],"version":1},"baby_symbol":{"id":"baby_symbol","name":"Baby Symbol","keywords":["orange","square","child"],"skins":[{"unified":"1f6bc","native":"🚼"}],"version":1},"wc":{"id":"wc","name":"Water Closet","keywords":["wc","toilet","restroom","blue","square"],"skins":[{"unified":"1f6be","native":"🚾"}],"version":1},"passport_control":{"id":"passport_control","name":"Passport Control","keywords":["custom","blue","square"],"skins":[{"unified":"1f6c2","native":"🛂"}],"version":1},"customs":{"id":"customs","name":"Customs","keywords":["passport","border","blue","square"],"skins":[{"unified":"1f6c3","native":"🛃"}],"version":1},"baggage_claim":{"id":"baggage_claim","name":"Baggage Claim","keywords":["blue","square","airport","transport"],"skins":[{"unified":"1f6c4","native":"🛄"}],"version":1},"left_luggage":{"id":"left_luggage","name":"Left Luggage","keywords":["blue","square","travel"],"skins":[{"unified":"1f6c5","native":"🛅"}],"version":1},"warning":{"id":"warning","name":"Warning","keywords":["exclamation","wip","alert","error","problem","issue"],"skins":[{"unified":"26a0-fe0f","native":"⚠️"}],"version":1},"children_crossing":{"id":"children_crossing","name":"Children Crossing","keywords":["school","warning","danger","sign","driving","yellow","diamond"],"skins":[{"unified":"1f6b8","native":"🚸"}],"version":1},"no_entry":{"id":"no_entry","name":"No Entry","keywords":["limit","security","privacy","bad","denied","stop","circle"],"skins":[{"unified":"26d4","native":"⛔"}],"version":1},"no_entry_sign":{"id":"no_entry_sign","name":"Prohibited","keywords":["no","entry","sign","forbid","stop","limit","denied","disallow","circle"],"skins":[{"unified":"1f6ab","native":"🚫"}],"version":1},"no_bicycles":{"id":"no_bicycles","name":"No Bicycles","keywords":["cyclist","prohibited","circle"],"skins":[{"unified":"1f6b3","native":"🚳"}],"version":1},"no_smoking":{"id":"no_smoking","name":"No Smoking","keywords":["cigarette","blue","square","smell","smoke"],"skins":[{"unified":"1f6ad","native":"🚭"}],"version":1},"do_not_litter":{"id":"do_not_litter","name":"No Littering","keywords":["do","not","litter","trash","bin","garbage","circle"],"skins":[{"unified":"1f6af","native":"🚯"}],"version":1},"non-potable_water":{"id":"non-potable_water","name":"Non-Potable Water","keywords":["non","potable","drink","faucet","tap","circle"],"skins":[{"unified":"1f6b1","native":"🚱"}],"version":1},"no_pedestrians":{"id":"no_pedestrians","name":"No Pedestrians","keywords":["rules","crossing","walking","circle"],"skins":[{"unified":"1f6b7","native":"🚷"}],"version":1},"no_mobile_phones":{"id":"no_mobile_phones","name":"No Mobile Phones","keywords":["iphone","mute","circle"],"skins":[{"unified":"1f4f5","native":"📵"}],"version":1},"underage":{"id":"underage","name":"No One Under Eighteen","keywords":["underage","18","drink","pub","night","minor","circle"],"skins":[{"unified":"1f51e","native":"🔞"}],"version":1},"radioactive_sign":{"id":"radioactive_sign","name":"Radioactive","keywords":["sign","nuclear","danger"],"skins":[{"unified":"2622-fe0f","native":"☢️"}],"version":1},"biohazard_sign":{"id":"biohazard_sign","name":"Biohazard","keywords":["sign","danger"],"skins":[{"unified":"2623-fe0f","native":"☣️"}],"version":1},"arrow_up":{"id":"arrow_up","name":"Up Arrow","keywords":["blue","square","continue","top","direction"],"skins":[{"unified":"2b06-fe0f","native":"⬆️"}],"version":1},"arrow_upper_right":{"id":"arrow_upper_right","name":"Up-Right Arrow","keywords":["upper","right","up","blue","square","point","direction","diagonal","northeast"],"skins":[{"unified":"2197-fe0f","native":"↗️"}],"version":1},"arrow_right":{"id":"arrow_right","name":"Right Arrow","keywords":["blue","square","next"],"skins":[{"unified":"27a1-fe0f","native":"➡️"}],"version":1},"arrow_lower_right":{"id":"arrow_lower_right","name":"South East Arrow","keywords":["lower","right","down","blue","square","direction","diagonal","southeast"],"skins":[{"unified":"2198-fe0f","native":"↘️"}],"version":1},"arrow_down":{"id":"arrow_down","name":"Down Arrow","keywords":["blue","square","direction","bottom"],"skins":[{"unified":"2b07-fe0f","native":"⬇️"}],"version":1},"arrow_lower_left":{"id":"arrow_lower_left","name":"Down-Left Arrow","keywords":["lower","left","down","blue","square","direction","diagonal","southwest"],"skins":[{"unified":"2199-fe0f","native":"↙️"}],"version":1},"arrow_left":{"id":"arrow_left","name":"Left Arrow","keywords":["blue","square","previous","back"],"skins":[{"unified":"2b05-fe0f","native":"⬅️"}],"version":1},"arrow_upper_left":{"id":"arrow_upper_left","name":"Up-Left Arrow","keywords":["upper","left","up","blue","square","point","direction","diagonal","northwest"],"skins":[{"unified":"2196-fe0f","native":"↖️"}],"version":1},"arrow_up_down":{"id":"arrow_up_down","name":"Up Down Arrow","keywords":["blue","square","direction","way","vertical"],"skins":[{"unified":"2195-fe0f","native":"↕️"}],"version":1},"left_right_arrow":{"id":"left_right_arrow","name":"Left Right Arrow","keywords":["shape","direction","horizontal","sideways"],"skins":[{"unified":"2194-fe0f","native":"↔️"}],"version":1},"leftwards_arrow_with_hook":{"id":"leftwards_arrow_with_hook","name":"Right Arrow Curving Left","keywords":["leftwards","with","hook","back","return","blue","square","undo","enter"],"skins":[{"unified":"21a9-fe0f","native":"↩️"}],"version":1},"arrow_right_hook":{"id":"arrow_right_hook","name":"Left Arrow Curving Right","keywords":["hook","blue","square","return","rotate","direction"],"skins":[{"unified":"21aa-fe0f","native":"↪️"}],"version":1},"arrow_heading_up":{"id":"arrow_heading_up","name":"Right Arrow Curving Up","keywords":["heading","blue","square","direction","top"],"skins":[{"unified":"2934-fe0f","native":"⤴️"}],"version":1},"arrow_heading_down":{"id":"arrow_heading_down","name":"Right Arrow Curving Down","keywords":["heading","blue","square","direction","bottom"],"skins":[{"unified":"2935-fe0f","native":"⤵️"}],"version":1},"arrows_clockwise":{"id":"arrows_clockwise","name":"Clockwise Vertical Arrows","keywords":["sync","cycle","round","repeat"],"skins":[{"unified":"1f503","native":"🔃"}],"version":1},"arrows_counterclockwise":{"id":"arrows_counterclockwise","name":"Counterclockwise Arrows Button","keywords":["blue","square","sync","cycle"],"skins":[{"unified":"1f504","native":"🔄"}],"version":1},"back":{"id":"back","name":"Back Arrow","keywords":["words","return"],"skins":[{"unified":"1f519","native":"🔙"}],"version":1},"end":{"id":"end","name":"End Arrow","keywords":["words"],"skins":[{"unified":"1f51a","native":"🔚"}],"version":1},"on":{"id":"on","name":"On! Arrow","keywords":["on","words"],"skins":[{"unified":"1f51b","native":"🔛"}],"version":1},"soon":{"id":"soon","name":"Soon Arrow","keywords":["words"],"skins":[{"unified":"1f51c","native":"🔜"}],"version":1},"top":{"id":"top","name":"Top Arrow","keywords":["words","blue","square"],"skins":[{"unified":"1f51d","native":"🔝"}],"version":1},"place_of_worship":{"id":"place_of_worship","name":"Place of Worship","keywords":["religion","church","temple","prayer"],"skins":[{"unified":"1f6d0","native":"🛐"}],"version":1},"atom_symbol":{"id":"atom_symbol","name":"Atom Symbol","keywords":["science","physics","chemistry"],"skins":[{"unified":"269b-fe0f","native":"⚛️"}],"version":1},"om_symbol":{"id":"om_symbol","name":"Om","keywords":["symbol","hinduism","buddhism","sikhism","jainism"],"skins":[{"unified":"1f549-fe0f","native":"🕉️"}],"version":1},"star_of_david":{"id":"star_of_david","name":"Star of David","keywords":["judaism"],"skins":[{"unified":"2721-fe0f","native":"✡️"}],"version":1},"wheel_of_dharma":{"id":"wheel_of_dharma","name":"Wheel of Dharma","keywords":["hinduism","buddhism","sikhism","jainism"],"skins":[{"unified":"2638-fe0f","native":"☸️"}],"version":1},"yin_yang":{"id":"yin_yang","name":"Yin Yang","keywords":["balance"],"skins":[{"unified":"262f-fe0f","native":"☯️"}],"version":1},"latin_cross":{"id":"latin_cross","name":"Latin Cross","keywords":["christianity"],"skins":[{"unified":"271d-fe0f","native":"✝️"}],"version":1},"orthodox_cross":{"id":"orthodox_cross","name":"Orthodox Cross","keywords":["suppedaneum","religion"],"skins":[{"unified":"2626-fe0f","native":"☦️"}],"version":1},"star_and_crescent":{"id":"star_and_crescent","name":"Star and Crescent","keywords":["islam"],"skins":[{"unified":"262a-fe0f","native":"☪️"}],"version":1},"peace_symbol":{"id":"peace_symbol","name":"Peace Symbol","keywords":["hippie"],"skins":[{"unified":"262e-fe0f","native":"☮️"}],"version":1},"menorah_with_nine_branches":{"id":"menorah_with_nine_branches","name":"Menorah","keywords":["with","nine","branches","hanukkah","candles","jewish"],"skins":[{"unified":"1f54e","native":"🕎"}],"version":1},"six_pointed_star":{"id":"six_pointed_star","name":"Dotted Six-Pointed Star","keywords":["six","pointed","purple","square","religion","jewish","hexagram"],"skins":[{"unified":"1f52f","native":"🔯"}],"version":1},"khanda":{"id":"khanda","name":"Khanda","keywords":["Sikhism","religion"],"skins":[{"unified":"1faaf","native":"🪯"}],"version":15},"aries":{"id":"aries","name":"Aries","keywords":["sign","purple","square","zodiac","astrology"],"skins":[{"unified":"2648","native":"♈"}],"version":1},"taurus":{"id":"taurus","name":"Taurus","keywords":["purple","square","sign","zodiac","astrology"],"skins":[{"unified":"2649","native":"♉"}],"version":1},"gemini":{"id":"gemini","name":"Gemini","keywords":["sign","zodiac","purple","square","astrology"],"skins":[{"unified":"264a","native":"♊"}],"version":1},"cancer":{"id":"cancer","name":"Cancer","keywords":["sign","zodiac","purple","square","astrology"],"skins":[{"unified":"264b","native":"♋"}],"version":1},"leo":{"id":"leo","name":"Leo","keywords":["sign","purple","square","zodiac","astrology"],"skins":[{"unified":"264c","native":"♌"}],"version":1},"virgo":{"id":"virgo","name":"Virgo","keywords":["sign","zodiac","purple","square","astrology"],"skins":[{"unified":"264d","native":"♍"}],"version":1},"libra":{"id":"libra","name":"Libra","keywords":["sign","purple","square","zodiac","astrology"],"skins":[{"unified":"264e","native":"♎"}],"version":1},"scorpius":{"id":"scorpius","name":"Scorpio","keywords":["scorpius","sign","zodiac","purple","square","astrology"],"skins":[{"unified":"264f","native":"♏"}],"version":1},"sagittarius":{"id":"sagittarius","name":"Sagittarius","keywords":["sign","zodiac","purple","square","astrology"],"skins":[{"unified":"2650","native":"♐"}],"version":1},"capricorn":{"id":"capricorn","name":"Capricorn","keywords":["sign","zodiac","purple","square","astrology"],"skins":[{"unified":"2651","native":"♑"}],"version":1},"aquarius":{"id":"aquarius","name":"Aquarius","keywords":["sign","purple","square","zodiac","astrology"],"skins":[{"unified":"2652","native":"♒"}],"version":1},"pisces":{"id":"pisces","name":"Pisces","keywords":["purple","square","sign","zodiac","astrology"],"skins":[{"unified":"2653","native":"♓"}],"version":1},"ophiuchus":{"id":"ophiuchus","name":"Ophiuchus","keywords":["sign","purple","square","constellation","astrology"],"skins":[{"unified":"26ce","native":"⛎"}],"version":1},"twisted_rightwards_arrows":{"id":"twisted_rightwards_arrows","name":"Shuffle Tracks Button","keywords":["twisted","rightwards","arrows","blue","square","music","random"],"skins":[{"unified":"1f500","native":"🔀"}],"version":1},"repeat":{"id":"repeat","name":"Repeat Button","keywords":["loop","record"],"skins":[{"unified":"1f501","native":"🔁"}],"version":1},"repeat_one":{"id":"repeat_one","name":"Repeat Single Button","keywords":["one","blue","square","loop"],"skins":[{"unified":"1f502","native":"🔂"}],"version":1},"arrow_forward":{"id":"arrow_forward","name":"Play Button","keywords":["arrow","forward","blue","square","right","direction"],"skins":[{"unified":"25b6-fe0f","native":"▶️"}],"version":1},"fast_forward":{"id":"fast_forward","name":"Fast-Forward Button","keywords":["fast","forward","blue","square","play","speed","continue"],"skins":[{"unified":"23e9","native":"⏩"}],"version":1},"black_right_pointing_double_triangle_with_vertical_bar":{"id":"black_right_pointing_double_triangle_with_vertical_bar","name":"Next Track Button","keywords":["black","right","pointing","double","triangle","with","vertical","bar","forward","blue","square"],"skins":[{"unified":"23ed-fe0f","native":"⏭️"}],"version":1},"black_right_pointing_triangle_with_double_vertical_bar":{"id":"black_right_pointing_triangle_with_double_vertical_bar","name":"Play or Pause Button","keywords":["black","right","pointing","triangle","with","double","vertical","bar","blue","square"],"skins":[{"unified":"23ef-fe0f","native":"⏯️"}],"version":1},"arrow_backward":{"id":"arrow_backward","name":"Reverse Button","keywords":["arrow","backward","blue","square","left","direction"],"skins":[{"unified":"25c0-fe0f","native":"◀️"}],"version":1},"rewind":{"id":"rewind","name":"Fast Reverse Button","keywords":["rewind","play","blue","square"],"skins":[{"unified":"23ea","native":"⏪"}],"version":1},"black_left_pointing_double_triangle_with_vertical_bar":{"id":"black_left_pointing_double_triangle_with_vertical_bar","name":"Last Track Button","keywords":["black","left","pointing","double","triangle","with","vertical","bar","backward"],"skins":[{"unified":"23ee-fe0f","native":"⏮️"}],"version":1},"arrow_up_small":{"id":"arrow_up_small","name":"Upwards Button","keywords":["arrow","up","small","blue","square","triangle","direction","point","forward","top"],"skins":[{"unified":"1f53c","native":"🔼"}],"version":1},"arrow_double_up":{"id":"arrow_double_up","name":"Fast Up Button","keywords":["arrow","double","blue","square","direction","top"],"skins":[{"unified":"23eb","native":"⏫"}],"version":1},"arrow_down_small":{"id":"arrow_down_small","name":"Downwards Button","keywords":["arrow","down","small","blue","square","direction","bottom"],"skins":[{"unified":"1f53d","native":"🔽"}],"version":1},"arrow_double_down":{"id":"arrow_double_down","name":"Fast Down Button","keywords":["arrow","double","blue","square","direction","bottom"],"skins":[{"unified":"23ec","native":"⏬"}],"version":1},"double_vertical_bar":{"id":"double_vertical_bar","name":"Pause Button","keywords":["double","vertical","bar","blue","square"],"skins":[{"unified":"23f8-fe0f","native":"⏸️"}],"version":1},"black_square_for_stop":{"id":"black_square_for_stop","name":"Stop Button","keywords":["black","square","for","blue"],"skins":[{"unified":"23f9-fe0f","native":"⏹️"}],"version":1},"black_circle_for_record":{"id":"black_circle_for_record","name":"Record Button","keywords":["black","circle","for","blue","square"],"skins":[{"unified":"23fa-fe0f","native":"⏺️"}],"version":1},"eject":{"id":"eject","name":"Eject Button","keywords":["blue","square"],"skins":[{"unified":"23cf-fe0f","native":"⏏️"}],"version":1},"cinema":{"id":"cinema","name":"Cinema","keywords":["blue","square","record","film","movie","curtain","stage","theater"],"skins":[{"unified":"1f3a6","native":"🎦"}],"version":1},"low_brightness":{"id":"low_brightness","name":"Dim Button","keywords":["low","brightness","sun","afternoon","warm","summer"],"skins":[{"unified":"1f505","native":"🔅"}],"version":1},"high_brightness":{"id":"high_brightness","name":"Bright Button","keywords":["high","brightness","sun","light"],"skins":[{"unified":"1f506","native":"🔆"}],"version":1},"signal_strength":{"id":"signal_strength","name":"Antenna Bars","keywords":["signal","strength","blue","square","reception","phone","internet","connection","wifi","bluetooth"],"skins":[{"unified":"1f4f6","native":"📶"}],"version":1},"wireless":{"id":"wireless","name":"Wireless","keywords":["wifi","internet","contactless","signal"],"skins":[{"unified":"1f6dc","native":"🛜"}],"version":15},"vibration_mode":{"id":"vibration_mode","name":"Vibration Mode","keywords":["orange","square","phone"],"skins":[{"unified":"1f4f3","native":"📳"}],"version":1},"mobile_phone_off":{"id":"mobile_phone_off","name":"Mobile Phone off","keywords":["mute","orange","square","silence","quiet"],"skins":[{"unified":"1f4f4","native":"📴"}],"version":1},"female_sign":{"id":"female_sign","name":"Female Sign","keywords":["woman","women","lady","girl"],"skins":[{"unified":"2640-fe0f","native":"♀️"}],"version":4},"male_sign":{"id":"male_sign","name":"Male Sign","keywords":["man","boy","men"],"skins":[{"unified":"2642-fe0f","native":"♂️"}],"version":4},"transgender_symbol":{"id":"transgender_symbol","name":"Transgender Symbol","keywords":["lgbtq"],"skins":[{"unified":"26a7-fe0f","native":"⚧️"}],"version":13},"heavy_multiplication_x":{"id":"heavy_multiplication_x","name":"Multiply","keywords":["heavy","multiplication","x","sign","math","calculation"],"skins":[{"unified":"2716-fe0f","native":"✖️"}],"version":1},"heavy_plus_sign":{"id":"heavy_plus_sign","name":"Plus","keywords":["heavy","sign","math","calculation","addition","more","increase"],"skins":[{"unified":"2795","native":"➕"}],"version":1},"heavy_minus_sign":{"id":"heavy_minus_sign","name":"Minus","keywords":["heavy","sign","math","calculation","subtract","less"],"skins":[{"unified":"2796","native":"➖"}],"version":1},"heavy_division_sign":{"id":"heavy_division_sign","name":"Divide","keywords":["heavy","division","sign","math","calculation"],"skins":[{"unified":"2797","native":"➗"}],"version":1},"heavy_equals_sign":{"id":"heavy_equals_sign","name":"Heavy Equals Sign","keywords":["math"],"skins":[{"unified":"1f7f0","native":"🟰"}],"version":14},"infinity":{"id":"infinity","name":"Infinity","keywords":["forever"],"skins":[{"unified":"267e-fe0f","native":"♾️"}],"version":11},"bangbang":{"id":"bangbang","name":"Double Exclamation Mark","keywords":["bangbang","surprise"],"skins":[{"unified":"203c-fe0f","native":"‼️"}],"version":1},"interrobang":{"id":"interrobang","name":"Exclamation Question Mark","keywords":["interrobang","wat","punctuation","surprise"],"skins":[{"unified":"2049-fe0f","native":"⁉️"}],"version":1},"question":{"id":"question","name":"Red Question Mark","keywords":["doubt","confused"],"skins":[{"unified":"2753","native":"❓"}],"version":1},"grey_question":{"id":"grey_question","name":"White Question Mark","keywords":["grey","doubts","gray","huh","confused"],"skins":[{"unified":"2754","native":"❔"}],"version":1},"grey_exclamation":{"id":"grey_exclamation","name":"White Exclamation Mark","keywords":["grey","surprise","punctuation","gray","wow","warning"],"skins":[{"unified":"2755","native":"❕"}],"version":1},"exclamation":{"id":"exclamation","name":"Red Exclamation Mark","keywords":["heavy","danger","surprise","punctuation","wow","warning"],"skins":[{"unified":"2757","native":"❗"}],"version":1},"wavy_dash":{"id":"wavy_dash","name":"Wavy Dash","keywords":["draw","line","moustache","mustache","squiggle","scribble"],"skins":[{"unified":"3030-fe0f","native":"〰️"}],"version":1},"currency_exchange":{"id":"currency_exchange","name":"Currency Exchange","keywords":["money","sales","dollar","travel"],"skins":[{"unified":"1f4b1","native":"💱"}],"version":1},"heavy_dollar_sign":{"id":"heavy_dollar_sign","name":"Heavy Dollar Sign","keywords":["money","sales","payment","currency","buck"],"skins":[{"unified":"1f4b2","native":"💲"}],"version":1},"medical_symbol":{"id":"medical_symbol","name":"Medical Symbol","keywords":["staff","of","aesculapius","health","hospital"],"skins":[{"unified":"2695-fe0f","native":"⚕️"}],"version":4},"recycle":{"id":"recycle","name":"Recycling Symbol","keywords":["recycle","arrow","environment","garbage","trash"],"skins":[{"unified":"267b-fe0f","native":"♻️"}],"version":1},"fleur_de_lis":{"id":"fleur_de_lis","name":"Fleur-De-Lis","keywords":["fleur","de","lis","decorative","scout"],"skins":[{"unified":"269c-fe0f","native":"⚜️"}],"version":1},"trident":{"id":"trident","name":"Trident Emblem","keywords":["weapon","spear"],"skins":[{"unified":"1f531","native":"🔱"}],"version":1},"name_badge":{"id":"name_badge","name":"Name Badge","keywords":["fire","forbid"],"skins":[{"unified":"1f4db","native":"📛"}],"version":1},"beginner":{"id":"beginner","name":"Japanese Symbol for Beginner","keywords":["badge","shield"],"skins":[{"unified":"1f530","native":"🔰"}],"version":1},"o":{"id":"o","name":"Hollow Red Circle","keywords":["o","round"],"skins":[{"unified":"2b55","native":"⭕"}],"version":1},"white_check_mark":{"id":"white_check_mark","name":"Check Mark Button","keywords":["white","green","square","ok","agree","vote","election","answer","tick"],"skins":[{"unified":"2705","native":"✅"}],"version":1},"ballot_box_with_check":{"id":"ballot_box_with_check","name":"Check Box with Check","keywords":["ballot","ok","agree","confirm","black","square","vote","election","yes","tick"],"skins":[{"unified":"2611-fe0f","native":"☑️"}],"version":1},"heavy_check_mark":{"id":"heavy_check_mark","name":"Check Mark","keywords":["heavy","ok","nike","answer","yes","tick"],"skins":[{"unified":"2714-fe0f","native":"✔️"}],"version":1},"x":{"id":"x","name":"Cross Mark","keywords":["x","no","delete","remove","cancel","red"],"skins":[{"unified":"274c","native":"❌"}],"version":1},"negative_squared_cross_mark":{"id":"negative_squared_cross_mark","name":"Cross Mark Button","keywords":["negative","squared","x","green","square","no","deny"],"skins":[{"unified":"274e","native":"❎"}],"version":1},"curly_loop":{"id":"curly_loop","name":"Curly Loop","keywords":["scribble","draw","shape","squiggle"],"skins":[{"unified":"27b0","native":"➰"}],"version":1},"loop":{"id":"loop","name":"Double Curly Loop","keywords":["tape","cassette"],"skins":[{"unified":"27bf","native":"➿"}],"version":1},"part_alternation_mark":{"id":"part_alternation_mark","name":"Part Alternation Mark","keywords":["graph","presentation","stats","business","economics","bad"],"skins":[{"unified":"303d-fe0f","native":"〽️"}],"version":1},"eight_spoked_asterisk":{"id":"eight_spoked_asterisk","name":"Eight Spoked Asterisk","keywords":["star","sparkle","green","square"],"skins":[{"unified":"2733-fe0f","native":"✳️"}],"version":1},"eight_pointed_black_star":{"id":"eight_pointed_black_star","name":"Eight-Pointed Star","keywords":["eight","pointed","black","orange","square","shape","polygon"],"skins":[{"unified":"2734-fe0f","native":"✴️"}],"version":1},"sparkle":{"id":"sparkle","name":"Sparkle","keywords":["stars","green","square","awesome","good","fireworks"],"skins":[{"unified":"2747-fe0f","native":"❇️"}],"version":1},"copyright":{"id":"copyright","name":"Copyright","keywords":["ip","license","circle","law","legal"],"skins":[{"unified":"00a9-fe0f","native":"©️"}],"version":1},"registered":{"id":"registered","name":"Registered","keywords":["alphabet","circle"],"skins":[{"unified":"00ae-fe0f","native":"®️"}],"version":1},"tm":{"id":"tm","name":"Trade Mark","keywords":["tm","trademark","brand","law","legal"],"skins":[{"unified":"2122-fe0f","native":"™️"}],"version":1},"hash":{"id":"hash","name":"Hash Key","keywords":["keycap","","symbol","blue","square","twitter"],"skins":[{"unified":"0023-fe0f-20e3","native":"#️⃣"}],"version":1},"keycap_star":{"id":"keycap_star","name":"Keycap: *","keywords":["keycap","star",""],"skins":[{"unified":"002a-fe0f-20e3","native":"*️⃣"}],"version":2},"zero":{"id":"zero","name":"Keycap 0","keywords":["zero","numbers","blue","square","null"],"skins":[{"unified":"0030-fe0f-20e3","native":"0️⃣"}],"version":1},"one":{"id":"one","name":"Keycap 1","keywords":["one","blue","square","numbers"],"skins":[{"unified":"0031-fe0f-20e3","native":"1️⃣"}],"version":1},"two":{"id":"two","name":"Keycap 2","keywords":["two","numbers","prime","blue","square"],"skins":[{"unified":"0032-fe0f-20e3","native":"2️⃣"}],"version":1},"three":{"id":"three","name":"Keycap 3","keywords":["three","numbers","prime","blue","square"],"skins":[{"unified":"0033-fe0f-20e3","native":"3️⃣"}],"version":1},"four":{"id":"four","name":"Keycap 4","keywords":["four","numbers","blue","square"],"skins":[{"unified":"0034-fe0f-20e3","native":"4️⃣"}],"version":1},"five":{"id":"five","name":"Keycap 5","keywords":["five","numbers","blue","square","prime"],"skins":[{"unified":"0035-fe0f-20e3","native":"5️⃣"}],"version":1},"six":{"id":"six","name":"Keycap 6","keywords":["six","numbers","blue","square"],"skins":[{"unified":"0036-fe0f-20e3","native":"6️⃣"}],"version":1},"seven":{"id":"seven","name":"Keycap 7","keywords":["seven","numbers","blue","square","prime"],"skins":[{"unified":"0037-fe0f-20e3","native":"7️⃣"}],"version":1},"eight":{"id":"eight","name":"Keycap 8","keywords":["eight","blue","square","numbers"],"skins":[{"unified":"0038-fe0f-20e3","native":"8️⃣"}],"version":1},"nine":{"id":"nine","name":"Keycap 9","keywords":["nine","blue","square","numbers"],"skins":[{"unified":"0039-fe0f-20e3","native":"9️⃣"}],"version":1},"keycap_ten":{"id":"keycap_ten","name":"Keycap 10","keywords":["ten","numbers","blue","square"],"skins":[{"unified":"1f51f","native":"🔟"}],"version":1},"capital_abcd":{"id":"capital_abcd","name":"Input Latin Uppercase","keywords":["capital","abcd","alphabet","words","blue","square"],"skins":[{"unified":"1f520","native":"🔠"}],"version":1},"abcd":{"id":"abcd","name":"Input Latin Lowercase","keywords":["abcd","blue","square","alphabet"],"skins":[{"unified":"1f521","native":"🔡"}],"version":1},"symbols":{"id":"symbols","name":"Input Symbols","keywords":["blue","square","music","note","ampersand","percent","glyphs","characters"],"skins":[{"unified":"1f523","native":"🔣"}],"version":1},"abc":{"id":"abc","name":"Input Latin Letters","keywords":["abc","blue","square","alphabet"],"skins":[{"unified":"1f524","native":"🔤"}],"version":1},"a":{"id":"a","name":"A Button (blood Type)","keywords":["red","square","alphabet","letter"],"skins":[{"unified":"1f170-fe0f","native":"🅰️"}],"version":1},"ab":{"id":"ab","name":"Negative Squared Ab","keywords":["button","red","square","alphabet"],"skins":[{"unified":"1f18e","native":"🆎"}],"version":1},"b":{"id":"b","name":"B Button (blood Type)","keywords":["red","square","alphabet","letter"],"skins":[{"unified":"1f171-fe0f","native":"🅱️"}],"version":1},"cl":{"id":"cl","name":"Cl Button","keywords":["alphabet","words","red","square"],"skins":[{"unified":"1f191","native":"🆑"}],"version":1},"cool":{"id":"cool","name":"Cool Button","keywords":["words","blue","square"],"skins":[{"unified":"1f192","native":"🆒"}],"version":1},"free":{"id":"free","name":"Free Button","keywords":["blue","square","words"],"skins":[{"unified":"1f193","native":"🆓"}],"version":1},"information_source":{"id":"information_source","name":"Information","keywords":["source","blue","square","alphabet","letter"],"skins":[{"unified":"2139-fe0f","native":"ℹ️"}],"version":1},"id":{"id":"id","name":"Id Button","keywords":["purple","square","words"],"skins":[{"unified":"1f194","native":"🆔"}],"version":1},"m":{"id":"m","name":"Circled M","keywords":["alphabet","blue","circle","letter"],"skins":[{"unified":"24c2-fe0f","native":"Ⓜ️"}],"version":1},"new":{"id":"new","name":"New Button","keywords":["blue","square","words","start"],"skins":[{"unified":"1f195","native":"🆕"}],"version":1},"ng":{"id":"ng","name":"Ng Button","keywords":["blue","square","words","shape","icon"],"skins":[{"unified":"1f196","native":"🆖"}],"version":1},"o2":{"id":"o2","name":"O Button (blood Type)","keywords":["o2","alphabet","red","square","letter"],"skins":[{"unified":"1f17e-fe0f","native":"🅾️"}],"version":1},"ok":{"id":"ok","name":"Ok Button","keywords":["good","agree","yes","blue","square"],"skins":[{"unified":"1f197","native":"🆗"}],"version":1},"parking":{"id":"parking","name":"P Button","keywords":["parking","cars","blue","square","alphabet","letter"],"skins":[{"unified":"1f17f-fe0f","native":"🅿️"}],"version":1},"sos":{"id":"sos","name":"Sos Button","keywords":["help","red","square","words","emergency","911"],"skins":[{"unified":"1f198","native":"🆘"}],"version":1},"up":{"id":"up","name":"Up! Button","keywords":["up","blue","square","above","high"],"skins":[{"unified":"1f199","native":"🆙"}],"version":1},"vs":{"id":"vs","name":"Vs Button","keywords":["words","orange","square"],"skins":[{"unified":"1f19a","native":"🆚"}],"version":1},"koko":{"id":"koko","name":"Squared Katakana Koko","keywords":["japanese","here","button","blue","square","destination"],"skins":[{"unified":"1f201","native":"🈁"}],"version":1},"sa":{"id":"sa","name":"Squared Katakana Sa","keywords":["japanese","service","charge","button","blue","square"],"skins":[{"unified":"1f202-fe0f","native":"🈂️"}],"version":1},"u6708":{"id":"u6708","name":"Japanese “monthly Amount” Button","keywords":["u6708","monthly","amount","chinese","month","moon","orange","square","kanji"],"skins":[{"unified":"1f237-fe0f","native":"🈷️"}],"version":1},"u6709":{"id":"u6709","name":"Squared Cjk Unified Ideograph-6709","keywords":["u6709","japanese","not","free","of","charge","button","orange","square","chinese","have","kanji"],"skins":[{"unified":"1f236","native":"🈶"}],"version":1},"u6307":{"id":"u6307","name":"Japanese “reserved” Button","keywords":["u6307","reserved","chinese","point","green","square","kanji"],"skins":[{"unified":"1f22f","native":"🈯"}],"version":1},"ideograph_advantage":{"id":"ideograph_advantage","name":"Japanese “bargain” Button","keywords":["ideograph","advantage","bargain","chinese","kanji","obtain","get","circle"],"skins":[{"unified":"1f250","native":"🉐"}],"version":1},"u5272":{"id":"u5272","name":"Japanese “discount” Button","keywords":["u5272","discount","cut","divide","chinese","kanji","pink","square"],"skins":[{"unified":"1f239","native":"🈹"}],"version":1},"u7121":{"id":"u7121","name":"Japanese “free of Charge” Button","keywords":["u7121","free","charge","nothing","chinese","kanji","orange","square"],"skins":[{"unified":"1f21a","native":"🈚"}],"version":1},"u7981":{"id":"u7981","name":"Japanese “prohibited” Button","keywords":["u7981","prohibited","kanji","chinese","forbidden","limit","restricted","red","square"],"skins":[{"unified":"1f232","native":"🈲"}],"version":1},"accept":{"id":"accept","name":"Circled Ideograph Accept","keywords":["japanese","acceptable","button","ok","good","chinese","kanji","agree","yes","orange","circle"],"skins":[{"unified":"1f251","native":"🉑"}],"version":1},"u7533":{"id":"u7533","name":"Japanese “application” Button","keywords":["u7533","application","chinese","kanji","orange","square"],"skins":[{"unified":"1f238","native":"🈸"}],"version":1},"u5408":{"id":"u5408","name":"Japanese “passing Grade” Button","keywords":["u5408","passing","grade","chinese","join","kanji","red","square"],"skins":[{"unified":"1f234","native":"🈴"}],"version":1},"u7a7a":{"id":"u7a7a","name":"Japanese “vacancy” Button","keywords":["u7a7a","vacancy","kanji","chinese","empty","sky","blue","square"],"skins":[{"unified":"1f233","native":"🈳"}],"version":1},"congratulations":{"id":"congratulations","name":"Circled Ideograph Congratulation","keywords":["congratulations","japanese","button","chinese","kanji","red","circle"],"skins":[{"unified":"3297-fe0f","native":"㊗️"}],"version":1},"secret":{"id":"secret","name":"Circled Ideograph Secret","keywords":["japanese","button","privacy","chinese","sshh","kanji","red","circle"],"skins":[{"unified":"3299-fe0f","native":"㊙️"}],"version":1},"u55b6":{"id":"u55b6","name":"Squared Cjk Unified Ideograph-55b6","keywords":["u55b6","japanese","open","for","business","button","opening","hours","orange","square"],"skins":[{"unified":"1f23a","native":"🈺"}],"version":1},"u6e80":{"id":"u6e80","name":"Japanese “no Vacancy” Button","keywords":["u6e80","no","vacancy","full","chinese","red","square","kanji"],"skins":[{"unified":"1f235","native":"🈵"}],"version":1},"red_circle":{"id":"red_circle","name":"Red Circle","keywords":["shape","error","danger"],"skins":[{"unified":"1f534","native":"🔴"}],"version":1},"large_orange_circle":{"id":"large_orange_circle","name":"Orange Circle","keywords":["large","round"],"skins":[{"unified":"1f7e0","native":"🟠"}],"version":12},"large_yellow_circle":{"id":"large_yellow_circle","name":"Yellow Circle","keywords":["large","round"],"skins":[{"unified":"1f7e1","native":"🟡"}],"version":12},"large_green_circle":{"id":"large_green_circle","name":"Green Circle","keywords":["large","round"],"skins":[{"unified":"1f7e2","native":"🟢"}],"version":12},"large_blue_circle":{"id":"large_blue_circle","name":"Blue Circle","keywords":["large","shape","icon","button"],"skins":[{"unified":"1f535","native":"🔵"}],"version":1},"large_purple_circle":{"id":"large_purple_circle","name":"Purple Circle","keywords":["large","round"],"skins":[{"unified":"1f7e3","native":"🟣"}],"version":12},"large_brown_circle":{"id":"large_brown_circle","name":"Brown Circle","keywords":["large","round"],"skins":[{"unified":"1f7e4","native":"🟤"}],"version":12},"black_circle":{"id":"black_circle","name":"Black Circle","keywords":["shape","button","round"],"skins":[{"unified":"26ab","native":"⚫"}],"version":1},"white_circle":{"id":"white_circle","name":"White Circle","keywords":["shape","round"],"skins":[{"unified":"26aa","native":"⚪"}],"version":1},"large_red_square":{"id":"large_red_square","name":"Red Square","keywords":["large"],"skins":[{"unified":"1f7e5","native":"🟥"}],"version":12},"large_orange_square":{"id":"large_orange_square","name":"Orange Square","keywords":["large"],"skins":[{"unified":"1f7e7","native":"🟧"}],"version":12},"large_yellow_square":{"id":"large_yellow_square","name":"Yellow Square","keywords":["large"],"skins":[{"unified":"1f7e8","native":"🟨"}],"version":12},"large_green_square":{"id":"large_green_square","name":"Green Square","keywords":["large"],"skins":[{"unified":"1f7e9","native":"🟩"}],"version":12},"large_blue_square":{"id":"large_blue_square","name":"Blue Square","keywords":["large"],"skins":[{"unified":"1f7e6","native":"🟦"}],"version":12},"large_purple_square":{"id":"large_purple_square","name":"Purple Square","keywords":["large"],"skins":[{"unified":"1f7ea","native":"🟪"}],"version":12},"large_brown_square":{"id":"large_brown_square","name":"Brown Square","keywords":["large"],"skins":[{"unified":"1f7eb","native":"🟫"}],"version":12},"black_large_square":{"id":"black_large_square","name":"Black Large Square","keywords":["shape","icon","button"],"skins":[{"unified":"2b1b","native":"⬛"}],"version":1},"white_large_square":{"id":"white_large_square","name":"White Large Square","keywords":["shape","icon","stone","button"],"skins":[{"unified":"2b1c","native":"⬜"}],"version":1},"black_medium_square":{"id":"black_medium_square","name":"Black Medium Square","keywords":["shape","button","icon"],"skins":[{"unified":"25fc-fe0f","native":"◼️"}],"version":1},"white_medium_square":{"id":"white_medium_square","name":"White Medium Square","keywords":["shape","stone","icon"],"skins":[{"unified":"25fb-fe0f","native":"◻️"}],"version":1},"black_medium_small_square":{"id":"black_medium_small_square","name":"Black Medium Small Square","keywords":["icon","shape","button"],"skins":[{"unified":"25fe","native":"◾"}],"version":1},"white_medium_small_square":{"id":"white_medium_small_square","name":"White Medium Small Square","keywords":["shape","stone","icon","button"],"skins":[{"unified":"25fd","native":"◽"}],"version":1},"black_small_square":{"id":"black_small_square","name":"Black Small Square","keywords":["shape","icon"],"skins":[{"unified":"25aa-fe0f","native":"▪️"}],"version":1},"white_small_square":{"id":"white_small_square","name":"White Small Square","keywords":["shape","icon"],"skins":[{"unified":"25ab-fe0f","native":"▫️"}],"version":1},"large_orange_diamond":{"id":"large_orange_diamond","name":"Large Orange Diamond","keywords":["shape","jewel","gem"],"skins":[{"unified":"1f536","native":"🔶"}],"version":1},"large_blue_diamond":{"id":"large_blue_diamond","name":"Large Blue Diamond","keywords":["shape","jewel","gem"],"skins":[{"unified":"1f537","native":"🔷"}],"version":1},"small_orange_diamond":{"id":"small_orange_diamond","name":"Small Orange Diamond","keywords":["shape","jewel","gem"],"skins":[{"unified":"1f538","native":"🔸"}],"version":1},"small_blue_diamond":{"id":"small_blue_diamond","name":"Small Blue Diamond","keywords":["shape","jewel","gem"],"skins":[{"unified":"1f539","native":"🔹"}],"version":1},"small_red_triangle":{"id":"small_red_triangle","name":"Red Triangle Pointed Up","keywords":["small","shape","direction","top"],"skins":[{"unified":"1f53a","native":"🔺"}],"version":1},"small_red_triangle_down":{"id":"small_red_triangle_down","name":"Red Triangle Pointed Down","keywords":["small","shape","direction","bottom"],"skins":[{"unified":"1f53b","native":"🔻"}],"version":1},"diamond_shape_with_a_dot_inside":{"id":"diamond_shape_with_a_dot_inside","name":"Diamond with a Dot","keywords":["shape","inside","jewel","blue","gem","crystal","fancy"],"skins":[{"unified":"1f4a0","native":"💠"}],"version":1},"radio_button":{"id":"radio_button","name":"Radio Button","keywords":["input","old","music","circle"],"skins":[{"unified":"1f518","native":"🔘"}],"version":1},"white_square_button":{"id":"white_square_button","name":"White Square Button","keywords":["shape","input"],"skins":[{"unified":"1f533","native":"🔳"}],"version":1},"black_square_button":{"id":"black_square_button","name":"Black Square Button","keywords":["shape","input","frame"],"skins":[{"unified":"1f532","native":"🔲"}],"version":1},"checkered_flag":{"id":"checkered_flag","name":"Chequered Flag","keywords":["checkered","contest","finishline","race","gokart"],"skins":[{"unified":"1f3c1","native":"🏁"}],"version":1},"triangular_flag_on_post":{"id":"triangular_flag_on_post","name":"Triangular Flag","keywords":["on","post","mark","milestone","place"],"skins":[{"unified":"1f6a9","native":"🚩"}],"version":1},"crossed_flags":{"id":"crossed_flags","name":"Crossed Flags","keywords":["japanese","nation","country","border"],"skins":[{"unified":"1f38c","native":"🎌"}],"version":1},"waving_black_flag":{"id":"waving_black_flag","name":"Black Flag","keywords":["waving","pirate"],"skins":[{"unified":"1f3f4","native":"🏴"}],"version":1},"waving_white_flag":{"id":"waving_white_flag","name":"White Flag","keywords":["waving","losing","loser","lost","surrender","give","up","fail"],"skins":[{"unified":"1f3f3-fe0f","native":"🏳️"}],"version":1},"rainbow-flag":{"id":"rainbow-flag","name":"Rainbow Flag","keywords":["pride","gay","lgbt","glbt","queer","homosexual","lesbian","bisexual","transgender"],"skins":[{"unified":"1f3f3-fe0f-200d-1f308","native":"🏳️‍🌈"}],"version":4},"transgender_flag":{"id":"transgender_flag","name":"Transgender Flag","keywords":["lgbtq"],"skins":[{"unified":"1f3f3-fe0f-200d-26a7-fe0f","native":"🏳️‍⚧️"}],"version":13},"pirate_flag":{"id":"pirate_flag","name":"Pirate Flag","keywords":["skull","crossbones","banner"],"skins":[{"unified":"1f3f4-200d-2620-fe0f","native":"🏴‍☠️"}],"version":11},"flag-ac":{"id":"flag-ac","name":"Ascension Island Flag","keywords":["ac"],"skins":[{"unified":"1f1e6-1f1e8","native":"🇦🇨"}],"version":2},"flag-ad":{"id":"flag-ad","name":"Andorra Flag","keywords":["ad","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1e9","native":"🇦🇩"}],"version":2},"flag-ae":{"id":"flag-ae","name":"United Arab Emirates Flag","keywords":["ae","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1ea","native":"🇦🇪"}],"version":2},"flag-af":{"id":"flag-af","name":"Afghanistan Flag","keywords":["af","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1eb","native":"🇦🇫"}],"version":2},"flag-ag":{"id":"flag-ag","name":"Antigua & Barbuda Flag","keywords":["ag","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1ec","native":"🇦🇬"}],"version":2},"flag-ai":{"id":"flag-ai","name":"Anguilla Flag","keywords":["ai","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1ee","native":"🇦🇮"}],"version":2},"flag-al":{"id":"flag-al","name":"Albania Flag","keywords":["al","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1f1","native":"🇦🇱"}],"version":2},"flag-am":{"id":"flag-am","name":"Armenia Flag","keywords":["am","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1f2","native":"🇦🇲"}],"version":2},"flag-ao":{"id":"flag-ao","name":"Angola Flag","keywords":["ao","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1f4","native":"🇦🇴"}],"version":2},"flag-aq":{"id":"flag-aq","name":"Antarctica Flag","keywords":["aq","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1f6","native":"🇦🇶"}],"version":2},"flag-ar":{"id":"flag-ar","name":"Argentina Flag","keywords":["ar","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1f7","native":"🇦🇷"}],"version":2},"flag-as":{"id":"flag-as","name":"American Samoa Flag","keywords":["as","ws","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1f8","native":"🇦🇸"}],"version":2},"flag-at":{"id":"flag-at","name":"Austria Flag","keywords":["at","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1f9","native":"🇦🇹"}],"version":2},"flag-au":{"id":"flag-au","name":"Australia Flag","keywords":["au","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1fa","native":"🇦🇺"}],"version":2},"flag-aw":{"id":"flag-aw","name":"Aruba Flag","keywords":["aw","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1fc","native":"🇦🇼"}],"version":2},"flag-ax":{"id":"flag-ax","name":"Åland Islands Flag","keywords":["ax","aland","Aland","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1fd","native":"🇦🇽"}],"version":2},"flag-az":{"id":"flag-az","name":"Azerbaijan Flag","keywords":["az","nation","country","banner"],"skins":[{"unified":"1f1e6-1f1ff","native":"🇦🇿"}],"version":2},"flag-ba":{"id":"flag-ba","name":"Bosnia & Herzegovina Flag","keywords":["ba","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1e6","native":"🇧🇦"}],"version":2},"flag-bb":{"id":"flag-bb","name":"Barbados Flag","keywords":["bb","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1e7","native":"🇧🇧"}],"version":2},"flag-bd":{"id":"flag-bd","name":"Bangladesh Flag","keywords":["bd","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1e9","native":"🇧🇩"}],"version":2},"flag-be":{"id":"flag-be","name":"Belgium Flag","keywords":["be","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1ea","native":"🇧🇪"}],"version":2},"flag-bf":{"id":"flag-bf","name":"Burkina Faso Flag","keywords":["bf","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1eb","native":"🇧🇫"}],"version":2},"flag-bg":{"id":"flag-bg","name":"Bulgaria Flag","keywords":["bg","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1ec","native":"🇧🇬"}],"version":2},"flag-bh":{"id":"flag-bh","name":"Bahrain Flag","keywords":["bh","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1ed","native":"🇧🇭"}],"version":2},"flag-bi":{"id":"flag-bi","name":"Burundi Flag","keywords":["bi","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1ee","native":"🇧🇮"}],"version":2},"flag-bj":{"id":"flag-bj","name":"Benin Flag","keywords":["bj","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1ef","native":"🇧🇯"}],"version":2},"flag-bl":{"id":"flag-bl","name":"St. Barthélemy Flag","keywords":["bl","st","barthelemy","saint","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1f1","native":"🇧🇱"}],"version":2},"flag-bm":{"id":"flag-bm","name":"Bermuda Flag","keywords":["bm","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1f2","native":"🇧🇲"}],"version":2},"flag-bn":{"id":"flag-bn","name":"Brunei Flag","keywords":["bn","darussalam","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1f3","native":"🇧🇳"}],"version":2},"flag-bo":{"id":"flag-bo","name":"Bolivia Flag","keywords":["bo","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1f4","native":"🇧🇴"}],"version":2},"flag-bq":{"id":"flag-bq","name":"Caribbean Netherlands Flag","keywords":["bq","bonaire","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1f6","native":"🇧🇶"}],"version":2},"flag-br":{"id":"flag-br","name":"Brazil Flag","keywords":["br","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1f7","native":"🇧🇷"}],"version":2},"flag-bs":{"id":"flag-bs","name":"Bahamas Flag","keywords":["bs","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1f8","native":"🇧🇸"}],"version":2},"flag-bt":{"id":"flag-bt","name":"Bhutan Flag","keywords":["bt","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1f9","native":"🇧🇹"}],"version":2},"flag-bv":{"id":"flag-bv","name":"Bouvet Island Flag","keywords":["bv","norway"],"skins":[{"unified":"1f1e7-1f1fb","native":"🇧🇻"}],"version":2},"flag-bw":{"id":"flag-bw","name":"Botswana Flag","keywords":["bw","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1fc","native":"🇧🇼"}],"version":2},"flag-by":{"id":"flag-by","name":"Belarus Flag","keywords":["by","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1fe","native":"🇧🇾"}],"version":2},"flag-bz":{"id":"flag-bz","name":"Belize Flag","keywords":["bz","nation","country","banner"],"skins":[{"unified":"1f1e7-1f1ff","native":"🇧🇿"}],"version":2},"flag-ca":{"id":"flag-ca","name":"Canada Flag","keywords":["ca","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1e6","native":"🇨🇦"}],"version":2},"flag-cc":{"id":"flag-cc","name":"Cocos (keeling) Islands Flag","keywords":["cc","keeling","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1e8","native":"🇨🇨"}],"version":2},"flag-cd":{"id":"flag-cd","name":"Congo - Kinshasa Flag","keywords":["cd","democratic","republic","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1e9","native":"🇨🇩"}],"version":2},"flag-cf":{"id":"flag-cf","name":"Central African Republic Flag","keywords":["cf","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1eb","native":"🇨🇫"}],"version":2},"flag-cg":{"id":"flag-cg","name":"Congo - Brazzaville Flag","keywords":["cg","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1ec","native":"🇨🇬"}],"version":2},"flag-ch":{"id":"flag-ch","name":"Switzerland Flag","keywords":["ch","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1ed","native":"🇨🇭"}],"version":2},"flag-ci":{"id":"flag-ci","name":"Côte D’ivoire Flag","keywords":["ci","cote","d","ivoire","ivory","coast","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1ee","native":"🇨🇮"}],"version":2},"flag-ck":{"id":"flag-ck","name":"Cook Islands Flag","keywords":["ck","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1f0","native":"🇨🇰"}],"version":2},"flag-cl":{"id":"flag-cl","name":"Chile Flag","keywords":["cl","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1f1","native":"🇨🇱"}],"version":2},"flag-cm":{"id":"flag-cm","name":"Cameroon Flag","keywords":["cm","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1f2","native":"🇨🇲"}],"version":2},"cn":{"id":"cn","name":"China Flag","keywords":["cn","chinese","prc","country","nation","banner"],"skins":[{"unified":"1f1e8-1f1f3","native":"🇨🇳"}],"version":1},"flag-co":{"id":"flag-co","name":"Colombia Flag","keywords":["co","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1f4","native":"🇨🇴"}],"version":2},"flag-cp":{"id":"flag-cp","name":"Clipperton Island Flag","keywords":["cp"],"skins":[{"unified":"1f1e8-1f1f5","native":"🇨🇵"}],"version":2},"flag-cr":{"id":"flag-cr","name":"Costa Rica Flag","keywords":["cr","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1f7","native":"🇨🇷"}],"version":2},"flag-cu":{"id":"flag-cu","name":"Cuba Flag","keywords":["cu","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1fa","native":"🇨🇺"}],"version":2},"flag-cv":{"id":"flag-cv","name":"Cape Verde Flag","keywords":["cv","cabo","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1fb","native":"🇨🇻"}],"version":2},"flag-cw":{"id":"flag-cw","name":"Curaçao Flag","keywords":["cw","curacao","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1fc","native":"🇨🇼"}],"version":2},"flag-cx":{"id":"flag-cx","name":"Christmas Island Flag","keywords":["cx","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1fd","native":"🇨🇽"}],"version":2},"flag-cy":{"id":"flag-cy","name":"Cyprus Flag","keywords":["cy","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1fe","native":"🇨🇾"}],"version":2},"flag-cz":{"id":"flag-cz","name":"Czechia Flag","keywords":["cz","nation","country","banner"],"skins":[{"unified":"1f1e8-1f1ff","native":"🇨🇿"}],"version":2},"de":{"id":"de","name":"Germany Flag","keywords":["de","german","nation","country","banner"],"skins":[{"unified":"1f1e9-1f1ea","native":"🇩🇪"}],"version":1},"flag-dg":{"id":"flag-dg","name":"Diego Garcia Flag","keywords":["dg"],"skins":[{"unified":"1f1e9-1f1ec","native":"🇩🇬"}],"version":2},"flag-dj":{"id":"flag-dj","name":"Djibouti Flag","keywords":["dj","nation","country","banner"],"skins":[{"unified":"1f1e9-1f1ef","native":"🇩🇯"}],"version":2},"flag-dk":{"id":"flag-dk","name":"Denmark Flag","keywords":["dk","nation","country","banner"],"skins":[{"unified":"1f1e9-1f1f0","native":"🇩🇰"}],"version":2},"flag-dm":{"id":"flag-dm","name":"Dominica Flag","keywords":["dm","nation","country","banner"],"skins":[{"unified":"1f1e9-1f1f2","native":"🇩🇲"}],"version":2},"flag-do":{"id":"flag-do","name":"Dominican Republic Flag","keywords":["do","nation","country","banner"],"skins":[{"unified":"1f1e9-1f1f4","native":"🇩🇴"}],"version":2},"flag-dz":{"id":"flag-dz","name":"Algeria Flag","keywords":["dz","nation","country","banner"],"skins":[{"unified":"1f1e9-1f1ff","native":"🇩🇿"}],"version":2},"flag-ea":{"id":"flag-ea","name":"Ceuta & Melilla Flag","keywords":["ea"],"skins":[{"unified":"1f1ea-1f1e6","native":"🇪🇦"}],"version":2},"flag-ec":{"id":"flag-ec","name":"Ecuador Flag","keywords":["ec","nation","country","banner"],"skins":[{"unified":"1f1ea-1f1e8","native":"🇪🇨"}],"version":2},"flag-ee":{"id":"flag-ee","name":"Estonia Flag","keywords":["ee","nation","country","banner"],"skins":[{"unified":"1f1ea-1f1ea","native":"🇪🇪"}],"version":2},"flag-eg":{"id":"flag-eg","name":"Egypt Flag","keywords":["eg","nation","country","banner"],"skins":[{"unified":"1f1ea-1f1ec","native":"🇪🇬"}],"version":2},"flag-eh":{"id":"flag-eh","name":"Western Sahara Flag","keywords":["eh","nation","country","banner"],"skins":[{"unified":"1f1ea-1f1ed","native":"🇪🇭"}],"version":2},"flag-er":{"id":"flag-er","name":"Eritrea Flag","keywords":["er","nation","country","banner"],"skins":[{"unified":"1f1ea-1f1f7","native":"🇪🇷"}],"version":2},"es":{"id":"es","name":"Spain Flag","keywords":["es","nation","country","banner"],"skins":[{"unified":"1f1ea-1f1f8","native":"🇪🇸"}],"version":1},"flag-et":{"id":"flag-et","name":"Ethiopia Flag","keywords":["et","nation","country","banner"],"skins":[{"unified":"1f1ea-1f1f9","native":"🇪🇹"}],"version":2},"flag-eu":{"id":"flag-eu","name":"European Union Flag","keywords":["eu","banner"],"skins":[{"unified":"1f1ea-1f1fa","native":"🇪🇺"}],"version":2},"flag-fi":{"id":"flag-fi","name":"Finland Flag","keywords":["fi","nation","country","banner"],"skins":[{"unified":"1f1eb-1f1ee","native":"🇫🇮"}],"version":2},"flag-fj":{"id":"flag-fj","name":"Fiji Flag","keywords":["fj","nation","country","banner"],"skins":[{"unified":"1f1eb-1f1ef","native":"🇫🇯"}],"version":2},"flag-fk":{"id":"flag-fk","name":"Falkland Islands Flag","keywords":["fk","malvinas","nation","country","banner"],"skins":[{"unified":"1f1eb-1f1f0","native":"🇫🇰"}],"version":2},"flag-fm":{"id":"flag-fm","name":"Micronesia Flag","keywords":["fm","federated","states","nation","country","banner"],"skins":[{"unified":"1f1eb-1f1f2","native":"🇫🇲"}],"version":2},"flag-fo":{"id":"flag-fo","name":"Faroe Islands Flag","keywords":["fo","nation","country","banner"],"skins":[{"unified":"1f1eb-1f1f4","native":"🇫🇴"}],"version":2},"fr":{"id":"fr","name":"France Flag","keywords":["fr","banner","nation","french","country"],"skins":[{"unified":"1f1eb-1f1f7","native":"🇫🇷"}],"version":1},"flag-ga":{"id":"flag-ga","name":"Gabon Flag","keywords":["ga","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1e6","native":"🇬🇦"}],"version":2},"gb":{"id":"gb","name":"United Kingdom Flag","keywords":["gb","uk","great","britain","northern","ireland","nation","country","banner","british","UK","english","england","union","jack"],"skins":[{"unified":"1f1ec-1f1e7","native":"🇬🇧"}],"version":1},"flag-gd":{"id":"flag-gd","name":"Grenada Flag","keywords":["gd","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1e9","native":"🇬🇩"}],"version":2},"flag-ge":{"id":"flag-ge","name":"Georgia Flag","keywords":["ge","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1ea","native":"🇬🇪"}],"version":2},"flag-gf":{"id":"flag-gf","name":"French Guiana Flag","keywords":["gf","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1eb","native":"🇬🇫"}],"version":2},"flag-gg":{"id":"flag-gg","name":"Guernsey Flag","keywords":["gg","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1ec","native":"🇬🇬"}],"version":2},"flag-gh":{"id":"flag-gh","name":"Ghana Flag","keywords":["gh","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1ed","native":"🇬🇭"}],"version":2},"flag-gi":{"id":"flag-gi","name":"Gibraltar Flag","keywords":["gi","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1ee","native":"🇬🇮"}],"version":2},"flag-gl":{"id":"flag-gl","name":"Greenland Flag","keywords":["gl","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1f1","native":"🇬🇱"}],"version":2},"flag-gm":{"id":"flag-gm","name":"Gambia Flag","keywords":["gm","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1f2","native":"🇬🇲"}],"version":2},"flag-gn":{"id":"flag-gn","name":"Guinea Flag","keywords":["gn","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1f3","native":"🇬🇳"}],"version":2},"flag-gp":{"id":"flag-gp","name":"Guadeloupe Flag","keywords":["gp","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1f5","native":"🇬🇵"}],"version":2},"flag-gq":{"id":"flag-gq","name":"Equatorial Guinea Flag","keywords":["gq","gn","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1f6","native":"🇬🇶"}],"version":2},"flag-gr":{"id":"flag-gr","name":"Greece Flag","keywords":["gr","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1f7","native":"🇬🇷"}],"version":2},"flag-gs":{"id":"flag-gs","name":"South Georgia & South Sandwich Islands Flag","keywords":["gs","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1f8","native":"🇬🇸"}],"version":2},"flag-gt":{"id":"flag-gt","name":"Guatemala Flag","keywords":["gt","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1f9","native":"🇬🇹"}],"version":2},"flag-gu":{"id":"flag-gu","name":"Guam Flag","keywords":["gu","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1fa","native":"🇬🇺"}],"version":2},"flag-gw":{"id":"flag-gw","name":"Guinea-Bissau Flag","keywords":["gw","guinea","bissau","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1fc","native":"🇬🇼"}],"version":2},"flag-gy":{"id":"flag-gy","name":"Guyana Flag","keywords":["gy","nation","country","banner"],"skins":[{"unified":"1f1ec-1f1fe","native":"🇬🇾"}],"version":2},"flag-hk":{"id":"flag-hk","name":"Hong Kong Sar China Flag","keywords":["hk","nation","country","banner"],"skins":[{"unified":"1f1ed-1f1f0","native":"🇭🇰"}],"version":2},"flag-hm":{"id":"flag-hm","name":"Heard & Mcdonald Islands Flag","keywords":["hm"],"skins":[{"unified":"1f1ed-1f1f2","native":"🇭🇲"}],"version":2},"flag-hn":{"id":"flag-hn","name":"Honduras Flag","keywords":["hn","nation","country","banner"],"skins":[{"unified":"1f1ed-1f1f3","native":"🇭🇳"}],"version":2},"flag-hr":{"id":"flag-hr","name":"Croatia Flag","keywords":["hr","nation","country","banner"],"skins":[{"unified":"1f1ed-1f1f7","native":"🇭🇷"}],"version":2},"flag-ht":{"id":"flag-ht","name":"Haiti Flag","keywords":["ht","nation","country","banner"],"skins":[{"unified":"1f1ed-1f1f9","native":"🇭🇹"}],"version":2},"flag-hu":{"id":"flag-hu","name":"Hungary Flag","keywords":["hu","nation","country","banner"],"skins":[{"unified":"1f1ed-1f1fa","native":"🇭🇺"}],"version":2},"flag-ic":{"id":"flag-ic","name":"Canary Islands Flag","keywords":["ic","nation","country","banner"],"skins":[{"unified":"1f1ee-1f1e8","native":"🇮🇨"}],"version":2},"flag-id":{"id":"flag-id","name":"Indonesia Flag","keywords":["id","nation","country","banner"],"skins":[{"unified":"1f1ee-1f1e9","native":"🇮🇩"}],"version":2},"flag-ie":{"id":"flag-ie","name":"Ireland Flag","keywords":["ie","nation","country","banner"],"skins":[{"unified":"1f1ee-1f1ea","native":"🇮🇪"}],"version":2},"flag-il":{"id":"flag-il","name":"Israel Flag","keywords":["il","nation","country","banner"],"skins":[{"unified":"1f1ee-1f1f1","native":"🇮🇱"}],"version":2},"flag-im":{"id":"flag-im","name":"Isle of Man Flag","keywords":["im","nation","country","banner"],"skins":[{"unified":"1f1ee-1f1f2","native":"🇮🇲"}],"version":2},"flag-in":{"id":"flag-in","name":"India Flag","keywords":["in","nation","country","banner"],"skins":[{"unified":"1f1ee-1f1f3","native":"🇮🇳"}],"version":2},"flag-io":{"id":"flag-io","name":"British Indian Ocean Territory Flag","keywords":["io","nation","country","banner"],"skins":[{"unified":"1f1ee-1f1f4","native":"🇮🇴"}],"version":2},"flag-iq":{"id":"flag-iq","name":"Iraq Flag","keywords":["iq","nation","country","banner"],"skins":[{"unified":"1f1ee-1f1f6","native":"🇮🇶"}],"version":2},"flag-ir":{"id":"flag-ir","name":"Iran Flag","keywords":["ir","islamic","republic","nation","country","banner"],"skins":[{"unified":"1f1ee-1f1f7","native":"🇮🇷"}],"version":2},"flag-is":{"id":"flag-is","name":"Iceland Flag","keywords":["is","nation","country","banner"],"skins":[{"unified":"1f1ee-1f1f8","native":"🇮🇸"}],"version":2},"it":{"id":"it","name":"Italy Flag","keywords":["it","nation","country","banner"],"skins":[{"unified":"1f1ee-1f1f9","native":"🇮🇹"}],"version":1},"flag-je":{"id":"flag-je","name":"Jersey Flag","keywords":["je","nation","country","banner"],"skins":[{"unified":"1f1ef-1f1ea","native":"🇯🇪"}],"version":2},"flag-jm":{"id":"flag-jm","name":"Jamaica Flag","keywords":["jm","nation","country","banner"],"skins":[{"unified":"1f1ef-1f1f2","native":"🇯🇲"}],"version":2},"flag-jo":{"id":"flag-jo","name":"Jordan Flag","keywords":["jo","nation","country","banner"],"skins":[{"unified":"1f1ef-1f1f4","native":"🇯🇴"}],"version":2},"jp":{"id":"jp","name":"Japan Flag","keywords":["jp","japanese","nation","country","banner","ja"],"skins":[{"unified":"1f1ef-1f1f5","native":"🇯🇵"}],"version":1},"flag-ke":{"id":"flag-ke","name":"Kenya Flag","keywords":["ke","nation","country","banner"],"skins":[{"unified":"1f1f0-1f1ea","native":"🇰🇪"}],"version":2},"flag-kg":{"id":"flag-kg","name":"Kyrgyzstan Flag","keywords":["kg","nation","country","banner"],"skins":[{"unified":"1f1f0-1f1ec","native":"🇰🇬"}],"version":2},"flag-kh":{"id":"flag-kh","name":"Cambodia Flag","keywords":["kh","nation","country","banner"],"skins":[{"unified":"1f1f0-1f1ed","native":"🇰🇭"}],"version":2},"flag-ki":{"id":"flag-ki","name":"Kiribati Flag","keywords":["ki","nation","country","banner"],"skins":[{"unified":"1f1f0-1f1ee","native":"🇰🇮"}],"version":2},"flag-km":{"id":"flag-km","name":"Comoros Flag","keywords":["km","nation","country","banner"],"skins":[{"unified":"1f1f0-1f1f2","native":"🇰🇲"}],"version":2},"flag-kn":{"id":"flag-kn","name":"St. Kitts & Nevis Flag","keywords":["kn","st","saint","nation","country","banner"],"skins":[{"unified":"1f1f0-1f1f3","native":"🇰🇳"}],"version":2},"flag-kp":{"id":"flag-kp","name":"North Korea Flag","keywords":["kp","nation","country","banner"],"skins":[{"unified":"1f1f0-1f1f5","native":"🇰🇵"}],"version":2},"kr":{"id":"kr","name":"South Korea Flag","keywords":["kr","nation","country","banner"],"skins":[{"unified":"1f1f0-1f1f7","native":"🇰🇷"}],"version":1},"flag-kw":{"id":"flag-kw","name":"Kuwait Flag","keywords":["kw","nation","country","banner"],"skins":[{"unified":"1f1f0-1f1fc","native":"🇰🇼"}],"version":2},"flag-ky":{"id":"flag-ky","name":"Cayman Islands Flag","keywords":["ky","nation","country","banner"],"skins":[{"unified":"1f1f0-1f1fe","native":"🇰🇾"}],"version":2},"flag-kz":{"id":"flag-kz","name":"Kazakhstan Flag","keywords":["kz","nation","country","banner"],"skins":[{"unified":"1f1f0-1f1ff","native":"🇰🇿"}],"version":2},"flag-la":{"id":"flag-la","name":"Laos Flag","keywords":["la","lao","democratic","republic","nation","country","banner"],"skins":[{"unified":"1f1f1-1f1e6","native":"🇱🇦"}],"version":2},"flag-lb":{"id":"flag-lb","name":"Lebanon Flag","keywords":["lb","nation","country","banner"],"skins":[{"unified":"1f1f1-1f1e7","native":"🇱🇧"}],"version":2},"flag-lc":{"id":"flag-lc","name":"St. Lucia Flag","keywords":["lc","st","saint","nation","country","banner"],"skins":[{"unified":"1f1f1-1f1e8","native":"🇱🇨"}],"version":2},"flag-li":{"id":"flag-li","name":"Liechtenstein Flag","keywords":["li","nation","country","banner"],"skins":[{"unified":"1f1f1-1f1ee","native":"🇱🇮"}],"version":2},"flag-lk":{"id":"flag-lk","name":"Sri Lanka Flag","keywords":["lk","nation","country","banner"],"skins":[{"unified":"1f1f1-1f1f0","native":"🇱🇰"}],"version":2},"flag-lr":{"id":"flag-lr","name":"Liberia Flag","keywords":["lr","nation","country","banner"],"skins":[{"unified":"1f1f1-1f1f7","native":"🇱🇷"}],"version":2},"flag-ls":{"id":"flag-ls","name":"Lesotho Flag","keywords":["ls","nation","country","banner"],"skins":[{"unified":"1f1f1-1f1f8","native":"🇱🇸"}],"version":2},"flag-lt":{"id":"flag-lt","name":"Lithuania Flag","keywords":["lt","nation","country","banner"],"skins":[{"unified":"1f1f1-1f1f9","native":"🇱🇹"}],"version":2},"flag-lu":{"id":"flag-lu","name":"Luxembourg Flag","keywords":["lu","nation","country","banner"],"skins":[{"unified":"1f1f1-1f1fa","native":"🇱🇺"}],"version":2},"flag-lv":{"id":"flag-lv","name":"Latvia Flag","keywords":["lv","nation","country","banner"],"skins":[{"unified":"1f1f1-1f1fb","native":"🇱🇻"}],"version":2},"flag-ly":{"id":"flag-ly","name":"Libya Flag","keywords":["ly","nation","country","banner"],"skins":[{"unified":"1f1f1-1f1fe","native":"🇱🇾"}],"version":2},"flag-ma":{"id":"flag-ma","name":"Morocco Flag","keywords":["ma","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1e6","native":"🇲🇦"}],"version":2},"flag-mc":{"id":"flag-mc","name":"Monaco Flag","keywords":["mc","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1e8","native":"🇲🇨"}],"version":2},"flag-md":{"id":"flag-md","name":"Moldova Flag","keywords":["md","republic","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1e9","native":"🇲🇩"}],"version":2},"flag-me":{"id":"flag-me","name":"Montenegro Flag","keywords":["me","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1ea","native":"🇲🇪"}],"version":2},"flag-mf":{"id":"flag-mf","name":"St. Martin Flag","keywords":["mf","st"],"skins":[{"unified":"1f1f2-1f1eb","native":"🇲🇫"}],"version":2},"flag-mg":{"id":"flag-mg","name":"Madagascar Flag","keywords":["mg","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1ec","native":"🇲🇬"}],"version":2},"flag-mh":{"id":"flag-mh","name":"Marshall Islands Flag","keywords":["mh","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1ed","native":"🇲🇭"}],"version":2},"flag-mk":{"id":"flag-mk","name":"North Macedonia Flag","keywords":["mk","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1f0","native":"🇲🇰"}],"version":2},"flag-ml":{"id":"flag-ml","name":"Mali Flag","keywords":["ml","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1f1","native":"🇲🇱"}],"version":2},"flag-mm":{"id":"flag-mm","name":"Myanmar (burma) Flag","keywords":["mm","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1f2","native":"🇲🇲"}],"version":2},"flag-mn":{"id":"flag-mn","name":"Mongolia Flag","keywords":["mn","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1f3","native":"🇲🇳"}],"version":2},"flag-mo":{"id":"flag-mo","name":"Macao Sar China Flag","keywords":["mo","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1f4","native":"🇲🇴"}],"version":2},"flag-mp":{"id":"flag-mp","name":"Northern Mariana Islands Flag","keywords":["mp","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1f5","native":"🇲🇵"}],"version":2},"flag-mq":{"id":"flag-mq","name":"Martinique Flag","keywords":["mq","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1f6","native":"🇲🇶"}],"version":2},"flag-mr":{"id":"flag-mr","name":"Mauritania Flag","keywords":["mr","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1f7","native":"🇲🇷"}],"version":2},"flag-ms":{"id":"flag-ms","name":"Montserrat Flag","keywords":["ms","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1f8","native":"🇲🇸"}],"version":2},"flag-mt":{"id":"flag-mt","name":"Malta Flag","keywords":["mt","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1f9","native":"🇲🇹"}],"version":2},"flag-mu":{"id":"flag-mu","name":"Mauritius Flag","keywords":["mu","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1fa","native":"🇲🇺"}],"version":2},"flag-mv":{"id":"flag-mv","name":"Maldives Flag","keywords":["mv","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1fb","native":"🇲🇻"}],"version":2},"flag-mw":{"id":"flag-mw","name":"Malawi Flag","keywords":["mw","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1fc","native":"🇲🇼"}],"version":2},"flag-mx":{"id":"flag-mx","name":"Mexico Flag","keywords":["mx","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1fd","native":"🇲🇽"}],"version":2},"flag-my":{"id":"flag-my","name":"Malaysia Flag","keywords":["my","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1fe","native":"🇲🇾"}],"version":2},"flag-mz":{"id":"flag-mz","name":"Mozambique Flag","keywords":["mz","nation","country","banner"],"skins":[{"unified":"1f1f2-1f1ff","native":"🇲🇿"}],"version":2},"flag-na":{"id":"flag-na","name":"Namibia Flag","keywords":["na","nation","country","banner"],"skins":[{"unified":"1f1f3-1f1e6","native":"🇳🇦"}],"version":2},"flag-nc":{"id":"flag-nc","name":"New Caledonia Flag","keywords":["nc","nation","country","banner"],"skins":[{"unified":"1f1f3-1f1e8","native":"🇳🇨"}],"version":2},"flag-ne":{"id":"flag-ne","name":"Niger Flag","keywords":["ne","nation","country","banner"],"skins":[{"unified":"1f1f3-1f1ea","native":"🇳🇪"}],"version":2},"flag-nf":{"id":"flag-nf","name":"Norfolk Island Flag","keywords":["nf","nation","country","banner"],"skins":[{"unified":"1f1f3-1f1eb","native":"🇳🇫"}],"version":2},"flag-ng":{"id":"flag-ng","name":"Nigeria Flag","keywords":["ng","nation","country","banner"],"skins":[{"unified":"1f1f3-1f1ec","native":"🇳🇬"}],"version":2},"flag-ni":{"id":"flag-ni","name":"Nicaragua Flag","keywords":["ni","nation","country","banner"],"skins":[{"unified":"1f1f3-1f1ee","native":"🇳🇮"}],"version":2},"flag-nl":{"id":"flag-nl","name":"Netherlands Flag","keywords":["nl","nation","country","banner"],"skins":[{"unified":"1f1f3-1f1f1","native":"🇳🇱"}],"version":2},"flag-no":{"id":"flag-no","name":"Norway Flag","keywords":["no","nation","country","banner"],"skins":[{"unified":"1f1f3-1f1f4","native":"🇳🇴"}],"version":2},"flag-np":{"id":"flag-np","name":"Nepal Flag","keywords":["np","nation","country","banner"],"skins":[{"unified":"1f1f3-1f1f5","native":"🇳🇵"}],"version":2},"flag-nr":{"id":"flag-nr","name":"Nauru Flag","keywords":["nr","nation","country","banner"],"skins":[{"unified":"1f1f3-1f1f7","native":"🇳🇷"}],"version":2},"flag-nu":{"id":"flag-nu","name":"Niue Flag","keywords":["nu","nation","country","banner"],"skins":[{"unified":"1f1f3-1f1fa","native":"🇳🇺"}],"version":2},"flag-nz":{"id":"flag-nz","name":"New Zealand Flag","keywords":["nz","nation","country","banner"],"skins":[{"unified":"1f1f3-1f1ff","native":"🇳🇿"}],"version":2},"flag-om":{"id":"flag-om","name":"Oman Flag","keywords":["om","symbol","nation","country","banner"],"skins":[{"unified":"1f1f4-1f1f2","native":"🇴🇲"}],"version":2},"flag-pa":{"id":"flag-pa","name":"Panama Flag","keywords":["pa","nation","country","banner"],"skins":[{"unified":"1f1f5-1f1e6","native":"🇵🇦"}],"version":2},"flag-pe":{"id":"flag-pe","name":"Peru Flag","keywords":["pe","nation","country","banner"],"skins":[{"unified":"1f1f5-1f1ea","native":"🇵🇪"}],"version":2},"flag-pf":{"id":"flag-pf","name":"French Polynesia Flag","keywords":["pf","nation","country","banner"],"skins":[{"unified":"1f1f5-1f1eb","native":"🇵🇫"}],"version":2},"flag-pg":{"id":"flag-pg","name":"Papua New Guinea Flag","keywords":["pg","nation","country","banner"],"skins":[{"unified":"1f1f5-1f1ec","native":"🇵🇬"}],"version":2},"flag-ph":{"id":"flag-ph","name":"Philippines Flag","keywords":["ph","nation","country","banner"],"skins":[{"unified":"1f1f5-1f1ed","native":"🇵🇭"}],"version":2},"flag-pk":{"id":"flag-pk","name":"Pakistan Flag","keywords":["pk","nation","country","banner"],"skins":[{"unified":"1f1f5-1f1f0","native":"🇵🇰"}],"version":2},"flag-pl":{"id":"flag-pl","name":"Poland Flag","keywords":["pl","nation","country","banner"],"skins":[{"unified":"1f1f5-1f1f1","native":"🇵🇱"}],"version":2},"flag-pm":{"id":"flag-pm","name":"St. Pierre & Miquelon Flag","keywords":["pm","st","saint","nation","country","banner"],"skins":[{"unified":"1f1f5-1f1f2","native":"🇵🇲"}],"version":2},"flag-pn":{"id":"flag-pn","name":"Pitcairn Islands Flag","keywords":["pn","nation","country","banner"],"skins":[{"unified":"1f1f5-1f1f3","native":"🇵🇳"}],"version":2},"flag-pr":{"id":"flag-pr","name":"Puerto Rico Flag","keywords":["pr","nation","country","banner"],"skins":[{"unified":"1f1f5-1f1f7","native":"🇵🇷"}],"version":2},"flag-ps":{"id":"flag-ps","name":"Palestinian Territories Flag","keywords":["ps","palestine","nation","country","banner"],"skins":[{"unified":"1f1f5-1f1f8","native":"🇵🇸"}],"version":2},"flag-pt":{"id":"flag-pt","name":"Portugal Flag","keywords":["pt","nation","country","banner"],"skins":[{"unified":"1f1f5-1f1f9","native":"🇵🇹"}],"version":2},"flag-pw":{"id":"flag-pw","name":"Palau Flag","keywords":["pw","nation","country","banner"],"skins":[{"unified":"1f1f5-1f1fc","native":"🇵🇼"}],"version":2},"flag-py":{"id":"flag-py","name":"Paraguay Flag","keywords":["py","nation","country","banner"],"skins":[{"unified":"1f1f5-1f1fe","native":"🇵🇾"}],"version":2},"flag-qa":{"id":"flag-qa","name":"Qatar Flag","keywords":["qa","nation","country","banner"],"skins":[{"unified":"1f1f6-1f1e6","native":"🇶🇦"}],"version":2},"flag-re":{"id":"flag-re","name":"Réunion Flag","keywords":["re","reunion","nation","country","banner"],"skins":[{"unified":"1f1f7-1f1ea","native":"🇷🇪"}],"version":2},"flag-ro":{"id":"flag-ro","name":"Romania Flag","keywords":["ro","nation","country","banner"],"skins":[{"unified":"1f1f7-1f1f4","native":"🇷🇴"}],"version":2},"flag-rs":{"id":"flag-rs","name":"Serbia Flag","keywords":["rs","nation","country","banner"],"skins":[{"unified":"1f1f7-1f1f8","native":"🇷🇸"}],"version":2},"ru":{"id":"ru","name":"Russia Flag","keywords":["ru","russian","federation","nation","country","banner"],"skins":[{"unified":"1f1f7-1f1fa","native":"🇷🇺"}],"version":1},"flag-rw":{"id":"flag-rw","name":"Rwanda Flag","keywords":["rw","nation","country","banner"],"skins":[{"unified":"1f1f7-1f1fc","native":"🇷🇼"}],"version":2},"flag-sa":{"id":"flag-sa","name":"Saudi Arabia Flag","keywords":["sa","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1e6","native":"🇸🇦"}],"version":2},"flag-sb":{"id":"flag-sb","name":"Solomon Islands Flag","keywords":["sb","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1e7","native":"🇸🇧"}],"version":2},"flag-sc":{"id":"flag-sc","name":"Seychelles Flag","keywords":["sc","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1e8","native":"🇸🇨"}],"version":2},"flag-sd":{"id":"flag-sd","name":"Sudan Flag","keywords":["sd","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1e9","native":"🇸🇩"}],"version":2},"flag-se":{"id":"flag-se","name":"Sweden Flag","keywords":["se","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1ea","native":"🇸🇪"}],"version":2},"flag-sg":{"id":"flag-sg","name":"Singapore Flag","keywords":["sg","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1ec","native":"🇸🇬"}],"version":2},"flag-sh":{"id":"flag-sh","name":"St. Helena Flag","keywords":["sh","st","saint","ascension","tristan","cunha","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1ed","native":"🇸🇭"}],"version":2},"flag-si":{"id":"flag-si","name":"Slovenia Flag","keywords":["si","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1ee","native":"🇸🇮"}],"version":2},"flag-sj":{"id":"flag-sj","name":"Svalbard & Jan Mayen Flag","keywords":["sj"],"skins":[{"unified":"1f1f8-1f1ef","native":"🇸🇯"}],"version":2},"flag-sk":{"id":"flag-sk","name":"Slovakia Flag","keywords":["sk","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1f0","native":"🇸🇰"}],"version":2},"flag-sl":{"id":"flag-sl","name":"Sierra Leone Flag","keywords":["sl","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1f1","native":"🇸🇱"}],"version":2},"flag-sm":{"id":"flag-sm","name":"San Marino Flag","keywords":["sm","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1f2","native":"🇸🇲"}],"version":2},"flag-sn":{"id":"flag-sn","name":"Senegal Flag","keywords":["sn","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1f3","native":"🇸🇳"}],"version":2},"flag-so":{"id":"flag-so","name":"Somalia Flag","keywords":["so","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1f4","native":"🇸🇴"}],"version":2},"flag-sr":{"id":"flag-sr","name":"Suriname Flag","keywords":["sr","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1f7","native":"🇸🇷"}],"version":2},"flag-ss":{"id":"flag-ss","name":"South Sudan Flag","keywords":["ss","sd","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1f8","native":"🇸🇸"}],"version":2},"flag-st":{"id":"flag-st","name":"São Tomé & Príncipe Flag","keywords":["st","sao","tome","principe","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1f9","native":"🇸🇹"}],"version":2},"flag-sv":{"id":"flag-sv","name":"El Salvador Flag","keywords":["sv","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1fb","native":"🇸🇻"}],"version":2},"flag-sx":{"id":"flag-sx","name":"Sint Maarten Flag","keywords":["sx","dutch","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1fd","native":"🇸🇽"}],"version":2},"flag-sy":{"id":"flag-sy","name":"Syria Flag","keywords":["sy","syrian","arab","republic","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1fe","native":"🇸🇾"}],"version":2},"flag-sz":{"id":"flag-sz","name":"Eswatini Flag","keywords":["sz","nation","country","banner"],"skins":[{"unified":"1f1f8-1f1ff","native":"🇸🇿"}],"version":2},"flag-ta":{"id":"flag-ta","name":"Tristan Da Cunha Flag","keywords":["ta"],"skins":[{"unified":"1f1f9-1f1e6","native":"🇹🇦"}],"version":2},"flag-tc":{"id":"flag-tc","name":"Turks & Caicos Islands Flag","keywords":["tc","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1e8","native":"🇹🇨"}],"version":2},"flag-td":{"id":"flag-td","name":"Chad Flag","keywords":["td","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1e9","native":"🇹🇩"}],"version":2},"flag-tf":{"id":"flag-tf","name":"French Southern Territories Flag","keywords":["tf","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1eb","native":"🇹🇫"}],"version":2},"flag-tg":{"id":"flag-tg","name":"Togo Flag","keywords":["tg","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1ec","native":"🇹🇬"}],"version":2},"flag-th":{"id":"flag-th","name":"Thailand Flag","keywords":["th","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1ed","native":"🇹🇭"}],"version":2},"flag-tj":{"id":"flag-tj","name":"Tajikistan Flag","keywords":["tj","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1ef","native":"🇹🇯"}],"version":2},"flag-tk":{"id":"flag-tk","name":"Tokelau Flag","keywords":["tk","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1f0","native":"🇹🇰"}],"version":2},"flag-tl":{"id":"flag-tl","name":"Timor-Leste Flag","keywords":["tl","timor","leste","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1f1","native":"🇹🇱"}],"version":2},"flag-tm":{"id":"flag-tm","name":"Turkmenistan Flag","keywords":["tm","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1f2","native":"🇹🇲"}],"version":2},"flag-tn":{"id":"flag-tn","name":"Tunisia Flag","keywords":["tn","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1f3","native":"🇹🇳"}],"version":2},"flag-to":{"id":"flag-to","name":"Tonga Flag","keywords":["to","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1f4","native":"🇹🇴"}],"version":2},"flag-tr":{"id":"flag-tr","name":"Turkey Flag","keywords":["tr","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1f7","native":"🇹🇷"}],"version":2},"flag-tt":{"id":"flag-tt","name":"Trinidad & Tobago Flag","keywords":["tt","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1f9","native":"🇹🇹"}],"version":2},"flag-tv":{"id":"flag-tv","name":"Tuvalu Flag","keywords":["tv","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1fb","native":"🇹🇻"}],"version":2},"flag-tw":{"id":"flag-tw","name":"Taiwan Flag","keywords":["tw","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1fc","native":"🇹🇼"}],"version":2},"flag-tz":{"id":"flag-tz","name":"Tanzania Flag","keywords":["tz","united","republic","nation","country","banner"],"skins":[{"unified":"1f1f9-1f1ff","native":"🇹🇿"}],"version":2},"flag-ua":{"id":"flag-ua","name":"Ukraine Flag","keywords":["ua","nation","country","banner"],"skins":[{"unified":"1f1fa-1f1e6","native":"🇺🇦"}],"version":2},"flag-ug":{"id":"flag-ug","name":"Uganda Flag","keywords":["ug","nation","country","banner"],"skins":[{"unified":"1f1fa-1f1ec","native":"🇺🇬"}],"version":2},"flag-um":{"id":"flag-um","name":"U.s. Outlying Islands Flag","keywords":["um","u","s"],"skins":[{"unified":"1f1fa-1f1f2","native":"🇺🇲"}],"version":2},"flag-un":{"id":"flag-un","name":"United Nations Flag","keywords":["un","banner"],"skins":[{"unified":"1f1fa-1f1f3","native":"🇺🇳"}],"version":4},"us":{"id":"us","name":"United States Flag","keywords":["us","america","nation","country","banner"],"skins":[{"unified":"1f1fa-1f1f8","native":"🇺🇸"}],"version":1},"flag-uy":{"id":"flag-uy","name":"Uruguay Flag","keywords":["uy","nation","country","banner"],"skins":[{"unified":"1f1fa-1f1fe","native":"🇺🇾"}],"version":2},"flag-uz":{"id":"flag-uz","name":"Uzbekistan Flag","keywords":["uz","nation","country","banner"],"skins":[{"unified":"1f1fa-1f1ff","native":"🇺🇿"}],"version":2},"flag-va":{"id":"flag-va","name":"Vatican City Flag","keywords":["va","nation","country","banner"],"skins":[{"unified":"1f1fb-1f1e6","native":"🇻🇦"}],"version":2},"flag-vc":{"id":"flag-vc","name":"St. Vincent & Grenadines Flag","keywords":["vc","st","saint","nation","country","banner"],"skins":[{"unified":"1f1fb-1f1e8","native":"🇻🇨"}],"version":2},"flag-ve":{"id":"flag-ve","name":"Venezuela Flag","keywords":["ve","bolivarian","republic","nation","country","banner"],"skins":[{"unified":"1f1fb-1f1ea","native":"🇻🇪"}],"version":2},"flag-vg":{"id":"flag-vg","name":"British Virgin Islands Flag","keywords":["vg","bvi","nation","country","banner"],"skins":[{"unified":"1f1fb-1f1ec","native":"🇻🇬"}],"version":2},"flag-vi":{"id":"flag-vi","name":"U.s. Virgin Islands Flag","keywords":["vi","u","s","us","nation","country","banner"],"skins":[{"unified":"1f1fb-1f1ee","native":"🇻🇮"}],"version":2},"flag-vn":{"id":"flag-vn","name":"Vietnam Flag","keywords":["vn","viet","nam","nation","country","banner"],"skins":[{"unified":"1f1fb-1f1f3","native":"🇻🇳"}],"version":2},"flag-vu":{"id":"flag-vu","name":"Vanuatu Flag","keywords":["vu","nation","country","banner"],"skins":[{"unified":"1f1fb-1f1fa","native":"🇻🇺"}],"version":2},"flag-wf":{"id":"flag-wf","name":"Wallis & Futuna Flag","keywords":["wf","nation","country","banner"],"skins":[{"unified":"1f1fc-1f1eb","native":"🇼🇫"}],"version":2},"flag-ws":{"id":"flag-ws","name":"Samoa Flag","keywords":["ws","nation","country","banner"],"skins":[{"unified":"1f1fc-1f1f8","native":"🇼🇸"}],"version":2},"flag-xk":{"id":"flag-xk","name":"Kosovo Flag","keywords":["xk","nation","country","banner"],"skins":[{"unified":"1f1fd-1f1f0","native":"🇽🇰"}],"version":2},"flag-ye":{"id":"flag-ye","name":"Yemen Flag","keywords":["ye","nation","country","banner"],"skins":[{"unified":"1f1fe-1f1ea","native":"🇾🇪"}],"version":2},"flag-yt":{"id":"flag-yt","name":"Mayotte Flag","keywords":["yt","nation","country","banner"],"skins":[{"unified":"1f1fe-1f1f9","native":"🇾🇹"}],"version":2},"flag-za":{"id":"flag-za","name":"South Africa Flag","keywords":["za","nation","country","banner"],"skins":[{"unified":"1f1ff-1f1e6","native":"🇿🇦"}],"version":2},"flag-zm":{"id":"flag-zm","name":"Zambia Flag","keywords":["zm","nation","country","banner"],"skins":[{"unified":"1f1ff-1f1f2","native":"🇿🇲"}],"version":2},"flag-zw":{"id":"flag-zw","name":"Zimbabwe Flag","keywords":["zw","nation","country","banner"],"skins":[{"unified":"1f1ff-1f1fc","native":"🇿🇼"}],"version":2},"flag-england":{"id":"flag-england","name":"England Flag","keywords":["english"],"skins":[{"unified":"1f3f4-e0067-e0062-e0065-e006e-e0067-e007f","native":"🏴󠁧󠁢󠁥󠁮󠁧󠁿"}],"version":5},"flag-scotland":{"id":"flag-scotland","name":"Scotland Flag","keywords":["scottish"],"skins":[{"unified":"1f3f4-e0067-e0062-e0073-e0063-e0074-e007f","native":"🏴󠁧󠁢󠁳󠁣󠁴󠁿"}],"version":5},"flag-wales":{"id":"flag-wales","name":"Wales Flag","keywords":["welsh"],"skins":[{"unified":"1f3f4-e0067-e0062-e0077-e006c-e0073-e007f","native":"🏴󠁧󠁢󠁷󠁬󠁳󠁿"}],"version":5}},"aliases":{"satisfied":"laughing","grinning_face_with_star_eyes":"star-struck","grinning_face_with_one_large_and_one_small_eye":"zany_face","smiling_face_with_smiling_eyes_and_hand_covering_mouth":"face_with_hand_over_mouth","face_with_finger_covering_closed_lips":"shushing_face","face_with_one_eyebrow_raised":"face_with_raised_eyebrow","face_with_open_mouth_vomiting":"face_vomiting","shocked_face_with_exploding_head":"exploding_head","serious_face_with_symbols_covering_mouth":"face_with_symbols_on_mouth","poop":"hankey","shit":"hankey","collision":"boom","raised_hand":"hand","hand_with_index_and_middle_fingers_crossed":"crossed_fingers","sign_of_the_horns":"the_horns","reversed_hand_with_middle_finger_extended":"middle_finger","thumbsup":"+1","thumbsdown":"-1","punch":"facepunch","mother_christmas":"mrs_claus","running":"runner","man-with-bunny-ears-partying":"men-with-bunny-ears-partying","woman-with-bunny-ears-partying":"women-with-bunny-ears-partying","women_holding_hands":"two_women_holding_hands","woman_and_man_holding_hands":"man_and_woman_holding_hands","couple":"man_and_woman_holding_hands","men_holding_hands":"two_men_holding_hands","paw_prints":"feet","flipper":"dolphin","honeybee":"bee","lady_beetle":"ladybug","cooking":"fried_egg","knife":"hocho","red_car":"car","sailboat":"boat","waxing_gibbous_moon":"moon","sun_small_cloud":"mostly_sunny","sun_behind_cloud":"barely_sunny","sun_behind_rain_cloud":"partly_sunny_rain","lightning_cloud":"lightning","tornado_cloud":"tornado","tshirt":"shirt","shoe":"mans_shoe","telephone":"phone","lantern":"izakaya_lantern","open_book":"book","envelope":"email","pencil":"memo","heavy_exclamation_mark":"exclamation","staff_of_aesculapius":"medical_symbol","flag-cn":"cn","flag-de":"de","flag-es":"es","flag-fr":"fr","uk":"gb","flag-gb":"gb","flag-it":"it","flag-jp":"jp","flag-kr":"kr","flag-ru":"ru","flag-us":"us"},"sheet":{"cols":61,"rows":61}};

	function $parcel$interopDefault(a) {
	  return a && a.__esModule ? a.default : a;
	}
	function $c770c458706daa72$export$2e2bcd8739ae039(obj, key, value) {
	    if (key in obj) Object.defineProperty(obj, key, {
	        value: value,
	        enumerable: true,
	        configurable: true,
	        writable: true
	    });
	    else obj[key] = value;
	    return obj;
	}


	var $fb96b826c0c5f37a$var$n, $fb96b826c0c5f37a$export$41c562ebe57d11e2, $fb96b826c0c5f37a$var$u, $fb96b826c0c5f37a$var$t, $fb96b826c0c5f37a$var$r, $fb96b826c0c5f37a$var$o, $fb96b826c0c5f37a$var$e = {}, $fb96b826c0c5f37a$var$c = [], $fb96b826c0c5f37a$var$s = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;
	function $fb96b826c0c5f37a$var$a(n1, l1) {
	    for(var u1 in l1)n1[u1] = l1[u1];
	    return n1;
	}
	function $fb96b826c0c5f37a$var$h(n2) {
	    var l2 = n2.parentNode;
	    l2 && l2.removeChild(n2);
	}
	function $fb96b826c0c5f37a$export$c8a8987d4410bf2d(l3, u2, i1) {
	    var t1, r1, o1, f1 = {};
	    for(o1 in u2)"key" == o1 ? t1 = u2[o1] : "ref" == o1 ? r1 = u2[o1] : f1[o1] = u2[o1];
	    if (arguments.length > 2 && (f1.children = arguments.length > 3 ? $fb96b826c0c5f37a$var$n.call(arguments, 2) : i1), "function" == typeof l3 && null != l3.defaultProps) for(o1 in l3.defaultProps)void 0 === f1[o1] && (f1[o1] = l3.defaultProps[o1]);
	    return $fb96b826c0c5f37a$var$y(l3, f1, t1, r1, null);
	}
	function $fb96b826c0c5f37a$var$y(n3, i2, t2, r2, o2) {
	    var f2 = {
	        type: n3,
	        props: i2,
	        key: t2,
	        ref: r2,
	        __k: null,
	        __: null,
	        __b: 0,
	        __e: null,
	        __d: void 0,
	        __c: null,
	        __h: null,
	        constructor: void 0,
	        __v: null == o2 ? ++$fb96b826c0c5f37a$var$u : o2
	    };
	    return null == o2 && null != $fb96b826c0c5f37a$export$41c562ebe57d11e2.vnode && $fb96b826c0c5f37a$export$41c562ebe57d11e2.vnode(f2), f2;
	}
	function $fb96b826c0c5f37a$export$7d1e3a5e95ceca43() {
	    return {
	        current: null
	    };
	}
	function $fb96b826c0c5f37a$export$ffb0004e005737fa(n4) {
	    return n4.children;
	}
	function $fb96b826c0c5f37a$export$16fa2f45be04daa8(n5, l4) {
	    this.props = n5, this.context = l4;
	}
	function $fb96b826c0c5f37a$var$k(n6, l5) {
	    if (null == l5) return n6.__ ? $fb96b826c0c5f37a$var$k(n6.__, n6.__.__k.indexOf(n6) + 1) : null;
	    for(var u3; l5 < n6.__k.length; l5++)if (null != (u3 = n6.__k[l5]) && null != u3.__e) return u3.__e;
	    return "function" == typeof n6.type ? $fb96b826c0c5f37a$var$k(n6) : null;
	}
	function $fb96b826c0c5f37a$var$b(n7) {
	    var l6, u4;
	    if (null != (n7 = n7.__) && null != n7.__c) {
	        for(n7.__e = n7.__c.base = null, l6 = 0; l6 < n7.__k.length; l6++)if (null != (u4 = n7.__k[l6]) && null != u4.__e) {
	            n7.__e = n7.__c.base = u4.__e;
	            break;
	        }
	        return $fb96b826c0c5f37a$var$b(n7);
	    }
	}
	function $fb96b826c0c5f37a$var$m(n8) {
	    (!n8.__d && (n8.__d = !0) && $fb96b826c0c5f37a$var$t.push(n8) && !$fb96b826c0c5f37a$var$g.__r++ || $fb96b826c0c5f37a$var$o !== $fb96b826c0c5f37a$export$41c562ebe57d11e2.debounceRendering) && (($fb96b826c0c5f37a$var$o = $fb96b826c0c5f37a$export$41c562ebe57d11e2.debounceRendering) || $fb96b826c0c5f37a$var$r)($fb96b826c0c5f37a$var$g);
	}
	function $fb96b826c0c5f37a$var$g() {
	    for(var n9; $fb96b826c0c5f37a$var$g.__r = $fb96b826c0c5f37a$var$t.length;)n9 = $fb96b826c0c5f37a$var$t.sort(function(n10, l7) {
	        return n10.__v.__b - l7.__v.__b;
	    }), $fb96b826c0c5f37a$var$t = [], n9.some(function(n11) {
	        var l8, u5, i3, t3, r3, o3;
	        n11.__d && (r3 = (t3 = (l8 = n11).__v).__e, (o3 = l8.__P) && (u5 = [], (i3 = $fb96b826c0c5f37a$var$a({}, t3)).__v = t3.__v + 1, $fb96b826c0c5f37a$var$j(o3, t3, i3, l8.__n, void 0 !== o3.ownerSVGElement, null != t3.__h ? [
	            r3
	        ] : null, u5, null == r3 ? $fb96b826c0c5f37a$var$k(t3) : r3, t3.__h), $fb96b826c0c5f37a$var$z(u5, t3), t3.__e != r3 && $fb96b826c0c5f37a$var$b(t3)));
	    });
	}
	function $fb96b826c0c5f37a$var$w(n12, l9, u6, i4, t4, r4, o4, f3, s1, a1) {
	    var h1, v1, p1, _1, b1, m1, g1, w1 = i4 && i4.__k || $fb96b826c0c5f37a$var$c, A1 = w1.length;
	    for(u6.__k = [], h1 = 0; h1 < l9.length; h1++)if (null != (_1 = u6.__k[h1] = null == (_1 = l9[h1]) || "boolean" == typeof _1 ? null : "string" == typeof _1 || "number" == typeof _1 || "bigint" == typeof _1 ? $fb96b826c0c5f37a$var$y(null, _1, null, null, _1) : Array.isArray(_1) ? $fb96b826c0c5f37a$var$y($fb96b826c0c5f37a$export$ffb0004e005737fa, {
	        children: _1
	    }, null, null, null) : _1.__b > 0 ? $fb96b826c0c5f37a$var$y(_1.type, _1.props, _1.key, null, _1.__v) : _1)) {
	        if (_1.__ = u6, _1.__b = u6.__b + 1, null === (p1 = w1[h1]) || p1 && _1.key == p1.key && _1.type === p1.type) w1[h1] = void 0;
	        else for(v1 = 0; v1 < A1; v1++){
	            if ((p1 = w1[v1]) && _1.key == p1.key && _1.type === p1.type) {
	                w1[v1] = void 0;
	                break;
	            }
	            p1 = null;
	        }
	        $fb96b826c0c5f37a$var$j(n12, _1, p1 = p1 || $fb96b826c0c5f37a$var$e, t4, r4, o4, f3, s1, a1), b1 = _1.__e, (v1 = _1.ref) && p1.ref != v1 && (g1 || (g1 = []), p1.ref && g1.push(p1.ref, null, _1), g1.push(v1, _1.__c || b1, _1)), null != b1 ? (null == m1 && (m1 = b1), "function" == typeof _1.type && _1.__k === p1.__k ? _1.__d = s1 = $fb96b826c0c5f37a$var$x(_1, s1, n12) : s1 = $fb96b826c0c5f37a$var$P(n12, _1, p1, w1, b1, s1), "function" == typeof u6.type && (u6.__d = s1)) : s1 && p1.__e == s1 && s1.parentNode != n12 && (s1 = $fb96b826c0c5f37a$var$k(p1));
	    }
	    for(u6.__e = m1, h1 = A1; h1--;)null != w1[h1] && ("function" == typeof u6.type && null != w1[h1].__e && w1[h1].__e == u6.__d && (u6.__d = $fb96b826c0c5f37a$var$k(i4, h1 + 1)), $fb96b826c0c5f37a$var$N(w1[h1], w1[h1]));
	    if (g1) for(h1 = 0; h1 < g1.length; h1++)$fb96b826c0c5f37a$var$M(g1[h1], g1[++h1], g1[++h1]);
	}
	function $fb96b826c0c5f37a$var$x(n13, l10, u7) {
	    for(var i5, t5 = n13.__k, r5 = 0; t5 && r5 < t5.length; r5++)(i5 = t5[r5]) && (i5.__ = n13, l10 = "function" == typeof i5.type ? $fb96b826c0c5f37a$var$x(i5, l10, u7) : $fb96b826c0c5f37a$var$P(u7, i5, i5, t5, i5.__e, l10));
	    return l10;
	}
	function $fb96b826c0c5f37a$export$47e4c5b300681277(n14, l11) {
	    return l11 = l11 || [], null == n14 || "boolean" == typeof n14 || (Array.isArray(n14) ? n14.some(function(n15) {
	        $fb96b826c0c5f37a$export$47e4c5b300681277(n15, l11);
	    }) : l11.push(n14)), l11;
	}
	function $fb96b826c0c5f37a$var$P(n16, l12, u8, i6, t6, r6) {
	    var o5, f4, e1;
	    if (void 0 !== l12.__d) o5 = l12.__d, l12.__d = void 0;
	    else if (null == u8 || t6 != r6 || null == t6.parentNode) n: if (null == r6 || r6.parentNode !== n16) n16.appendChild(t6), o5 = null;
	    else {
	        for(f4 = r6, e1 = 0; (f4 = f4.nextSibling) && e1 < i6.length; e1 += 2)if (f4 == t6) break n;
	        n16.insertBefore(t6, r6), o5 = r6;
	    }
	    return void 0 !== o5 ? o5 : t6.nextSibling;
	}
	function $fb96b826c0c5f37a$var$C(n17, l13, u9, i7, t7) {
	    var r7;
	    for(r7 in u9)"children" === r7 || "key" === r7 || r7 in l13 || $fb96b826c0c5f37a$var$H(n17, r7, null, u9[r7], i7);
	    for(r7 in l13)t7 && "function" != typeof l13[r7] || "children" === r7 || "key" === r7 || "value" === r7 || "checked" === r7 || u9[r7] === l13[r7] || $fb96b826c0c5f37a$var$H(n17, r7, l13[r7], u9[r7], i7);
	}
	function $fb96b826c0c5f37a$var$$(n18, l14, u10) {
	    "-" === l14[0] ? n18.setProperty(l14, u10) : n18[l14] = null == u10 ? "" : "number" != typeof u10 || $fb96b826c0c5f37a$var$s.test(l14) ? u10 : u10 + "px";
	}
	function $fb96b826c0c5f37a$var$H(n19, l15, u11, i8, t8) {
	    var r8;
	    n: if ("style" === l15) {
	        if ("string" == typeof u11) n19.style.cssText = u11;
	        else {
	            if ("string" == typeof i8 && (n19.style.cssText = i8 = ""), i8) for(l15 in i8)u11 && l15 in u11 || $fb96b826c0c5f37a$var$$(n19.style, l15, "");
	            if (u11) for(l15 in u11)i8 && u11[l15] === i8[l15] || $fb96b826c0c5f37a$var$$(n19.style, l15, u11[l15]);
	        }
	    } else if ("o" === l15[0] && "n" === l15[1]) r8 = l15 !== (l15 = l15.replace(/Capture$/, "")), l15 = l15.toLowerCase() in n19 ? l15.toLowerCase().slice(2) : l15.slice(2), n19.l || (n19.l = {}), n19.l[l15 + r8] = u11, u11 ? i8 || n19.addEventListener(l15, r8 ? $fb96b826c0c5f37a$var$T : $fb96b826c0c5f37a$var$I, r8) : n19.removeEventListener(l15, r8 ? $fb96b826c0c5f37a$var$T : $fb96b826c0c5f37a$var$I, r8);
	    else if ("dangerouslySetInnerHTML" !== l15) {
	        if (t8) l15 = l15.replace(/xlink[H:h]/, "h").replace(/sName$/, "s");
	        else if ("href" !== l15 && "list" !== l15 && "form" !== l15 && "tabIndex" !== l15 && "download" !== l15 && l15 in n19) try {
	            n19[l15] = null == u11 ? "" : u11;
	            break n;
	        } catch (n) {}
	        "function" == typeof u11 || (null != u11 && (!1 !== u11 || "a" === l15[0] && "r" === l15[1]) ? n19.setAttribute(l15, u11) : n19.removeAttribute(l15));
	    }
	}
	function $fb96b826c0c5f37a$var$I(n20) {
	    this.l[n20.type + !1]($fb96b826c0c5f37a$export$41c562ebe57d11e2.event ? $fb96b826c0c5f37a$export$41c562ebe57d11e2.event(n20) : n20);
	}
	function $fb96b826c0c5f37a$var$T(n21) {
	    this.l[n21.type + !0]($fb96b826c0c5f37a$export$41c562ebe57d11e2.event ? $fb96b826c0c5f37a$export$41c562ebe57d11e2.event(n21) : n21);
	}
	function $fb96b826c0c5f37a$var$j(n22, u12, i9, t9, r9, o6, f5, e2, c1) {
	    var s2, h2, v2, y1, p2, k1, b2, m2, g2, x1, A2, P1 = u12.type;
	    if (void 0 !== u12.constructor) return null;
	    null != i9.__h && (c1 = i9.__h, e2 = u12.__e = i9.__e, u12.__h = null, o6 = [
	        e2
	    ]), (s2 = $fb96b826c0c5f37a$export$41c562ebe57d11e2.__b) && s2(u12);
	    try {
	        n: if ("function" == typeof P1) {
	            if (m2 = u12.props, g2 = (s2 = P1.contextType) && t9[s2.__c], x1 = s2 ? g2 ? g2.props.value : s2.__ : t9, i9.__c ? b2 = (h2 = u12.__c = i9.__c).__ = h2.__E : ("prototype" in P1 && P1.prototype.render ? u12.__c = h2 = new P1(m2, x1) : (u12.__c = h2 = new $fb96b826c0c5f37a$export$16fa2f45be04daa8(m2, x1), h2.constructor = P1, h2.render = $fb96b826c0c5f37a$var$O), g2 && g2.sub(h2), h2.props = m2, h2.state || (h2.state = {}), h2.context = x1, h2.__n = t9, v2 = h2.__d = !0, h2.__h = []), null == h2.__s && (h2.__s = h2.state), null != P1.getDerivedStateFromProps && (h2.__s == h2.state && (h2.__s = $fb96b826c0c5f37a$var$a({}, h2.__s)), $fb96b826c0c5f37a$var$a(h2.__s, P1.getDerivedStateFromProps(m2, h2.__s))), y1 = h2.props, p2 = h2.state, v2) null == P1.getDerivedStateFromProps && null != h2.componentWillMount && h2.componentWillMount(), null != h2.componentDidMount && h2.__h.push(h2.componentDidMount);
	            else {
	                if (null == P1.getDerivedStateFromProps && m2 !== y1 && null != h2.componentWillReceiveProps && h2.componentWillReceiveProps(m2, x1), !h2.__e && null != h2.shouldComponentUpdate && !1 === h2.shouldComponentUpdate(m2, h2.__s, x1) || u12.__v === i9.__v) {
	                    h2.props = m2, h2.state = h2.__s, u12.__v !== i9.__v && (h2.__d = !1), h2.__v = u12, u12.__e = i9.__e, u12.__k = i9.__k, u12.__k.forEach(function(n23) {
	                        n23 && (n23.__ = u12);
	                    }), h2.__h.length && f5.push(h2);
	                    break n;
	                }
	                null != h2.componentWillUpdate && h2.componentWillUpdate(m2, h2.__s, x1), null != h2.componentDidUpdate && h2.__h.push(function() {
	                    h2.componentDidUpdate(y1, p2, k1);
	                });
	            }
	            h2.context = x1, h2.props = m2, h2.state = h2.__s, (s2 = $fb96b826c0c5f37a$export$41c562ebe57d11e2.__r) && s2(u12), h2.__d = !1, h2.__v = u12, h2.__P = n22, s2 = h2.render(h2.props, h2.state, h2.context), h2.state = h2.__s, null != h2.getChildContext && (t9 = $fb96b826c0c5f37a$var$a($fb96b826c0c5f37a$var$a({}, t9), h2.getChildContext())), v2 || null == h2.getSnapshotBeforeUpdate || (k1 = h2.getSnapshotBeforeUpdate(y1, p2)), A2 = null != s2 && s2.type === $fb96b826c0c5f37a$export$ffb0004e005737fa && null == s2.key ? s2.props.children : s2, $fb96b826c0c5f37a$var$w(n22, Array.isArray(A2) ? A2 : [
	                A2
	            ], u12, i9, t9, r9, o6, f5, e2, c1), h2.base = u12.__e, u12.__h = null, h2.__h.length && f5.push(h2), b2 && (h2.__E = h2.__ = null), h2.__e = !1;
	        } else null == o6 && u12.__v === i9.__v ? (u12.__k = i9.__k, u12.__e = i9.__e) : u12.__e = $fb96b826c0c5f37a$var$L(i9.__e, u12, i9, t9, r9, o6, f5, c1);
	        (s2 = $fb96b826c0c5f37a$export$41c562ebe57d11e2.diffed) && s2(u12);
	    } catch (n24) {
	        u12.__v = null, (c1 || null != o6) && (u12.__e = e2, u12.__h = !!c1, o6[o6.indexOf(e2)] = null), $fb96b826c0c5f37a$export$41c562ebe57d11e2.__e(n24, u12, i9);
	    }
	}
	function $fb96b826c0c5f37a$var$z(n25, u13) {
	    $fb96b826c0c5f37a$export$41c562ebe57d11e2.__c && $fb96b826c0c5f37a$export$41c562ebe57d11e2.__c(u13, n25), n25.some(function(u14) {
	        try {
	            n25 = u14.__h, u14.__h = [], n25.some(function(n26) {
	                n26.call(u14);
	            });
	        } catch (n27) {
	            $fb96b826c0c5f37a$export$41c562ebe57d11e2.__e(n27, u14.__v);
	        }
	    });
	}
	function $fb96b826c0c5f37a$var$L(l16, u15, i10, t10, r10, o7, f6, c2) {
	    var s3, a2, v3, y2 = i10.props, p3 = u15.props, d1 = u15.type, _2 = 0;
	    if ("svg" === d1 && (r10 = !0), null != o7) {
	        for(; _2 < o7.length; _2++)if ((s3 = o7[_2]) && "setAttribute" in s3 == !!d1 && (d1 ? s3.localName === d1 : 3 === s3.nodeType)) {
	            l16 = s3, o7[_2] = null;
	            break;
	        }
	    }
	    if (null == l16) {
	        if (null === d1) return document.createTextNode(p3);
	        l16 = r10 ? document.createElementNS("http://www.w3.org/2000/svg", d1) : document.createElement(d1, p3.is && p3), o7 = null, c2 = !1;
	    }
	    if (null === d1) y2 === p3 || c2 && l16.data === p3 || (l16.data = p3);
	    else {
	        if (o7 = o7 && $fb96b826c0c5f37a$var$n.call(l16.childNodes), a2 = (y2 = i10.props || $fb96b826c0c5f37a$var$e).dangerouslySetInnerHTML, v3 = p3.dangerouslySetInnerHTML, !c2) {
	            if (null != o7) for(y2 = {}, _2 = 0; _2 < l16.attributes.length; _2++)y2[l16.attributes[_2].name] = l16.attributes[_2].value;
	            (v3 || a2) && (v3 && (a2 && v3.__html == a2.__html || v3.__html === l16.innerHTML) || (l16.innerHTML = v3 && v3.__html || ""));
	        }
	        if ($fb96b826c0c5f37a$var$C(l16, p3, y2, r10, c2), v3) u15.__k = [];
	        else if (_2 = u15.props.children, $fb96b826c0c5f37a$var$w(l16, Array.isArray(_2) ? _2 : [
	            _2
	        ], u15, i10, t10, r10 && "foreignObject" !== d1, o7, f6, o7 ? o7[0] : i10.__k && $fb96b826c0c5f37a$var$k(i10, 0), c2), null != o7) for(_2 = o7.length; _2--;)null != o7[_2] && $fb96b826c0c5f37a$var$h(o7[_2]);
	        c2 || ("value" in p3 && void 0 !== (_2 = p3.value) && (_2 !== y2.value || _2 !== l16.value || "progress" === d1 && !_2) && $fb96b826c0c5f37a$var$H(l16, "value", _2, y2.value, !1), "checked" in p3 && void 0 !== (_2 = p3.checked) && _2 !== l16.checked && $fb96b826c0c5f37a$var$H(l16, "checked", _2, y2.checked, !1));
	    }
	    return l16;
	}
	function $fb96b826c0c5f37a$var$M(n28, u16, i11) {
	    try {
	        "function" == typeof n28 ? n28(u16) : n28.current = u16;
	    } catch (n29) {
	        $fb96b826c0c5f37a$export$41c562ebe57d11e2.__e(n29, i11);
	    }
	}
	function $fb96b826c0c5f37a$var$N(n30, u17, i12) {
	    var t11, r11;
	    if ($fb96b826c0c5f37a$export$41c562ebe57d11e2.unmount && $fb96b826c0c5f37a$export$41c562ebe57d11e2.unmount(n30), (t11 = n30.ref) && (t11.current && t11.current !== n30.__e || $fb96b826c0c5f37a$var$M(t11, null, u17)), null != (t11 = n30.__c)) {
	        if (t11.componentWillUnmount) try {
	            t11.componentWillUnmount();
	        } catch (n31) {
	            $fb96b826c0c5f37a$export$41c562ebe57d11e2.__e(n31, u17);
	        }
	        t11.base = t11.__P = null;
	    }
	    if (t11 = n30.__k) for(r11 = 0; r11 < t11.length; r11++)t11[r11] && $fb96b826c0c5f37a$var$N(t11[r11], u17, "function" != typeof n30.type);
	    i12 || null == n30.__e || $fb96b826c0c5f37a$var$h(n30.__e), n30.__e = n30.__d = void 0;
	}
	function $fb96b826c0c5f37a$var$O(n32, l, u18) {
	    return this.constructor(n32, u18);
	}
	function $fb96b826c0c5f37a$export$b3890eb0ae9dca99(u19, i13, t12) {
	    var r12, o8, f7;
	    $fb96b826c0c5f37a$export$41c562ebe57d11e2.__ && $fb96b826c0c5f37a$export$41c562ebe57d11e2.__(u19, i13), o8 = (r12 = "function" == typeof t12) ? null : t12 && t12.__k || i13.__k, f7 = [], $fb96b826c0c5f37a$var$j(i13, u19 = (!r12 && t12 || i13).__k = $fb96b826c0c5f37a$export$c8a8987d4410bf2d($fb96b826c0c5f37a$export$ffb0004e005737fa, null, [
	        u19
	    ]), o8 || $fb96b826c0c5f37a$var$e, $fb96b826c0c5f37a$var$e, void 0 !== i13.ownerSVGElement, !r12 && t12 ? [
	        t12
	    ] : o8 ? null : i13.firstChild ? $fb96b826c0c5f37a$var$n.call(i13.childNodes) : null, f7, !r12 && t12 ? t12 : o8 ? o8.__e : i13.firstChild, r12), $fb96b826c0c5f37a$var$z(f7, u19);
	}
	$fb96b826c0c5f37a$var$n = $fb96b826c0c5f37a$var$c.slice, $fb96b826c0c5f37a$export$41c562ebe57d11e2 = {
	    __e: function(n39, l22) {
	        for(var u23, i16, t14; l22 = l22.__;)if ((u23 = l22.__c) && !u23.__) try {
	            if ((i16 = u23.constructor) && null != i16.getDerivedStateFromError && (u23.setState(i16.getDerivedStateFromError(n39)), t14 = u23.__d), null != u23.componentDidCatch && (u23.componentDidCatch(n39), t14 = u23.__d), t14) return u23.__E = u23;
	        } catch (l23) {
	            n39 = l23;
	        }
	        throw n39;
	    }
	}, $fb96b826c0c5f37a$var$u = 0, $fb96b826c0c5f37a$export$16fa2f45be04daa8.prototype.setState = function(n41, l24) {
	    var u24;
	    u24 = null != this.__s && this.__s !== this.state ? this.__s : this.__s = $fb96b826c0c5f37a$var$a({}, this.state), "function" == typeof n41 && (n41 = n41($fb96b826c0c5f37a$var$a({}, u24), this.props)), n41 && $fb96b826c0c5f37a$var$a(u24, n41), null != n41 && this.__v && (l24 && this.__h.push(l24), $fb96b826c0c5f37a$var$m(this));
	}, $fb96b826c0c5f37a$export$16fa2f45be04daa8.prototype.forceUpdate = function(n42) {
	    this.__v && (this.__e = !0, n42 && this.__h.push(n42), $fb96b826c0c5f37a$var$m(this));
	}, $fb96b826c0c5f37a$export$16fa2f45be04daa8.prototype.render = $fb96b826c0c5f37a$export$ffb0004e005737fa, $fb96b826c0c5f37a$var$t = [], $fb96b826c0c5f37a$var$r = "function" == typeof Promise ? Promise.prototype.then.bind(Promise.resolve()) : setTimeout, $fb96b826c0c5f37a$var$g.__r = 0;



	var $bd9dd35321b03dd4$var$o = 0;
	function $bd9dd35321b03dd4$export$34b9dba7ce09269b(_1, e1, n, t, f) {
	    var l, s, u = {};
	    for(s in e1)"ref" == s ? l = e1[s] : u[s] = e1[s];
	    var a = {
	        type: _1,
	        props: u,
	        key: n,
	        ref: l,
	        __k: null,
	        __: null,
	        __b: 0,
	        __e: null,
	        __d: void 0,
	        __c: null,
	        __h: null,
	        constructor: void 0,
	        __v: --$bd9dd35321b03dd4$var$o,
	        __source: t,
	        __self: f
	    };
	    if ("function" == typeof _1 && (l = _1.defaultProps)) for(s in l)void 0 === u[s] && (u[s] = l[s]);
	    return ($fb96b826c0c5f37a$export$41c562ebe57d11e2).vnode && ($fb96b826c0c5f37a$export$41c562ebe57d11e2).vnode(a), a;
	}



	function $f72b75cf796873c7$var$set(key, value) {
	    try {
	        window.localStorage[`emoji-mart.${key}`] = JSON.stringify(value);
	    } catch (error) {}
	}
	function $f72b75cf796873c7$var$get(key) {
	    try {
	        const value = window.localStorage[`emoji-mart.${key}`];
	        if (value) return JSON.parse(value);
	    } catch (error) {}
	}
	var $f72b75cf796873c7$export$2e2bcd8739ae039 = {
	    set: $f72b75cf796873c7$var$set,
	    get: $f72b75cf796873c7$var$get
	};


	const $c84d045dcc34faf5$var$CACHE = new Map();
	const $c84d045dcc34faf5$var$VERSIONS = [
	    {
	        v: 14,
	        emoji: "\uD83E\uDEE0"
	    },
	    {
	        v: 13.1,
	        emoji: "\uD83D\uDE36\u200D\uD83C\uDF2B\uFE0F"
	    },
	    {
	        v: 13,
	        emoji: "\uD83E\uDD78"
	    },
	    {
	        v: 12.1,
	        emoji: "\uD83E\uDDD1\u200D\uD83E\uDDB0"
	    },
	    {
	        v: 12,
	        emoji: "\uD83E\uDD71"
	    },
	    {
	        v: 11,
	        emoji: "\uD83E\uDD70"
	    },
	    {
	        v: 5,
	        emoji: "\uD83E\uDD29"
	    },
	    {
	        v: 4,
	        emoji: "\uD83D\uDC71\u200D\u2640\uFE0F"
	    },
	    {
	        v: 3,
	        emoji: "\uD83E\uDD23"
	    },
	    {
	        v: 2,
	        emoji: "\uD83D\uDC4B\uD83C\uDFFB"
	    },
	    {
	        v: 1,
	        emoji: "\uD83D\uDE43"
	    }, 
	];
	function $c84d045dcc34faf5$var$latestVersion() {
	    for (const { v: v , emoji: emoji  } of $c84d045dcc34faf5$var$VERSIONS){
	        if ($c84d045dcc34faf5$var$isSupported(emoji)) return v;
	    }
	}
	function $c84d045dcc34faf5$var$noCountryFlags() {
	    if ($c84d045dcc34faf5$var$isSupported("\uD83C\uDDE8\uD83C\uDDE6")) return false;
	    return true;
	}
	function $c84d045dcc34faf5$var$isSupported(emoji) {
	    if ($c84d045dcc34faf5$var$CACHE.has(emoji)) return $c84d045dcc34faf5$var$CACHE.get(emoji);
	    const supported = $c84d045dcc34faf5$var$isEmojiSupported(emoji);
	    $c84d045dcc34faf5$var$CACHE.set(emoji, supported);
	    return supported;
	}
	// https://github.com/koala-interactive/is-emoji-supported
	const $c84d045dcc34faf5$var$isEmojiSupported = (()=>{
	    let ctx = null;
	    try {
	        if (!navigator.userAgent.includes("jsdom")) ctx = document.createElement("canvas").getContext("2d", {
	            willReadFrequently: true
	        });
	    } catch  {}
	    // Not in browser env
	    if (!ctx) return ()=>false;
	    const CANVAS_HEIGHT = 25;
	    const CANVAS_WIDTH = 20;
	    const textSize = Math.floor(CANVAS_HEIGHT / 2);
	    // Initialize convas context
	    ctx.font = textSize + "px Arial, Sans-Serif";
	    ctx.textBaseline = "top";
	    ctx.canvas.width = CANVAS_WIDTH * 2;
	    ctx.canvas.height = CANVAS_HEIGHT;
	    return (unicode)=>{
	        ctx.clearRect(0, 0, CANVAS_WIDTH * 2, CANVAS_HEIGHT);
	        // Draw in red on the left
	        ctx.fillStyle = "#FF0000";
	        ctx.fillText(unicode, 0, 22);
	        // Draw in blue on right
	        ctx.fillStyle = "#0000FF";
	        ctx.fillText(unicode, CANVAS_WIDTH, 22);
	        const a = ctx.getImageData(0, 0, CANVAS_WIDTH, CANVAS_HEIGHT).data;
	        const count = a.length;
	        let i = 0;
	        // Search the first visible pixel
	        for(; i < count && !a[i + 3]; i += 4);
	        // No visible pixel
	        if (i >= count) return false;
	        // Emoji has immutable color, so we check the color of the emoji in two different colors
	        // the result show be the same.
	        const x = CANVAS_WIDTH + i / 4 % CANVAS_WIDTH;
	        const y = Math.floor(i / 4 / CANVAS_WIDTH);
	        const b = ctx.getImageData(x, y, 1, 1).data;
	        if (a[i] !== b[0] || a[i + 2] !== b[2]) return false;
	        // Some emojis are a contraction of different ones, so if it's not
	        // supported, it will show multiple characters
	        if (ctx.measureText(unicode).width >= CANVAS_WIDTH) return false;
	        // Supported
	        return true;
	    };
	})();
	var $c84d045dcc34faf5$export$2e2bcd8739ae039 = {
	    latestVersion: $c84d045dcc34faf5$var$latestVersion,
	    noCountryFlags: $c84d045dcc34faf5$var$noCountryFlags
	};



	const $b22cfd0a55410b4f$var$DEFAULTS = [
	    "+1",
	    "grinning",
	    "kissing_heart",
	    "heart_eyes",
	    "laughing",
	    "stuck_out_tongue_winking_eye",
	    "sweat_smile",
	    "joy",
	    "scream",
	    "disappointed",
	    "unamused",
	    "weary",
	    "sob",
	    "sunglasses",
	    "heart", 
	];
	let $b22cfd0a55410b4f$var$Index = null;
	function $b22cfd0a55410b4f$var$add(emoji) {
	    $b22cfd0a55410b4f$var$Index || ($b22cfd0a55410b4f$var$Index = ($f72b75cf796873c7$export$2e2bcd8739ae039).get("frequently") || {});
	    const emojiId = emoji.id || emoji;
	    if (!emojiId) return;
	    $b22cfd0a55410b4f$var$Index[emojiId] || ($b22cfd0a55410b4f$var$Index[emojiId] = 0);
	    $b22cfd0a55410b4f$var$Index[emojiId] += 1;
	    ($f72b75cf796873c7$export$2e2bcd8739ae039).set("last", emojiId);
	    ($f72b75cf796873c7$export$2e2bcd8739ae039).set("frequently", $b22cfd0a55410b4f$var$Index);
	}
	function $b22cfd0a55410b4f$var$get({ maxFrequentRows: maxFrequentRows , perLine: perLine  }) {
	    if (!maxFrequentRows) return [];
	    $b22cfd0a55410b4f$var$Index || ($b22cfd0a55410b4f$var$Index = ($f72b75cf796873c7$export$2e2bcd8739ae039).get("frequently"));
	    let emojiIds = [];
	    if (!$b22cfd0a55410b4f$var$Index) {
	        $b22cfd0a55410b4f$var$Index = {};
	        for(let i in $b22cfd0a55410b4f$var$DEFAULTS.slice(0, perLine)){
	            const emojiId = $b22cfd0a55410b4f$var$DEFAULTS[i];
	            $b22cfd0a55410b4f$var$Index[emojiId] = perLine - i;
	            emojiIds.push(emojiId);
	        }
	        return emojiIds;
	    }
	    const max = maxFrequentRows * perLine;
	    const last = ($f72b75cf796873c7$export$2e2bcd8739ae039).get("last");
	    for(let emojiId in $b22cfd0a55410b4f$var$Index)emojiIds.push(emojiId);
	    emojiIds.sort((a, b)=>{
	        const aScore = $b22cfd0a55410b4f$var$Index[b];
	        const bScore = $b22cfd0a55410b4f$var$Index[a];
	        if (aScore == bScore) return a.localeCompare(b);
	        return aScore - bScore;
	    });
	    if (emojiIds.length > max) {
	        const removedIds = emojiIds.slice(max);
	        emojiIds = emojiIds.slice(0, max);
	        for (let removedId of removedIds){
	            if (removedId == last) continue;
	            delete $b22cfd0a55410b4f$var$Index[removedId];
	        }
	        if (last && emojiIds.indexOf(last) == -1) {
	            delete $b22cfd0a55410b4f$var$Index[emojiIds[emojiIds.length - 1]];
	            emojiIds.splice(-1, 1, last);
	        }
	        ($f72b75cf796873c7$export$2e2bcd8739ae039).set("frequently", $b22cfd0a55410b4f$var$Index);
	    }
	    return emojiIds;
	}
	var $b22cfd0a55410b4f$export$2e2bcd8739ae039 = {
	    add: $b22cfd0a55410b4f$var$add,
	    get: $b22cfd0a55410b4f$var$get,
	    DEFAULTS: $b22cfd0a55410b4f$var$DEFAULTS
	};


	var $8d50d93417ef682a$exports = {};
	$8d50d93417ef682a$exports = JSON.parse('{"search":"Search","search_no_results_1":"Oh no!","search_no_results_2":"That emoji couldn\u2019t be found","pick":"Pick an emoji\u2026","add_custom":"Add custom emoji","categories":{"activity":"Activity","custom":"Custom","flags":"Flags","foods":"Food & Drink","frequent":"Frequently used","nature":"Animals & Nature","objects":"Objects","people":"Smileys & People","places":"Travel & Places","search":"Search Results","symbols":"Symbols"},"skins":{"1":"Default","2":"Light","3":"Medium-Light","4":"Medium","5":"Medium-Dark","6":"Dark","choose":"Choose default skin tone"}}');


	var $b247ea80b67298d5$export$2e2bcd8739ae039 = {
	    autoFocus: {
	        value: false
	    },
	    dynamicWidth: {
	        value: false
	    },
	    emojiButtonColors: {
	        value: null
	    },
	    emojiButtonRadius: {
	        value: "100%"
	    },
	    emojiButtonSize: {
	        value: 36
	    },
	    emojiSize: {
	        value: 24
	    },
	    emojiVersion: {
	        value: 14,
	        choices: [
	            1,
	            2,
	            3,
	            4,
	            5,
	            11,
	            12,
	            12.1,
	            13,
	            13.1,
	            14
	        ]
	    },
	    exceptEmojis: {
	        value: []
	    },
	    icons: {
	        value: "auto",
	        choices: [
	            "auto",
	            "outline",
	            "solid"
	        ]
	    },
	    locale: {
	        value: "en",
	        choices: [
	            "en",
	            "ar",
	            "be",
	            "cs",
	            "de",
	            "es",
	            "fa",
	            "fi",
	            "fr",
	            "hi",
	            "it",
	            "ja",
	            "kr",
	            "nl",
	            "pl",
	            "pt",
	            "ru",
	            "sa",
	            "tr",
	            "uk",
	            "vi",
	            "zh", 
	        ]
	    },
	    maxFrequentRows: {
	        value: 4
	    },
	    navPosition: {
	        value: "top",
	        choices: [
	            "top",
	            "bottom",
	            "none"
	        ]
	    },
	    noCountryFlags: {
	        value: false
	    },
	    noResultsEmoji: {
	        value: null
	    },
	    perLine: {
	        value: 9
	    },
	    previewEmoji: {
	        value: null
	    },
	    previewPosition: {
	        value: "bottom",
	        choices: [
	            "top",
	            "bottom",
	            "none"
	        ]
	    },
	    searchPosition: {
	        value: "sticky",
	        choices: [
	            "sticky",
	            "static",
	            "none"
	        ]
	    },
	    set: {
	        value: "native",
	        choices: [
	            "native",
	            "apple",
	            "facebook",
	            "google",
	            "twitter"
	        ]
	    },
	    skin: {
	        value: 1,
	        choices: [
	            1,
	            2,
	            3,
	            4,
	            5,
	            6
	        ]
	    },
	    skinTonePosition: {
	        value: "preview",
	        choices: [
	            "preview",
	            "search",
	            "none"
	        ]
	    },
	    theme: {
	        value: "auto",
	        choices: [
	            "auto",
	            "light",
	            "dark"
	        ]
	    },
	    // Data
	    categories: null,
	    categoryIcons: null,
	    custom: null,
	    data: null,
	    i18n: null,
	    // Callbacks
	    getImageURL: null,
	    getSpritesheetURL: null,
	    onAddCustomEmoji: null,
	    onClickOutside: null,
	    onEmojiSelect: null,
	    // Deprecated
	    stickySearch: {
	        deprecated: true,
	        value: true
	    }
	};



	let $7adb23b0109cc36a$export$dbe3113d60765c1a = null;
	let $7adb23b0109cc36a$export$2d0294657ab35f1b = null;
	const $7adb23b0109cc36a$var$fetchCache = {};
	async function $7adb23b0109cc36a$var$fetchJSON(src) {
	    if ($7adb23b0109cc36a$var$fetchCache[src]) return $7adb23b0109cc36a$var$fetchCache[src];
	    const response = await fetch(src);
	    const json = await response.json();
	    $7adb23b0109cc36a$var$fetchCache[src] = json;
	    return json;
	}
	let $7adb23b0109cc36a$var$promise = null;
	let $7adb23b0109cc36a$var$initCallback = null;
	let $7adb23b0109cc36a$var$initialized = false;
	function $7adb23b0109cc36a$export$2cd8252107eb640b(options, { caller: caller  } = {}) {
	    $7adb23b0109cc36a$var$promise || ($7adb23b0109cc36a$var$promise = new Promise((resolve)=>{
	        $7adb23b0109cc36a$var$initCallback = resolve;
	    }));
	    if (options) $7adb23b0109cc36a$var$_init(options);
	    else if (caller && !$7adb23b0109cc36a$var$initialized) console.warn(`\`${caller}\` requires data to be initialized first. Promise will be pending until \`init\` is called.`);
	    return $7adb23b0109cc36a$var$promise;
	}
	async function $7adb23b0109cc36a$var$_init(props) {
	    $7adb23b0109cc36a$var$initialized = true;
	    let { emojiVersion: emojiVersion , set: set , locale: locale  } = props;
	    emojiVersion || (emojiVersion = ($b247ea80b67298d5$export$2e2bcd8739ae039).emojiVersion.value);
	    set || (set = ($b247ea80b67298d5$export$2e2bcd8739ae039).set.value);
	    locale || (locale = ($b247ea80b67298d5$export$2e2bcd8739ae039).locale.value);
	    if (!$7adb23b0109cc36a$export$2d0294657ab35f1b) {
	        $7adb23b0109cc36a$export$2d0294657ab35f1b = (typeof props.data === "function" ? await props.data() : props.data) || await $7adb23b0109cc36a$var$fetchJSON(`https://cdn.jsdelivr.net/npm/@emoji-mart/data@latest/sets/${emojiVersion}/${set}.json`);
	        $7adb23b0109cc36a$export$2d0294657ab35f1b.emoticons = {};
	        $7adb23b0109cc36a$export$2d0294657ab35f1b.natives = {};
	        $7adb23b0109cc36a$export$2d0294657ab35f1b.categories.unshift({
	            id: "frequent",
	            emojis: []
	        });
	        for(const alias in $7adb23b0109cc36a$export$2d0294657ab35f1b.aliases){
	            const emojiId = $7adb23b0109cc36a$export$2d0294657ab35f1b.aliases[alias];
	            const emoji = $7adb23b0109cc36a$export$2d0294657ab35f1b.emojis[emojiId];
	            if (!emoji) continue;
	            emoji.aliases || (emoji.aliases = []);
	            emoji.aliases.push(alias);
	        }
	        $7adb23b0109cc36a$export$2d0294657ab35f1b.originalCategories = $7adb23b0109cc36a$export$2d0294657ab35f1b.categories;
	    } else $7adb23b0109cc36a$export$2d0294657ab35f1b.categories = $7adb23b0109cc36a$export$2d0294657ab35f1b.categories.filter((c)=>{
	        const isCustom = !!c.name;
	        if (!isCustom) return true;
	        return false;
	    });
	    $7adb23b0109cc36a$export$dbe3113d60765c1a = (typeof props.i18n === "function" ? await props.i18n() : props.i18n) || (locale == "en" ? ((/*@__PURE__*/$parcel$interopDefault($8d50d93417ef682a$exports))) : await $7adb23b0109cc36a$var$fetchJSON(`https://cdn.jsdelivr.net/npm/@emoji-mart/data@latest/i18n/${locale}.json`));
	    if (props.custom) for(let i in props.custom){
	        i = parseInt(i);
	        const category = props.custom[i];
	        const prevCategory = props.custom[i - 1];
	        if (!category.emojis || !category.emojis.length) continue;
	        category.id || (category.id = `custom_${i + 1}`);
	        category.name || (category.name = $7adb23b0109cc36a$export$dbe3113d60765c1a.categories.custom);
	        if (prevCategory && !category.icon) category.target = prevCategory.target || prevCategory;
	        $7adb23b0109cc36a$export$2d0294657ab35f1b.categories.push(category);
	        for (const emoji of category.emojis)$7adb23b0109cc36a$export$2d0294657ab35f1b.emojis[emoji.id] = emoji;
	    }
	    if (props.categories) $7adb23b0109cc36a$export$2d0294657ab35f1b.categories = $7adb23b0109cc36a$export$2d0294657ab35f1b.originalCategories.filter((c)=>{
	        return props.categories.indexOf(c.id) != -1;
	    }).sort((c1, c2)=>{
	        const i1 = props.categories.indexOf(c1.id);
	        const i2 = props.categories.indexOf(c2.id);
	        return i1 - i2;
	    });
	    let latestVersionSupport = null;
	    let noCountryFlags = null;
	    if (set == "native") {
	        latestVersionSupport = ($c84d045dcc34faf5$export$2e2bcd8739ae039).latestVersion();
	        noCountryFlags = props.noCountryFlags || ($c84d045dcc34faf5$export$2e2bcd8739ae039).noCountryFlags();
	    }
	    let categoryIndex = $7adb23b0109cc36a$export$2d0294657ab35f1b.categories.length;
	    let resetSearchIndex = false;
	    while(categoryIndex--){
	        const category = $7adb23b0109cc36a$export$2d0294657ab35f1b.categories[categoryIndex];
	        if (category.id == "frequent") {
	            let { maxFrequentRows: maxFrequentRows , perLine: perLine  } = props;
	            maxFrequentRows = maxFrequentRows >= 0 ? maxFrequentRows : ($b247ea80b67298d5$export$2e2bcd8739ae039).maxFrequentRows.value;
	            perLine || (perLine = ($b247ea80b67298d5$export$2e2bcd8739ae039).perLine.value);
	            category.emojis = ($b22cfd0a55410b4f$export$2e2bcd8739ae039).get({
	                maxFrequentRows: maxFrequentRows,
	                perLine: perLine
	            });
	        }
	        if (!category.emojis || !category.emojis.length) {
	            $7adb23b0109cc36a$export$2d0294657ab35f1b.categories.splice(categoryIndex, 1);
	            continue;
	        }
	        const { categoryIcons: categoryIcons  } = props;
	        if (categoryIcons) {
	            const icon = categoryIcons[category.id];
	            if (icon && !category.icon) category.icon = icon;
	        }
	        let emojiIndex = category.emojis.length;
	        while(emojiIndex--){
	            const emojiId = category.emojis[emojiIndex];
	            const emoji = emojiId.id ? emojiId : $7adb23b0109cc36a$export$2d0294657ab35f1b.emojis[emojiId];
	            const ignore = ()=>{
	                category.emojis.splice(emojiIndex, 1);
	            };
	            if (!emoji || props.exceptEmojis && props.exceptEmojis.includes(emoji.id)) {
	                ignore();
	                continue;
	            }
	            if (latestVersionSupport && emoji.version > latestVersionSupport) {
	                ignore();
	                continue;
	            }
	            if (noCountryFlags && category.id == "flags") {
	                if (!($e6eae5155b87f591$export$bcb25aa587e9cb13).includes(emoji.id)) {
	                    ignore();
	                    continue;
	                }
	            }
	            if (!emoji.search) {
	                resetSearchIndex = true;
	                emoji.search = "," + [
	                    [
	                        emoji.id,
	                        false
	                    ],
	                    [
	                        emoji.name,
	                        true
	                    ],
	                    [
	                        emoji.keywords,
	                        false
	                    ],
	                    [
	                        emoji.emoticons,
	                        false
	                    ], 
	                ].map(([strings, split])=>{
	                    if (!strings) return;
	                    return (Array.isArray(strings) ? strings : [
	                        strings
	                    ]).map((string)=>{
	                        return (split ? string.split(/[-|_|\s]+/) : [
	                            string
	                        ]).map((s)=>s.toLowerCase());
	                    }).flat();
	                }).flat().filter((a)=>a && a.trim()).join(",");
	                if (emoji.emoticons) for (const emoticon of emoji.emoticons){
	                    if ($7adb23b0109cc36a$export$2d0294657ab35f1b.emoticons[emoticon]) continue;
	                    $7adb23b0109cc36a$export$2d0294657ab35f1b.emoticons[emoticon] = emoji.id;
	                }
	                let skinIndex = 0;
	                for (const skin of emoji.skins){
	                    if (!skin) continue;
	                    skinIndex++;
	                    const { native: native  } = skin;
	                    if (native) {
	                        $7adb23b0109cc36a$export$2d0294657ab35f1b.natives[native] = emoji.id;
	                        emoji.search += `,${native}`;
	                    }
	                    const skinShortcodes = skinIndex == 1 ? "" : `:skin-tone-${skinIndex}:`;
	                    skin.shortcodes = `:${emoji.id}:${skinShortcodes}`;
	                }
	            }
	        }
	    }
	    if (resetSearchIndex) ($c4d155af13ad4d4b$export$2e2bcd8739ae039).reset();
	    $7adb23b0109cc36a$var$initCallback();
	}
	function $7adb23b0109cc36a$export$75fe5f91d452f94b(props, defaultProps, element) {
	    props || (props = {});
	    const _props = {};
	    for(let k in defaultProps)_props[k] = $7adb23b0109cc36a$export$88c9ddb45cea7241(k, props, defaultProps, element);
	    return _props;
	}
	function $7adb23b0109cc36a$export$88c9ddb45cea7241(propName, props, defaultProps, element) {
	    const defaults = defaultProps[propName];
	    let value = element && element.getAttribute(propName) || (props[propName] != null && props[propName] != undefined ? props[propName] : null);
	    if (!defaults) return value;
	    if (value != null && defaults.value && typeof defaults.value != typeof value) {
	        if (typeof defaults.value == "boolean") value = value == "false" ? false : true;
	        else value = defaults.value.constructor(value);
	    }
	    if (defaults.transform && value) value = defaults.transform(value);
	    if (value == null || defaults.choices && defaults.choices.indexOf(value) == -1) value = defaults.value;
	    return value;
	}


	const $c4d155af13ad4d4b$var$SHORTCODES_REGEX = /^(?:\:([^\:]+)\:)(?:\:skin-tone-(\d)\:)?$/;
	let $c4d155af13ad4d4b$var$Pool = null;
	function $c4d155af13ad4d4b$var$get(emojiId) {
	    if (emojiId.id) return emojiId;
	    return ($7adb23b0109cc36a$export$2d0294657ab35f1b).emojis[emojiId] || ($7adb23b0109cc36a$export$2d0294657ab35f1b).emojis[($7adb23b0109cc36a$export$2d0294657ab35f1b).aliases[emojiId]] || ($7adb23b0109cc36a$export$2d0294657ab35f1b).emojis[($7adb23b0109cc36a$export$2d0294657ab35f1b).natives[emojiId]];
	}
	function $c4d155af13ad4d4b$var$reset() {
	    $c4d155af13ad4d4b$var$Pool = null;
	}
	async function $c4d155af13ad4d4b$var$search(value, { maxResults: maxResults , caller: caller  } = {}) {
	    if (!value || !value.trim().length) return null;
	    maxResults || (maxResults = 90);
	    await ($7adb23b0109cc36a$export$2cd8252107eb640b)(null, {
	        caller: caller || "SearchIndex.search"
	    });
	    const values = value.toLowerCase().replace(/(\w)-/, "$1 ").split(/[\s|,]+/).filter((word, i, words)=>{
	        return word.trim() && words.indexOf(word) == i;
	    });
	    if (!values.length) return;
	    let pool = $c4d155af13ad4d4b$var$Pool || ($c4d155af13ad4d4b$var$Pool = Object.values(($7adb23b0109cc36a$export$2d0294657ab35f1b).emojis));
	    let results, scores;
	    for (const value1 of values){
	        if (!pool.length) break;
	        results = [];
	        scores = {};
	        for (const emoji of pool){
	            if (!emoji.search) continue;
	            const score = emoji.search.indexOf(`,${value1}`);
	            if (score == -1) continue;
	            results.push(emoji);
	            scores[emoji.id] || (scores[emoji.id] = 0);
	            scores[emoji.id] += emoji.id == value1 ? 0 : score + 1;
	        }
	        pool = results;
	    }
	    if (results.length < 2) return results;
	    results.sort((a, b)=>{
	        const aScore = scores[a.id];
	        const bScore = scores[b.id];
	        if (aScore == bScore) return a.id.localeCompare(b.id);
	        return aScore - bScore;
	    });
	    if (results.length > maxResults) results = results.slice(0, maxResults);
	    return results;
	}
	var $c4d155af13ad4d4b$export$2e2bcd8739ae039 = {
	    search: $c4d155af13ad4d4b$var$search,
	    get: $c4d155af13ad4d4b$var$get,
	    reset: $c4d155af13ad4d4b$var$reset,
	    SHORTCODES_REGEX: $c4d155af13ad4d4b$var$SHORTCODES_REGEX
	};


	const $e6eae5155b87f591$export$bcb25aa587e9cb13 = [
	    "checkered_flag",
	    "crossed_flags",
	    "pirate_flag",
	    "rainbow-flag",
	    "transgender_flag",
	    "triangular_flag_on_post",
	    "waving_black_flag",
	    "waving_white_flag", 
	];


	function $693b183b0a78708f$export$9cb4719e2e525b7a(a, b) {
	    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((val, index)=>val == b[index]);
	}
	async function $693b183b0a78708f$export$e772c8ff12451969(frames = 1) {
	    for(let _ in [
	        ...Array(frames).keys()
	    ])await new Promise(requestAnimationFrame);
	}
	function $693b183b0a78708f$export$d10ac59fbe52a745(emoji, { skinIndex: skinIndex = 0  } = {}) {
	    const skin = emoji.skins[skinIndex] || (()=>{
	        skinIndex = 0;
	        return emoji.skins[skinIndex];
	    })();
	    const emojiData = {
	        id: emoji.id,
	        name: emoji.name,
	        native: skin.native,
	        unified: skin.unified,
	        keywords: emoji.keywords,
	        shortcodes: skin.shortcodes || emoji.shortcodes
	    };
	    if (emoji.skins.length > 1) emojiData.skin = skinIndex + 1;
	    if (skin.src) emojiData.src = skin.src;
	    if (emoji.aliases && emoji.aliases.length) emojiData.aliases = emoji.aliases;
	    if (emoji.emoticons && emoji.emoticons.length) emojiData.emoticons = emoji.emoticons;
	    return emojiData;
	}





	const $fcccfb36ed0cde68$var$categories = {
	    activity: {
	        outline: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 24 24",
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                d: "M12 0C5.373 0 0 5.372 0 12c0 6.627 5.373 12 12 12 6.628 0 12-5.373 12-12 0-6.628-5.372-12-12-12m9.949 11H17.05c.224-2.527 1.232-4.773 1.968-6.113A9.966 9.966 0 0 1 21.949 11M13 11V2.051a9.945 9.945 0 0 1 4.432 1.564c-.858 1.491-2.156 4.22-2.392 7.385H13zm-2 0H8.961c-.238-3.165-1.536-5.894-2.393-7.385A9.95 9.95 0 0 1 11 2.051V11zm0 2v8.949a9.937 9.937 0 0 1-4.432-1.564c.857-1.492 2.155-4.221 2.393-7.385H11zm4.04 0c.236 3.164 1.534 5.893 2.392 7.385A9.92 9.92 0 0 1 13 21.949V13h2.04zM4.982 4.887C5.718 6.227 6.726 8.473 6.951 11h-4.9a9.977 9.977 0 0 1 2.931-6.113M2.051 13h4.9c-.226 2.527-1.233 4.771-1.969 6.113A9.972 9.972 0 0 1 2.051 13m16.967 6.113c-.735-1.342-1.744-3.586-1.968-6.113h4.899a9.961 9.961 0 0 1-2.931 6.113"
	            })
	        }),
	        solid: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 512 512",
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                d: "M16.17 337.5c0 44.98 7.565 83.54 13.98 107.9C35.22 464.3 50.46 496 174.9 496c9.566 0 19.59-.4707 29.84-1.271L17.33 307.3C16.53 317.6 16.17 327.7 16.17 337.5zM495.8 174.5c0-44.98-7.565-83.53-13.98-107.9c-4.688-17.54-18.34-31.23-36.04-35.95C435.5 27.91 392.9 16 337 16c-9.564 0-19.59 .4707-29.84 1.271l187.5 187.5C495.5 194.4 495.8 184.3 495.8 174.5zM26.77 248.8l236.3 236.3c142-36.1 203.9-150.4 222.2-221.1L248.9 26.87C106.9 62.96 45.07 177.2 26.77 248.8zM256 335.1c0 9.141-7.474 16-16 16c-4.094 0-8.188-1.564-11.31-4.689L164.7 283.3C161.6 280.2 160 276.1 160 271.1c0-8.529 6.865-16 16-16c4.095 0 8.189 1.562 11.31 4.688l64.01 64C254.4 327.8 256 331.9 256 335.1zM304 287.1c0 9.141-7.474 16-16 16c-4.094 0-8.188-1.564-11.31-4.689L212.7 235.3C209.6 232.2 208 228.1 208 223.1c0-9.141 7.473-16 16-16c4.094 0 8.188 1.562 11.31 4.688l64.01 64.01C302.5 279.8 304 283.9 304 287.1zM256 175.1c0-9.141 7.473-16 16-16c4.094 0 8.188 1.562 11.31 4.688l64.01 64.01c3.125 3.125 4.688 7.219 4.688 11.31c0 9.133-7.468 16-16 16c-4.094 0-8.189-1.562-11.31-4.688l-64.01-64.01C257.6 184.2 256 180.1 256 175.1z"
	            })
	        })
	    },
	    custom: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	        xmlns: "http://www.w3.org/2000/svg",
	        viewBox: "0 0 448 512",
	        children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	            d: "M417.1 368c-5.937 10.27-16.69 16-27.75 16c-5.422 0-10.92-1.375-15.97-4.281L256 311.4V448c0 17.67-14.33 32-31.1 32S192 465.7 192 448V311.4l-118.3 68.29C68.67 382.6 63.17 384 57.75 384c-11.06 0-21.81-5.734-27.75-16c-8.828-15.31-3.594-34.88 11.72-43.72L159.1 256L41.72 187.7C26.41 178.9 21.17 159.3 29.1 144C36.63 132.5 49.26 126.7 61.65 128.2C65.78 128.7 69.88 130.1 73.72 132.3L192 200.6V64c0-17.67 14.33-32 32-32S256 46.33 256 64v136.6l118.3-68.29c3.838-2.213 7.939-3.539 12.07-4.051C398.7 126.7 411.4 132.5 417.1 144c8.828 15.31 3.594 34.88-11.72 43.72L288 256l118.3 68.28C421.6 333.1 426.8 352.7 417.1 368z"
	        })
	    }),
	    flags: {
	        outline: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 24 24",
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                d: "M0 0l6.084 24H8L1.916 0zM21 5h-4l-1-4H4l3 12h3l1 4h13L21 5zM6.563 3h7.875l2 8H8.563l-2-8zm8.832 10l-2.856 1.904L12.063 13h3.332zM19 13l-1.5-6h1.938l2 8H16l3-2z"
	            })
	        }),
	        solid: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 512 512",
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                d: "M64 496C64 504.8 56.75 512 48 512h-32C7.25 512 0 504.8 0 496V32c0-17.75 14.25-32 32-32s32 14.25 32 32V496zM476.3 0c-6.365 0-13.01 1.35-19.34 4.233c-45.69 20.86-79.56 27.94-107.8 27.94c-59.96 0-94.81-31.86-163.9-31.87C160.9 .3055 131.6 4.867 96 15.75v350.5c32-9.984 59.87-14.1 84.85-14.1c73.63 0 124.9 31.78 198.6 31.78c31.91 0 68.02-5.971 111.1-23.09C504.1 355.9 512 344.4 512 332.1V30.73C512 11.1 495.3 0 476.3 0z"
	            })
	        })
	    },
	    foods: {
	        outline: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 24 24",
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                d: "M17 4.978c-1.838 0-2.876.396-3.68.934.513-1.172 1.768-2.934 4.68-2.934a1 1 0 0 0 0-2c-2.921 0-4.629 1.365-5.547 2.512-.064.078-.119.162-.18.244C11.73 1.838 10.798.023 9.207.023 8.579.022 7.85.306 7 .978 5.027 2.54 5.329 3.902 6.492 4.999 3.609 5.222 0 7.352 0 12.969c0 4.582 4.961 11.009 9 11.009 1.975 0 2.371-.486 3-1 .629.514 1.025 1 3 1 4.039 0 9-6.418 9-11 0-5.953-4.055-8-7-8M8.242 2.546c.641-.508.943-.523.965-.523.426.169.975 1.405 1.357 3.055-1.527-.629-2.741-1.352-2.98-1.846.059-.112.241-.356.658-.686M15 21.978c-1.08 0-1.21-.109-1.559-.402l-.176-.146c-.367-.302-.816-.452-1.266-.452s-.898.15-1.266.452l-.176.146c-.347.292-.477.402-1.557.402-2.813 0-7-5.389-7-9.009 0-5.823 4.488-5.991 5-5.991 1.939 0 2.484.471 3.387 1.251l.323.276a1.995 1.995 0 0 0 2.58 0l.323-.276c.902-.78 1.447-1.251 3.387-1.251.512 0 5 .168 5 6 0 3.617-4.187 9-7 9"
	            })
	        }),
	        solid: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 512 512",
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                d: "M481.9 270.1C490.9 279.1 496 291.3 496 304C496 316.7 490.9 328.9 481.9 337.9C472.9 346.9 460.7 352 448 352H64C51.27 352 39.06 346.9 30.06 337.9C21.06 328.9 16 316.7 16 304C16 291.3 21.06 279.1 30.06 270.1C39.06 261.1 51.27 256 64 256H448C460.7 256 472.9 261.1 481.9 270.1zM475.3 388.7C478.3 391.7 480 395.8 480 400V416C480 432.1 473.3 449.3 461.3 461.3C449.3 473.3 432.1 480 416 480H96C79.03 480 62.75 473.3 50.75 461.3C38.74 449.3 32 432.1 32 416V400C32 395.8 33.69 391.7 36.69 388.7C39.69 385.7 43.76 384 48 384H464C468.2 384 472.3 385.7 475.3 388.7zM50.39 220.8C45.93 218.6 42.03 215.5 38.97 211.6C35.91 207.7 33.79 203.2 32.75 198.4C31.71 193.5 31.8 188.5 32.99 183.7C54.98 97.02 146.5 32 256 32C365.5 32 457 97.02 479 183.7C480.2 188.5 480.3 193.5 479.2 198.4C478.2 203.2 476.1 207.7 473 211.6C469.1 215.5 466.1 218.6 461.6 220.8C457.2 222.9 452.3 224 447.3 224H64.67C59.73 224 54.84 222.9 50.39 220.8zM372.7 116.7C369.7 119.7 368 123.8 368 128C368 131.2 368.9 134.3 370.7 136.9C372.5 139.5 374.1 141.6 377.9 142.8C380.8 143.1 384 144.3 387.1 143.7C390.2 143.1 393.1 141.6 395.3 139.3C397.6 137.1 399.1 134.2 399.7 131.1C400.3 128 399.1 124.8 398.8 121.9C397.6 118.1 395.5 116.5 392.9 114.7C390.3 112.9 387.2 111.1 384 111.1C379.8 111.1 375.7 113.7 372.7 116.7V116.7zM244.7 84.69C241.7 87.69 240 91.76 240 96C240 99.16 240.9 102.3 242.7 104.9C244.5 107.5 246.1 109.6 249.9 110.8C252.8 111.1 256 112.3 259.1 111.7C262.2 111.1 265.1 109.6 267.3 107.3C269.6 105.1 271.1 102.2 271.7 99.12C272.3 96.02 271.1 92.8 270.8 89.88C269.6 86.95 267.5 84.45 264.9 82.7C262.3 80.94 259.2 79.1 256 79.1C251.8 79.1 247.7 81.69 244.7 84.69V84.69zM116.7 116.7C113.7 119.7 112 123.8 112 128C112 131.2 112.9 134.3 114.7 136.9C116.5 139.5 118.1 141.6 121.9 142.8C124.8 143.1 128 144.3 131.1 143.7C134.2 143.1 137.1 141.6 139.3 139.3C141.6 137.1 143.1 134.2 143.7 131.1C144.3 128 143.1 124.8 142.8 121.9C141.6 118.1 139.5 116.5 136.9 114.7C134.3 112.9 131.2 111.1 128 111.1C123.8 111.1 119.7 113.7 116.7 116.7L116.7 116.7z"
	            })
	        })
	    },
	    frequent: {
	        outline: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 24 24",
	            children: [
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                    d: "M13 4h-2l-.001 7H9v2h2v2h2v-2h4v-2h-4z"
	                }),
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                    d: "M12 0C5.373 0 0 5.373 0 12s5.373 12 12 12 12-5.373 12-12S18.627 0 12 0m0 22C6.486 22 2 17.514 2 12S6.486 2 12 2s10 4.486 10 10-4.486 10-10 10"
	                })
	            ]
	        }),
	        solid: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 512 512",
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                d: "M256 512C114.6 512 0 397.4 0 256C0 114.6 114.6 0 256 0C397.4 0 512 114.6 512 256C512 397.4 397.4 512 256 512zM232 256C232 264 236 271.5 242.7 275.1L338.7 339.1C349.7 347.3 364.6 344.3 371.1 333.3C379.3 322.3 376.3 307.4 365.3 300L280 243.2V120C280 106.7 269.3 96 255.1 96C242.7 96 231.1 106.7 231.1 120L232 256z"
	            })
	        })
	    },
	    nature: {
	        outline: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 24 24",
	            children: [
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                    d: "M15.5 8a1.5 1.5 0 1 0 .001 3.001A1.5 1.5 0 0 0 15.5 8M8.5 8a1.5 1.5 0 1 0 .001 3.001A1.5 1.5 0 0 0 8.5 8"
	                }),
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                    d: "M18.933 0h-.027c-.97 0-2.138.787-3.018 1.497-1.274-.374-2.612-.51-3.887-.51-1.285 0-2.616.133-3.874.517C7.245.79 6.069 0 5.093 0h-.027C3.352 0 .07 2.67.002 7.026c-.039 2.479.276 4.238 1.04 5.013.254.258.882.677 1.295.882.191 3.177.922 5.238 2.536 6.38.897.637 2.187.949 3.2 1.102C8.04 20.6 8 20.795 8 21c0 1.773 2.35 3 4 3 1.648 0 4-1.227 4-3 0-.201-.038-.393-.072-.586 2.573-.385 5.435-1.877 5.925-7.587.396-.22.887-.568 1.104-.788.763-.774 1.079-2.534 1.04-5.013C23.929 2.67 20.646 0 18.933 0M3.223 9.135c-.237.281-.837 1.155-.884 1.238-.15-.41-.368-1.349-.337-3.291.051-3.281 2.478-4.972 3.091-5.031.256.015.731.27 1.265.646-1.11 1.171-2.275 2.915-2.352 5.125-.133.546-.398.858-.783 1.313M12 22c-.901 0-1.954-.693-2-1 0-.654.475-1.236 1-1.602V20a1 1 0 1 0 2 0v-.602c.524.365 1 .947 1 1.602-.046.307-1.099 1-2 1m3-3.48v.02a4.752 4.752 0 0 0-1.262-1.02c1.092-.516 2.239-1.334 2.239-2.217 0-1.842-1.781-2.195-3.977-2.195-2.196 0-3.978.354-3.978 2.195 0 .883 1.148 1.701 2.238 2.217A4.8 4.8 0 0 0 9 18.539v-.025c-1-.076-2.182-.281-2.973-.842-1.301-.92-1.838-3.045-1.853-6.478l.023-.041c.496-.826 1.49-1.45 1.804-3.102 0-2.047 1.357-3.631 2.362-4.522C9.37 3.178 10.555 3 11.948 3c1.447 0 2.685.192 3.733.57 1 .9 2.316 2.465 2.316 4.48.313 1.651 1.307 2.275 1.803 3.102.035.058.068.117.102.178-.059 5.967-1.949 7.01-4.902 7.19m6.628-8.202c-.037-.065-.074-.13-.113-.195a7.587 7.587 0 0 0-.739-.987c-.385-.455-.648-.768-.782-1.313-.076-2.209-1.241-3.954-2.353-5.124.531-.376 1.004-.63 1.261-.647.636.071 3.044 1.764 3.096 5.031.027 1.81-.347 3.218-.37 3.235"
	                })
	            ]
	        }),
	        solid: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 576 512",
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                d: "M332.7 19.85C334.6 8.395 344.5 0 356.1 0C363.6 0 370.6 3.52 375.1 9.502L392 32H444.1C456.8 32 469.1 37.06 478.1 46.06L496 64H552C565.3 64 576 74.75 576 88V112C576 156.2 540.2 192 496 192H426.7L421.6 222.5L309.6 158.5L332.7 19.85zM448 64C439.2 64 432 71.16 432 80C432 88.84 439.2 96 448 96C456.8 96 464 88.84 464 80C464 71.16 456.8 64 448 64zM416 256.1V480C416 497.7 401.7 512 384 512H352C334.3 512 320 497.7 320 480V364.8C295.1 377.1 268.8 384 240 384C211.2 384 184 377.1 160 364.8V480C160 497.7 145.7 512 128 512H96C78.33 512 64 497.7 64 480V249.8C35.23 238.9 12.64 214.5 4.836 183.3L.9558 167.8C-3.331 150.6 7.094 133.2 24.24 128.1C41.38 124.7 58.76 135.1 63.05 152.2L66.93 167.8C70.49 182 83.29 191.1 97.97 191.1H303.8L416 256.1z"
	            })
	        })
	    },
	    objects: {
	        outline: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 24 24",
	            children: [
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                    d: "M12 0a9 9 0 0 0-5 16.482V21s2.035 3 5 3 5-3 5-3v-4.518A9 9 0 0 0 12 0zm0 2c3.86 0 7 3.141 7 7s-3.14 7-7 7-7-3.141-7-7 3.14-7 7-7zM9 17.477c.94.332 1.946.523 3 .523s2.06-.19 3-.523v.834c-.91.436-1.925.689-3 .689a6.924 6.924 0 0 1-3-.69v-.833zm.236 3.07A8.854 8.854 0 0 0 12 21c.965 0 1.888-.167 2.758-.451C14.155 21.173 13.153 22 12 22c-1.102 0-2.117-.789-2.764-1.453z"
	                }),
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                    d: "M14.745 12.449h-.004c-.852-.024-1.188-.858-1.577-1.824-.421-1.061-.703-1.561-1.182-1.566h-.009c-.481 0-.783.497-1.235 1.537-.436.982-.801 1.811-1.636 1.791l-.276-.043c-.565-.171-.853-.691-1.284-1.794-.125-.313-.202-.632-.27-.913-.051-.213-.127-.53-.195-.634C7.067 9.004 7.039 9 6.99 9A1 1 0 0 1 7 7h.01c1.662.017 2.015 1.373 2.198 2.134.486-.981 1.304-2.058 2.797-2.075 1.531.018 2.28 1.153 2.731 2.141l.002-.008C14.944 8.424 15.327 7 16.979 7h.032A1 1 0 1 1 17 9h-.011c-.149.076-.256.474-.319.709a6.484 6.484 0 0 1-.311.951c-.429.973-.79 1.789-1.614 1.789"
	                })
	            ]
	        }),
	        solid: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 384 512",
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                d: "M112.1 454.3c0 6.297 1.816 12.44 5.284 17.69l17.14 25.69c5.25 7.875 17.17 14.28 26.64 14.28h61.67c9.438 0 21.36-6.401 26.61-14.28l17.08-25.68c2.938-4.438 5.348-12.37 5.348-17.7L272 415.1h-160L112.1 454.3zM191.4 .0132C89.44 .3257 16 82.97 16 175.1c0 44.38 16.44 84.84 43.56 115.8c16.53 18.84 42.34 58.23 52.22 91.45c.0313 .25 .0938 .5166 .125 .7823h160.2c.0313-.2656 .0938-.5166 .125-.7823c9.875-33.22 35.69-72.61 52.22-91.45C351.6 260.8 368 220.4 368 175.1C368 78.61 288.9-.2837 191.4 .0132zM192 96.01c-44.13 0-80 35.89-80 79.1C112 184.8 104.8 192 96 192S80 184.8 80 176c0-61.76 50.25-111.1 112-111.1c8.844 0 16 7.159 16 16S200.8 96.01 192 96.01z"
	            })
	        })
	    },
	    people: {
	        outline: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 24 24",
	            children: [
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                    d: "M12 0C5.373 0 0 5.373 0 12s5.373 12 12 12 12-5.373 12-12S18.627 0 12 0m0 22C6.486 22 2 17.514 2 12S6.486 2 12 2s10 4.486 10 10-4.486 10-10 10"
	                }),
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                    d: "M8 7a2 2 0 1 0-.001 3.999A2 2 0 0 0 8 7M16 7a2 2 0 1 0-.001 3.999A2 2 0 0 0 16 7M15.232 15c-.693 1.195-1.87 2-3.349 2-1.477 0-2.655-.805-3.347-2H15m3-2H6a6 6 0 1 0 12 0"
	                })
	            ]
	        }),
	        solid: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 512 512",
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                d: "M0 256C0 114.6 114.6 0 256 0C397.4 0 512 114.6 512 256C512 397.4 397.4 512 256 512C114.6 512 0 397.4 0 256zM256 432C332.1 432 396.2 382 415.2 314.1C419.1 300.4 407.8 288 393.6 288H118.4C104.2 288 92.92 300.4 96.76 314.1C115.8 382 179.9 432 256 432V432zM176.4 160C158.7 160 144.4 174.3 144.4 192C144.4 209.7 158.7 224 176.4 224C194 224 208.4 209.7 208.4 192C208.4 174.3 194 160 176.4 160zM336.4 224C354 224 368.4 209.7 368.4 192C368.4 174.3 354 160 336.4 160C318.7 160 304.4 174.3 304.4 192C304.4 209.7 318.7 224 336.4 224z"
	            })
	        })
	    },
	    places: {
	        outline: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 24 24",
	            children: [
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                    d: "M6.5 12C5.122 12 4 13.121 4 14.5S5.122 17 6.5 17 9 15.879 9 14.5 7.878 12 6.5 12m0 3c-.275 0-.5-.225-.5-.5s.225-.5.5-.5.5.225.5.5-.225.5-.5.5M17.5 12c-1.378 0-2.5 1.121-2.5 2.5s1.122 2.5 2.5 2.5 2.5-1.121 2.5-2.5-1.122-2.5-2.5-2.5m0 3c-.275 0-.5-.225-.5-.5s.225-.5.5-.5.5.225.5.5-.225.5-.5.5"
	                }),
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                    d: "M22.482 9.494l-1.039-.346L21.4 9h.6c.552 0 1-.439 1-.992 0-.006-.003-.008-.003-.008H23c0-1-.889-2-1.984-2h-.642l-.731-1.717C19.262 3.012 18.091 2 16.764 2H7.236C5.909 2 4.738 3.012 4.357 4.283L3.626 6h-.642C1.889 6 1 7 1 8h.003S1 8.002 1 8.008C1 8.561 1.448 9 2 9h.6l-.043.148-1.039.346a2.001 2.001 0 0 0-1.359 2.097l.751 7.508a1 1 0 0 0 .994.901H3v1c0 1.103.896 2 2 2h2c1.104 0 2-.897 2-2v-1h6v1c0 1.103.896 2 2 2h2c1.104 0 2-.897 2-2v-1h1.096a.999.999 0 0 0 .994-.901l.751-7.508a2.001 2.001 0 0 0-1.359-2.097M6.273 4.857C6.402 4.43 6.788 4 7.236 4h9.527c.448 0 .834.43.963.857L19.313 9H4.688l1.585-4.143zM7 21H5v-1h2v1zm12 0h-2v-1h2v1zm2.189-3H2.811l-.662-6.607L3 11h18l.852.393L21.189 18z"
	                })
	            ]
	        }),
	        solid: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 512 512",
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                d: "M39.61 196.8L74.8 96.29C88.27 57.78 124.6 32 165.4 32H346.6C387.4 32 423.7 57.78 437.2 96.29L472.4 196.8C495.6 206.4 512 229.3 512 256V448C512 465.7 497.7 480 480 480H448C430.3 480 416 465.7 416 448V400H96V448C96 465.7 81.67 480 64 480H32C14.33 480 0 465.7 0 448V256C0 229.3 16.36 206.4 39.61 196.8V196.8zM109.1 192H402.9L376.8 117.4C372.3 104.6 360.2 96 346.6 96H165.4C151.8 96 139.7 104.6 135.2 117.4L109.1 192zM96 256C78.33 256 64 270.3 64 288C64 305.7 78.33 320 96 320C113.7 320 128 305.7 128 288C128 270.3 113.7 256 96 256zM416 320C433.7 320 448 305.7 448 288C448 270.3 433.7 256 416 256C398.3 256 384 270.3 384 288C384 305.7 398.3 320 416 320z"
	            })
	        })
	    },
	    symbols: {
	        outline: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 24 24",
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                d: "M0 0h11v2H0zM4 11h3V6h4V4H0v2h4zM15.5 17c1.381 0 2.5-1.116 2.5-2.493s-1.119-2.493-2.5-2.493S13 13.13 13 14.507 14.119 17 15.5 17m0-2.986c.276 0 .5.222.5.493 0 .272-.224.493-.5.493s-.5-.221-.5-.493.224-.493.5-.493M21.5 19.014c-1.381 0-2.5 1.116-2.5 2.493S20.119 24 21.5 24s2.5-1.116 2.5-2.493-1.119-2.493-2.5-2.493m0 2.986a.497.497 0 0 1-.5-.493c0-.271.224-.493.5-.493s.5.222.5.493a.497.497 0 0 1-.5.493M22 13l-9 9 1.513 1.5 8.99-9.009zM17 11c2.209 0 4-1.119 4-2.5V2s.985-.161 1.498.949C23.01 4.055 23 6 23 6s1-1.119 1-3.135C24-.02 21 0 21 0h-2v6.347A5.853 5.853 0 0 0 17 6c-2.209 0-4 1.119-4 2.5s1.791 2.5 4 2.5M10.297 20.482l-1.475-1.585a47.54 47.54 0 0 1-1.442 1.129c-.307-.288-.989-1.016-2.045-2.183.902-.836 1.479-1.466 1.729-1.892s.376-.871.376-1.336c0-.592-.273-1.178-.818-1.759-.546-.581-1.329-.871-2.349-.871-1.008 0-1.79.293-2.344.879-.556.587-.832 1.181-.832 1.784 0 .813.419 1.748 1.256 2.805-.847.614-1.444 1.208-1.794 1.784a3.465 3.465 0 0 0-.523 1.833c0 .857.308 1.56.924 2.107.616.549 1.423.823 2.42.823 1.173 0 2.444-.379 3.813-1.137L8.235 24h2.819l-2.09-2.383 1.333-1.135zm-6.736-6.389a1.02 1.02 0 0 1 .73-.286c.31 0 .559.085.747.254a.849.849 0 0 1 .283.659c0 .518-.419 1.112-1.257 1.784-.536-.651-.805-1.231-.805-1.742a.901.901 0 0 1 .302-.669M3.74 22c-.427 0-.778-.116-1.057-.349-.279-.232-.418-.487-.418-.766 0-.594.509-1.288 1.527-2.083.968 1.134 1.717 1.946 2.248 2.438-.921.507-1.686.76-2.3.76"
	            })
	        }),
	        solid: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	            xmlns: "http://www.w3.org/2000/svg",
	            viewBox: "0 0 512 512",
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	                d: "M500.3 7.251C507.7 13.33 512 22.41 512 31.1V175.1C512 202.5 483.3 223.1 447.1 223.1C412.7 223.1 383.1 202.5 383.1 175.1C383.1 149.5 412.7 127.1 447.1 127.1V71.03L351.1 90.23V207.1C351.1 234.5 323.3 255.1 287.1 255.1C252.7 255.1 223.1 234.5 223.1 207.1C223.1 181.5 252.7 159.1 287.1 159.1V63.1C287.1 48.74 298.8 35.61 313.7 32.62L473.7 .6198C483.1-1.261 492.9 1.173 500.3 7.251H500.3zM74.66 303.1L86.5 286.2C92.43 277.3 102.4 271.1 113.1 271.1H174.9C185.6 271.1 195.6 277.3 201.5 286.2L213.3 303.1H239.1C266.5 303.1 287.1 325.5 287.1 351.1V463.1C287.1 490.5 266.5 511.1 239.1 511.1H47.1C21.49 511.1-.0019 490.5-.0019 463.1V351.1C-.0019 325.5 21.49 303.1 47.1 303.1H74.66zM143.1 359.1C117.5 359.1 95.1 381.5 95.1 407.1C95.1 434.5 117.5 455.1 143.1 455.1C170.5 455.1 191.1 434.5 191.1 407.1C191.1 381.5 170.5 359.1 143.1 359.1zM440.3 367.1H496C502.7 367.1 508.6 372.1 510.1 378.4C513.3 384.6 511.6 391.7 506.5 396L378.5 508C372.9 512.1 364.6 513.3 358.6 508.9C352.6 504.6 350.3 496.6 353.3 489.7L391.7 399.1H336C329.3 399.1 323.4 395.9 321 389.6C318.7 383.4 320.4 376.3 325.5 371.1L453.5 259.1C459.1 255 467.4 254.7 473.4 259.1C479.4 263.4 481.6 271.4 478.7 278.3L440.3 367.1zM116.7 219.1L19.85 119.2C-8.112 90.26-6.614 42.31 24.85 15.34C51.82-8.137 93.26-3.642 118.2 21.83L128.2 32.32L137.7 21.83C162.7-3.642 203.6-8.137 231.6 15.34C262.6 42.31 264.1 90.26 236.1 119.2L139.7 219.1C133.2 225.6 122.7 225.6 116.7 219.1H116.7z"
	            })
	        })
	    }
	};
	const $fcccfb36ed0cde68$var$search = {
	    loupe: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	        xmlns: "http://www.w3.org/2000/svg",
	        viewBox: "0 0 20 20",
	        children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	            d: "M12.9 14.32a8 8 0 1 1 1.41-1.41l5.35 5.33-1.42 1.42-5.33-5.34zM8 14A6 6 0 1 0 8 2a6 6 0 0 0 0 12z"
	        })
	    }),
	    delete: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("svg", {
	        xmlns: "http://www.w3.org/2000/svg",
	        viewBox: "0 0 20 20",
	        children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("path", {
	            d: "M10 8.586L2.929 1.515 1.515 2.929 8.586 10l-7.071 7.071 1.414 1.414L10 11.414l7.071 7.071 1.414-1.414L11.414 10l7.071-7.071-1.414-1.414L10 8.586z"
	        })
	    })
	};
	var $fcccfb36ed0cde68$export$2e2bcd8739ae039 = {
	    categories: $fcccfb36ed0cde68$var$categories,
	    search: $fcccfb36ed0cde68$var$search
	};





	function $254755d3f438722f$export$2e2bcd8739ae039(props) {
	    let { id: id , skin: skin , emoji: emoji  } = props;
	    if (props.shortcodes) {
	        const matches = props.shortcodes.match(($c4d155af13ad4d4b$export$2e2bcd8739ae039).SHORTCODES_REGEX);
	        if (matches) {
	            id = matches[1];
	            if (matches[2]) skin = matches[2];
	        }
	    }
	    emoji || (emoji = ($c4d155af13ad4d4b$export$2e2bcd8739ae039).get(id || props.native));
	    if (!emoji) return props.fallback;
	    const emojiSkin = emoji.skins[skin - 1] || emoji.skins[0];
	    const imageSrc = emojiSkin.src || (props.set != "native" && !props.spritesheet ? typeof props.getImageURL === "function" ? props.getImageURL(props.set, emojiSkin.unified) : `https://cdn.jsdelivr.net/npm/emoji-datasource-${props.set}@14.0.0/img/${props.set}/64/${emojiSkin.unified}.png` : undefined);
	    const spritesheetSrc = typeof props.getSpritesheetURL === "function" ? props.getSpritesheetURL(props.set) : `https://cdn.jsdelivr.net/npm/emoji-datasource-${props.set}@14.0.0/img/${props.set}/sheets-256/64.png`;
	    return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("span", {
	        class: "emoji-mart-emoji",
	        "data-emoji-set": props.set,
	        children: imageSrc ? /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("img", {
	            style: {
	                maxWidth: props.size || "1em",
	                maxHeight: props.size || "1em",
	                display: "inline-block"
	            },
	            alt: emojiSkin.native || emojiSkin.shortcodes,
	            src: imageSrc
	        }) : props.set == "native" ? /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("span", {
	            style: {
	                fontSize: props.size,
	                fontFamily: '"EmojiMart", "Segoe UI Emoji", "Segoe UI Symbol", "Segoe UI", "Apple Color Emoji", "Twemoji Mozilla", "Noto Color Emoji", "Android Emoji"'
	            },
	            children: emojiSkin.native
	        }) : /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("span", {
	            style: {
	                display: "block",
	                width: props.size,
	                height: props.size,
	                backgroundImage: `url(${spritesheetSrc})`,
	                backgroundSize: `${100 * ($7adb23b0109cc36a$export$2d0294657ab35f1b).sheet.cols}% ${100 * ($7adb23b0109cc36a$export$2d0294657ab35f1b).sheet.rows}%`,
	                backgroundPosition: `${100 / (($7adb23b0109cc36a$export$2d0294657ab35f1b).sheet.cols - 1) * emojiSkin.x}% ${100 / (($7adb23b0109cc36a$export$2d0294657ab35f1b).sheet.rows - 1) * emojiSkin.y}%`
	            }
	        })
	    });
	}







	const $6f57cc9cd54c5aaa$var$WindowHTMLElement = typeof window !== "undefined" && window.HTMLElement ? window.HTMLElement : Object;
	class $6f57cc9cd54c5aaa$export$2e2bcd8739ae039 extends $6f57cc9cd54c5aaa$var$WindowHTMLElement {
	    static get observedAttributes() {
	        return Object.keys(this.Props);
	    }
	    update(props = {}) {
	        for(let k in props)this.attributeChangedCallback(k, null, props[k]);
	    }
	    attributeChangedCallback(attr, _, newValue) {
	        if (!this.component) return;
	        const value = ($7adb23b0109cc36a$export$88c9ddb45cea7241)(attr, {
	            [attr]: newValue
	        }, this.constructor.Props, this);
	        if (this.component.componentWillReceiveProps) this.component.componentWillReceiveProps({
	            [attr]: value
	        });
	        else {
	            this.component.props[attr] = value;
	            this.component.forceUpdate();
	        }
	    }
	    disconnectedCallback() {
	        this.disconnected = true;
	        if (this.component && this.component.unregister) this.component.unregister();
	    }
	    constructor(props = {}){
	        super();
	        this.props = props;
	        if (props.parent || props.ref) {
	            let ref = null;
	            const parent = props.parent || (ref = props.ref && props.ref.current);
	            if (ref) ref.innerHTML = "";
	            if (parent) parent.appendChild(this);
	        }
	    }
	}



	class $26f27c338a96b1a6$export$2e2bcd8739ae039 extends ($6f57cc9cd54c5aaa$export$2e2bcd8739ae039) {
	    setShadow() {
	        this.attachShadow({
	            mode: "open"
	        });
	    }
	    injectStyles(styles) {
	        if (!styles) return;
	        const style = document.createElement("style");
	        style.textContent = styles;
	        this.shadowRoot.insertBefore(style, this.shadowRoot.firstChild);
	    }
	    constructor(props, { styles: styles  } = {}){
	        super(props);
	        this.setShadow();
	        this.injectStyles(styles);
	    }
	}






	var $3d90f6e46fb2dd47$export$2e2bcd8739ae039 = {
	    fallback: "",
	    id: "",
	    native: "",
	    shortcodes: "",
	    size: {
	        value: "",
	        transform: (value)=>{
	            // If the value is a number, then we assume it’s a pixel value.
	            if (!/\D/.test(value)) return `${value}px`;
	            return value;
	        }
	    },
	    // Shared
	    set: ($b247ea80b67298d5$export$2e2bcd8739ae039).set,
	    skin: ($b247ea80b67298d5$export$2e2bcd8739ae039).skin
	};


	class $331b4160623139bf$export$2e2bcd8739ae039 extends ($6f57cc9cd54c5aaa$export$2e2bcd8739ae039) {
	    async connectedCallback() {
	        const props = ($7adb23b0109cc36a$export$75fe5f91d452f94b)(this.props, ($3d90f6e46fb2dd47$export$2e2bcd8739ae039), this);
	        props.element = this;
	        props.ref = (component)=>{
	            this.component = component;
	        };
	        await ($7adb23b0109cc36a$export$2cd8252107eb640b)();
	        if (this.disconnected) return;
	        ($fb96b826c0c5f37a$export$b3890eb0ae9dca99)(/*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)(($254755d3f438722f$export$2e2bcd8739ae039), {
	            ...props
	        }), this);
	    }
	    constructor(props){
	        super(props);
	    }
	}
	($c770c458706daa72$export$2e2bcd8739ae039)($331b4160623139bf$export$2e2bcd8739ae039, "Props", ($3d90f6e46fb2dd47$export$2e2bcd8739ae039));
	if (typeof customElements !== "undefined" && !customElements.get("em-emoji")) customElements.define("em-emoji", $331b4160623139bf$export$2e2bcd8739ae039);






	var $1a9a8ef576b7773d$var$r, $1a9a8ef576b7773d$var$i = [], $1a9a8ef576b7773d$var$c = ($fb96b826c0c5f37a$export$41c562ebe57d11e2).__b, $1a9a8ef576b7773d$var$f = ($fb96b826c0c5f37a$export$41c562ebe57d11e2).__r, $1a9a8ef576b7773d$var$e = ($fb96b826c0c5f37a$export$41c562ebe57d11e2).diffed, $1a9a8ef576b7773d$var$a = ($fb96b826c0c5f37a$export$41c562ebe57d11e2).__c, $1a9a8ef576b7773d$var$v = ($fb96b826c0c5f37a$export$41c562ebe57d11e2).unmount;
	function $1a9a8ef576b7773d$var$x() {
	    var t6;
	    for($1a9a8ef576b7773d$var$i.sort(function(n11, t7) {
	        return n11.__v.__b - t7.__v.__b;
	    }); t6 = $1a9a8ef576b7773d$var$i.pop();)if (t6.__P) try {
	        t6.__H.__h.forEach($1a9a8ef576b7773d$var$g), t6.__H.__h.forEach($1a9a8ef576b7773d$var$j), t6.__H.__h = [];
	    } catch (u4) {
	        t6.__H.__h = [], ($fb96b826c0c5f37a$export$41c562ebe57d11e2).__e(u4, t6.__v);
	    }
	}
	($fb96b826c0c5f37a$export$41c562ebe57d11e2).__b = function(n12) {
	    $1a9a8ef576b7773d$var$c && $1a9a8ef576b7773d$var$c(n12);
	}, ($fb96b826c0c5f37a$export$41c562ebe57d11e2).__r = function(n13) {
	    $1a9a8ef576b7773d$var$f && $1a9a8ef576b7773d$var$f(n13);
	    var r8 = (n13.__c).__H;
	    r8 && (r8.__h.forEach($1a9a8ef576b7773d$var$g), r8.__h.forEach($1a9a8ef576b7773d$var$j), r8.__h = []);
	}, ($fb96b826c0c5f37a$export$41c562ebe57d11e2).diffed = function(t8) {
	    $1a9a8ef576b7773d$var$e && $1a9a8ef576b7773d$var$e(t8);
	    var o6 = t8.__c;
	    o6 && o6.__H && o6.__H.__h.length && (1 !== $1a9a8ef576b7773d$var$i.push(o6) && $1a9a8ef576b7773d$var$r === ($fb96b826c0c5f37a$export$41c562ebe57d11e2).requestAnimationFrame || (($1a9a8ef576b7773d$var$r = ($fb96b826c0c5f37a$export$41c562ebe57d11e2).requestAnimationFrame) || function(n14) {
	        var t9, u5 = function() {
	            clearTimeout(r9), $1a9a8ef576b7773d$var$b && cancelAnimationFrame(t9), setTimeout(n14);
	        }, r9 = setTimeout(u5, 100);
	        $1a9a8ef576b7773d$var$b && (t9 = requestAnimationFrame(u5));
	    })($1a9a8ef576b7773d$var$x));
	}, ($fb96b826c0c5f37a$export$41c562ebe57d11e2).__c = function(t10, u6) {
	    u6.some(function(t11) {
	        try {
	            t11.__h.forEach($1a9a8ef576b7773d$var$g), t11.__h = t11.__h.filter(function(n15) {
	                return !n15.__ || $1a9a8ef576b7773d$var$j(n15);
	            });
	        } catch (r10) {
	            u6.some(function(n16) {
	                n16.__h && (n16.__h = []);
	            }), u6 = [], ($fb96b826c0c5f37a$export$41c562ebe57d11e2).__e(r10, t11.__v);
	        }
	    }), $1a9a8ef576b7773d$var$a && $1a9a8ef576b7773d$var$a(t10, u6);
	}, ($fb96b826c0c5f37a$export$41c562ebe57d11e2).unmount = function(t12) {
	    $1a9a8ef576b7773d$var$v && $1a9a8ef576b7773d$var$v(t12);
	    var u7, r11 = t12.__c;
	    r11 && r11.__H && (r11.__H.__.forEach(function(n17) {
	        try {
	            $1a9a8ef576b7773d$var$g(n17);
	        } catch (n18) {
	            u7 = n18;
	        }
	    }), u7 && ($fb96b826c0c5f37a$export$41c562ebe57d11e2).__e(u7, r11.__v));
	};
	var $1a9a8ef576b7773d$var$b = "function" == typeof requestAnimationFrame;
	function $1a9a8ef576b7773d$var$g(n19) {
	    var r12 = n19.__c;
	    "function" == typeof r12 && (n19.__c = void 0, r12());
	}
	function $1a9a8ef576b7773d$var$j(n20) {
	    n20.__c = n20.__();
	}





	function $dc040a17866866fa$var$S(n1, t1) {
	    for(var e1 in t1)n1[e1] = t1[e1];
	    return n1;
	}
	function $dc040a17866866fa$var$C(n2, t2) {
	    for(var e2 in n2)if ("__source" !== e2 && !(e2 in t2)) return !0;
	    for(var r1 in t2)if ("__source" !== r1 && n2[r1] !== t2[r1]) return !0;
	    return !1;
	}
	function $dc040a17866866fa$export$221d75b3f55bb0bd(n3) {
	    this.props = n3;
	}
	($dc040a17866866fa$export$221d75b3f55bb0bd.prototype = new ($fb96b826c0c5f37a$export$16fa2f45be04daa8)).isPureReactComponent = !0, $dc040a17866866fa$export$221d75b3f55bb0bd.prototype.shouldComponentUpdate = function(n6, t5) {
	    return $dc040a17866866fa$var$C(this.props, n6) || $dc040a17866866fa$var$C(this.state, t5);
	};
	var $dc040a17866866fa$var$w = ($fb96b826c0c5f37a$export$41c562ebe57d11e2).__b;
	($fb96b826c0c5f37a$export$41c562ebe57d11e2).__b = function(n7) {
	    n7.type && n7.type.__f && n7.ref && (n7.props.ref = n7.ref, n7.ref = null), $dc040a17866866fa$var$w && $dc040a17866866fa$var$w(n7);
	};
	var $dc040a17866866fa$var$A = ($fb96b826c0c5f37a$export$41c562ebe57d11e2).__e;
	($fb96b826c0c5f37a$export$41c562ebe57d11e2).__e = function(n12, t10, e6) {
	    if (n12.then) {
	        for(var r5, u1 = t10; u1 = u1.__;)if ((r5 = u1.__c) && r5.__c) return null == t10.__e && (t10.__e = e6.__e, t10.__k = e6.__k), r5.__c(n12, t10);
	    }
	    $dc040a17866866fa$var$A(n12, t10, e6);
	};
	var $dc040a17866866fa$var$O = ($fb96b826c0c5f37a$export$41c562ebe57d11e2).unmount;
	function $dc040a17866866fa$export$74bf444e3cd11ea5() {
	    this.__u = 0, this.t = null, this.__b = null;
	}
	function $dc040a17866866fa$var$U(n13) {
	    var t11 = n13.__.__c;
	    return t11 && t11.__e && t11.__e(n13);
	}
	function $dc040a17866866fa$export$998bcd577473dd93() {
	    this.u = null, this.o = null;
	}
	($fb96b826c0c5f37a$export$41c562ebe57d11e2).unmount = function(n17) {
	    var t13 = n17.__c;
	    t13 && t13.__R && t13.__R(), t13 && !0 === n17.__h && (n17.type = null), $dc040a17866866fa$var$O && $dc040a17866866fa$var$O(n17);
	}, ($dc040a17866866fa$export$74bf444e3cd11ea5.prototype = new ($fb96b826c0c5f37a$export$16fa2f45be04daa8)).__c = function(n18, t14) {
	    var e8 = t14.__c, r7 = this;
	    null == r7.t && (r7.t = []), r7.t.push(e8);
	    var u4 = $dc040a17866866fa$var$U(r7.__v), o1 = !1, i1 = function() {
	        o1 || (o1 = !0, e8.__R = null, u4 ? u4(l1) : l1());
	    };
	    e8.__R = i1;
	    var l1 = function() {
	        if (!--r7.__u) {
	            if (r7.state.__e) {
	                var n19 = r7.state.__e;
	                r7.__v.__k[0] = function n22(t17, e9, r8) {
	                    return t17 && (t17.__v = null, t17.__k = t17.__k && t17.__k.map(function(t18) {
	                        return n22(t18, e9, r8);
	                    }), t17.__c && t17.__c.__P === e9 && (t17.__e && r8.insertBefore(t17.__e, t17.__d), t17.__c.__e = !0, t17.__c.__P = r8)), t17;
	                }(n19, n19.__c.__P, n19.__c.__O);
	            }
	            var t15;
	            for(r7.setState({
	                __e: r7.__b = null
	            }); t15 = r7.t.pop();)t15.forceUpdate();
	        }
	    }, c1 = !0 === t14.__h;
	    (r7.__u++) || c1 || r7.setState({
	        __e: r7.__b = r7.__v.__k[0]
	    }), n18.then(i1, i1);
	}, $dc040a17866866fa$export$74bf444e3cd11ea5.prototype.componentWillUnmount = function() {
	    this.t = [];
	}, $dc040a17866866fa$export$74bf444e3cd11ea5.prototype.render = function(n23, t19) {
	    if (this.__b) {
	        if (this.__v.__k) {
	            var e10 = document.createElement("div"), r9 = this.__v.__k[0].__c;
	            this.__v.__k[0] = function n24(t20, e13, r12) {
	                return t20 && (t20.__c && t20.__c.__H && (t20.__c.__H.__.forEach(function(n25) {
	                    "function" == typeof n25.__c && n25.__c();
	                }), t20.__c.__H = null), null != (t20 = $dc040a17866866fa$var$S({}, t20)).__c && (t20.__c.__P === r12 && (t20.__c.__P = e13), t20.__c = null), t20.__k = t20.__k && t20.__k.map(function(t21) {
	                    return n24(t21, e13, r12);
	                })), t20;
	            }(this.__b, e10, r9.__O = r9.__P);
	        }
	        this.__b = null;
	    }
	    var u5 = t19.__e && ($fb96b826c0c5f37a$export$c8a8987d4410bf2d)(($fb96b826c0c5f37a$export$ffb0004e005737fa), null, n23.fallback);
	    return u5 && (u5.__h = null), [
	        ($fb96b826c0c5f37a$export$c8a8987d4410bf2d)(($fb96b826c0c5f37a$export$ffb0004e005737fa), null, t19.__e ? null : n23.children),
	        u5
	    ];
	};
	var $dc040a17866866fa$var$T = function(n26, t22, e14) {
	    if (++e14[1] === e14[0] && n26.o.delete(t22), n26.props.revealOrder && ("t" !== n26.props.revealOrder[0] || !n26.o.size)) for(e14 = n26.u; e14;){
	        for(; e14.length > 3;)e14.pop()();
	        if (e14[1] < e14[0]) break;
	        n26.u = e14 = e14[2];
	    }
	};
	($dc040a17866866fa$export$998bcd577473dd93.prototype = new ($fb96b826c0c5f37a$export$16fa2f45be04daa8)).__e = function(n33) {
	    var t25 = this, e16 = $dc040a17866866fa$var$U(t25.__v), r13 = t25.o.get(n33);
	    return r13[0]++, function(u6) {
	        var o2 = function() {
	            t25.props.revealOrder ? (r13.push(u6), $dc040a17866866fa$var$T(t25, n33, r13)) : u6();
	        };
	        e16 ? e16(o2) : o2();
	    };
	}, $dc040a17866866fa$export$998bcd577473dd93.prototype.render = function(n34) {
	    this.u = null, this.o = new Map;
	    var t26 = ($fb96b826c0c5f37a$export$47e4c5b300681277)(n34.children);
	    n34.revealOrder && "b" === n34.revealOrder[0] && t26.reverse();
	    for(var e17 = t26.length; e17--;)this.o.set(t26[e17], this.u = [
	        1,
	        0,
	        this.u
	    ]);
	    return n34.children;
	}, $dc040a17866866fa$export$998bcd577473dd93.prototype.componentDidUpdate = $dc040a17866866fa$export$998bcd577473dd93.prototype.componentDidMount = function() {
	    var n35 = this;
	    this.o.forEach(function(t27, e18) {
	        $dc040a17866866fa$var$T(n35, e18, t27);
	    });
	};
	var $dc040a17866866fa$var$j = "undefined" != typeof Symbol && Symbol.for && Symbol.for("react.element") || 60103, $dc040a17866866fa$var$P = /^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|marker(?!H|W|U)|overline|paint|stop|strikethrough|stroke|text(?!L)|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/, $dc040a17866866fa$var$V = "undefined" != typeof document, $dc040a17866866fa$var$z = function(n36) {
	    return ("undefined" != typeof Symbol && "symbol" == typeof Symbol() ? /fil|che|rad/i : /fil|che|ra/i).test(n36);
	};
	($fb96b826c0c5f37a$export$16fa2f45be04daa8).prototype.isReactComponent = {}, [
	    "componentWillMount",
	    "componentWillReceiveProps",
	    "componentWillUpdate"
	].forEach(function(n39) {
	    Object.defineProperty(($fb96b826c0c5f37a$export$16fa2f45be04daa8).prototype, n39, {
	        configurable: !0,
	        get: function() {
	            return this["UNSAFE_" + n39];
	        },
	        set: function(t30) {
	            Object.defineProperty(this, n39, {
	                configurable: !0,
	                writable: !0,
	                value: t30
	            });
	        }
	    });
	});
	var $dc040a17866866fa$var$H = ($fb96b826c0c5f37a$export$41c562ebe57d11e2).event;
	function $dc040a17866866fa$var$Z() {}
	function $dc040a17866866fa$var$Y() {
	    return this.cancelBubble;
	}
	function $dc040a17866866fa$var$q() {
	    return this.defaultPrevented;
	}
	($fb96b826c0c5f37a$export$41c562ebe57d11e2).event = function(n40) {
	    return $dc040a17866866fa$var$H && (n40 = $dc040a17866866fa$var$H(n40)), n40.persist = $dc040a17866866fa$var$Z, n40.isPropagationStopped = $dc040a17866866fa$var$Y, n40.isDefaultPrevented = $dc040a17866866fa$var$q, n40.nativeEvent = n40;
	};
	var $dc040a17866866fa$var$J = {
	    configurable: !0,
	    get: function() {
	        return this.class;
	    }
	}, $dc040a17866866fa$var$K = ($fb96b826c0c5f37a$export$41c562ebe57d11e2).vnode;
	($fb96b826c0c5f37a$export$41c562ebe57d11e2).vnode = function(n41) {
	    var t31 = n41.type, e21 = n41.props, r14 = e21;
	    if ("string" == typeof t31) {
	        var u7 = -1 === t31.indexOf("-");
	        for(var o3 in r14 = {}, e21){
	            var i2 = e21[o3];
	            $dc040a17866866fa$var$V && "children" === o3 && "noscript" === t31 || "value" === o3 && "defaultValue" in e21 && null == i2 || ("defaultValue" === o3 && "value" in e21 && null == e21.value ? o3 = "value" : "download" === o3 && !0 === i2 ? i2 = "" : /ondoubleclick/i.test(o3) ? o3 = "ondblclick" : /^onchange(textarea|input)/i.test(o3 + t31) && !$dc040a17866866fa$var$z(e21.type) ? o3 = "oninput" : /^onfocus$/i.test(o3) ? o3 = "onfocusin" : /^onblur$/i.test(o3) ? o3 = "onfocusout" : /^on(Ani|Tra|Tou|BeforeInp)/.test(o3) ? o3 = o3.toLowerCase() : u7 && $dc040a17866866fa$var$P.test(o3) ? o3 = o3.replace(/[A-Z0-9]/, "-$&").toLowerCase() : null === i2 && (i2 = void 0), r14[o3] = i2);
	        }
	        "select" == t31 && r14.multiple && Array.isArray(r14.value) && (r14.value = ($fb96b826c0c5f37a$export$47e4c5b300681277)(e21.children).forEach(function(n42) {
	            n42.props.selected = -1 != r14.value.indexOf(n42.props.value);
	        })), "select" == t31 && null != r14.defaultValue && (r14.value = ($fb96b826c0c5f37a$export$47e4c5b300681277)(e21.children).forEach(function(n43) {
	            n43.props.selected = r14.multiple ? -1 != r14.defaultValue.indexOf(n43.props.value) : r14.defaultValue == n43.props.value;
	        })), n41.props = r14, e21.class != e21.className && ($dc040a17866866fa$var$J.enumerable = "className" in e21, null != e21.className && (r14.class = e21.className), Object.defineProperty(r14, "className", $dc040a17866866fa$var$J));
	    }
	    n41.$$typeof = $dc040a17866866fa$var$j, $dc040a17866866fa$var$K && $dc040a17866866fa$var$K(n41);
	};
	var $dc040a17866866fa$var$Q = ($fb96b826c0c5f37a$export$41c562ebe57d11e2).__r;
	($fb96b826c0c5f37a$export$41c562ebe57d11e2).__r = function(n44) {
	    $dc040a17866866fa$var$Q && $dc040a17866866fa$var$Q(n44), n44.__c;
	};




	const $ec8c39fdad15601a$var$THEME_ICONS = {
	    light: "outline",
	    dark: "solid"
	};
	class $ec8c39fdad15601a$export$2e2bcd8739ae039 extends ($dc040a17866866fa$export$221d75b3f55bb0bd) {
	    renderIcon(category) {
	        const { icon: icon  } = category;
	        if (icon) {
	            if (icon.svg) return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("span", {
	                class: "flex",
	                dangerouslySetInnerHTML: {
	                    __html: icon.svg
	                }
	            });
	            if (icon.src) return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("img", {
	                src: icon.src
	            });
	        }
	        const categoryIcons = ($fcccfb36ed0cde68$export$2e2bcd8739ae039).categories[category.id] || ($fcccfb36ed0cde68$export$2e2bcd8739ae039).categories.custom;
	        const style = this.props.icons == "auto" ? $ec8c39fdad15601a$var$THEME_ICONS[this.props.theme] : this.props.icons;
	        return categoryIcons[style] || categoryIcons;
	    }
	    render() {
	        let selectedCategoryIndex = null;
	        return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("nav", {
	            id: "nav",
	            class: "padding",
	            "data-position": this.props.position,
	            dir: this.props.dir,
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                class: "flex relative",
	                children: [
	                    this.categories.map((category, i)=>{
	                        const title = category.name || ($7adb23b0109cc36a$export$dbe3113d60765c1a).categories[category.id];
	                        const selected = !this.props.unfocused && category.id == this.state.categoryId;
	                        if (selected) selectedCategoryIndex = i;
	                        return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("button", {
	                            "aria-label": title,
	                            "aria-selected": selected || undefined,
	                            title: title,
	                            type: "button",
	                            class: "flex flex-grow flex-center",
	                            onMouseDown: (e)=>e.preventDefault(),
	                            onClick: ()=>{
	                                this.props.onClick({
	                                    category: category,
	                                    i: i
	                                });
	                            },
	                            children: this.renderIcon(category)
	                        });
	                    }),
	                    /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                        class: "bar",
	                        style: {
	                            width: `${100 / this.categories.length}%`,
	                            opacity: selectedCategoryIndex == null ? 0 : 1,
	                            transform: this.props.dir === "rtl" ? `scaleX(-1) translateX(${selectedCategoryIndex * 100}%)` : `translateX(${selectedCategoryIndex * 100}%)`
	                        }
	                    })
	                ]
	            })
	        });
	    }
	    constructor(){
	        super();
	        this.categories = ($7adb23b0109cc36a$export$2d0294657ab35f1b).categories.filter((category)=>{
	            return !category.target;
	        });
	        this.state = {
	            categoryId: this.categories[0].id
	        };
	    }
	}





	class $e0d4dda61265ff1e$export$2e2bcd8739ae039 extends ($dc040a17866866fa$export$221d75b3f55bb0bd) {
	    shouldComponentUpdate(nextProps) {
	        for(let k in nextProps){
	            if (k == "children") continue;
	            if (nextProps[k] != this.props[k]) return true;
	        }
	        return false;
	    }
	    render() {
	        return this.props.children;
	    }
	}




	const $89bd6bb200cc8fef$var$Performance = {
	    rowsPerRender: 10
	};
	class $89bd6bb200cc8fef$export$2e2bcd8739ae039 extends ($fb96b826c0c5f37a$export$16fa2f45be04daa8) {
	    getInitialState(props = this.props) {
	        return {
	            skin: ($f72b75cf796873c7$export$2e2bcd8739ae039).get("skin") || props.skin,
	            theme: this.initTheme(props.theme)
	        };
	    }
	    componentWillMount() {
	        this.dir = ($7adb23b0109cc36a$export$dbe3113d60765c1a).rtl ? "rtl" : "ltr";
	        this.refs = {
	            menu: ($fb96b826c0c5f37a$export$7d1e3a5e95ceca43)(),
	            navigation: ($fb96b826c0c5f37a$export$7d1e3a5e95ceca43)(),
	            scroll: ($fb96b826c0c5f37a$export$7d1e3a5e95ceca43)(),
	            search: ($fb96b826c0c5f37a$export$7d1e3a5e95ceca43)(),
	            searchInput: ($fb96b826c0c5f37a$export$7d1e3a5e95ceca43)(),
	            skinToneButton: ($fb96b826c0c5f37a$export$7d1e3a5e95ceca43)(),
	            skinToneRadio: ($fb96b826c0c5f37a$export$7d1e3a5e95ceca43)()
	        };
	        this.initGrid();
	        if (this.props.stickySearch == false && this.props.searchPosition == "sticky") {
	            console.warn("[EmojiMart] Deprecation warning: `stickySearch` has been renamed `searchPosition`.");
	            this.props.searchPosition = "static";
	        }
	    }
	    componentDidMount() {
	        this.register();
	        this.shadowRoot = this.base.parentNode;
	        if (this.props.autoFocus) {
	            const { searchInput: searchInput  } = this.refs;
	            if (searchInput.current) searchInput.current.focus();
	        }
	    }
	    componentWillReceiveProps(nextProps) {
	        this.nextState || (this.nextState = {});
	        for(const k1 in nextProps)this.nextState[k1] = nextProps[k1];
	        clearTimeout(this.nextStateTimer);
	        this.nextStateTimer = setTimeout(()=>{
	            let requiresGridReset = false;
	            for(const k in this.nextState){
	                this.props[k] = this.nextState[k];
	                if (k === "custom" || k === "categories") requiresGridReset = true;
	            }
	            delete this.nextState;
	            const nextState = this.getInitialState();
	            if (requiresGridReset) return this.reset(nextState);
	            this.setState(nextState);
	        });
	    }
	    componentWillUnmount() {
	        this.unregister();
	    }
	    async reset(nextState = {}) {
	        await ($7adb23b0109cc36a$export$2cd8252107eb640b)(this.props);
	        this.initGrid();
	        this.unobserve();
	        this.setState(nextState, ()=>{
	            this.observeCategories();
	            this.observeRows();
	        });
	    }
	    register() {
	        document.addEventListener("click", this.handleClickOutside);
	        this.observe();
	    }
	    unregister() {
	        document.removeEventListener("click", this.handleClickOutside);
	        this.unobserve();
	    }
	    observe() {
	        this.observeCategories();
	        this.observeRows();
	    }
	    unobserve({ except: except = []  } = {}) {
	        if (!Array.isArray(except)) except = [
	            except
	        ];
	        for (const observer of this.observers){
	            if (except.includes(observer)) continue;
	            observer.disconnect();
	        }
	        this.observers = [].concat(except);
	    }
	    initGrid() {
	        const { categories: categories  } = ($7adb23b0109cc36a$export$2d0294657ab35f1b);
	        this.refs.categories = new Map();
	        const navKey = ($7adb23b0109cc36a$export$2d0294657ab35f1b).categories.map((category)=>category.id).join(",");
	        if (this.navKey && this.navKey != navKey) this.refs.scroll.current && (this.refs.scroll.current.scrollTop = 0);
	        this.navKey = navKey;
	        this.grid = [];
	        this.grid.setsize = 0;
	        const addRow = (rows, category)=>{
	            const row = [];
	            row.__categoryId = category.id;
	            row.__index = rows.length;
	            this.grid.push(row);
	            const rowIndex = this.grid.length - 1;
	            const rowRef = rowIndex % $89bd6bb200cc8fef$var$Performance.rowsPerRender ? {} : ($fb96b826c0c5f37a$export$7d1e3a5e95ceca43)();
	            rowRef.index = rowIndex;
	            rowRef.posinset = this.grid.setsize + 1;
	            rows.push(rowRef);
	            return row;
	        };
	        for (let category1 of categories){
	            const rows = [];
	            let row = addRow(rows, category1);
	            for (let emoji of category1.emojis){
	                if (row.length == this.getPerLine()) row = addRow(rows, category1);
	                this.grid.setsize += 1;
	                row.push(emoji);
	            }
	            this.refs.categories.set(category1.id, {
	                root: ($fb96b826c0c5f37a$export$7d1e3a5e95ceca43)(),
	                rows: rows
	            });
	        }
	    }
	    initTheme(theme) {
	        if (theme != "auto") return theme;
	        if (!this.darkMedia) {
	            this.darkMedia = matchMedia("(prefers-color-scheme: dark)");
	            if (this.darkMedia.media.match(/^not/)) return "light";
	            this.darkMedia.addListener(()=>{
	                if (this.props.theme != "auto") return;
	                this.setState({
	                    theme: this.darkMedia.matches ? "dark" : "light"
	                });
	            });
	        }
	        return this.darkMedia.matches ? "dark" : "light";
	    }
	    initDynamicPerLine(props = this.props) {
	        if (!props.dynamicWidth) return;
	        const { element: element , emojiButtonSize: emojiButtonSize  } = props;
	        const calculatePerLine = ()=>{
	            const { width: width  } = element.getBoundingClientRect();
	            return Math.floor(width / emojiButtonSize);
	        };
	        const observer = new ResizeObserver(()=>{
	            this.unobserve({
	                except: observer
	            });
	            this.setState({
	                perLine: calculatePerLine()
	            }, ()=>{
	                this.initGrid();
	                this.forceUpdate(()=>{
	                    this.observeCategories();
	                    this.observeRows();
	                });
	            });
	        });
	        observer.observe(element);
	        this.observers.push(observer);
	        return calculatePerLine();
	    }
	    getPerLine() {
	        return this.state.perLine || this.props.perLine;
	    }
	    getEmojiByPos([p1, p2]) {
	        const grid = this.state.searchResults || this.grid;
	        const emoji = grid[p1] && grid[p1][p2];
	        if (!emoji) return;
	        return ($c4d155af13ad4d4b$export$2e2bcd8739ae039).get(emoji);
	    }
	    observeCategories() {
	        const navigation = this.refs.navigation.current;
	        if (!navigation) return;
	        const visibleCategories = new Map();
	        const setFocusedCategory = (categoryId)=>{
	            if (categoryId != navigation.state.categoryId) navigation.setState({
	                categoryId: categoryId
	            });
	        };
	        const observerOptions = {
	            root: this.refs.scroll.current,
	            threshold: [
	                0.0,
	                1.0
	            ]
	        };
	        const observer = new IntersectionObserver((entries)=>{
	            for (const entry of entries){
	                const id = entry.target.dataset.id;
	                visibleCategories.set(id, entry.intersectionRatio);
	            }
	            const ratios = [
	                ...visibleCategories
	            ];
	            for (const [id, ratio] of ratios)if (ratio) {
	                setFocusedCategory(id);
	                break;
	            }
	        }, observerOptions);
	        for (const { root: root  } of this.refs.categories.values())observer.observe(root.current);
	        this.observers.push(observer);
	    }
	    observeRows() {
	        const visibleRows = {
	            ...this.state.visibleRows
	        };
	        const observer = new IntersectionObserver((entries)=>{
	            for (const entry of entries){
	                const index = parseInt(entry.target.dataset.index);
	                if (entry.isIntersecting) visibleRows[index] = true;
	                else delete visibleRows[index];
	            }
	            this.setState({
	                visibleRows: visibleRows
	            });
	        }, {
	            root: this.refs.scroll.current,
	            rootMargin: `${this.props.emojiButtonSize * ($89bd6bb200cc8fef$var$Performance.rowsPerRender + 5)}px 0px ${this.props.emojiButtonSize * $89bd6bb200cc8fef$var$Performance.rowsPerRender}px`
	        });
	        for (const { rows: rows  } of this.refs.categories.values()){
	            for (const row of rows)if (row.current) observer.observe(row.current);
	        }
	        this.observers.push(observer);
	    }
	    preventDefault(e) {
	        e.preventDefault();
	    }
	    unfocusSearch() {
	        const input = this.refs.searchInput.current;
	        if (!input) return;
	        input.blur();
	    }
	    navigate({ e: e , input: input , left: left , right: right , up: up , down: down  }) {
	        const grid = this.state.searchResults || this.grid;
	        if (!grid.length) return;
	        let [p1, p2] = this.state.pos;
	        const pos = (()=>{
	            if (p1 == 0) {
	                if (p2 == 0 && !e.repeat && (left || up)) return null;
	            }
	            if (p1 == -1) {
	                if (!e.repeat && (right || down) && input.selectionStart == input.value.length) return [
	                    0,
	                    0
	                ];
	                return null;
	            }
	            if (left || right) {
	                let row = grid[p1];
	                const increment = left ? -1 : 1;
	                p2 += increment;
	                if (!row[p2]) {
	                    p1 += increment;
	                    row = grid[p1];
	                    if (!row) {
	                        p1 = left ? 0 : grid.length - 1;
	                        p2 = left ? 0 : grid[p1].length - 1;
	                        return [
	                            p1,
	                            p2
	                        ];
	                    }
	                    p2 = left ? row.length - 1 : 0;
	                }
	                return [
	                    p1,
	                    p2
	                ];
	            }
	            if (up || down) {
	                p1 += up ? -1 : 1;
	                const row = grid[p1];
	                if (!row) {
	                    p1 = up ? 0 : grid.length - 1;
	                    p2 = up ? 0 : grid[p1].length - 1;
	                    return [
	                        p1,
	                        p2
	                    ];
	                }
	                if (!row[p2]) p2 = row.length - 1;
	                return [
	                    p1,
	                    p2
	                ];
	            }
	        })();
	        if (pos) e.preventDefault();
	        else {
	            if (this.state.pos[0] > -1) this.setState({
	                pos: [
	                    -1,
	                    -1
	                ]
	            });
	            return;
	        }
	        this.setState({
	            pos: pos,
	            keyboard: true
	        }, ()=>{
	            this.scrollTo({
	                row: pos[0]
	            });
	        });
	    }
	    scrollTo({ categoryId: categoryId , row: row  }) {
	        const grid = this.state.searchResults || this.grid;
	        if (!grid.length) return;
	        const scroll = this.refs.scroll.current;
	        const scrollRect = scroll.getBoundingClientRect();
	        let scrollTop = 0;
	        if (row >= 0) categoryId = grid[row].__categoryId;
	        if (categoryId) {
	            const ref = this.refs[categoryId] || this.refs.categories.get(categoryId).root;
	            const categoryRect = ref.current.getBoundingClientRect();
	            scrollTop = categoryRect.top - (scrollRect.top - scroll.scrollTop) + 1;
	        }
	        if (row >= 0) {
	            if (!row) scrollTop = 0;
	            else {
	                const rowIndex = grid[row].__index;
	                const rowTop = scrollTop + rowIndex * this.props.emojiButtonSize;
	                const rowBot = rowTop + this.props.emojiButtonSize + this.props.emojiButtonSize * 0.88;
	                if (rowTop < scroll.scrollTop) scrollTop = rowTop;
	                else if (rowBot > scroll.scrollTop + scrollRect.height) scrollTop = rowBot - scrollRect.height;
	                else return;
	            }
	        }
	        this.ignoreMouse();
	        scroll.scrollTop = scrollTop;
	    }
	    ignoreMouse() {
	        this.mouseIsIgnored = true;
	        clearTimeout(this.ignoreMouseTimer);
	        this.ignoreMouseTimer = setTimeout(()=>{
	            delete this.mouseIsIgnored;
	        }, 100);
	    }
	    handleEmojiOver(pos) {
	        if (this.mouseIsIgnored || this.state.showSkins) return;
	        this.setState({
	            pos: pos || [
	                -1,
	                -1
	            ],
	            keyboard: false
	        });
	    }
	    handleEmojiClick({ e: e , emoji: emoji , pos: pos  }) {
	        if (!this.props.onEmojiSelect) return;
	        if (!emoji && pos) emoji = this.getEmojiByPos(pos);
	        if (emoji) {
	            const emojiData = ($693b183b0a78708f$export$d10ac59fbe52a745)(emoji, {
	                skinIndex: this.state.skin - 1
	            });
	            if (this.props.maxFrequentRows) ($b22cfd0a55410b4f$export$2e2bcd8739ae039).add(emojiData, this.props);
	            this.props.onEmojiSelect(emojiData, e);
	        }
	    }
	    closeSkins() {
	        if (!this.state.showSkins) return;
	        this.setState({
	            showSkins: null,
	            tempSkin: null
	        });
	        this.base.removeEventListener("click", this.handleBaseClick);
	        this.base.removeEventListener("keydown", this.handleBaseKeydown);
	    }
	    handleSkinMouseOver(tempSkin) {
	        this.setState({
	            tempSkin: tempSkin
	        });
	    }
	    handleSkinClick(skin) {
	        this.ignoreMouse();
	        this.closeSkins();
	        this.setState({
	            skin: skin,
	            tempSkin: null
	        });
	        ($f72b75cf796873c7$export$2e2bcd8739ae039).set("skin", skin);
	    }
	    renderNav() {
	        return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)(($ec8c39fdad15601a$export$2e2bcd8739ae039), {
	            ref: this.refs.navigation,
	            icons: this.props.icons,
	            theme: this.state.theme,
	            dir: this.dir,
	            unfocused: !!this.state.searchResults,
	            position: this.props.navPosition,
	            onClick: this.handleCategoryClick
	        }, this.navKey);
	    }
	    renderPreview() {
	        const emoji = this.getEmojiByPos(this.state.pos);
	        const noSearchResults = this.state.searchResults && !this.state.searchResults.length;
	        return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	            id: "preview",
	            class: "flex flex-middle",
	            dir: this.dir,
	            "data-position": this.props.previewPosition,
	            children: [
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                    class: "flex flex-middle flex-grow",
	                    children: [
	                        /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                            class: "flex flex-auto flex-middle flex-center",
	                            style: {
	                                height: this.props.emojiButtonSize,
	                                fontSize: this.props.emojiButtonSize
	                            },
	                            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)(($254755d3f438722f$export$2e2bcd8739ae039), {
	                                emoji: emoji,
	                                id: noSearchResults ? this.props.noResultsEmoji || "cry" : this.props.previewEmoji || (this.props.previewPosition == "top" ? "point_down" : "point_up"),
	                                set: this.props.set,
	                                size: this.props.emojiButtonSize,
	                                skin: this.state.tempSkin || this.state.skin,
	                                spritesheet: true,
	                                getSpritesheetURL: this.props.getSpritesheetURL
	                            })
	                        }),
	                        /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                            class: `margin-${this.dir[0]}`,
	                            children: emoji || noSearchResults ? /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                                class: `padding-${this.dir[2]} align-${this.dir[0]}`,
	                                children: [
	                                    /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                                        class: "preview-title ellipsis",
	                                        children: emoji ? emoji.name : ($7adb23b0109cc36a$export$dbe3113d60765c1a).search_no_results_1
	                                    }),
	                                    /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                                        class: "preview-subtitle ellipsis color-c",
	                                        children: emoji ? emoji.skins[0].shortcodes : ($7adb23b0109cc36a$export$dbe3113d60765c1a).search_no_results_2
	                                    })
	                                ]
	                            }) : /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                                class: "preview-placeholder color-c",
	                                children: ($7adb23b0109cc36a$export$dbe3113d60765c1a).pick
	                            })
	                        })
	                    ]
	                }),
	                !emoji && this.props.skinTonePosition == "preview" && this.renderSkinToneButton()
	            ]
	        });
	    }
	    renderEmojiButton(emoji, { pos: pos , posinset: posinset , grid: grid  }) {
	        const size = this.props.emojiButtonSize;
	        const skin = this.state.tempSkin || this.state.skin;
	        const emojiSkin = emoji.skins[skin - 1] || emoji.skins[0];
	        const native = emojiSkin.native;
	        const selected = ($693b183b0a78708f$export$9cb4719e2e525b7a)(this.state.pos, pos);
	        const key = pos.concat(emoji.id).join("");
	        return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)(($e0d4dda61265ff1e$export$2e2bcd8739ae039), {
	            selected: selected,
	            skin: skin,
	            size: size,
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("button", {
	                "aria-label": native,
	                "aria-selected": selected || undefined,
	                "aria-posinset": posinset,
	                "aria-setsize": grid.setsize,
	                "data-keyboard": this.state.keyboard,
	                title: this.props.previewPosition == "none" ? emoji.name : undefined,
	                type: "button",
	                class: "flex flex-center flex-middle",
	                tabindex: "-1",
	                onClick: (e)=>this.handleEmojiClick({
	                        e: e,
	                        emoji: emoji
	                    }),
	                onMouseEnter: ()=>this.handleEmojiOver(pos),
	                onMouseLeave: ()=>this.handleEmojiOver(),
	                style: {
	                    width: this.props.emojiButtonSize,
	                    height: this.props.emojiButtonSize,
	                    fontSize: this.props.emojiSize,
	                    lineHeight: 0
	                },
	                children: [
	                    /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                        "aria-hidden": "true",
	                        class: "background",
	                        style: {
	                            borderRadius: this.props.emojiButtonRadius,
	                            backgroundColor: this.props.emojiButtonColors ? this.props.emojiButtonColors[(posinset - 1) % this.props.emojiButtonColors.length] : undefined
	                        }
	                    }),
	                    /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)(($254755d3f438722f$export$2e2bcd8739ae039), {
	                        emoji: emoji,
	                        set: this.props.set,
	                        size: this.props.emojiSize,
	                        skin: skin,
	                        spritesheet: true,
	                        getSpritesheetURL: this.props.getSpritesheetURL
	                    })
	                ]
	            })
	        }, key);
	    }
	    renderSearch() {
	        const renderSkinTone = this.props.previewPosition == "none" || this.props.skinTonePosition == "search";
	        return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	            children: [
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                    class: "spacer"
	                }),
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                    class: "flex flex-middle",
	                    children: [
	                        /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                            class: "search relative flex-grow",
	                            children: [
	                                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("input", {
	                                    type: "search",
	                                    ref: this.refs.searchInput,
	                                    placeholder: ($7adb23b0109cc36a$export$dbe3113d60765c1a).search,
	                                    onClick: this.handleSearchClick,
	                                    onInput: this.handleSearchInput,
	                                    onKeyDown: this.handleSearchKeyDown,
	                                    autoComplete: "off"
	                                }),
	                                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("span", {
	                                    class: "icon loupe flex",
	                                    children: ($fcccfb36ed0cde68$export$2e2bcd8739ae039).search.loupe
	                                }),
	                                this.state.searchResults && /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("button", {
	                                    title: "Clear",
	                                    "aria-label": "Clear",
	                                    type: "button",
	                                    class: "icon delete flex",
	                                    onClick: this.clearSearch,
	                                    onMouseDown: this.preventDefault,
	                                    children: ($fcccfb36ed0cde68$export$2e2bcd8739ae039).search.delete
	                                })
	                            ]
	                        }),
	                        renderSkinTone && this.renderSkinToneButton()
	                    ]
	                })
	            ]
	        });
	    }
	    renderSearchResults() {
	        const { searchResults: searchResults  } = this.state;
	        if (!searchResults) return null;
	        return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	            class: "category",
	            ref: this.refs.search,
	            children: [
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                    class: `sticky padding-small align-${this.dir[0]}`,
	                    children: ($7adb23b0109cc36a$export$dbe3113d60765c1a).categories.search
	                }),
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                    children: !searchResults.length ? /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                        class: `padding-small align-${this.dir[0]}`,
	                        children: this.props.onAddCustomEmoji && /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("a", {
	                            onClick: this.props.onAddCustomEmoji,
	                            children: ($7adb23b0109cc36a$export$dbe3113d60765c1a).add_custom
	                        })
	                    }) : searchResults.map((row, i)=>{
	                        return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                            class: "flex",
	                            children: row.map((emoji, ii)=>{
	                                return this.renderEmojiButton(emoji, {
	                                    pos: [
	                                        i,
	                                        ii
	                                    ],
	                                    posinset: i * this.props.perLine + ii + 1,
	                                    grid: searchResults
	                                });
	                            })
	                        });
	                    })
	                })
	            ]
	        });
	    }
	    renderCategories() {
	        const { categories: categories  } = ($7adb23b0109cc36a$export$2d0294657ab35f1b);
	        const hidden = !!this.state.searchResults;
	        const perLine = this.getPerLine();
	        return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	            style: {
	                visibility: hidden ? "hidden" : undefined,
	                display: hidden ? "none" : undefined,
	                height: "100%"
	            },
	            children: categories.map((category)=>{
	                const { root: root , rows: rows  } = this.refs.categories.get(category.id);
	                return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                    "data-id": category.target ? category.target.id : category.id,
	                    class: "category",
	                    ref: root,
	                    children: [
	                        /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                            class: `sticky padding-small align-${this.dir[0]}`,
	                            children: category.name || ($7adb23b0109cc36a$export$dbe3113d60765c1a).categories[category.id]
	                        }),
	                        /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                            class: "relative",
	                            style: {
	                                height: rows.length * this.props.emojiButtonSize
	                            },
	                            children: rows.map((row, i)=>{
	                                const targetRow = row.index - row.index % $89bd6bb200cc8fef$var$Performance.rowsPerRender;
	                                const visible = this.state.visibleRows[targetRow];
	                                const ref = "current" in row ? row : undefined;
	                                if (!visible && !ref) return null;
	                                const start = i * perLine;
	                                const end = start + perLine;
	                                const emojiIds = category.emojis.slice(start, end);
	                                if (emojiIds.length < perLine) emojiIds.push(...new Array(perLine - emojiIds.length));
	                                return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                                    "data-index": row.index,
	                                    ref: ref,
	                                    class: "flex row",
	                                    style: {
	                                        top: i * this.props.emojiButtonSize
	                                    },
	                                    children: visible && emojiIds.map((emojiId, ii)=>{
	                                        if (!emojiId) return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                                            style: {
	                                                width: this.props.emojiButtonSize,
	                                                height: this.props.emojiButtonSize
	                                            }
	                                        });
	                                        const emoji = ($c4d155af13ad4d4b$export$2e2bcd8739ae039).get(emojiId);
	                                        return this.renderEmojiButton(emoji, {
	                                            pos: [
	                                                row.index,
	                                                ii
	                                            ],
	                                            posinset: row.posinset + ii,
	                                            grid: this.grid
	                                        });
	                                    })
	                                }, row.index);
	                            })
	                        })
	                    ]
	                });
	            })
	        });
	    }
	    renderSkinToneButton() {
	        if (this.props.skinTonePosition == "none") return null;
	        return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	            class: "flex flex-auto flex-center flex-middle",
	            style: {
	                position: "relative",
	                width: this.props.emojiButtonSize,
	                height: this.props.emojiButtonSize
	            },
	            children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("button", {
	                type: "button",
	                ref: this.refs.skinToneButton,
	                class: "skin-tone-button flex flex-auto flex-center flex-middle",
	                "aria-selected": this.state.showSkins ? "" : undefined,
	                "aria-label": ($7adb23b0109cc36a$export$dbe3113d60765c1a).skins.choose,
	                title: ($7adb23b0109cc36a$export$dbe3113d60765c1a).skins.choose,
	                onClick: this.openSkins,
	                style: {
	                    width: this.props.emojiSize,
	                    height: this.props.emojiSize
	                },
	                children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("span", {
	                    class: `skin-tone skin-tone-${this.state.skin}`
	                })
	            })
	        });
	    }
	    renderLiveRegion() {
	        const emoji = this.getEmojiByPos(this.state.pos);
	        const contents = emoji ? emoji.name : "";
	        return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	            "aria-live": "polite",
	            class: "sr-only",
	            children: contents
	        });
	    }
	    renderSkins() {
	        const skinToneButton = this.refs.skinToneButton.current;
	        const skinToneButtonRect = skinToneButton.getBoundingClientRect();
	        const baseRect = this.base.getBoundingClientRect();
	        const position = {};
	        if (this.dir == "ltr") position.right = baseRect.right - skinToneButtonRect.right - 3;
	        else position.left = skinToneButtonRect.left - baseRect.left - 3;
	        if (this.props.previewPosition == "bottom" && this.props.skinTonePosition == "preview") position.bottom = baseRect.bottom - skinToneButtonRect.top + 6;
	        else {
	            position.top = skinToneButtonRect.bottom - baseRect.top + 3;
	            position.bottom = "auto";
	        }
	        return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	            ref: this.refs.menu,
	            role: "radiogroup",
	            dir: this.dir,
	            "aria-label": ($7adb23b0109cc36a$export$dbe3113d60765c1a).skins.choose,
	            class: "menu hidden",
	            "data-position": position.top ? "top" : "bottom",
	            style: position,
	            children: [
	                ...Array(6).keys()
	            ].map((i)=>{
	                const skin = i + 1;
	                const checked = this.state.skin == skin;
	                return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                    children: [
	                        /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("input", {
	                            type: "radio",
	                            name: "skin-tone",
	                            value: skin,
	                            "aria-label": ($7adb23b0109cc36a$export$dbe3113d60765c1a).skins[skin],
	                            ref: checked ? this.refs.skinToneRadio : null,
	                            defaultChecked: checked,
	                            onChange: ()=>this.handleSkinMouseOver(skin),
	                            onKeyDown: (e)=>{
	                                if (e.code == "Enter" || e.code == "Space" || e.code == "Tab") {
	                                    e.preventDefault();
	                                    this.handleSkinClick(skin);
	                                }
	                            }
	                        }),
	                        /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("button", {
	                            "aria-hidden": "true",
	                            tabindex: "-1",
	                            onClick: ()=>this.handleSkinClick(skin),
	                            onMouseEnter: ()=>this.handleSkinMouseOver(skin),
	                            onMouseLeave: ()=>this.handleSkinMouseOver(),
	                            class: "option flex flex-grow flex-middle",
	                            children: [
	                                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("span", {
	                                    class: `skin-tone skin-tone-${skin}`
	                                }),
	                                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("span", {
	                                    class: "margin-small-lr",
	                                    children: ($7adb23b0109cc36a$export$dbe3113d60765c1a).skins[skin]
	                                })
	                            ]
	                        })
	                    ]
	                });
	            })
	        });
	    }
	    render() {
	        const lineWidth = this.props.perLine * this.props.emojiButtonSize;
	        return /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("section", {
	            id: "root",
	            class: "flex flex-column",
	            dir: this.dir,
	            style: {
	                width: this.props.dynamicWidth ? "100%" : `calc(${lineWidth}px + (var(--padding) + var(--sidebar-width)))`
	            },
	            "data-emoji-set": this.props.set,
	            "data-theme": this.state.theme,
	            "data-menu": this.state.showSkins ? "" : undefined,
	            children: [
	                this.props.previewPosition == "top" && this.renderPreview(),
	                this.props.navPosition == "top" && this.renderNav(),
	                this.props.searchPosition == "sticky" && /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                    class: "padding-lr",
	                    children: this.renderSearch()
	                }),
	                /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                    ref: this.refs.scroll,
	                    class: "scroll flex-grow padding-lr",
	                    children: /*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)("div", {
	                        style: {
	                            width: this.props.dynamicWidth ? "100%" : lineWidth,
	                            height: "100%"
	                        },
	                        children: [
	                            this.props.searchPosition == "static" && this.renderSearch(),
	                            this.renderSearchResults(),
	                            this.renderCategories()
	                        ]
	                    })
	                }),
	                this.props.navPosition == "bottom" && this.renderNav(),
	                this.props.previewPosition == "bottom" && this.renderPreview(),
	                this.state.showSkins && this.renderSkins(),
	                this.renderLiveRegion()
	            ]
	        });
	    }
	    constructor(props){
	        super();
	        ($c770c458706daa72$export$2e2bcd8739ae039)(this, "handleClickOutside", (e)=>{
	            const { element: element  } = this.props;
	            if (e.target != element) {
	                if (this.state.showSkins) this.closeSkins();
	                if (this.props.onClickOutside) this.props.onClickOutside(e);
	            }
	        });
	        ($c770c458706daa72$export$2e2bcd8739ae039)(this, "handleBaseClick", (e)=>{
	            if (!this.state.showSkins) return;
	            if (!e.target.closest(".menu")) {
	                e.preventDefault();
	                e.stopImmediatePropagation();
	                this.closeSkins();
	            }
	        });
	        ($c770c458706daa72$export$2e2bcd8739ae039)(this, "handleBaseKeydown", (e)=>{
	            if (!this.state.showSkins) return;
	            if (e.key == "Escape") {
	                e.preventDefault();
	                e.stopImmediatePropagation();
	                this.closeSkins();
	            }
	        });
	        ($c770c458706daa72$export$2e2bcd8739ae039)(this, "handleSearchClick", ()=>{
	            const emoji = this.getEmojiByPos(this.state.pos);
	            if (!emoji) return;
	            this.setState({
	                pos: [
	                    -1,
	                    -1
	                ]
	            });
	        });
	        ($c770c458706daa72$export$2e2bcd8739ae039)(this, "handleSearchInput", async ()=>{
	            const input = this.refs.searchInput.current;
	            if (!input) return;
	            const { value: value  } = input;
	            const searchResults = await ($c4d155af13ad4d4b$export$2e2bcd8739ae039).search(value);
	            const afterRender = ()=>{
	                if (!this.refs.scroll.current) return;
	                this.refs.scroll.current.scrollTop = 0;
	            };
	            if (!searchResults) return this.setState({
	                searchResults: searchResults,
	                pos: [
	                    -1,
	                    -1
	                ]
	            }, afterRender);
	            const pos = input.selectionStart == input.value.length ? [
	                0,
	                0
	            ] : [
	                -1,
	                -1
	            ];
	            const grid = [];
	            grid.setsize = searchResults.length;
	            let row = null;
	            for (let emoji of searchResults){
	                if (!grid.length || row.length == this.getPerLine()) {
	                    row = [];
	                    row.__categoryId = "search";
	                    row.__index = grid.length;
	                    grid.push(row);
	                }
	                row.push(emoji);
	            }
	            this.ignoreMouse();
	            this.setState({
	                searchResults: grid,
	                pos: pos
	            }, afterRender);
	        });
	        ($c770c458706daa72$export$2e2bcd8739ae039)(this, "handleSearchKeyDown", (e)=>{
	            // const specialKey = e.altKey || e.ctrlKey || e.metaKey
	            const input = e.currentTarget;
	            e.stopImmediatePropagation();
	            switch(e.key){
	                case "ArrowLeft":
	                    // if (specialKey) return
	                    // e.preventDefault()
	                    this.navigate({
	                        e: e,
	                        input: input,
	                        left: true
	                    });
	                    break;
	                case "ArrowRight":
	                    // if (specialKey) return
	                    // e.preventDefault()
	                    this.navigate({
	                        e: e,
	                        input: input,
	                        right: true
	                    });
	                    break;
	                case "ArrowUp":
	                    // if (specialKey) return
	                    // e.preventDefault()
	                    this.navigate({
	                        e: e,
	                        input: input,
	                        up: true
	                    });
	                    break;
	                case "ArrowDown":
	                    // if (specialKey) return
	                    // e.preventDefault()
	                    this.navigate({
	                        e: e,
	                        input: input,
	                        down: true
	                    });
	                    break;
	                case "Enter":
	                    e.preventDefault();
	                    this.handleEmojiClick({
	                        e: e,
	                        pos: this.state.pos
	                    });
	                    break;
	                case "Escape":
	                    e.preventDefault();
	                    if (this.state.searchResults) this.clearSearch();
	                    else this.unfocusSearch();
	                    break;
	            }
	        });
	        ($c770c458706daa72$export$2e2bcd8739ae039)(this, "clearSearch", ()=>{
	            const input = this.refs.searchInput.current;
	            if (!input) return;
	            input.value = "";
	            input.focus();
	            this.handleSearchInput();
	        });
	        ($c770c458706daa72$export$2e2bcd8739ae039)(this, "handleCategoryClick", ({ category: category , i: i  })=>{
	            this.scrollTo(i == 0 ? {
	                row: -1
	            } : {
	                categoryId: category.id
	            });
	        });
	        ($c770c458706daa72$export$2e2bcd8739ae039)(this, "openSkins", (e)=>{
	            const { currentTarget: currentTarget  } = e;
	            const rect = currentTarget.getBoundingClientRect();
	            this.setState({
	                showSkins: rect
	            }, async ()=>{
	                // Firefox requires 2 frames for the transition to consistenly work
	                await ($693b183b0a78708f$export$e772c8ff12451969)(2);
	                const menu = this.refs.menu.current;
	                if (!menu) return;
	                menu.classList.remove("hidden");
	                this.refs.skinToneRadio.current.focus();
	                this.base.addEventListener("click", this.handleBaseClick, true);
	                this.base.addEventListener("keydown", this.handleBaseKeydown, true);
	            });
	        });
	        this.observers = [];
	        this.state = {
	            pos: [
	                -1,
	                -1
	            ],
	            perLine: this.initDynamicPerLine(props),
	            visibleRows: {
	                0: true
	            },
	            ...this.getInitialState(props)
	        };
	    }
	}









	class $efa000751917694d$export$2e2bcd8739ae039 extends ($26f27c338a96b1a6$export$2e2bcd8739ae039) {
	    async connectedCallback() {
	        const props = ($7adb23b0109cc36a$export$75fe5f91d452f94b)(this.props, ($b247ea80b67298d5$export$2e2bcd8739ae039), this);
	        props.element = this;
	        props.ref = (component)=>{
	            this.component = component;
	        };
	        await ($7adb23b0109cc36a$export$2cd8252107eb640b)(props);
	        if (this.disconnected) return;
	        ($fb96b826c0c5f37a$export$b3890eb0ae9dca99)(/*#__PURE__*/ ($bd9dd35321b03dd4$export$34b9dba7ce09269b)(($89bd6bb200cc8fef$export$2e2bcd8739ae039), {
	            ...props
	        }), this.shadowRoot);
	    }
	    constructor(props){
	        super(props, {
	            styles: ((/*@__PURE__*/$parcel$interopDefault($329d53ba9fd7125f$exports)))
	        });
	    }
	}
	($c770c458706daa72$export$2e2bcd8739ae039)($efa000751917694d$export$2e2bcd8739ae039, "Props", ($b247ea80b67298d5$export$2e2bcd8739ae039));
	if (typeof customElements !== "undefined" && !customElements.get("em-emoji-picker")) customElements.define("em-emoji-picker", $efa000751917694d$export$2e2bcd8739ae039);


	var $329d53ba9fd7125f$exports = {};
	$329d53ba9fd7125f$exports = ":host {\n  width: min-content;\n  height: 435px;\n  min-height: 230px;\n  border-radius: var(--border-radius);\n  box-shadow: var(--shadow);\n  --border-radius: 10px;\n  --category-icon-size: 18px;\n  --font-family: -apple-system, BlinkMacSystemFont, \"Helvetica Neue\", sans-serif;\n  --font-size: 15px;\n  --preview-placeholder-size: 21px;\n  --preview-title-size: 1.1em;\n  --preview-subtitle-size: .9em;\n  --shadow-color: 0deg 0% 0%;\n  --shadow: .3px .5px 2.7px hsl(var(--shadow-color) / .14), .4px .8px 1px -3.2px hsl(var(--shadow-color) / .14), 1px 2px 2.5px -4.5px hsl(var(--shadow-color) / .14);\n  display: flex;\n}\n\n[data-theme=\"light\"] {\n  --em-rgb-color: var(--rgb-color, 34, 36, 39);\n  --em-rgb-accent: var(--rgb-accent, 34, 102, 237);\n  --em-rgb-background: var(--rgb-background, 255, 255, 255);\n  --em-rgb-input: var(--rgb-input, 255, 255, 255);\n  --em-color-border: var(--color-border, rgba(0, 0, 0, .05));\n  --em-color-border-over: var(--color-border-over, rgba(0, 0, 0, .1));\n}\n\n[data-theme=\"dark\"] {\n  --em-rgb-color: var(--rgb-color, 222, 222, 221);\n  --em-rgb-accent: var(--rgb-accent, 58, 130, 247);\n  --em-rgb-background: var(--rgb-background, 21, 22, 23);\n  --em-rgb-input: var(--rgb-input, 0, 0, 0);\n  --em-color-border: var(--color-border, rgba(255, 255, 255, .1));\n  --em-color-border-over: var(--color-border-over, rgba(255, 255, 255, .2));\n}\n\n#root {\n  --color-a: rgb(var(--em-rgb-color));\n  --color-b: rgba(var(--em-rgb-color), .65);\n  --color-c: rgba(var(--em-rgb-color), .45);\n  --padding: 12px;\n  --padding-small: calc(var(--padding) / 2);\n  --sidebar-width: 16px;\n  --duration: 225ms;\n  --duration-fast: 125ms;\n  --duration-instant: 50ms;\n  --easing: cubic-bezier(.4, 0, .2, 1);\n  width: 100%;\n  text-align: left;\n  border-radius: var(--border-radius);\n  background-color: rgb(var(--em-rgb-background));\n  position: relative;\n}\n\n@media (prefers-reduced-motion) {\n  #root {\n    --duration: 0;\n    --duration-fast: 0;\n    --duration-instant: 0;\n  }\n}\n\n#root[data-menu] button {\n  cursor: auto;\n}\n\n#root[data-menu] .menu button {\n  cursor: pointer;\n}\n\n:host, #root, input, button {\n  color: rgb(var(--em-rgb-color));\n  font-family: var(--font-family);\n  font-size: var(--font-size);\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n  line-height: normal;\n}\n\n*, :before, :after {\n  box-sizing: border-box;\n  min-width: 0;\n  margin: 0;\n  padding: 0;\n}\n\n.relative {\n  position: relative;\n}\n\n.flex {\n  display: flex;\n}\n\n.flex-auto {\n  flex: none;\n}\n\n.flex-center {\n  justify-content: center;\n}\n\n.flex-column {\n  flex-direction: column;\n}\n\n.flex-grow {\n  flex: auto;\n}\n\n.flex-middle {\n  align-items: center;\n}\n\n.flex-wrap {\n  flex-wrap: wrap;\n}\n\n.padding {\n  padding: var(--padding);\n}\n\n.padding-t {\n  padding-top: var(--padding);\n}\n\n.padding-lr {\n  padding-left: var(--padding);\n  padding-right: var(--padding);\n}\n\n.padding-r {\n  padding-right: var(--padding);\n}\n\n.padding-small {\n  padding: var(--padding-small);\n}\n\n.padding-small-b {\n  padding-bottom: var(--padding-small);\n}\n\n.padding-small-lr {\n  padding-left: var(--padding-small);\n  padding-right: var(--padding-small);\n}\n\n.margin {\n  margin: var(--padding);\n}\n\n.margin-r {\n  margin-right: var(--padding);\n}\n\n.margin-l {\n  margin-left: var(--padding);\n}\n\n.margin-small-l {\n  margin-left: var(--padding-small);\n}\n\n.margin-small-lr {\n  margin-left: var(--padding-small);\n  margin-right: var(--padding-small);\n}\n\n.align-l {\n  text-align: left;\n}\n\n.align-r {\n  text-align: right;\n}\n\n.color-a {\n  color: var(--color-a);\n}\n\n.color-b {\n  color: var(--color-b);\n}\n\n.color-c {\n  color: var(--color-c);\n}\n\n.ellipsis {\n  white-space: nowrap;\n  max-width: 100%;\n  width: auto;\n  text-overflow: ellipsis;\n  overflow: hidden;\n}\n\n.sr-only {\n  width: 1px;\n  height: 1px;\n  position: absolute;\n  top: auto;\n  left: -10000px;\n  overflow: hidden;\n}\n\na {\n  cursor: pointer;\n  color: rgb(var(--em-rgb-accent));\n}\n\na:hover {\n  text-decoration: underline;\n}\n\n.spacer {\n  height: 10px;\n}\n\n[dir=\"rtl\"] .scroll {\n  padding-left: 0;\n  padding-right: var(--padding);\n}\n\n.scroll {\n  padding-right: 0;\n  overflow-x: hidden;\n  overflow-y: auto;\n}\n\n.scroll::-webkit-scrollbar {\n  width: var(--sidebar-width);\n  height: var(--sidebar-width);\n}\n\n.scroll::-webkit-scrollbar-track {\n  border: 0;\n}\n\n.scroll::-webkit-scrollbar-button {\n  width: 0;\n  height: 0;\n  display: none;\n}\n\n.scroll::-webkit-scrollbar-corner {\n  background-color: rgba(0, 0, 0, 0);\n}\n\n.scroll::-webkit-scrollbar-thumb {\n  min-height: 20%;\n  min-height: 65px;\n  border: 4px solid rgb(var(--em-rgb-background));\n  border-radius: 8px;\n}\n\n.scroll::-webkit-scrollbar-thumb:hover {\n  background-color: var(--em-color-border-over) !important;\n}\n\n.scroll:hover::-webkit-scrollbar-thumb {\n  background-color: var(--em-color-border);\n}\n\n.sticky {\n  z-index: 1;\n  background-color: rgba(var(--em-rgb-background), .9);\n  -webkit-backdrop-filter: blur(4px);\n  backdrop-filter: blur(4px);\n  font-weight: 500;\n  position: sticky;\n  top: -1px;\n}\n\n[dir=\"rtl\"] .search input[type=\"search\"] {\n  padding: 10px 2.2em 10px 2em;\n}\n\n[dir=\"rtl\"] .search .loupe {\n  left: auto;\n  right: .7em;\n}\n\n[dir=\"rtl\"] .search .delete {\n  left: .7em;\n  right: auto;\n}\n\n.search {\n  z-index: 2;\n  position: relative;\n}\n\n.search input, .search button {\n  font-size: calc(var(--font-size)  - 1px);\n}\n\n.search input[type=\"search\"] {\n  width: 100%;\n  background-color: var(--em-color-border);\n  transition-duration: var(--duration);\n  transition-property: background-color, box-shadow;\n  transition-timing-function: var(--easing);\n  border: 0;\n  border-radius: 10px;\n  outline: 0;\n  padding: 10px 2em 10px 2.2em;\n  display: block;\n}\n\n.search input[type=\"search\"]::-ms-input-placeholder {\n  color: inherit;\n  opacity: .6;\n}\n\n.search input[type=\"search\"]::placeholder {\n  color: inherit;\n  opacity: .6;\n}\n\n.search input[type=\"search\"], .search input[type=\"search\"]::-webkit-search-decoration, .search input[type=\"search\"]::-webkit-search-cancel-button, .search input[type=\"search\"]::-webkit-search-results-button, .search input[type=\"search\"]::-webkit-search-results-decoration {\n  -webkit-appearance: none;\n  -ms-appearance: none;\n  appearance: none;\n}\n\n.search input[type=\"search\"]:focus {\n  background-color: rgb(var(--em-rgb-input));\n  box-shadow: inset 0 0 0 1px rgb(var(--em-rgb-accent)), 0 1px 3px rgba(65, 69, 73, .2);\n}\n\n.search .icon {\n  z-index: 1;\n  color: rgba(var(--em-rgb-color), .7);\n  position: absolute;\n  top: 50%;\n  transform: translateY(-50%);\n}\n\n.search .loupe {\n  pointer-events: none;\n  left: .7em;\n}\n\n.search .delete {\n  right: .7em;\n}\n\nsvg {\n  fill: currentColor;\n  width: 1em;\n  height: 1em;\n}\n\nbutton {\n  -webkit-appearance: none;\n  -ms-appearance: none;\n  appearance: none;\n  cursor: pointer;\n  color: currentColor;\n  background-color: rgba(0, 0, 0, 0);\n  border: 0;\n}\n\n#nav {\n  z-index: 2;\n  padding-top: 12px;\n  padding-bottom: 12px;\n  padding-right: var(--sidebar-width);\n  position: relative;\n}\n\n#nav button {\n  color: var(--color-b);\n  transition: color var(--duration) var(--easing);\n}\n\n#nav button:hover {\n  color: var(--color-a);\n}\n\n#nav svg, #nav img {\n  width: var(--category-icon-size);\n  height: var(--category-icon-size);\n}\n\n#nav[dir=\"rtl\"] .bar {\n  left: auto;\n  right: 0;\n}\n\n#nav .bar {\n  width: 100%;\n  height: 3px;\n  background-color: rgb(var(--em-rgb-accent));\n  transition: transform var(--duration) var(--easing);\n  border-radius: 3px 3px 0 0;\n  position: absolute;\n  bottom: -12px;\n  left: 0;\n}\n\n#nav button[aria-selected] {\n  color: rgb(var(--em-rgb-accent));\n}\n\n#preview {\n  z-index: 2;\n  padding: calc(var(--padding)  + 4px) var(--padding);\n  padding-right: var(--sidebar-width);\n  position: relative;\n}\n\n#preview .preview-placeholder {\n  font-size: var(--preview-placeholder-size);\n}\n\n#preview .preview-title {\n  font-size: var(--preview-title-size);\n}\n\n#preview .preview-subtitle {\n  font-size: var(--preview-subtitle-size);\n}\n\n#nav:before, #preview:before {\n  content: \"\";\n  height: 2px;\n  position: absolute;\n  left: 0;\n  right: 0;\n}\n\n#nav[data-position=\"top\"]:before, #preview[data-position=\"top\"]:before {\n  background: linear-gradient(to bottom, var(--em-color-border), transparent);\n  top: 100%;\n}\n\n#nav[data-position=\"bottom\"]:before, #preview[data-position=\"bottom\"]:before {\n  background: linear-gradient(to top, var(--em-color-border), transparent);\n  bottom: 100%;\n}\n\n.category:last-child {\n  min-height: calc(100% + 1px);\n}\n\n.category button {\n  font-family: -apple-system, BlinkMacSystemFont, Helvetica Neue, sans-serif;\n  position: relative;\n}\n\n.category button > * {\n  position: relative;\n}\n\n.category button .background {\n  opacity: 0;\n  background-color: var(--em-color-border);\n  transition: opacity var(--duration-fast) var(--easing) var(--duration-instant);\n  position: absolute;\n  top: 0;\n  bottom: 0;\n  left: 0;\n  right: 0;\n}\n\n.category button:hover .background {\n  transition-duration: var(--duration-instant);\n  transition-delay: 0s;\n}\n\n.category button[aria-selected] .background {\n  opacity: 1;\n}\n\n.category button[data-keyboard] .background {\n  transition: none;\n}\n\n.row {\n  width: 100%;\n  position: absolute;\n  top: 0;\n  left: 0;\n}\n\n.skin-tone-button {\n  border: 1px solid rgba(0, 0, 0, 0);\n  border-radius: 100%;\n}\n\n.skin-tone-button:hover {\n  border-color: var(--em-color-border);\n}\n\n.skin-tone-button:active .skin-tone {\n  transform: scale(.85) !important;\n}\n\n.skin-tone-button .skin-tone {\n  transition: transform var(--duration) var(--easing);\n}\n\n.skin-tone-button[aria-selected] {\n  background-color: var(--em-color-border);\n  border-top-color: rgba(0, 0, 0, .05);\n  border-bottom-color: rgba(0, 0, 0, 0);\n  border-left-width: 0;\n  border-right-width: 0;\n}\n\n.skin-tone-button[aria-selected] .skin-tone {\n  transform: scale(.9);\n}\n\n.menu {\n  z-index: 2;\n  white-space: nowrap;\n  border: 1px solid var(--em-color-border);\n  background-color: rgba(var(--em-rgb-background), .9);\n  -webkit-backdrop-filter: blur(4px);\n  backdrop-filter: blur(4px);\n  transition-property: opacity, transform;\n  transition-duration: var(--duration);\n  transition-timing-function: var(--easing);\n  border-radius: 10px;\n  padding: 4px;\n  position: absolute;\n  box-shadow: 1px 1px 5px rgba(0, 0, 0, .05);\n}\n\n.menu.hidden {\n  opacity: 0;\n}\n\n.menu[data-position=\"bottom\"] {\n  transform-origin: 100% 100%;\n}\n\n.menu[data-position=\"bottom\"].hidden {\n  transform: scale(.9)rotate(-3deg)translateY(5%);\n}\n\n.menu[data-position=\"top\"] {\n  transform-origin: 100% 0;\n}\n\n.menu[data-position=\"top\"].hidden {\n  transform: scale(.9)rotate(3deg)translateY(-5%);\n}\n\n.menu input[type=\"radio\"] {\n  clip: rect(0 0 0 0);\n  width: 1px;\n  height: 1px;\n  border: 0;\n  margin: 0;\n  padding: 0;\n  position: absolute;\n  overflow: hidden;\n}\n\n.menu input[type=\"radio\"]:checked + .option {\n  box-shadow: 0 0 0 2px rgb(var(--em-rgb-accent));\n}\n\n.option {\n  width: 100%;\n  border-radius: 6px;\n  padding: 4px 6px;\n}\n\n.option:hover {\n  color: #fff;\n  background-color: rgb(var(--em-rgb-accent));\n}\n\n.skin-tone {\n  width: 16px;\n  height: 16px;\n  border-radius: 100%;\n  display: inline-block;\n  position: relative;\n  overflow: hidden;\n}\n\n.skin-tone:after {\n  content: \"\";\n  mix-blend-mode: overlay;\n  background: linear-gradient(rgba(255, 255, 255, .2), rgba(0, 0, 0, 0));\n  border: 1px solid rgba(0, 0, 0, .8);\n  border-radius: 100%;\n  position: absolute;\n  top: 0;\n  bottom: 0;\n  left: 0;\n  right: 0;\n  box-shadow: inset 0 -2px 3px #000, inset 0 1px 2px #fff;\n}\n\n.skin-tone-1 {\n  background-color: #ffc93a;\n}\n\n.skin-tone-2 {\n  background-color: #ffdab7;\n}\n\n.skin-tone-3 {\n  background-color: #e7b98f;\n}\n\n.skin-tone-4 {\n  background-color: #c88c61;\n}\n\n.skin-tone-5 {\n  background-color: #a46134;\n}\n\n.skin-tone-6 {\n  background-color: #5d4437;\n}\n\n[data-index] {\n  justify-content: space-between;\n}\n\n[data-emoji-set=\"twitter\"] .skin-tone:after {\n  box-shadow: none;\n  border-color: rgba(0, 0, 0, .5);\n}\n\n[data-emoji-set=\"twitter\"] .skin-tone-1 {\n  background-color: #fade72;\n}\n\n[data-emoji-set=\"twitter\"] .skin-tone-2 {\n  background-color: #f3dfd0;\n}\n\n[data-emoji-set=\"twitter\"] .skin-tone-3 {\n  background-color: #eed3a8;\n}\n\n[data-emoji-set=\"twitter\"] .skin-tone-4 {\n  background-color: #cfad8d;\n}\n\n[data-emoji-set=\"twitter\"] .skin-tone-5 {\n  background-color: #a8805d;\n}\n\n[data-emoji-set=\"twitter\"] .skin-tone-6 {\n  background-color: #765542;\n}\n\n[data-emoji-set=\"google\"] .skin-tone:after {\n  box-shadow: inset 0 0 2px 2px rgba(0, 0, 0, .4);\n}\n\n[data-emoji-set=\"google\"] .skin-tone-1 {\n  background-color: #f5c748;\n}\n\n[data-emoji-set=\"google\"] .skin-tone-2 {\n  background-color: #f1d5aa;\n}\n\n[data-emoji-set=\"google\"] .skin-tone-3 {\n  background-color: #d4b48d;\n}\n\n[data-emoji-set=\"google\"] .skin-tone-4 {\n  background-color: #aa876b;\n}\n\n[data-emoji-set=\"google\"] .skin-tone-5 {\n  background-color: #916544;\n}\n\n[data-emoji-set=\"google\"] .skin-tone-6 {\n  background-color: #61493f;\n}\n\n[data-emoji-set=\"facebook\"] .skin-tone:after {\n  border-color: rgba(0, 0, 0, .4);\n  box-shadow: inset 0 -2px 3px #000, inset 0 1px 4px #fff;\n}\n\n[data-emoji-set=\"facebook\"] .skin-tone-1 {\n  background-color: #f5c748;\n}\n\n[data-emoji-set=\"facebook\"] .skin-tone-2 {\n  background-color: #f1d5aa;\n}\n\n[data-emoji-set=\"facebook\"] .skin-tone-3 {\n  background-color: #d4b48d;\n}\n\n[data-emoji-set=\"facebook\"] .skin-tone-4 {\n  background-color: #aa876b;\n}\n\n[data-emoji-set=\"facebook\"] .skin-tone-5 {\n  background-color: #916544;\n}\n\n[data-emoji-set=\"facebook\"] .skin-tone-6 {\n  background-color: #61493f;\n}\n\n";

	function $e5534fc185f7111e$export$2e2bcd8739ae039(props) {
	    const ref = (reactExports.useRef)(null);
	    const instance = (reactExports.useRef)(null);
	    if (instance.current) instance.current.update(props);
	    (reactExports.useEffect)(()=>{
	        instance.current = new ($efa000751917694d$export$2e2bcd8739ae039)({
	            ...props,
	            ref: ref
	        });
	        return ()=>{
	            instance.current = null;
	        };
	    }, []);
	    return /*#__PURE__*/ (React$2).createElement("div", {
	        ref: ref
	    });
	}

	function t$2(t){return t.split("-")[1]}function e(t){return "y"===t?"height":"width"}function n$2(t){return t.split("-")[0]}function o$1(t){return ["top","bottom"].includes(n$2(t))?"x":"y"}function i$1(i,r,a){let{reference:l,floating:s}=i;const c=l.x+l.width/2-s.width/2,f=l.y+l.height/2-s.height/2,m=o$1(r),u=e(m),g=l[u]/2-s[u]/2,d="x"===m;let p;switch(n$2(r)){case"top":p={x:c,y:l.y-s.height};break;case"bottom":p={x:c,y:l.y+l.height};break;case"right":p={x:l.x+l.width,y:f};break;case"left":p={x:l.x-s.width,y:f};break;default:p={x:l.x,y:l.y};}switch(t$2(r)){case"start":p[m]-=g*(a&&d?-1:1);break;case"end":p[m]+=g*(a&&d?-1:1);}return p}const r$2=async(t,e,n)=>{const{placement:o="bottom",strategy:r="absolute",middleware:a=[],platform:l}=n,s=a.filter(Boolean),c=await(null==l.isRTL?void 0:l.isRTL(e));let f=await l.getElementRects({reference:t,floating:e,strategy:r}),{x:m,y:u}=i$1(f,o,c),g=o,d={},p=0;for(let n=0;n<s.length;n++){const{name:a,fn:h}=s[n],{x:y,y:x,data:w,reset:v}=await h({x:m,y:u,initialPlacement:o,placement:g,strategy:r,middlewareData:d,rects:f,platform:l,elements:{reference:t,floating:e}});m=null!=y?y:m,u=null!=x?x:u,d={...d,[a]:{...d[a],...w}},v&&p<=50&&(p++,"object"==typeof v&&(v.placement&&(g=v.placement),v.rects&&(f=!0===v.rects?await l.getElementRects({reference:t,floating:e,strategy:r}):v.rects),({x:m,y:u}=i$1(f,g,c))),n=-1);}return {x:m,y:u,placement:g,strategy:r,middlewareData:d}};function a$1(t,e){return "function"==typeof t?t(e):t}function l$3(t){return "number"!=typeof t?function(t){return {top:0,right:0,bottom:0,left:0,...t}}(t):{top:t,right:t,bottom:t,left:t}}function s$3(t){return {...t,top:t.y,left:t.x,right:t.x+t.width,bottom:t.y+t.height}}async function c$1(t,e){var n;void 0===e&&(e={});const{x:o,y:i,platform:r,rects:c,elements:f,strategy:m}=t,{boundary:u="clippingAncestors",rootBoundary:g="viewport",elementContext:d="floating",altBoundary:p=!1,padding:h=0}=a$1(e,t),y=l$3(h),x=f[p?"floating"===d?"reference":"floating":d],w=s$3(await r.getClippingRect({element:null==(n=await(null==r.isElement?void 0:r.isElement(x)))||n?x:x.contextElement||await(null==r.getDocumentElement?void 0:r.getDocumentElement(f.floating)),boundary:u,rootBoundary:g,strategy:m})),v="floating"===d?{...c.floating,x:o,y:i}:c.reference,b=await(null==r.getOffsetParent?void 0:r.getOffsetParent(f.floating)),A=await(null==r.isElement?void 0:r.isElement(b))&&await(null==r.getScale?void 0:r.getScale(b))||{x:1,y:1},R=s$3(r.convertOffsetParentRelativeRectToViewportRelativeRect?await r.convertOffsetParentRelativeRectToViewportRelativeRect({rect:v,offsetParent:b,strategy:m}):v);return {top:(w.top-R.top+y.top)/A.y,bottom:(R.bottom-w.bottom+y.bottom)/A.y,left:(w.left-R.left+y.left)/A.x,right:(R.right-w.right+y.right)/A.x}}const f$1=Math.min,m$2=Math.max;function u$4(t,e,n){return m$2(t,f$1(e,n))}const d$2=["top","right","bottom","left"];d$2.reduce(((t,e)=>t.concat(e,e+"-start",e+"-end")),[]);const L$4=function(e){return {name:"offset",options:e,async fn(i){const{x:r,y:l}=i,s=await async function(e,i){const{placement:r,platform:l,elements:s}=e,c=await(null==l.isRTL?void 0:l.isRTL(s.floating)),f=n$2(r),m=t$2(r),u="x"===o$1(r),g=["left","top"].includes(f)?-1:1,d=c&&u?-1:1,p=a$1(i,e);let{mainAxis:h,crossAxis:y,alignmentAxis:x}="number"==typeof p?{mainAxis:p,crossAxis:0,alignmentAxis:null}:{mainAxis:0,crossAxis:0,alignmentAxis:null,...p};return m&&"number"==typeof x&&(y="end"===m?-1*x:x),u?{x:y*d,y:h*g}:{x:h*g,y:y*d}}(i,e);return {x:r+s.x,y:l+s.y,data:s}}}};function k$3(t){return "x"===t?"y":"x"}const O$4=function(t){return void 0===t&&(t={}),{name:"shift",options:t,async fn(e){const{x:i,y:r,placement:l}=e,{mainAxis:s=!0,crossAxis:f=!1,limiter:m={fn:t=>{let{x:e,y:n}=t;return {x:e,y:n}}},...g}=a$1(t,e),d={x:i,y:r},p=await c$1(e,g),h=o$1(n$2(l)),y=k$3(h);let x=d[h],w=d[y];if(s){const t="y"===h?"bottom":"right";x=u$4(x+p["y"===h?"top":"left"],x,x-p[t]);}if(f){const t="y"===y?"bottom":"right";w=u$4(w+p["y"===y?"top":"left"],w,w-p[t]);}const v=m.fn({...e,[h]:x,[y]:w});return {...v,data:{x:v.x-i,y:v.y-r}}}}};

	function n$1(t){var e;return (null==(e=t.ownerDocument)?void 0:e.defaultView)||window}function o(t){return n$1(t).getComputedStyle(t)}function i(t){return t instanceof n$1(t).Node}function r$1(t){return i(t)?(t.nodeName||"").toLowerCase():"#document"}function c(t){return t instanceof n$1(t).HTMLElement}function l$2(t){return t instanceof n$1(t).Element}function s$2(t){return "undefined"!=typeof ShadowRoot&&(t instanceof n$1(t).ShadowRoot||t instanceof ShadowRoot)}function f(t){const{overflow:e,overflowX:n,overflowY:i,display:r}=o(t);return /auto|scroll|overlay|hidden|clip/.test(e+i+n)&&!["inline","contents"].includes(r)}function u$3(t){return ["table","td","th"].includes(r$1(t))}function a(t){const e=d$1(),n=o(t);return "none"!==n.transform||"none"!==n.perspective||!!n.containerType&&"normal"!==n.containerType||!e&&!!n.backdropFilter&&"none"!==n.backdropFilter||!e&&!!n.filter&&"none"!==n.filter||["transform","perspective","filter"].some((t=>(n.willChange||"").includes(t)))||["paint","layout","strict","content"].some((t=>(n.contain||"").includes(t)))}function d$1(){return !("undefined"==typeof CSS||!CSS.supports)&&CSS.supports("-webkit-backdrop-filter","none")}function h$2(t){return ["html","body","#document"].includes(r$1(t))}const p$2=Math.min,m$1=Math.max,g$1=Math.round,y$3=Math.floor,w$3=t=>({x:t,y:t});function x$2(t){const e=o(t);let n=parseFloat(e.width)||0,i=parseFloat(e.height)||0;const r=c(t),l=r?t.offsetWidth:n,s=r?t.offsetHeight:i,f=g$1(n)!==l||g$1(i)!==s;return f&&(n=l,i=s),{width:n,height:i,$:f}}function v$3(t){return l$2(t)?t:t.contextElement}function b$1(t){const e=v$3(t);if(!c(e))return w$3(1);const n=e.getBoundingClientRect(),{width:o,height:i,$:r}=x$2(e);let l=(r?g$1(n.width):n.width)/o,s=(r?g$1(n.height):n.height)/i;return l&&Number.isFinite(l)||(l=1),s&&Number.isFinite(s)||(s=1),{x:l,y:s}}const L$3=w$3(0);function T$3(t,e,o){var i,r;if(void 0===e&&(e=!0),!d$1())return L$3;const c=t?n$1(t):window;return !o||e&&o!==c?L$3:{x:(null==(i=c.visualViewport)?void 0:i.offsetLeft)||0,y:(null==(r=c.visualViewport)?void 0:r.offsetTop)||0}}function R$3(e,o,i,r){void 0===o&&(o=!1),void 0===i&&(i=!1);const c=e.getBoundingClientRect(),s=v$3(e);let f=w$3(1);o&&(r?l$2(r)&&(f=b$1(r)):f=b$1(e));const u=T$3(s,i,r);let a=(c.left+u.x)/f.x,d=(c.top+u.y)/f.y,h=c.width/f.x,p=c.height/f.y;if(s){const t=n$1(s),e=r&&l$2(r)?n$1(r):r;let o=t.frameElement;for(;o&&r&&e!==t;){const t=b$1(o),e=o.getBoundingClientRect(),i=getComputedStyle(o),r=e.left+(o.clientLeft+parseFloat(i.paddingLeft))*t.x,c=e.top+(o.clientTop+parseFloat(i.paddingTop))*t.y;a*=t.x,d*=t.y,h*=t.x,p*=t.y,a+=r,d+=c,o=n$1(o).frameElement;}}return s$3({width:h,height:p,x:a,y:d})}function S$2(t){return ((i(t)?t.ownerDocument:t.document)||window.document).documentElement}function E$2(t){return l$2(t)?{scrollLeft:t.scrollLeft,scrollTop:t.scrollTop}:{scrollLeft:t.pageXOffset,scrollTop:t.pageYOffset}}function C$1(t){return R$3(S$2(t)).left+E$2(t).scrollLeft}function F$2(t){if("html"===r$1(t))return t;const e=t.assignedSlot||t.parentNode||s$2(t)&&t.host||S$2(t);return s$2(e)?e.host:e}function O$3(t){const e=F$2(t);return h$2(e)?t.ownerDocument?t.ownerDocument.body:t.body:c(e)&&f(e)?e:O$3(e)}function D$3(t,e){var o;void 0===e&&(e=[]);const i=O$3(t),r=i===(null==(o=t.ownerDocument)?void 0:o.body),c=n$1(i);return r?e.concat(c,c.visualViewport||[],f(i)?i:[]):e.concat(i,D$3(i))}function W$3(e,i,r){let s;if("viewport"===i)s=function(t,e){const o=n$1(t),i=S$2(t),r=o.visualViewport;let c=i.clientWidth,l=i.clientHeight,s=0,f=0;if(r){c=r.width,l=r.height;const t=d$1();(!t||t&&"fixed"===e)&&(s=r.offsetLeft,f=r.offsetTop);}return {width:c,height:l,x:s,y:f}}(e,r);else if("document"===i)s=function(t){const e=S$2(t),n=E$2(t),i=t.ownerDocument.body,r=m$1(e.scrollWidth,e.clientWidth,i.scrollWidth,i.clientWidth),c=m$1(e.scrollHeight,e.clientHeight,i.scrollHeight,i.clientHeight);let l=-n.scrollLeft+C$1(t);const s=-n.scrollTop;return "rtl"===o(i).direction&&(l+=m$1(e.clientWidth,i.clientWidth)-r),{width:r,height:c,x:l,y:s}}(S$2(e));else if(l$2(i))s=function(t,e){const n=R$3(t,!0,"fixed"===e),o=n.top+t.clientTop,i=n.left+t.clientLeft,r=c(t)?b$1(t):w$3(1);return {width:t.clientWidth*r.x,height:t.clientHeight*r.y,x:i*r.x,y:o*r.y}}(i,r);else {const t=T$3(e);s={...i,x:i.x-t.x,y:i.y-t.y};}return s$3(s)}function H$3(t,e){const n=F$2(t);return !(n===e||!l$2(n)||h$2(n))&&("fixed"===o(n).position||H$3(n,e))}function z$2(t,e){return c(t)&&"fixed"!==o(t).position?e?e(t):t.offsetParent:null}function M$2(t,e){const i=n$1(t);if(!c(t))return i;let l=z$2(t,e);for(;l&&u$3(l)&&"static"===o(l).position;)l=z$2(l,e);return l&&("html"===r$1(l)||"body"===r$1(l)&&"static"===o(l).position&&!a(l))?i:l||function(t){let e=F$2(t);for(;c(e)&&!h$2(e);){if(a(e))return e;e=F$2(e);}return null}(t)||i}function P$2(t,e,n){const o=c(e),i=S$2(e),l="fixed"===n,s=R$3(t,!0,l,e);let u={scrollLeft:0,scrollTop:0};const a=w$3(0);if(o||!o&&!l)if(("body"!==r$1(e)||f(i))&&(u=E$2(e)),c(e)){const t=R$3(e,!0,l,e);a.x=t.x+e.clientLeft,a.y=t.y+e.clientTop;}else i&&(a.x=C$1(i));return {x:s.left+u.scrollLeft-a.x,y:s.top+u.scrollTop-a.y,width:s.width,height:s.height}}const A$3={getClippingRect:function(t){let{element:e,boundary:n,rootBoundary:i,strategy:c}=t;const s="clippingAncestors"===n?function(t,e){const n=e.get(t);if(n)return n;let i=D$3(t).filter((t=>l$2(t)&&"body"!==r$1(t))),c=null;const s="fixed"===o(t).position;let u=s?F$2(t):t;for(;l$2(u)&&!h$2(u);){const e=o(u),n=a(u);n||"fixed"!==e.position||(c=null),(s?!n&&!c:!n&&"static"===e.position&&c&&["absolute","fixed"].includes(c.position)||f(u)&&!n&&H$3(t,u))?i=i.filter((t=>t!==u)):c=e,u=F$2(u);}return e.set(t,i),i}(e,this._c):[].concat(n),u=[...s,i],d=u[0],g=u.reduce(((t,n)=>{const o=W$3(e,n,c);return t.top=m$1(o.top,t.top),t.right=p$2(o.right,t.right),t.bottom=p$2(o.bottom,t.bottom),t.left=m$1(o.left,t.left),t}),W$3(e,d,c));return {width:g.right-g.left,height:g.bottom-g.top,x:g.left,y:g.top}},convertOffsetParentRelativeRectToViewportRelativeRect:function(t){let{rect:e,offsetParent:n,strategy:o}=t;const i=c(n),l=S$2(n);if(n===l)return e;let s={scrollLeft:0,scrollTop:0},u=w$3(1);const a=w$3(0);if((i||!i&&"fixed"!==o)&&(("body"!==r$1(n)||f(l))&&(s=E$2(n)),c(n))){const t=R$3(n);u=b$1(n),a.x=t.x+n.clientLeft,a.y=t.y+n.clientTop;}return {width:e.width*u.x,height:e.height*u.y,x:e.x*u.x-s.scrollLeft*u.x+a.x,y:e.y*u.y-s.scrollTop*u.y+a.y}},isElement:l$2,getDimensions:function(t){return x$2(t)},getOffsetParent:M$2,getDocumentElement:S$2,getScale:b$1,async getElementRects(t){let{reference:e,floating:n,strategy:o}=t;const i=this.getOffsetParent||M$2,r=this.getDimensions;return {reference:P$2(e,await i(n),o),floating:{x:0,y:0,...await r(n)}}},getClientRects:t=>Array.from(t.getClientRects()),isRTL:t=>"rtl"===o(t).direction};function V$3(t,e,n,o){void 0===o&&(o={});const{ancestorScroll:i=!0,ancestorResize:r=!0,elementResize:c="function"==typeof ResizeObserver,layoutShift:l="function"==typeof IntersectionObserver,animationFrame:s=!1}=o,f=v$3(t),u=i||r?[...f?D$3(f):[],...D$3(e)]:[];u.forEach((t=>{i&&t.addEventListener("scroll",n,{passive:!0}),r&&t.addEventListener("resize",n);}));const a=f&&l?function(t,e){let n,o=null;const i=S$2(t);function r(){clearTimeout(n),o&&o.disconnect(),o=null;}return function c(l,s){void 0===l&&(l=!1),void 0===s&&(s=1),r();const{left:f,top:u,width:a,height:d}=t.getBoundingClientRect();if(l||e(),!a||!d)return;const h={rootMargin:-y$3(u)+"px "+-y$3(i.clientWidth-(f+a))+"px "+-y$3(i.clientHeight-(u+d))+"px "+-y$3(f)+"px",threshold:m$1(0,p$2(1,s))||1};let g=!0;function w(t){const e=t[0].intersectionRatio;if(e!==s){if(!g)return c();e?c(!1,e):n=setTimeout((()=>{c(!1,1e-7);}),100);}g=!1;}try{o=new IntersectionObserver(w,{...h,root:i.ownerDocument});}catch(t){o=new IntersectionObserver(w,h);}o.observe(t);}(!0),r}(f,n):null;let d,h=-1,g=null;c&&(g=new ResizeObserver((t=>{let[o]=t;o&&o.target===f&&g&&(g.unobserve(e),cancelAnimationFrame(h),h=requestAnimationFrame((()=>{g&&g.observe(e);}))),n();})),f&&!s&&g.observe(f),g.observe(e));let w=s?R$3(t):null;return s&&function e(){const o=R$3(t);!w||o.x===w.x&&o.y===w.y&&o.width===w.width&&o.height===w.height||n();w=o,d=requestAnimationFrame(e);}(),n(),()=>{u.forEach((t=>{i&&t.removeEventListener("scroll",n),r&&t.removeEventListener("resize",n);})),a&&a(),g&&g.disconnect(),g=null,s&&cancelAnimationFrame(d);}}const B$3=(t,n,o)=>{const i=new Map,r={platform:A$3,...o},c={...r.platform,_c:i};return r$2(t,n,{...r,platform:c})};

	var index$1 = typeof document !== 'undefined' ? reactExports.useLayoutEffect : reactExports.useEffect;

	// Fork of `fast-deep-equal` that only does the comparisons we need and compares
	// functions
	function deepEqual(a, b) {
	  if (a === b) {
	    return true;
	  }
	  if (typeof a !== typeof b) {
	    return false;
	  }
	  if (typeof a === 'function' && a.toString() === b.toString()) {
	    return true;
	  }
	  let length, i, keys;
	  if (a && b && typeof a == 'object') {
	    if (Array.isArray(a)) {
	      length = a.length;
	      if (length != b.length) return false;
	      for (i = length; i-- !== 0;) {
	        if (!deepEqual(a[i], b[i])) {
	          return false;
	        }
	      }
	      return true;
	    }
	    keys = Object.keys(a);
	    length = keys.length;
	    if (length !== Object.keys(b).length) {
	      return false;
	    }
	    for (i = length; i-- !== 0;) {
	      if (!{}.hasOwnProperty.call(b, keys[i])) {
	        return false;
	      }
	    }
	    for (i = length; i-- !== 0;) {
	      const key = keys[i];
	      if (key === '_owner' && a.$$typeof) {
	        continue;
	      }
	      if (!deepEqual(a[key], b[key])) {
	        return false;
	      }
	    }
	    return true;
	  }
	  return a !== a && b !== b;
	}

	function getDPR(element) {
	  if (typeof window === 'undefined') {
	    return 1;
	  }
	  const win = element.ownerDocument.defaultView || window;
	  return win.devicePixelRatio || 1;
	}

	function roundByDPR(element, value) {
	  const dpr = getDPR(element);
	  return Math.round(value * dpr) / dpr;
	}

	function useLatestRef(value) {
	  const ref = reactExports.useRef(value);
	  index$1(() => {
	    ref.current = value;
	  });
	  return ref;
	}

	/**
	 * Provides data to position a floating element.
	 * @see https://floating-ui.com/docs/react
	 */
	function useFloating(options) {
	  if (options === void 0) {
	    options = {};
	  }
	  const {
	    placement = 'bottom',
	    strategy = 'absolute',
	    middleware = [],
	    platform,
	    elements: {
	      reference: externalReference,
	      floating: externalFloating
	    } = {},
	    transform = true,
	    whileElementsMounted,
	    open
	  } = options;
	  const [data, setData] = reactExports.useState({
	    x: 0,
	    y: 0,
	    strategy,
	    placement,
	    middlewareData: {},
	    isPositioned: false
	  });
	  const [latestMiddleware, setLatestMiddleware] = reactExports.useState(middleware);
	  if (!deepEqual(latestMiddleware, middleware)) {
	    setLatestMiddleware(middleware);
	  }
	  const [_reference, _setReference] = reactExports.useState(null);
	  const [_floating, _setFloating] = reactExports.useState(null);
	  const setReference = reactExports.useCallback(node => {
	    if (node != referenceRef.current) {
	      referenceRef.current = node;
	      _setReference(node);
	    }
	  }, [_setReference]);
	  const setFloating = reactExports.useCallback(node => {
	    if (node !== floatingRef.current) {
	      floatingRef.current = node;
	      _setFloating(node);
	    }
	  }, [_setFloating]);
	  const referenceEl = externalReference || _reference;
	  const floatingEl = externalFloating || _floating;
	  const referenceRef = reactExports.useRef(null);
	  const floatingRef = reactExports.useRef(null);
	  const dataRef = reactExports.useRef(data);
	  const whileElementsMountedRef = useLatestRef(whileElementsMounted);
	  const platformRef = useLatestRef(platform);
	  const update = reactExports.useCallback(() => {
	    if (!referenceRef.current || !floatingRef.current) {
	      return;
	    }
	    const config = {
	      placement,
	      strategy,
	      middleware: latestMiddleware
	    };
	    if (platformRef.current) {
	      config.platform = platformRef.current;
	    }
	    B$3(referenceRef.current, floatingRef.current, config).then(data => {
	      const fullData = {
	        ...data,
	        isPositioned: true
	      };
	      if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
	        dataRef.current = fullData;
	        reactDomExports.flushSync(() => {
	          setData(fullData);
	        });
	      }
	    });
	  }, [latestMiddleware, placement, strategy, platformRef]);
	  index$1(() => {
	    if (open === false && dataRef.current.isPositioned) {
	      dataRef.current.isPositioned = false;
	      setData(data => ({
	        ...data,
	        isPositioned: false
	      }));
	    }
	  }, [open]);
	  const isMountedRef = reactExports.useRef(false);
	  index$1(() => {
	    isMountedRef.current = true;
	    return () => {
	      isMountedRef.current = false;
	    };
	  }, []);
	  index$1(() => {
	    if (referenceEl) referenceRef.current = referenceEl;
	    if (floatingEl) floatingRef.current = floatingEl;
	    if (referenceEl && floatingEl) {
	      if (whileElementsMountedRef.current) {
	        return whileElementsMountedRef.current(referenceEl, floatingEl, update);
	      } else {
	        update();
	      }
	    }
	  }, [referenceEl, floatingEl, update, whileElementsMountedRef]);
	  const refs = reactExports.useMemo(() => ({
	    reference: referenceRef,
	    floating: floatingRef,
	    setReference,
	    setFloating
	  }), [setReference, setFloating]);
	  const elements = reactExports.useMemo(() => ({
	    reference: referenceEl,
	    floating: floatingEl
	  }), [referenceEl, floatingEl]);
	  const floatingStyles = reactExports.useMemo(() => {
	    const initialStyles = {
	      position: strategy,
	      left: 0,
	      top: 0
	    };
	    if (!elements.floating) {
	      return initialStyles;
	    }
	    const x = roundByDPR(elements.floating, data.x);
	    const y = roundByDPR(elements.floating, data.y);
	    if (transform) {
	      return {
	        ...initialStyles,
	        transform: "translate(" + x + "px, " + y + "px)",
	        ...(getDPR(elements.floating) >= 1.5 && {
	          willChange: 'transform'
	        })
	      };
	    }
	    return {
	      position: strategy,
	      left: x,
	      top: y
	    };
	  }, [strategy, transform, elements.floating, data.x, data.y]);
	  return reactExports.useMemo(() => ({
	    ...data,
	    update,
	    refs,
	    elements,
	    floatingStyles
	  }), [data, update, refs, elements, floatingStyles]);
	}

	const EmojiButton = React$2.memo(
	    ({ onSelectEmoji, disabled, hasCohostPlus }) => {
	        const { refs, floatingStyles } = useFloating({
	            whileElementsMounted: V$3,
	            middleware: [O$4()],
	            placement: "bottom",
	        });

	        const [customEmojiRef, setCustomEmojiRef] = reactExports.useState

	(null);

	        reactExports.useEffect(() => {
	            Promise.resolve().then(function () { return emoji; })
	                .then((emoji) => {
	                    setCustomEmojiRef(emoji);
	                })
	                .catch((err) => {
	                    console.error(err);
	                });
	        }, []);

	        const customEmojiList = reactExports.useMemo(() => {
	            if (customEmojiRef) {
	                if (hasCohostPlus) {
	                    // sort the merged custom emoji by name so eggbugs are grouped
	                    // together
	                    const categories = [
	                        ...customEmojiRef.customEmoji,
	                        ...customEmojiRef.cohostPlusCustomEmoji,
	                    ]
	                        .sort((a, b) =>
	                            a.name.localeCompare(b.name, "en", {
	                                sensitivity: "base",
	                            })
	                        )
	                        .reduce



	(
	                            (acc, emoji) => {
	                                if (emoji.name.includes("eggbug")) {
	                                    acc.eggbug.push(emoji);
	                                } else if (emoji.name.includes("host")) {
	                                    acc.host.push(emoji);
	                                } else {
	                                    acc.custom.push(emoji);
	                                }

	                                return acc;
	                            },
	                            {
	                                eggbug: [],
	                                host: [],
	                                custom: [],
	                            }
	                        );

	                    return [
	                        {
	                            id: "eggbug",
	                            name: "eggbug! (by @dzuk)",
	                            emojis: categories.eggbug,
	                        },
	                        {
	                            id: "host",
	                            name: "The Host (by @SilverStarsIllustration)",
	                            emojis: categories.host,
	                        },
	                        {
	                            id: "custom",
	                            name: "everything else",
	                            emojis: categories.custom,
	                        },
	                    ];
	                }
	                // sorting is unnecessary since the base custom emoji are already
	                // sorted
	                return [
	                    {
	                        id: "custom",
	                        name: "custom emoji",
	                        emojis: customEmojiRef.customEmoji,
	                    },
	                ];
	            }
	            return [];
	        }, [customEmojiRef, hasCohostPlus]);

	        return (
	            React$2.createElement(React$2.Fragment, null
	                , React$2.createElement(Lt, null
	                    , React$2.createElement(Lt.Button, {
	                        ref: refs.setReference,
	                        className: tw`co-link-button disabled:cursor-not-allowed disabled:text-foreground-300`,
	                        disabled: disabled,
	                        title: "insert emoji" ,}

	                        , React$2.createElement(ForwardRef$J, { className: "inline-block h-6" ,} )
	                    )
	                    , React$2.createElement(Lt.Panel, {
	                        // don't want this popover to pop under avatars
	                        style: { ...floatingStyles, zIndex: 9999 },
	                        ref: refs.setFloating,}

	                        /* <style>{postBoxThemes["dark"]["emojimart"]}</style> */
	                        , React$2.createElement($e5534fc185f7111e$export$2e2bcd8739ae039, {
	                            onEmojiSelect: onSelectEmoji,
	                            custom: customEmojiList,
	                            data: data,
	                            emojiButtonColors: [
	                                "rgb(var(--color-secondary-200))",
	                            ],
	                            set: "native",
	                            theme: "auto",
	                            title: "",
	                            emoji: "",}
	                        )
	                    )
	                )
	            )
	        );
	    }
	);
	EmojiButton.displayName = "EmojiButton";

	const CustomEmoji


	 = React$2.memo(({ name = "missing", url = sitemap.public.static
	        .staticAsset({ path: missingAttachment })
	        .toString() }) => {
	    return (
	        React$2.createElement('img', {
	            src: url,
	            alt: `:${name}:`,
	            title: `:${name}:`,
	            className: "m-0 inline-block aspect-square object-contain align-middle"    ,
	            style: {
	                height: "var(--emoji-scale, 1em)",
	            },}
	        )
	    );
	});
	CustomEmoji.displayName = "CustomEmoji";

	var hp2Builder$2 = {};

	var lib$5 = {};

	var lib$4 = {};

	(function (exports) {
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.Doctype = exports.CDATA = exports.Tag = exports.Style = exports.Script = exports.Comment = exports.Directive = exports.Text = exports.Root = exports.isTag = exports.ElementType = void 0;
		/** Types of elements found in htmlparser2's DOM */
		var ElementType;
		(function (ElementType) {
		    /** Type for the root element of a document */
		    ElementType["Root"] = "root";
		    /** Type for Text */
		    ElementType["Text"] = "text";
		    /** Type for <? ... ?> */
		    ElementType["Directive"] = "directive";
		    /** Type for <!-- ... --> */
		    ElementType["Comment"] = "comment";
		    /** Type for <script> tags */
		    ElementType["Script"] = "script";
		    /** Type for <style> tags */
		    ElementType["Style"] = "style";
		    /** Type for Any tag */
		    ElementType["Tag"] = "tag";
		    /** Type for <![CDATA[ ... ]]> */
		    ElementType["CDATA"] = "cdata";
		    /** Type for <!doctype ...> */
		    ElementType["Doctype"] = "doctype";
		})(ElementType = exports.ElementType || (exports.ElementType = {}));
		/**
		 * Tests whether an element is a tag or not.
		 *
		 * @param elem Element to test
		 */
		function isTag(elem) {
		    return (elem.type === ElementType.Tag ||
		        elem.type === ElementType.Script ||
		        elem.type === ElementType.Style);
		}
		exports.isTag = isTag;
		// Exports for backwards compatibility
		/** Type for the root element of a document */
		exports.Root = ElementType.Root;
		/** Type for Text */
		exports.Text = ElementType.Text;
		/** Type for <? ... ?> */
		exports.Directive = ElementType.Directive;
		/** Type for <!-- ... --> */
		exports.Comment = ElementType.Comment;
		/** Type for <script> tags */
		exports.Script = ElementType.Script;
		/** Type for <style> tags */
		exports.Style = ElementType.Style;
		/** Type for Any tag */
		exports.Tag = ElementType.Tag;
		/** Type for <![CDATA[ ... ]]> */
		exports.CDATA = ElementType.CDATA;
		/** Type for <!doctype ...> */
		exports.Doctype = ElementType.Doctype; 
	} (lib$4));

	var node = {};

	var __extends$1 = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
	    var extendStatics = function (d, b) {
	        extendStatics = Object.setPrototypeOf ||
	            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
	            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
	        return extendStatics(d, b);
	    };
	    return function (d, b) {
	        if (typeof b !== "function" && b !== null)
	            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
	        extendStatics(d, b);
	        function __() { this.constructor = d; }
	        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	    };
	})();
	var __assign$2 = (commonjsGlobal && commonjsGlobal.__assign) || function () {
	    __assign$2 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$2.apply(this, arguments);
	};
	Object.defineProperty(node, "__esModule", { value: true });
	node.cloneNode = node.hasChildren = node.isDocument = node.isDirective = node.isComment = node.isText = node.isCDATA = node.isTag = node.Element = node.Document = node.NodeWithChildren = node.ProcessingInstruction = node.Comment = node.Text = node.DataNode = node.Node = void 0;
	var domelementtype_1$1 = lib$4;
	var nodeTypes = new Map([
	    [domelementtype_1$1.ElementType.Tag, 1],
	    [domelementtype_1$1.ElementType.Script, 1],
	    [domelementtype_1$1.ElementType.Style, 1],
	    [domelementtype_1$1.ElementType.Directive, 1],
	    [domelementtype_1$1.ElementType.Text, 3],
	    [domelementtype_1$1.ElementType.CDATA, 4],
	    [domelementtype_1$1.ElementType.Comment, 8],
	    [domelementtype_1$1.ElementType.Root, 9],
	]);
	/**
	 * This object will be used as the prototype for Nodes when creating a
	 * DOM-Level-1-compliant structure.
	 */
	var Node$1 = /** @class */ (function () {
	    /**
	     *
	     * @param type The type of the node.
	     */
	    function Node(type) {
	        this.type = type;
	        /** Parent of the node */
	        this.parent = null;
	        /** Previous sibling */
	        this.prev = null;
	        /** Next sibling */
	        this.next = null;
	        /** The start index of the node. Requires `withStartIndices` on the handler to be `true. */
	        this.startIndex = null;
	        /** The end index of the node. Requires `withEndIndices` on the handler to be `true. */
	        this.endIndex = null;
	    }
	    Object.defineProperty(Node.prototype, "nodeType", {
	        // Read-only aliases
	        get: function () {
	            var _a;
	            return (_a = nodeTypes.get(this.type)) !== null && _a !== void 0 ? _a : 1;
	        },
	        enumerable: false,
	        configurable: true
	    });
	    Object.defineProperty(Node.prototype, "parentNode", {
	        // Read-write aliases for properties
	        get: function () {
	            return this.parent;
	        },
	        set: function (parent) {
	            this.parent = parent;
	        },
	        enumerable: false,
	        configurable: true
	    });
	    Object.defineProperty(Node.prototype, "previousSibling", {
	        get: function () {
	            return this.prev;
	        },
	        set: function (prev) {
	            this.prev = prev;
	        },
	        enumerable: false,
	        configurable: true
	    });
	    Object.defineProperty(Node.prototype, "nextSibling", {
	        get: function () {
	            return this.next;
	        },
	        set: function (next) {
	            this.next = next;
	        },
	        enumerable: false,
	        configurable: true
	    });
	    /**
	     * Clone this node, and optionally its children.
	     *
	     * @param recursive Clone child nodes as well.
	     * @returns A clone of the node.
	     */
	    Node.prototype.cloneNode = function (recursive) {
	        if (recursive === void 0) { recursive = false; }
	        return cloneNode(this, recursive);
	    };
	    return Node;
	}());
	node.Node = Node$1;
	/**
	 * A node that contains some data.
	 */
	var DataNode = /** @class */ (function (_super) {
	    __extends$1(DataNode, _super);
	    /**
	     * @param type The type of the node
	     * @param data The content of the data node
	     */
	    function DataNode(type, data) {
	        var _this = _super.call(this, type) || this;
	        _this.data = data;
	        return _this;
	    }
	    Object.defineProperty(DataNode.prototype, "nodeValue", {
	        get: function () {
	            return this.data;
	        },
	        set: function (data) {
	            this.data = data;
	        },
	        enumerable: false,
	        configurable: true
	    });
	    return DataNode;
	}(Node$1));
	node.DataNode = DataNode;
	/**
	 * Text within the document.
	 */
	var Text = /** @class */ (function (_super) {
	    __extends$1(Text, _super);
	    function Text(data) {
	        return _super.call(this, domelementtype_1$1.ElementType.Text, data) || this;
	    }
	    return Text;
	}(DataNode));
	node.Text = Text;
	/**
	 * Comments within the document.
	 */
	var Comment = /** @class */ (function (_super) {
	    __extends$1(Comment, _super);
	    function Comment(data) {
	        return _super.call(this, domelementtype_1$1.ElementType.Comment, data) || this;
	    }
	    return Comment;
	}(DataNode));
	node.Comment = Comment;
	/**
	 * Processing instructions, including doc types.
	 */
	var ProcessingInstruction = /** @class */ (function (_super) {
	    __extends$1(ProcessingInstruction, _super);
	    function ProcessingInstruction(name, data) {
	        var _this = _super.call(this, domelementtype_1$1.ElementType.Directive, data) || this;
	        _this.name = name;
	        return _this;
	    }
	    return ProcessingInstruction;
	}(DataNode));
	node.ProcessingInstruction = ProcessingInstruction;
	/**
	 * A `Node` that can have children.
	 */
	var NodeWithChildren = /** @class */ (function (_super) {
	    __extends$1(NodeWithChildren, _super);
	    /**
	     * @param type Type of the node.
	     * @param children Children of the node. Only certain node types can have children.
	     */
	    function NodeWithChildren(type, children) {
	        var _this = _super.call(this, type) || this;
	        _this.children = children;
	        return _this;
	    }
	    Object.defineProperty(NodeWithChildren.prototype, "firstChild", {
	        // Aliases
	        get: function () {
	            var _a;
	            return (_a = this.children[0]) !== null && _a !== void 0 ? _a : null;
	        },
	        enumerable: false,
	        configurable: true
	    });
	    Object.defineProperty(NodeWithChildren.prototype, "lastChild", {
	        get: function () {
	            return this.children.length > 0
	                ? this.children[this.children.length - 1]
	                : null;
	        },
	        enumerable: false,
	        configurable: true
	    });
	    Object.defineProperty(NodeWithChildren.prototype, "childNodes", {
	        get: function () {
	            return this.children;
	        },
	        set: function (children) {
	            this.children = children;
	        },
	        enumerable: false,
	        configurable: true
	    });
	    return NodeWithChildren;
	}(Node$1));
	node.NodeWithChildren = NodeWithChildren;
	/**
	 * The root node of the document.
	 */
	var Document = /** @class */ (function (_super) {
	    __extends$1(Document, _super);
	    function Document(children) {
	        return _super.call(this, domelementtype_1$1.ElementType.Root, children) || this;
	    }
	    return Document;
	}(NodeWithChildren));
	node.Document = Document;
	/**
	 * An element within the DOM.
	 */
	var Element$1 = /** @class */ (function (_super) {
	    __extends$1(Element, _super);
	    /**
	     * @param name Name of the tag, eg. `div`, `span`.
	     * @param attribs Object mapping attribute names to attribute values.
	     * @param children Children of the node.
	     */
	    function Element(name, attribs, children, type) {
	        if (children === void 0) { children = []; }
	        if (type === void 0) { type = name === "script"
	            ? domelementtype_1$1.ElementType.Script
	            : name === "style"
	                ? domelementtype_1$1.ElementType.Style
	                : domelementtype_1$1.ElementType.Tag; }
	        var _this = _super.call(this, type, children) || this;
	        _this.name = name;
	        _this.attribs = attribs;
	        return _this;
	    }
	    Object.defineProperty(Element.prototype, "tagName", {
	        // DOM Level 1 aliases
	        get: function () {
	            return this.name;
	        },
	        set: function (name) {
	            this.name = name;
	        },
	        enumerable: false,
	        configurable: true
	    });
	    Object.defineProperty(Element.prototype, "attributes", {
	        get: function () {
	            var _this = this;
	            return Object.keys(this.attribs).map(function (name) {
	                var _a, _b;
	                return ({
	                    name: name,
	                    value: _this.attribs[name],
	                    namespace: (_a = _this["x-attribsNamespace"]) === null || _a === void 0 ? void 0 : _a[name],
	                    prefix: (_b = _this["x-attribsPrefix"]) === null || _b === void 0 ? void 0 : _b[name],
	                });
	            });
	        },
	        enumerable: false,
	        configurable: true
	    });
	    return Element;
	}(NodeWithChildren));
	node.Element = Element$1;
	/**
	 * @param node Node to check.
	 * @returns `true` if the node is a `Element`, `false` otherwise.
	 */
	function isTag(node) {
	    return (0, domelementtype_1$1.isTag)(node);
	}
	node.isTag = isTag;
	/**
	 * @param node Node to check.
	 * @returns `true` if the node has the type `CDATA`, `false` otherwise.
	 */
	function isCDATA(node) {
	    return node.type === domelementtype_1$1.ElementType.CDATA;
	}
	node.isCDATA = isCDATA;
	/**
	 * @param node Node to check.
	 * @returns `true` if the node has the type `Text`, `false` otherwise.
	 */
	function isText$1(node) {
	    return node.type === domelementtype_1$1.ElementType.Text;
	}
	node.isText = isText$1;
	/**
	 * @param node Node to check.
	 * @returns `true` if the node has the type `Comment`, `false` otherwise.
	 */
	function isComment(node) {
	    return node.type === domelementtype_1$1.ElementType.Comment;
	}
	node.isComment = isComment;
	/**
	 * @param node Node to check.
	 * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise.
	 */
	function isDirective(node) {
	    return node.type === domelementtype_1$1.ElementType.Directive;
	}
	node.isDirective = isDirective;
	/**
	 * @param node Node to check.
	 * @returns `true` if the node has the type `ProcessingInstruction`, `false` otherwise.
	 */
	function isDocument(node) {
	    return node.type === domelementtype_1$1.ElementType.Root;
	}
	node.isDocument = isDocument;
	/**
	 * @param node Node to check.
	 * @returns `true` if the node is a `NodeWithChildren` (has children), `false` otherwise.
	 */
	function hasChildren(node) {
	    return Object.prototype.hasOwnProperty.call(node, "children");
	}
	node.hasChildren = hasChildren;
	/**
	 * Clone a node, and optionally its children.
	 *
	 * @param recursive Clone child nodes as well.
	 * @returns A clone of the node.
	 */
	function cloneNode(node, recursive) {
	    if (recursive === void 0) { recursive = false; }
	    var result;
	    if (isText$1(node)) {
	        result = new Text(node.data);
	    }
	    else if (isComment(node)) {
	        result = new Comment(node.data);
	    }
	    else if (isTag(node)) {
	        var children = recursive ? cloneChildren(node.children) : [];
	        var clone_1 = new Element$1(node.name, __assign$2({}, node.attribs), children);
	        children.forEach(function (child) { return (child.parent = clone_1); });
	        if (node["x-attribsNamespace"]) {
	            clone_1["x-attribsNamespace"] = __assign$2({}, node["x-attribsNamespace"]);
	        }
	        if (node["x-attribsPrefix"]) {
	            clone_1["x-attribsPrefix"] = __assign$2({}, node["x-attribsPrefix"]);
	        }
	        result = clone_1;
	    }
	    else if (isCDATA(node)) {
	        var children = recursive ? cloneChildren(node.children) : [];
	        var clone_2 = new NodeWithChildren(domelementtype_1$1.ElementType.CDATA, children);
	        children.forEach(function (child) { return (child.parent = clone_2); });
	        result = clone_2;
	    }
	    else if (isDocument(node)) {
	        var children = recursive ? cloneChildren(node.children) : [];
	        var clone_3 = new Document(children);
	        children.forEach(function (child) { return (child.parent = clone_3); });
	        if (node["x-mode"]) {
	            clone_3["x-mode"] = node["x-mode"];
	        }
	        result = clone_3;
	    }
	    else if (isDirective(node)) {
	        var instruction = new ProcessingInstruction(node.name, node.data);
	        if (node["x-name"] != null) {
	            instruction["x-name"] = node["x-name"];
	            instruction["x-publicId"] = node["x-publicId"];
	            instruction["x-systemId"] = node["x-systemId"];
	        }
	        result = instruction;
	    }
	    else {
	        throw new Error("Not implemented yet: " + node.type);
	    }
	    result.startIndex = node.startIndex;
	    result.endIndex = node.endIndex;
	    return result;
	}
	node.cloneNode = cloneNode;
	function cloneChildren(childs) {
	    var children = childs.map(function (child) { return cloneNode(child, true); });
	    for (var i = 1; i < children.length; i++) {
	        children[i].prev = children[i - 1];
	        children[i - 1].next = children[i];
	    }
	    return children;
	}

	(function (exports) {
		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
		    if (k2 === undefined) k2 = k;
		    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
		}) : (function(o, m, k, k2) {
		    if (k2 === undefined) k2 = k;
		    o[k2] = m[k];
		}));
		var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.DomHandler = void 0;
		var domelementtype_1 = lib$4;
		var node_1 = node;
		__exportStar(node, exports);
		var reWhitespace = /\s+/g;
		// Default options
		var defaultOpts = {
		    normalizeWhitespace: false,
		    withStartIndices: false,
		    withEndIndices: false,
		    xmlMode: false,
		};
		var DomHandler = /** @class */ (function () {
		    /**
		     * @param callback Called once parsing has completed.
		     * @param options Settings for the handler.
		     * @param elementCB Callback whenever a tag is closed.
		     */
		    function DomHandler(callback, options, elementCB) {
		        /** The elements of the DOM */
		        this.dom = [];
		        /** The root element for the DOM */
		        this.root = new node_1.Document(this.dom);
		        /** Indicated whether parsing has been completed. */
		        this.done = false;
		        /** Stack of open tags. */
		        this.tagStack = [this.root];
		        /** A data node that is still being written to. */
		        this.lastNode = null;
		        /** Reference to the parser instance. Used for location information. */
		        this.parser = null;
		        // Make it possible to skip arguments, for backwards-compatibility
		        if (typeof options === "function") {
		            elementCB = options;
		            options = defaultOpts;
		        }
		        if (typeof callback === "object") {
		            options = callback;
		            callback = undefined;
		        }
		        this.callback = callback !== null && callback !== void 0 ? callback : null;
		        this.options = options !== null && options !== void 0 ? options : defaultOpts;
		        this.elementCB = elementCB !== null && elementCB !== void 0 ? elementCB : null;
		    }
		    DomHandler.prototype.onparserinit = function (parser) {
		        this.parser = parser;
		    };
		    // Resets the handler back to starting state
		    DomHandler.prototype.onreset = function () {
		        this.dom = [];
		        this.root = new node_1.Document(this.dom);
		        this.done = false;
		        this.tagStack = [this.root];
		        this.lastNode = null;
		        this.parser = null;
		    };
		    // Signals the handler that parsing is done
		    DomHandler.prototype.onend = function () {
		        if (this.done)
		            return;
		        this.done = true;
		        this.parser = null;
		        this.handleCallback(null);
		    };
		    DomHandler.prototype.onerror = function (error) {
		        this.handleCallback(error);
		    };
		    DomHandler.prototype.onclosetag = function () {
		        this.lastNode = null;
		        var elem = this.tagStack.pop();
		        if (this.options.withEndIndices) {
		            elem.endIndex = this.parser.endIndex;
		        }
		        if (this.elementCB)
		            this.elementCB(elem);
		    };
		    DomHandler.prototype.onopentag = function (name, attribs) {
		        var type = this.options.xmlMode ? domelementtype_1.ElementType.Tag : undefined;
		        var element = new node_1.Element(name, attribs, undefined, type);
		        this.addNode(element);
		        this.tagStack.push(element);
		    };
		    DomHandler.prototype.ontext = function (data) {
		        var normalizeWhitespace = this.options.normalizeWhitespace;
		        var lastNode = this.lastNode;
		        if (lastNode && lastNode.type === domelementtype_1.ElementType.Text) {
		            if (normalizeWhitespace) {
		                lastNode.data = (lastNode.data + data).replace(reWhitespace, " ");
		            }
		            else {
		                lastNode.data += data;
		            }
		            if (this.options.withEndIndices) {
		                lastNode.endIndex = this.parser.endIndex;
		            }
		        }
		        else {
		            if (normalizeWhitespace) {
		                data = data.replace(reWhitespace, " ");
		            }
		            var node = new node_1.Text(data);
		            this.addNode(node);
		            this.lastNode = node;
		        }
		    };
		    DomHandler.prototype.oncomment = function (data) {
		        if (this.lastNode && this.lastNode.type === domelementtype_1.ElementType.Comment) {
		            this.lastNode.data += data;
		            return;
		        }
		        var node = new node_1.Comment(data);
		        this.addNode(node);
		        this.lastNode = node;
		    };
		    DomHandler.prototype.oncommentend = function () {
		        this.lastNode = null;
		    };
		    DomHandler.prototype.oncdatastart = function () {
		        var text = new node_1.Text("");
		        var node = new node_1.NodeWithChildren(domelementtype_1.ElementType.CDATA, [text]);
		        this.addNode(node);
		        text.parent = node;
		        this.lastNode = text;
		    };
		    DomHandler.prototype.oncdataend = function () {
		        this.lastNode = null;
		    };
		    DomHandler.prototype.onprocessinginstruction = function (name, data) {
		        var node = new node_1.ProcessingInstruction(name, data);
		        this.addNode(node);
		    };
		    DomHandler.prototype.handleCallback = function (error) {
		        if (typeof this.callback === "function") {
		            this.callback(error, this.dom);
		        }
		        else if (error) {
		            throw error;
		        }
		    };
		    DomHandler.prototype.addNode = function (node) {
		        var parent = this.tagStack[this.tagStack.length - 1];
		        var previousSibling = parent.children[parent.children.length - 1];
		        if (this.options.withStartIndices) {
		            node.startIndex = this.parser.startIndex;
		        }
		        if (this.options.withEndIndices) {
		            node.endIndex = this.parser.endIndex;
		        }
		        parent.children.push(node);
		        if (previousSibling) {
		            node.prev = previousSibling;
		            previousSibling.next = node;
		        }
		        node.parent = parent;
		        this.lastNode = null;
		    };
		    return DomHandler;
		}());
		exports.DomHandler = DomHandler;
		exports.default = DomHandler; 
	} (lib$5));

	var selderee$2 = {};

	var parseley$1 = {};

	var nearley$1 = {exports: {}};

	(function (module) {
		(function(root, factory) {
		    if (module.exports) {
		        module.exports = factory();
		    } else {
		        root.nearley = factory();
		    }
		}(commonjsGlobal, function() {

		    function Rule(name, symbols, postprocess) {
		        this.id = ++Rule.highestId;
		        this.name = name;
		        this.symbols = symbols;        // a list of literal | regex class | nonterminal
		        this.postprocess = postprocess;
		        return this;
		    }
		    Rule.highestId = 0;

		    Rule.prototype.toString = function(withCursorAt) {
		        var symbolSequence = (typeof withCursorAt === "undefined")
		                             ? this.symbols.map(getSymbolShortDisplay).join(' ')
		                             : (   this.symbols.slice(0, withCursorAt).map(getSymbolShortDisplay).join(' ')
		                                 + " ● "
		                                 + this.symbols.slice(withCursorAt).map(getSymbolShortDisplay).join(' ')     );
		        return this.name + " → " + symbolSequence;
		    };


		    // a State is a rule at a position from a given starting point in the input stream (reference)
		    function State(rule, dot, reference, wantedBy) {
		        this.rule = rule;
		        this.dot = dot;
		        this.reference = reference;
		        this.data = [];
		        this.wantedBy = wantedBy;
		        this.isComplete = this.dot === rule.symbols.length;
		    }

		    State.prototype.toString = function() {
		        return "{" + this.rule.toString(this.dot) + "}, from: " + (this.reference || 0);
		    };

		    State.prototype.nextState = function(child) {
		        var state = new State(this.rule, this.dot + 1, this.reference, this.wantedBy);
		        state.left = this;
		        state.right = child;
		        if (state.isComplete) {
		            state.data = state.build();
		            // Having right set here will prevent the right state and its children
		            // form being garbage collected
		            state.right = undefined;
		        }
		        return state;
		    };

		    State.prototype.build = function() {
		        var children = [];
		        var node = this;
		        do {
		            children.push(node.right.data);
		            node = node.left;
		        } while (node.left);
		        children.reverse();
		        return children;
		    };

		    State.prototype.finish = function() {
		        if (this.rule.postprocess) {
		            this.data = this.rule.postprocess(this.data, this.reference, Parser.fail);
		        }
		    };


		    function Column(grammar, index) {
		        this.grammar = grammar;
		        this.index = index;
		        this.states = [];
		        this.wants = {}; // states indexed by the non-terminal they expect
		        this.scannable = []; // list of states that expect a token
		        this.completed = {}; // states that are nullable
		    }


		    Column.prototype.process = function(nextColumn) {
		        var states = this.states;
		        var wants = this.wants;
		        var completed = this.completed;

		        for (var w = 0; w < states.length; w++) { // nb. we push() during iteration
		            var state = states[w];

		            if (state.isComplete) {
		                state.finish();
		                if (state.data !== Parser.fail) {
		                    // complete
		                    var wantedBy = state.wantedBy;
		                    for (var i = wantedBy.length; i--; ) { // this line is hot
		                        var left = wantedBy[i];
		                        this.complete(left, state);
		                    }

		                    // special-case nullables
		                    if (state.reference === this.index) {
		                        // make sure future predictors of this rule get completed.
		                        var exp = state.rule.name;
		                        (this.completed[exp] = this.completed[exp] || []).push(state);
		                    }
		                }

		            } else {
		                // queue scannable states
		                var exp = state.rule.symbols[state.dot];
		                if (typeof exp !== 'string') {
		                    this.scannable.push(state);
		                    continue;
		                }

		                // predict
		                if (wants[exp]) {
		                    wants[exp].push(state);

		                    if (completed.hasOwnProperty(exp)) {
		                        var nulls = completed[exp];
		                        for (var i = 0; i < nulls.length; i++) {
		                            var right = nulls[i];
		                            this.complete(state, right);
		                        }
		                    }
		                } else {
		                    wants[exp] = [state];
		                    this.predict(exp);
		                }
		            }
		        }
		    };

		    Column.prototype.predict = function(exp) {
		        var rules = this.grammar.byName[exp] || [];

		        for (var i = 0; i < rules.length; i++) {
		            var r = rules[i];
		            var wantedBy = this.wants[exp];
		            var s = new State(r, 0, this.index, wantedBy);
		            this.states.push(s);
		        }
		    };

		    Column.prototype.complete = function(left, right) {
		        var copy = left.nextState(right);
		        this.states.push(copy);
		    };


		    function Grammar(rules, start) {
		        this.rules = rules;
		        this.start = start || this.rules[0].name;
		        var byName = this.byName = {};
		        this.rules.forEach(function(rule) {
		            if (!byName.hasOwnProperty(rule.name)) {
		                byName[rule.name] = [];
		            }
		            byName[rule.name].push(rule);
		        });
		    }

		    // So we can allow passing (rules, start) directly to Parser for backwards compatibility
		    Grammar.fromCompiled = function(rules, start) {
		        var lexer = rules.Lexer;
		        if (rules.ParserStart) {
		          start = rules.ParserStart;
		          rules = rules.ParserRules;
		        }
		        var rules = rules.map(function (r) { return (new Rule(r.name, r.symbols, r.postprocess)); });
		        var g = new Grammar(rules, start);
		        g.lexer = lexer; // nb. storing lexer on Grammar is iffy, but unavoidable
		        return g;
		    };


		    function StreamLexer() {
		      this.reset("");
		    }

		    StreamLexer.prototype.reset = function(data, state) {
		        this.buffer = data;
		        this.index = 0;
		        this.line = state ? state.line : 1;
		        this.lastLineBreak = state ? -state.col : 0;
		    };

		    StreamLexer.prototype.next = function() {
		        if (this.index < this.buffer.length) {
		            var ch = this.buffer[this.index++];
		            if (ch === '\n') {
		              this.line += 1;
		              this.lastLineBreak = this.index;
		            }
		            return {value: ch};
		        }
		    };

		    StreamLexer.prototype.save = function() {
		      return {
		        line: this.line,
		        col: this.index - this.lastLineBreak,
		      }
		    };

		    StreamLexer.prototype.formatError = function(token, message) {
		        // nb. this gets called after consuming the offending token,
		        // so the culprit is index-1
		        var buffer = this.buffer;
		        if (typeof buffer === 'string') {
		            var lines = buffer
		                .split("\n")
		                .slice(
		                    Math.max(0, this.line - 5), 
		                    this.line
		                );

		            var nextLineBreak = buffer.indexOf('\n', this.index);
		            if (nextLineBreak === -1) nextLineBreak = buffer.length;
		            var col = this.index - this.lastLineBreak;
		            var lastLineDigits = String(this.line).length;
		            message += " at line " + this.line + " col " + col + ":\n\n";
		            message += lines
		                .map(function(line, i) {
		                    return pad(this.line - lines.length + i + 1, lastLineDigits) + " " + line;
		                }, this)
		                .join("\n");
		            message += "\n" + pad("", lastLineDigits + col) + "^\n";
		            return message;
		        } else {
		            return message + " at index " + (this.index - 1);
		        }

		        function pad(n, length) {
		            var s = String(n);
		            return Array(length - s.length + 1).join(" ") + s;
		        }
		    };

		    function Parser(rules, start, options) {
		        if (rules instanceof Grammar) {
		            var grammar = rules;
		            var options = start;
		        } else {
		            var grammar = Grammar.fromCompiled(rules, start);
		        }
		        this.grammar = grammar;

		        // Read options
		        this.options = {
		            keepHistory: false,
		            lexer: grammar.lexer || new StreamLexer,
		        };
		        for (var key in (options || {})) {
		            this.options[key] = options[key];
		        }

		        // Setup lexer
		        this.lexer = this.options.lexer;
		        this.lexerState = undefined;

		        // Setup a table
		        var column = new Column(grammar, 0);
		        this.table = [column];

		        // I could be expecting anything.
		        column.wants[grammar.start] = [];
		        column.predict(grammar.start);
		        // TODO what if start rule is nullable?
		        column.process();
		        this.current = 0; // token index
		    }

		    // create a reserved token for indicating a parse fail
		    Parser.fail = {};

		    Parser.prototype.feed = function(chunk) {
		        var lexer = this.lexer;
		        lexer.reset(chunk, this.lexerState);

		        var token;
		        while (true) {
		            try {
		                token = lexer.next();
		                if (!token) {
		                    break;
		                }
		            } catch (e) {
		                // Create the next column so that the error reporter
		                // can display the correctly predicted states.
		                var nextColumn = new Column(this.grammar, this.current + 1);
		                this.table.push(nextColumn);
		                var err = new Error(this.reportLexerError(e));
		                err.offset = this.current;
		                err.token = e.token;
		                throw err;
		            }
		            // We add new states to table[current+1]
		            var column = this.table[this.current];

		            // GC unused states
		            if (!this.options.keepHistory) {
		                delete this.table[this.current - 1];
		            }

		            var n = this.current + 1;
		            var nextColumn = new Column(this.grammar, n);
		            this.table.push(nextColumn);

		            // Advance all tokens that expect the symbol
		            var literal = token.text !== undefined ? token.text : token.value;
		            var value = lexer.constructor === StreamLexer ? token.value : token;
		            var scannable = column.scannable;
		            for (var w = scannable.length; w--; ) {
		                var state = scannable[w];
		                var expect = state.rule.symbols[state.dot];
		                // Try to consume the token
		                // either regex or literal
		                if (expect.test ? expect.test(value) :
		                    expect.type ? expect.type === token.type
		                                : expect.literal === literal) {
		                    // Add it
		                    var next = state.nextState({data: value, token: token, isToken: true, reference: n - 1});
		                    nextColumn.states.push(next);
		                }
		            }

		            // Next, for each of the rules, we either
		            // (a) complete it, and try to see if the reference row expected that
		            //     rule
		            // (b) predict the next nonterminal it expects by adding that
		            //     nonterminal's start state
		            // To prevent duplication, we also keep track of rules we have already
		            // added

		            nextColumn.process();

		            // If needed, throw an error:
		            if (nextColumn.states.length === 0) {
		                // No states at all! This is not good.
		                var err = new Error(this.reportError(token));
		                err.offset = this.current;
		                err.token = token;
		                throw err;
		            }

		            // maybe save lexer state
		            if (this.options.keepHistory) {
		              column.lexerState = lexer.save();
		            }

		            this.current++;
		        }
		        if (column) {
		          this.lexerState = lexer.save();
		        }

		        // Incrementally keep track of results
		        this.results = this.finish();

		        // Allow chaining, for whatever it's worth
		        return this;
		    };

		    Parser.prototype.reportLexerError = function(lexerError) {
		        var tokenDisplay, lexerMessage;
		        // Planning to add a token property to moo's thrown error
		        // even on erroring tokens to be used in error display below
		        var token = lexerError.token;
		        if (token) {
		            tokenDisplay = "input " + JSON.stringify(token.text[0]) + " (lexer error)";
		            lexerMessage = this.lexer.formatError(token, "Syntax error");
		        } else {
		            tokenDisplay = "input (lexer error)";
		            lexerMessage = lexerError.message;
		        }
		        return this.reportErrorCommon(lexerMessage, tokenDisplay);
		    };

		    Parser.prototype.reportError = function(token) {
		        var tokenDisplay = (token.type ? token.type + " token: " : "") + JSON.stringify(token.value !== undefined ? token.value : token);
		        var lexerMessage = this.lexer.formatError(token, "Syntax error");
		        return this.reportErrorCommon(lexerMessage, tokenDisplay);
		    };

		    Parser.prototype.reportErrorCommon = function(lexerMessage, tokenDisplay) {
		        var lines = [];
		        lines.push(lexerMessage);
		        var lastColumnIndex = this.table.length - 2;
		        var lastColumn = this.table[lastColumnIndex];
		        var expectantStates = lastColumn.states
		            .filter(function(state) {
		                var nextSymbol = state.rule.symbols[state.dot];
		                return nextSymbol && typeof nextSymbol !== "string";
		            });

		        if (expectantStates.length === 0) {
		            lines.push('Unexpected ' + tokenDisplay + '. I did not expect any more input. Here is the state of my parse table:\n');
		            this.displayStateStack(lastColumn.states, lines);
		        } else {
		            lines.push('Unexpected ' + tokenDisplay + '. Instead, I was expecting to see one of the following:\n');
		            // Display a "state stack" for each expectant state
		            // - which shows you how this state came to be, step by step.
		            // If there is more than one derivation, we only display the first one.
		            var stateStacks = expectantStates
		                .map(function(state) {
		                    return this.buildFirstStateStack(state, []) || [state];
		                }, this);
		            // Display each state that is expecting a terminal symbol next.
		            stateStacks.forEach(function(stateStack) {
		                var state = stateStack[0];
		                var nextSymbol = state.rule.symbols[state.dot];
		                var symbolDisplay = this.getSymbolDisplay(nextSymbol);
		                lines.push('A ' + symbolDisplay + ' based on:');
		                this.displayStateStack(stateStack, lines);
		            }, this);
		        }
		        lines.push("");
		        return lines.join("\n");
		    };
		    
		    Parser.prototype.displayStateStack = function(stateStack, lines) {
		        var lastDisplay;
		        var sameDisplayCount = 0;
		        for (var j = 0; j < stateStack.length; j++) {
		            var state = stateStack[j];
		            var display = state.rule.toString(state.dot);
		            if (display === lastDisplay) {
		                sameDisplayCount++;
		            } else {
		                if (sameDisplayCount > 0) {
		                    lines.push('    ^ ' + sameDisplayCount + ' more lines identical to this');
		                }
		                sameDisplayCount = 0;
		                lines.push('    ' + display);
		            }
		            lastDisplay = display;
		        }
		    };

		    Parser.prototype.getSymbolDisplay = function(symbol) {
		        return getSymbolLongDisplay(symbol);
		    };

		    /*
		    Builds a the first state stack. You can think of a state stack as the call stack
		    of the recursive-descent parser which the Nearley parse algorithm simulates.
		    A state stack is represented as an array of state objects. Within a
		    state stack, the first item of the array will be the starting
		    state, with each successive item in the array going further back into history.

		    This function needs to be given a starting state and an empty array representing
		    the visited states, and it returns an single state stack.

		    */
		    Parser.prototype.buildFirstStateStack = function(state, visited) {
		        if (visited.indexOf(state) !== -1) {
		            // Found cycle, return null
		            // to eliminate this path from the results, because
		            // we don't know how to display it meaningfully
		            return null;
		        }
		        if (state.wantedBy.length === 0) {
		            return [state];
		        }
		        var prevState = state.wantedBy[0];
		        var childVisited = [state].concat(visited);
		        var childResult = this.buildFirstStateStack(prevState, childVisited);
		        if (childResult === null) {
		            return null;
		        }
		        return [state].concat(childResult);
		    };

		    Parser.prototype.save = function() {
		        var column = this.table[this.current];
		        column.lexerState = this.lexerState;
		        return column;
		    };

		    Parser.prototype.restore = function(column) {
		        var index = column.index;
		        this.current = index;
		        this.table[index] = column;
		        this.table.splice(index + 1);
		        this.lexerState = column.lexerState;

		        // Incrementally keep track of results
		        this.results = this.finish();
		    };

		    // nb. deprecated: use save/restore instead!
		    Parser.prototype.rewind = function(index) {
		        if (!this.options.keepHistory) {
		            throw new Error('set option `keepHistory` to enable rewinding')
		        }
		        // nb. recall column (table) indicies fall between token indicies.
		        //        col 0   --   token 0   --   col 1
		        this.restore(this.table[index]);
		    };

		    Parser.prototype.finish = function() {
		        // Return the possible parsings
		        var considerations = [];
		        var start = this.grammar.start;
		        var column = this.table[this.table.length - 1];
		        column.states.forEach(function (t) {
		            if (t.rule.name === start
		                    && t.dot === t.rule.symbols.length
		                    && t.reference === 0
		                    && t.data !== Parser.fail) {
		                considerations.push(t);
		            }
		        });
		        return considerations.map(function(c) {return c.data; });
		    };

		    function getSymbolLongDisplay(symbol) {
		        var type = typeof symbol;
		        if (type === "string") {
		            return symbol;
		        } else if (type === "object") {
		            if (symbol.literal) {
		                return JSON.stringify(symbol.literal);
		            } else if (symbol instanceof RegExp) {
		                return 'character matching ' + symbol;
		            } else if (symbol.type) {
		                return symbol.type + ' token';
		            } else if (symbol.test) {
		                return 'token matching ' + String(symbol.test);
		            } else {
		                throw new Error('Unknown symbol type: ' + symbol);
		            }
		        }
		    }

		    function getSymbolShortDisplay(symbol) {
		        var type = typeof symbol;
		        if (type === "string") {
		            return symbol;
		        } else if (type === "object") {
		            if (symbol.literal) {
		                return JSON.stringify(symbol.literal);
		            } else if (symbol instanceof RegExp) {
		                return symbol.toString();
		            } else if (symbol.type) {
		                return '%' + symbol.type;
		            } else if (symbol.test) {
		                return '<' + String(symbol.test) + '>';
		            } else {
		                throw new Error('Unknown symbol type: ' + symbol);
		            }
		        }
		    }

		    return {
		        Parser: Parser,
		        Grammar: Grammar,
		        Rule: Rule,
		    };

		})); 
	} (nearley$1));

	var nearleyExports = nearley$1.exports;

	var moo$1 = {exports: {}};

	(function (module) {
		(function(root, factory) {
		  if (module.exports) {
		    module.exports = factory();
		  } else {
		    root.moo = factory();
		  }
		}(commonjsGlobal, function() {

		  var hasOwnProperty = Object.prototype.hasOwnProperty;
		  var toString = Object.prototype.toString;
		  var hasSticky = typeof new RegExp().sticky === 'boolean';

		  /***************************************************************************/

		  function isRegExp(o) { return o && toString.call(o) === '[object RegExp]' }
		  function isObject(o) { return o && typeof o === 'object' && !isRegExp(o) && !Array.isArray(o) }

		  function reEscape(s) {
		    return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&')
		  }
		  function reGroups(s) {
		    var re = new RegExp('|' + s);
		    return re.exec('').length - 1
		  }
		  function reCapture(s) {
		    return '(' + s + ')'
		  }
		  function reUnion(regexps) {
		    if (!regexps.length) return '(?!)'
		    var source =  regexps.map(function(s) {
		      return "(?:" + s + ")"
		    }).join('|');
		    return "(?:" + source + ")"
		  }

		  function regexpOrLiteral(obj) {
		    if (typeof obj === 'string') {
		      return '(?:' + reEscape(obj) + ')'

		    } else if (isRegExp(obj)) {
		      // TODO: consider /u support
		      if (obj.ignoreCase) throw new Error('RegExp /i flag not allowed')
		      if (obj.global) throw new Error('RegExp /g flag is implied')
		      if (obj.sticky) throw new Error('RegExp /y flag is implied')
		      if (obj.multiline) throw new Error('RegExp /m flag is implied')
		      return obj.source

		    } else {
		      throw new Error('Not a pattern: ' + obj)
		    }
		  }

		  function objectToRules(object) {
		    var keys = Object.getOwnPropertyNames(object);
		    var result = [];
		    for (var i = 0; i < keys.length; i++) {
		      var key = keys[i];
		      var thing = object[key];
		      var rules = [].concat(thing);
		      if (key === 'include') {
		        for (var j = 0; j < rules.length; j++) {
		          result.push({include: rules[j]});
		        }
		        continue
		      }
		      var match = [];
		      rules.forEach(function(rule) {
		        if (isObject(rule)) {
		          if (match.length) result.push(ruleOptions(key, match));
		          result.push(ruleOptions(key, rule));
		          match = [];
		        } else {
		          match.push(rule);
		        }
		      });
		      if (match.length) result.push(ruleOptions(key, match));
		    }
		    return result
		  }

		  function arrayToRules(array) {
		    var result = [];
		    for (var i = 0; i < array.length; i++) {
		      var obj = array[i];
		      if (obj.include) {
		        var include = [].concat(obj.include);
		        for (var j = 0; j < include.length; j++) {
		          result.push({include: include[j]});
		        }
		        continue
		      }
		      if (!obj.type) {
		        throw new Error('Rule has no type: ' + JSON.stringify(obj))
		      }
		      result.push(ruleOptions(obj.type, obj));
		    }
		    return result
		  }

		  function ruleOptions(type, obj) {
		    if (!isObject(obj)) {
		      obj = { match: obj };
		    }
		    if (obj.include) {
		      throw new Error('Matching rules cannot also include states')
		    }

		    // nb. error and fallback imply lineBreaks
		    var options = {
		      defaultType: type,
		      lineBreaks: !!obj.error || !!obj.fallback,
		      pop: false,
		      next: null,
		      push: null,
		      error: false,
		      fallback: false,
		      value: null,
		      type: null,
		      shouldThrow: false,
		    };

		    // Avoid Object.assign(), so we support IE9+
		    for (var key in obj) {
		      if (hasOwnProperty.call(obj, key)) {
		        options[key] = obj[key];
		      }
		    }

		    // type transform cannot be a string
		    if (typeof options.type === 'string' && type !== options.type) {
		      throw new Error("Type transform cannot be a string (type '" + options.type + "' for token '" + type + "')")
		    }

		    // convert to array
		    var match = options.match;
		    options.match = Array.isArray(match) ? match : match ? [match] : [];
		    options.match.sort(function(a, b) {
		      return isRegExp(a) && isRegExp(b) ? 0
		           : isRegExp(b) ? -1 : isRegExp(a) ? +1 : b.length - a.length
		    });
		    return options
		  }

		  function toRules(spec) {
		    return Array.isArray(spec) ? arrayToRules(spec) : objectToRules(spec)
		  }

		  var defaultErrorRule = ruleOptions('error', {lineBreaks: true, shouldThrow: true});
		  function compileRules(rules, hasStates) {
		    var errorRule = null;
		    var fast = Object.create(null);
		    var fastAllowed = true;
		    var unicodeFlag = null;
		    var groups = [];
		    var parts = [];

		    // If there is a fallback rule, then disable fast matching
		    for (var i = 0; i < rules.length; i++) {
		      if (rules[i].fallback) {
		        fastAllowed = false;
		      }
		    }

		    for (var i = 0; i < rules.length; i++) {
		      var options = rules[i];

		      if (options.include) {
		        // all valid inclusions are removed by states() preprocessor
		        throw new Error('Inheritance is not allowed in stateless lexers')
		      }

		      if (options.error || options.fallback) {
		        // errorRule can only be set once
		        if (errorRule) {
		          if (!options.fallback === !errorRule.fallback) {
		            throw new Error("Multiple " + (options.fallback ? "fallback" : "error") + " rules not allowed (for token '" + options.defaultType + "')")
		          } else {
		            throw new Error("fallback and error are mutually exclusive (for token '" + options.defaultType + "')")
		          }
		        }
		        errorRule = options;
		      }

		      var match = options.match.slice();
		      if (fastAllowed) {
		        while (match.length && typeof match[0] === 'string' && match[0].length === 1) {
		          var word = match.shift();
		          fast[word.charCodeAt(0)] = options;
		        }
		      }

		      // Warn about inappropriate state-switching options
		      if (options.pop || options.push || options.next) {
		        if (!hasStates) {
		          throw new Error("State-switching options are not allowed in stateless lexers (for token '" + options.defaultType + "')")
		        }
		        if (options.fallback) {
		          throw new Error("State-switching options are not allowed on fallback tokens (for token '" + options.defaultType + "')")
		        }
		      }

		      // Only rules with a .match are included in the RegExp
		      if (match.length === 0) {
		        continue
		      }
		      fastAllowed = false;

		      groups.push(options);

		      // Check unicode flag is used everywhere or nowhere
		      for (var j = 0; j < match.length; j++) {
		        var obj = match[j];
		        if (!isRegExp(obj)) {
		          continue
		        }

		        if (unicodeFlag === null) {
		          unicodeFlag = obj.unicode;
		        } else if (unicodeFlag !== obj.unicode && options.fallback === false) {
		          throw new Error('If one rule is /u then all must be')
		        }
		      }

		      // convert to RegExp
		      var pat = reUnion(match.map(regexpOrLiteral));

		      // validate
		      var regexp = new RegExp(pat);
		      if (regexp.test("")) {
		        throw new Error("RegExp matches empty string: " + regexp)
		      }
		      var groupCount = reGroups(pat);
		      if (groupCount > 0) {
		        throw new Error("RegExp has capture groups: " + regexp + "\nUse (?: … ) instead")
		      }

		      // try and detect rules matching newlines
		      if (!options.lineBreaks && regexp.test('\n')) {
		        throw new Error('Rule should declare lineBreaks: ' + regexp)
		      }

		      // store regex
		      parts.push(reCapture(pat));
		    }


		    // If there's no fallback rule, use the sticky flag so we only look for
		    // matches at the current index.
		    //
		    // If we don't support the sticky flag, then fake it using an irrefutable
		    // match (i.e. an empty pattern).
		    var fallbackRule = errorRule && errorRule.fallback;
		    var flags = hasSticky && !fallbackRule ? 'ym' : 'gm';
		    var suffix = hasSticky || fallbackRule ? '' : '|';

		    if (unicodeFlag === true) flags += "u";
		    var combined = new RegExp(reUnion(parts) + suffix, flags);
		    return {regexp: combined, groups: groups, fast: fast, error: errorRule || defaultErrorRule}
		  }

		  function compile(rules) {
		    var result = compileRules(toRules(rules));
		    return new Lexer({start: result}, 'start')
		  }

		  function checkStateGroup(g, name, map) {
		    var state = g && (g.push || g.next);
		    if (state && !map[state]) {
		      throw new Error("Missing state '" + state + "' (in token '" + g.defaultType + "' of state '" + name + "')")
		    }
		    if (g && g.pop && +g.pop !== 1) {
		      throw new Error("pop must be 1 (in token '" + g.defaultType + "' of state '" + name + "')")
		    }
		  }
		  function compileStates(states, start) {
		    var all = states.$all ? toRules(states.$all) : [];
		    delete states.$all;

		    var keys = Object.getOwnPropertyNames(states);
		    if (!start) start = keys[0];

		    var ruleMap = Object.create(null);
		    for (var i = 0; i < keys.length; i++) {
		      var key = keys[i];
		      ruleMap[key] = toRules(states[key]).concat(all);
		    }
		    for (var i = 0; i < keys.length; i++) {
		      var key = keys[i];
		      var rules = ruleMap[key];
		      var included = Object.create(null);
		      for (var j = 0; j < rules.length; j++) {
		        var rule = rules[j];
		        if (!rule.include) continue
		        var splice = [j, 1];
		        if (rule.include !== key && !included[rule.include]) {
		          included[rule.include] = true;
		          var newRules = ruleMap[rule.include];
		          if (!newRules) {
		            throw new Error("Cannot include nonexistent state '" + rule.include + "' (in state '" + key + "')")
		          }
		          for (var k = 0; k < newRules.length; k++) {
		            var newRule = newRules[k];
		            if (rules.indexOf(newRule) !== -1) continue
		            splice.push(newRule);
		          }
		        }
		        rules.splice.apply(rules, splice);
		        j--;
		      }
		    }

		    var map = Object.create(null);
		    for (var i = 0; i < keys.length; i++) {
		      var key = keys[i];
		      map[key] = compileRules(ruleMap[key], true);
		    }

		    for (var i = 0; i < keys.length; i++) {
		      var name = keys[i];
		      var state = map[name];
		      var groups = state.groups;
		      for (var j = 0; j < groups.length; j++) {
		        checkStateGroup(groups[j], name, map);
		      }
		      var fastKeys = Object.getOwnPropertyNames(state.fast);
		      for (var j = 0; j < fastKeys.length; j++) {
		        checkStateGroup(state.fast[fastKeys[j]], name, map);
		      }
		    }

		    return new Lexer(map, start)
		  }

		  function keywordTransform(map) {
		    var reverseMap = Object.create(null);
		    var byLength = Object.create(null);
		    var types = Object.getOwnPropertyNames(map);
		    for (var i = 0; i < types.length; i++) {
		      var tokenType = types[i];
		      var item = map[tokenType];
		      var keywordList = Array.isArray(item) ? item : [item];
		      keywordList.forEach(function(keyword) {
		        (byLength[keyword.length] = byLength[keyword.length] || []).push(keyword);
		        if (typeof keyword !== 'string') {
		          throw new Error("keyword must be string (in keyword '" + tokenType + "')")
		        }
		        reverseMap[keyword] = tokenType;
		      });
		    }

		    // fast string lookup
		    // https://jsperf.com/string-lookups
		    function str(x) { return JSON.stringify(x) }
		    var source = '';
		    source += 'switch (value.length) {\n';
		    for (var length in byLength) {
		      var keywords = byLength[length];
		      source += 'case ' + length + ':\n';
		      source += 'switch (value) {\n';
		      keywords.forEach(function(keyword) {
		        var tokenType = reverseMap[keyword];
		        source += 'case ' + str(keyword) + ': return ' + str(tokenType) + '\n';
		      });
		      source += '}\n';
		    }
		    source += '}\n';
		    return Function('value', source) // type
		  }

		  /***************************************************************************/

		  var Lexer = function(states, state) {
		    this.startState = state;
		    this.states = states;
		    this.buffer = '';
		    this.stack = [];
		    this.reset();
		  };

		  Lexer.prototype.reset = function(data, info) {
		    this.buffer = data || '';
		    this.index = 0;
		    this.line = info ? info.line : 1;
		    this.col = info ? info.col : 1;
		    this.queuedToken = info ? info.queuedToken : null;
		    this.queuedThrow = info ? info.queuedThrow : null;
		    this.setState(info ? info.state : this.startState);
		    this.stack = info && info.stack ? info.stack.slice() : [];
		    return this
		  };

		  Lexer.prototype.save = function() {
		    return {
		      line: this.line,
		      col: this.col,
		      state: this.state,
		      stack: this.stack.slice(),
		      queuedToken: this.queuedToken,
		      queuedThrow: this.queuedThrow,
		    }
		  };

		  Lexer.prototype.setState = function(state) {
		    if (!state || this.state === state) return
		    this.state = state;
		    var info = this.states[state];
		    this.groups = info.groups;
		    this.error = info.error;
		    this.re = info.regexp;
		    this.fast = info.fast;
		  };

		  Lexer.prototype.popState = function() {
		    this.setState(this.stack.pop());
		  };

		  Lexer.prototype.pushState = function(state) {
		    this.stack.push(this.state);
		    this.setState(state);
		  };

		  var eat = hasSticky ? function(re, buffer) { // assume re is /y
		    return re.exec(buffer)
		  } : function(re, buffer) { // assume re is /g
		    var match = re.exec(buffer);
		    // will always match, since we used the |(?:) trick
		    if (match[0].length === 0) {
		      return null
		    }
		    return match
		  };

		  Lexer.prototype._getGroup = function(match) {
		    var groupCount = this.groups.length;
		    for (var i = 0; i < groupCount; i++) {
		      if (match[i + 1] !== undefined) {
		        return this.groups[i]
		      }
		    }
		    throw new Error('Cannot find token type for matched text')
		  };

		  function tokenToString() {
		    return this.value
		  }

		  Lexer.prototype.next = function() {
		    var index = this.index;

		    // If a fallback token matched, we don't need to re-run the RegExp
		    if (this.queuedGroup) {
		      var token = this._token(this.queuedGroup, this.queuedText, index);
		      this.queuedGroup = null;
		      this.queuedText = "";
		      return token
		    }

		    var buffer = this.buffer;
		    if (index === buffer.length) {
		      return // EOF
		    }

		    // Fast matching for single characters
		    var group = this.fast[buffer.charCodeAt(index)];
		    if (group) {
		      return this._token(group, buffer.charAt(index), index)
		    }

		    // Execute RegExp
		    var re = this.re;
		    re.lastIndex = index;
		    var match = eat(re, buffer);

		    // Error tokens match the remaining buffer
		    var error = this.error;
		    if (match == null) {
		      return this._token(error, buffer.slice(index, buffer.length), index)
		    }

		    var group = this._getGroup(match);
		    var text = match[0];

		    if (error.fallback && match.index !== index) {
		      this.queuedGroup = group;
		      this.queuedText = text;

		      // Fallback tokens contain the unmatched portion of the buffer
		      return this._token(error, buffer.slice(index, match.index), index)
		    }

		    return this._token(group, text, index)
		  };

		  Lexer.prototype._token = function(group, text, offset) {
		    // count line breaks
		    var lineBreaks = 0;
		    if (group.lineBreaks) {
		      var matchNL = /\n/g;
		      var nl = 1;
		      if (text === '\n') {
		        lineBreaks = 1;
		      } else {
		        while (matchNL.exec(text)) { lineBreaks++; nl = matchNL.lastIndex; }
		      }
		    }

		    var token = {
		      type: (typeof group.type === 'function' && group.type(text)) || group.defaultType,
		      value: typeof group.value === 'function' ? group.value(text) : text,
		      text: text,
		      toString: tokenToString,
		      offset: offset,
		      lineBreaks: lineBreaks,
		      line: this.line,
		      col: this.col,
		    };
		    // nb. adding more props to token object will make V8 sad!

		    var size = text.length;
		    this.index += size;
		    this.line += lineBreaks;
		    if (lineBreaks !== 0) {
		      this.col = size - nl + 1;
		    } else {
		      this.col += size;
		    }

		    // throw, if no rule with {error: true}
		    if (group.shouldThrow) {
		      throw new Error(this.formatError(token, "invalid syntax"))
		    }

		    if (group.pop) this.popState();
		    else if (group.push) this.pushState(group.push);
		    else if (group.next) this.setState(group.next);

		    return token
		  };

		  if (typeof Symbol !== 'undefined' && Symbol.iterator) {
		    var LexerIterator = function(lexer) {
		      this.lexer = lexer;
		    };

		    LexerIterator.prototype.next = function() {
		      var token = this.lexer.next();
		      return {value: token, done: !token}
		    };

		    LexerIterator.prototype[Symbol.iterator] = function() {
		      return this
		    };

		    Lexer.prototype[Symbol.iterator] = function() {
		      return new LexerIterator(this)
		    };
		  }

		  Lexer.prototype.formatError = function(token, message) {
		    if (token == null) {
		      // An undefined token indicates EOF
		      var text = this.buffer.slice(this.index);
		      var token = {
		        text: text,
		        offset: this.index,
		        lineBreaks: text.indexOf('\n') === -1 ? 0 : 1,
		        line: this.line,
		        col: this.col,
		      };
		    }
		    var start = Math.max(0, token.offset - token.col + 1);
		    var eol = token.lineBreaks ? token.text.indexOf('\n') : token.text.length;
		    var firstLine = this.buffer.substring(start, token.offset + eol);
		    message += " at line " + token.line + " col " + token.col + ":\n\n";
		    message += "  " + firstLine + "\n";
		    message += "  " + Array(token.col).join(" ") + "^";
		    return message
		  };

		  Lexer.prototype.clone = function() {
		    return new Lexer(this.states, this.state)
		  };

		  Lexer.prototype.has = function(tokenType) {
		    return true
		  };


		  return {
		    compile: compile,
		    states: compileStates,
		    error: Object.freeze({error: true}),
		    fallback: Object.freeze({fallback: true}),
		    keywords: keywordTransform,
		  }

		})); 
	} (moo$1));

	var mooExports = moo$1.exports;

	Object.defineProperty(parseley$1, '__esModule', { value: true });

	var nearley = nearleyExports;
	var moo = mooExports;

	function _interopNamespace$2(e) {
	    if (e && e.__esModule) return e;
	    var n = Object.create(null);
	    if (e) {
	        Object.keys(e).forEach(function (k) {
	            if (k !== 'default') {
	                var d = Object.getOwnPropertyDescriptor(e, k);
	                Object.defineProperty(n, k, d.get ? d : {
	                    enumerable: true,
	                    get: function () {
	                        return e[k];
	                    }
	                });
	            }
	        });
	    }
	    n['default'] = e;
	    return Object.freeze(n);
	}

	var moo__namespace = /*#__PURE__*/_interopNamespace$2(moo);

	// Generated automatically by nearley, version 2.20.1
	// http://github.com/Hardmath123/nearley
	// Bypasses TS6133. Allow declared but unused functions.
	// @ts-ignore
	function id(d) { return d[0]; }
	const lexer = moo__namespace.compile({
	    ws: { match: /[ \t\r\n\f]+/, lineBreaks: true },
	    idn: { match: /[a-zA-Z_-][a-zA-Z0-9_-]*/ },
	    hashToken: { match: /#[a-zA-Z0-9_-]+/, value: (s) => s.slice(1) },
	    str1: { match: /'(?:\\['\\]|[^\n'\\])*'/, value: (s) => s.slice(1, -1) },
	    str2: { match: /"(?:\\["\\]|[^\n"\\])*"/, value: (s) => s.slice(1, -1) },
	    asterisk: '*',
	    fullstop: '.',
	    comma: ',',
	    lbr: '[',
	    rbr: ']',
	    eq: '=',
	    gt: '>',
	    vbar: '|',
	    plus: '+',
	    tilde: '~',
	    caret: '^',
	    dollar: '$',
	    //colon:      ':',
	    //lpar:       '(',
	    //rpar:       ')',
	});
	function firstTokenValue(tokens) {
	    return tokens[0].value;
	}
	function second(tokens) {
	    return tokens[1];
	}
	function sumSpec([a0, a1, a2], [b0, b1, b2]) {
	    return [a0 + b0, a1 + b1, a2 + b2];
	}
	const grammar = {
	    Lexer: lexer,
	    ParserRules: [
	        { "name": "main", "symbols": ["_", "listSelector", "_"], "postprocess": second },
	        { "name": "mainNoList", "symbols": ["_", "complexSelector", "_"], "postprocess": second },
	        { "name": "listSelector", "symbols": ["complexSelector"], "postprocess": ([next]) => ({ type: 'list', list: [next] }) },
	        { "name": "listSelector", "symbols": ["listSelector", "_", (lexer.has("comma") ? { type: "comma" } : comma), "_", "complexSelector"], "postprocess": ([acc, , , , next]) => ({ type: 'list', list: [...acc.list, next] }) },
	        { "name": "complexSelector", "symbols": ["compoundSelector"], "postprocess": id },
	        { "name": "complexSelector", "symbols": ["complexSelector", "__", "compoundSelector"], "postprocess": ([left, , right]) => ({
	                type: 'compound',
	                list: [...right.list, { type: 'combinator', combinator: ' ', left: left, specificity: left.specificity }],
	                specificity: sumSpec(left.specificity, right.specificity)
	            }) },
	        { "name": "complexSelector", "symbols": ["complexSelector", "_", "combinator", "_", "compoundSelector"], "postprocess": ([left, , c, , right]) => ({
	                type: 'compound',
	                list: [...right.list, { type: 'combinator', combinator: c, left: left, specificity: left.specificity }],
	                specificity: sumSpec(left.specificity, right.specificity)
	            }) },
	        { "name": "combinator", "symbols": [(lexer.has("gt") ? { type: "gt" } : gt)], "postprocess": () => '>' },
	        { "name": "combinator", "symbols": [(lexer.has("plus") ? { type: "plus" } : plus)], "postprocess": () => '+' },
	        { "name": "combinator", "symbols": [(lexer.has("tilde") ? { type: "tilde" } : tilde)], "postprocess": () => '~' },
	        { "name": "combinator", "symbols": [(lexer.has("vbar") ? { type: "vbar" } : vbar), (lexer.has("vbar") ? { type: "vbar" } : vbar)], "postprocess": () => '||' },
	        { "name": "compoundSelector", "symbols": ["typeSelector"], "postprocess": ([next]) => ({
	                type: 'compound',
	                list: [next],
	                specificity: next.specificity
	            }) },
	        { "name": "compoundSelector", "symbols": ["subclassSelector"], "postprocess": ([next]) => ({
	                type: 'compound',
	                list: [next],
	                specificity: next.specificity
	            }) },
	        { "name": "compoundSelector", "symbols": ["compoundSelector", "subclassSelector"], "postprocess": ([acc, next]) => ({
	                type: 'compound',
	                list: [...acc.list, next],
	                specificity: sumSpec(acc.specificity, next.specificity)
	            }) },
	        { "name": "subclassSelector", "symbols": ["idSelector"], "postprocess": id },
	        { "name": "subclassSelector", "symbols": ["classSelector"], "postprocess": id },
	        { "name": "subclassSelector", "symbols": ["attrSelector"], "postprocess": id },
	        { "name": "attrSelector", "symbols": ["attrPresenceSelector"], "postprocess": id },
	        { "name": "attrSelector", "symbols": ["attrValueSelector"], "postprocess": id },
	        { "name": "typeSelector", "symbols": ["tagSelector"], "postprocess": id },
	        { "name": "typeSelector", "symbols": ["uniSelector"], "postprocess": id },
	        { "name": "attrPresenceSelector", "symbols": [(lexer.has("lbr") ? { type: "lbr" } : lbr), "_", "wqname", "_", (lexer.has("rbr") ? { type: "rbr" } : rbr)], "postprocess": ([, , wqname]) => ({
	                type: 'attrPresence',
	                name: wqname.name,
	                namespace: wqname.namespace,
	                specificity: [0, 1, 0]
	            })
	        },
	        { "name": "attrValueSelector", "symbols": [(lexer.has("lbr") ? { type: "lbr" } : lbr), "_", "wqname", "_", "attrMatcher", "_", "attrValue", "_", (lexer.has("rbr") ? { type: "rbr" } : rbr)], "postprocess": ([, , wqname, , matcher, , v]) => ({
	                type: 'attrValue',
	                name: wqname.name,
	                namespace: wqname.namespace,
	                matcher: matcher,
	                value: v.value,
	                modifier: v.modifier,
	                specificity: [0, 1, 0]
	            })
	        },
	        { "name": "attrMatcher", "symbols": [(lexer.has("eq") ? { type: "eq" } : eq)], "postprocess": () => '=' },
	        { "name": "attrMatcher", "symbols": [(lexer.has("tilde") ? { type: "tilde" } : tilde), (lexer.has("eq") ? { type: "eq" } : eq)], "postprocess": () => '~=' },
	        { "name": "attrMatcher", "symbols": [(lexer.has("vbar") ? { type: "vbar" } : vbar), (lexer.has("eq") ? { type: "eq" } : eq)], "postprocess": () => '|=' },
	        { "name": "attrMatcher", "symbols": [(lexer.has("caret") ? { type: "caret" } : caret), (lexer.has("eq") ? { type: "eq" } : eq)], "postprocess": () => '^=' },
	        { "name": "attrMatcher", "symbols": [(lexer.has("dollar") ? { type: "dollar" } : dollar), (lexer.has("eq") ? { type: "eq" } : eq)], "postprocess": () => '$=' },
	        { "name": "attrMatcher", "symbols": [(lexer.has("asterisk") ? { type: "asterisk" } : asterisk), (lexer.has("eq") ? { type: "eq" } : eq)], "postprocess": () => '*=' },
	        { "name": "attrValue", "symbols": ["str"], "postprocess": ([v]) => ({ value: v, modifier: null }) },
	        { "name": "attrValue", "symbols": ["idn"], "postprocess": ([v]) => ({ value: v, modifier: null }) },
	        { "name": "attrValue", "symbols": ["str", "_", "attrModifier"], "postprocess": ([v, , mod]) => ({ value: v, modifier: mod }) },
	        { "name": "attrValue", "symbols": ["idn", "__", "attrModifier"], "postprocess": ([v, , mod]) => ({ value: v, modifier: mod }) },
	        { "name": "attrModifier", "symbols": [{ "literal": "i" }], "postprocess": () => 'i' },
	        { "name": "attrModifier", "symbols": [{ "literal": "I" }], "postprocess": () => 'i' },
	        { "name": "attrModifier", "symbols": [{ "literal": "s" }], "postprocess": () => 's' },
	        { "name": "attrModifier", "symbols": [{ "literal": "S" }], "postprocess": () => 's' },
	        { "name": "idSelector", "symbols": [(lexer.has("hashToken") ? { type: "hashToken" } : hashToken)], "postprocess": ([{ value: name }]) => ({ type: 'id', name: name, specificity: [1, 0, 0] }) },
	        { "name": "classSelector", "symbols": [(lexer.has("fullstop") ? { type: "fullstop" } : fullstop), "idn"], "postprocess": ([, name]) => ({ type: 'class', name: name, specificity: [0, 1, 0] }) },
	        { "name": "tagSelector", "symbols": ["wqname"], "postprocess": ([wqname]) => ({
	                type: 'tag',
	                name: wqname.name,
	                namespace: wqname.namespace,
	                specificity: [0, 0, 1]
	            })
	        },
	        { "name": "uniSelector", "symbols": [(lexer.has("asterisk") ? { type: "asterisk" } : asterisk)], "postprocess": () => ({ type: 'universal', namespace: null, specificity: [0, 0, 0] }) },
	        { "name": "uniSelector", "symbols": ["ns", (lexer.has("asterisk") ? { type: "asterisk" } : asterisk)], "postprocess": ([ns]) => ({ type: 'universal', namespace: ns, specificity: [0, 0, 0] }) },
	        { "name": "wqname", "symbols": ["idn"], "postprocess": ([name]) => ({ name: name, namespace: null }) },
	        { "name": "wqname", "symbols": ["ns", "idn"], "postprocess": ([ns, name]) => ({ name: name, namespace: ns }) },
	        { "name": "ns", "symbols": [(lexer.has("vbar") ? { type: "vbar" } : vbar)], "postprocess": () => '' },
	        { "name": "ns", "symbols": ["idn", (lexer.has("vbar") ? { type: "vbar" } : vbar)], "postprocess": id },
	        { "name": "str", "symbols": [(lexer.has("str1") ? { type: "str1" } : str1)], "postprocess": firstTokenValue },
	        { "name": "str", "symbols": [(lexer.has("str2") ? { type: "str2" } : str2)], "postprocess": firstTokenValue },
	        { "name": "idn", "symbols": [(lexer.has("idn") ? { type: "idn" } : idn)], "postprocess": firstTokenValue },
	        { "name": "_$ebnf$1", "symbols": [(lexer.has("ws") ? { type: "ws" } : ws)], "postprocess": id },
	        { "name": "_$ebnf$1", "symbols": [], "postprocess": () => null },
	        { "name": "_", "symbols": ["_$ebnf$1"], "postprocess": () => null },
	        { "name": "__", "symbols": [(lexer.has("ws") ? { type: "ws" } : ws)], "postprocess": () => null }
	    ],
	    ParserStart: "main",
	};

	var ast = /*#__PURE__*/Object.freeze({
	    __proto__: null
	});

	// Passing the start argument to a parser or grammar constructor
	// doesn't seem to work as expected.
	const compiledRulesNoList = { ...grammar, ParserStart: 'mainNoList' };
	/**
	 * Parse a CSS selector string.
	 *
	 * This function supports comma-separated selector lists
	 * and always returns an AST starting from a node of type `list`.
	 *
	 * @param str - CSS selector string (can contain commas).
	 */
	function parse$3(str) {
	    return _parse(grammar, str);
	}
	/**
	 * Parse a CSS selector string.
	 *
	 * This function does not support comma-separated selector lists
	 * and always returns an AST starting from a node of type `compound`.
	 *
	 * @param str - CSS selector string (no commas).
	 */
	function parse1(str) {
	    return _parse(compiledRulesNoList, str);
	}
	function _parse(compiledRules1, str) {
	    const parser = new nearley.Parser(nearley.Grammar.fromCompiled(compiledRules1));
	    parser.feed(str);
	    if (parser.results.length === 0) {
	        throw new Error('Failed to parse - input string might be incomplete.');
	    }
	    return parser.results[0];
	}
	/**
	 * Convert a selector AST back to a string representation.
	 *
	 * Note: formatting is not preserved in the AST.
	 *
	 * @param selector - A selector AST object.
	 */
	function serialize$1(selector) {
	    if (!selector.type) {
	        throw new Error('This is not an AST node.');
	    }
	    switch (selector.type) {
	        case 'universal':
	            return _serNs(selector.namespace) + '*';
	        case 'tag':
	            return _serNs(selector.namespace) + selector.name;
	        case 'class':
	            return '.' + selector.name;
	        case 'id':
	            return '#' + selector.name;
	        case 'attrPresence':
	            return `[${_serNs(selector.namespace)}${selector.name}]`;
	        case 'attrValue':
	            return `[${_serNs(selector.namespace)}${selector.name}${selector.matcher}${_serStr(selector.value)}${(selector.modifier ? selector.modifier : '')}]`;
	        case 'combinator':
	            return serialize$1(selector.left) + selector.combinator;
	        case 'compound':
	            return selector.list.reduce((acc, node) => {
	                if (node.type === 'combinator') {
	                    return serialize$1(node) + acc;
	                }
	                else {
	                    return acc + serialize$1(node);
	                }
	            }, '');
	        case 'list':
	            return selector.list.map(serialize$1).join(',');
	    }
	}
	function _serNs(ns) {
	    return (ns || ns === '')
	        ? ns + '|'
	        : '';
	}
	function _serStr(str) {
	    if (str.indexOf('"') === -1) {
	        return `"${str}"`;
	    }
	    else if (str.indexOf("'") === -1) {
	        return `'${str}'`;
	    }
	    else {
	        return `"${str.replace('"', '\\"')}"`;
	    }
	}
	/**
	 * Modifies the given AST **in place** to have all internal arrays
	 * in a stable order. Returns the AST.
	 *
	 * Intended for consitent processing and normalized `serialize()` output.
	 *
	 * @param selector - A selector AST object.
	 */
	function normalize$3(selector) {
	    if (!selector.type) {
	        throw new Error('This is not an AST node.');
	    }
	    switch (selector.type) {
	        case 'compound': {
	            selector.list.forEach(normalize$3);
	            selector.list.sort((a, b) => _compareArrays(_getSelectorPriority(a), _getSelectorPriority(b)));
	            break;
	        }
	        case 'combinator': {
	            normalize$3(selector.left);
	            break;
	        }
	        case 'list': {
	            selector.list.forEach(normalize$3);
	            selector.list.sort((a, b) => (serialize$1(a) < serialize$1(b)) ? -1 : 1);
	            break;
	        }
	    }
	    return selector;
	}
	function _getSelectorPriority(selector) {
	    switch (selector.type) {
	        case 'universal':
	            return [1];
	        case 'tag':
	            return [1];
	        case 'id':
	            return [2];
	        case 'class':
	            return [3, selector.name];
	        case 'attrPresence':
	            return [4, serialize$1(selector)];
	        case 'attrValue':
	            return [5, serialize$1(selector)];
	        case 'combinator':
	            return [15, serialize$1(selector)];
	    }
	}
	/**
	 * Compare selectors based on their specificity.
	 *
	 * Usable as a comparator for sorting.
	 *
	 * @param a - First selector.
	 * @param b - Second selector.
	 */
	function compareSelectors(a, b) {
	    return _compareArrays(a.specificity, b.specificity);
	}
	/**
	 * Compare specificity values without reducing them
	 * as arbitrary base numbers.
	 *
	 * Usable as a comparator for sorting.
	 *
	 * @param a - First specificity value.
	 * @param b - Second specificity value.
	 */
	function compareSpecificity(a, b) {
	    return _compareArrays(a, b);
	}
	function _compareArrays(a, b) {
	    if (!Array.isArray(a) || !Array.isArray(b)) {
	        throw new Error('Arguments must be arrays.');
	    }
	    const shorter = (a.length < b.length) ? a.length : b.length;
	    for (let i = 0; i < shorter; i++) {
	        if (a[i] === b[i]) {
	            continue;
	        }
	        return (a[i] < b[i]) ? -1 : 1;
	    }
	    return a.length - b.length;
	}

	parseley$1.Ast = ast;
	parseley$1.compareSelectors = compareSelectors;
	parseley$1.compareSpecificity = compareSpecificity;
	parseley$1.normalize = normalize$3;
	parseley$1.parse = parse$3;
	parseley$1.parse1 = parse1;
	parseley$1.serialize = serialize$1;

	Object.defineProperty(selderee$2, '__esModule', { value: true });

	var parseley = parseley$1;

	function _interopNamespace$1(e) {
	    if (e && e.__esModule) return e;
	    var n = Object.create(null);
	    if (e) {
	        Object.keys(e).forEach(function (k) {
	            if (k !== 'default') {
	                var d = Object.getOwnPropertyDescriptor(e, k);
	                Object.defineProperty(n, k, d.get ? d : {
	                    enumerable: true,
	                    get: function () {
	                        return e[k];
	                    }
	                });
	            }
	        });
	    }
	    n['default'] = e;
	    return Object.freeze(n);
	}

	var parseley__namespace = /*#__PURE__*/_interopNamespace$1(parseley);

	var Ast = /*#__PURE__*/Object.freeze({
	    __proto__: null
	});

	var Types = /*#__PURE__*/Object.freeze({
	    __proto__: null
	});

	/**
	 * A {@link BuilderFunction} implementation.
	 *
	 * Produces a string representation of the tree
	 * for testing and debug purposes.
	 *
	 * Only accepts `string` as the associated value type.
	 * Map your input collection before creating a {@link DecisionTree}
	 * if you want to use it with a different type -
	 * the decision on how to stringify the value is up to you.
	 *
	 * @param nodes - nodes from the root level of the decision tree.
	 * @returns the string representation of the tree.
	 */
	const treeify = (nodes) => '▽\n' + treeifyArray(nodes, thinLines);
	const thinLines = [['├─', '│ '], ['└─', '  ']];
	const heavyLines = [['┠─', '┃ '], ['┖─', '  ']];
	const doubleLines = [['╟─', '║ '], ['╙─', '  ']];
	function treeifyArray(nodes, tpl = heavyLines) {
	    return prefixItems(tpl, nodes.map(n => treeifyNode(n)));
	}
	function treeifyNode(node) {
	    switch (node.type) {
	        case 'terminal': {
	            const vctr = node.valueContainer;
	            return `◁ #${vctr.index} ${JSON.stringify(vctr.specificity)} ${vctr.value}`;
	        }
	        case 'tagName':
	            return `◻ Tag name\n${treeifyArray(node.variants, doubleLines)}`;
	        case 'attrValue':
	            return `▣ Attr value: ${node.name}\n${treeifyArray(node.matchers, doubleLines)}`;
	        case 'attrPresence':
	            return `◨ Attr presence: ${node.name}\n${treeifyArray(node.cont)}`;
	        case 'pushElement':
	            return `◉ Push element: ${node.combinator}\n${treeifyArray(node.cont, thinLines)}`;
	        case 'popElement':
	            return `◌ Pop element\n${treeifyArray(node.cont, thinLines)}`;
	        case 'variant':
	            return `◇ = ${node.value}\n${treeifyArray(node.cont)}`;
	        case 'matcher':
	            return `◈ ${node.matcher} "${node.value}"${node.modifier || ''}\n${treeifyArray(node.cont)}`;
	    }
	}
	function prefixItems(tpl, items) {
	    return items
	        .map((item, i, { length }) => prefixItem(tpl, item, i === length - 1))
	        .join('\n');
	}
	function prefixItem(tpl, item, tail = true) {
	    const tpl1 = tpl[tail ? 1 : 0];
	    return tpl1[0] + item.split('\n').join('\n' + tpl1[1]);
	}

	var TreeifyBuilder = /*#__PURE__*/Object.freeze({
	    __proto__: null,
	    treeify: treeify
	});

	/**
	 * CSS selectors decision tree.
	 * Data structure that weaves similar selectors together
	 * in order to minimize the number of checks required
	 * to find the ones matching a given HTML element.
	 *
	 * Converted into a functioning implementation via plugins
	 * tailored for specific DOM ASTs.
	 *
	 * @typeParam V - the type of values associated with selectors.
	 */
	class DecisionTree {
	    /**
	     * Create new DecisionTree object.
	     *
	     * @param input - an array containing all selectors
	     * paired with associated values.
	     *
	     * @typeParam V - the type of values associated with selectors.
	     */
	    constructor(input) {
	        this.branches = weave(toAstTerminalPairs(input));
	    }
	    /**
	     * Turn this decision tree into a usable form.
	     *
	     * @typeParam R - return type defined by the builder function.
	     *
	     * @param builder - the builder function.
	     *
	     * @returns the decision tree in a form ready for use.
	     */
	    build(builder) {
	        return builder(this.branches);
	    }
	}
	function toAstTerminalPairs(array) {
	    const len = array.length;
	    const results = new Array(len);
	    for (let i = 0; i < len; i++) {
	        const [selectorString, val] = array[i];
	        const ast = preprocess$1(parseley__namespace.parse1(selectorString));
	        results[i] = {
	            ast: ast,
	            terminal: {
	                type: 'terminal',
	                valueContainer: { index: i, value: val, specificity: ast.specificity }
	            }
	        };
	    }
	    return results;
	}
	function preprocess$1(ast) {
	    reduceSelectorVariants(ast);
	    parseley__namespace.normalize(ast);
	    return ast;
	}
	function reduceSelectorVariants(ast) {
	    const newList = [];
	    ast.list.forEach(sel => {
	        switch (sel.type) {
	            case 'class':
	                newList.push({
	                    matcher: '~=',
	                    modifier: null,
	                    name: 'class',
	                    namespace: null,
	                    specificity: sel.specificity,
	                    type: 'attrValue',
	                    value: sel.name,
	                });
	                break;
	            case 'id':
	                newList.push({
	                    matcher: '=',
	                    modifier: null,
	                    name: 'id',
	                    namespace: null,
	                    specificity: sel.specificity,
	                    type: 'attrValue',
	                    value: sel.name,
	                });
	                break;
	            case 'combinator':
	                reduceSelectorVariants(sel.left);
	                newList.push(sel);
	                break;
	            case 'universal':
	                // skip it
	                break;
	            default:
	                newList.push(sel);
	                break;
	        }
	    });
	    ast.list = newList;
	}
	function weave(items) {
	    const branches = [];
	    while (items.length) {
	        const topKind = findTopKey(items, (sel) => true, getSelectorKind);
	        const { matches, nonmatches, empty } = breakByKind(items, topKind);
	        items = nonmatches;
	        if (matches.length) {
	            branches.push(branchOfKind(topKind, matches));
	        }
	        if (empty.length) {
	            branches.push(...terminate(empty));
	        }
	    }
	    return branches;
	}
	function terminate(items) {
	    const results = [];
	    for (const item of items) {
	        const terminal = item.terminal;
	        if (terminal.type === 'terminal') {
	            results.push(terminal);
	        }
	        else { // popElement - lift contained terminals
	            const { matches, rest } = partition(terminal.cont, (node) => node.type === 'terminal');
	            matches.forEach((node) => results.push(node));
	            if (rest.length) {
	                terminal.cont = rest;
	                results.push(terminal);
	            }
	        }
	    }
	    return results;
	}
	function breakByKind(items, selectedKind) {
	    const matches = [];
	    const nonmatches = [];
	    const empty = [];
	    for (const item of items) {
	        const simpsels = item.ast.list;
	        if (simpsels.length) {
	            const isMatch = simpsels.some(node => getSelectorKind(node) === selectedKind);
	            (isMatch ? matches : nonmatches).push(item);
	        }
	        else {
	            empty.push(item);
	        }
	    }
	    return { matches, nonmatches, empty };
	}
	function getSelectorKind(sel) {
	    switch (sel.type) {
	        case 'attrPresence':
	            return `attrPresence ${sel.name}`;
	        case 'attrValue':
	            return `attrValue ${sel.name}`;
	        case 'combinator':
	            return `combinator ${sel.combinator}`;
	        default:
	            return sel.type;
	    }
	}
	function branchOfKind(kind, items) {
	    if (kind === 'tag') {
	        return tagNameBranch(items);
	    }
	    if (kind.startsWith('attrValue ')) {
	        return attrValueBranch(kind.substring(10), items);
	    }
	    if (kind.startsWith('attrPresence ')) {
	        return attrPresenceBranch(kind.substring(13), items);
	    }
	    if (kind === 'combinator >') {
	        return combinatorBranch('>', items);
	    }
	    if (kind === 'combinator +') {
	        return combinatorBranch('+', items);
	    }
	    throw new Error(`Unsupported selector kind: ${kind}`);
	}
	function tagNameBranch(items) {
	    const groups = spliceAndGroup(items, (x) => x.type === 'tag', (x) => x.name);
	    const variants = Object.entries(groups).map(([name, group]) => ({
	        type: 'variant',
	        value: name,
	        cont: weave(group.items)
	    }));
	    return {
	        type: 'tagName',
	        variants: variants
	    };
	}
	function attrPresenceBranch(name, items) {
	    for (const item of items) {
	        spliceSimpleSelector(item, (x) => (x.type === 'attrPresence') && (x.name === name));
	    }
	    return {
	        type: 'attrPresence',
	        name: name,
	        cont: weave(items)
	    };
	}
	function attrValueBranch(name, items) {
	    const groups = spliceAndGroup(items, (x) => (x.type === 'attrValue') && (x.name === name), (x) => `${x.matcher} ${x.modifier || ''} ${x.value}`);
	    const matchers = [];
	    for (const group of Object.values(groups)) {
	        const sel = group.oneSimpleSelector;
	        const predicate = getAttrPredicate(sel);
	        const continuation = weave(group.items);
	        matchers.push({
	            type: 'matcher',
	            matcher: sel.matcher,
	            modifier: sel.modifier,
	            value: sel.value,
	            predicate: predicate,
	            cont: continuation
	        });
	    }
	    return {
	        type: 'attrValue',
	        name: name,
	        matchers: matchers
	    };
	}
	function getAttrPredicate(sel) {
	    if (sel.modifier === 'i') {
	        const expected = sel.value.toLowerCase();
	        switch (sel.matcher) {
	            case '=':
	                return (actual) => expected === actual.toLowerCase();
	            case '~=':
	                return (actual) => actual.toLowerCase().split(/[ \t]+/).includes(expected);
	            case '^=':
	                return (actual) => actual.toLowerCase().startsWith(expected);
	            case '$=':
	                return (actual) => actual.toLowerCase().endsWith(expected);
	            case '*=':
	                return (actual) => actual.toLowerCase().includes(expected);
	            case '|=':
	                return (actual) => {
	                    const lower = actual.toLowerCase();
	                    return (expected === lower) || (lower.startsWith(expected) && lower[expected.length] === '-');
	                };
	        }
	    }
	    else {
	        const expected = sel.value;
	        switch (sel.matcher) {
	            case '=':
	                return (actual) => expected === actual;
	            case '~=':
	                return (actual) => actual.split(/[ \t]+/).includes(expected);
	            case '^=':
	                return (actual) => actual.startsWith(expected);
	            case '$=':
	                return (actual) => actual.endsWith(expected);
	            case '*=':
	                return (actual) => actual.includes(expected);
	            case '|=':
	                return (actual) => (expected === actual) || (actual.startsWith(expected) && actual[expected.length] === '-');
	        }
	    }
	}
	function combinatorBranch(combinator, items) {
	    const groups = spliceAndGroup(items, (x) => (x.type === 'combinator') && (x.combinator === combinator), (x) => parseley__namespace.serialize(x.left));
	    const leftItems = [];
	    for (const group of Object.values(groups)) {
	        const rightCont = weave(group.items);
	        const leftAst = group.oneSimpleSelector.left;
	        leftItems.push({
	            ast: leftAst,
	            terminal: { type: 'popElement', cont: rightCont }
	        });
	    }
	    return {
	        type: 'pushElement',
	        combinator: combinator,
	        cont: weave(leftItems)
	    };
	}
	function spliceAndGroup(items, predicate, keyCallback) {
	    const groups = {};
	    while (items.length) {
	        const bestKey = findTopKey(items, predicate, keyCallback);
	        const bestKeyPredicate = (sel) => predicate(sel) && keyCallback(sel) === bestKey;
	        const hasBestKeyPredicate = (item) => item.ast.list.some(bestKeyPredicate);
	        const { matches, rest } = partition1(items, hasBestKeyPredicate);
	        let oneSimpleSelector = null;
	        for (const item of matches) {
	            const splicedNode = spliceSimpleSelector(item, bestKeyPredicate);
	            if (!oneSimpleSelector) {
	                oneSimpleSelector = splicedNode;
	            }
	        }
	        if (oneSimpleSelector == null) {
	            throw new Error('No simple selector is found.');
	        }
	        groups[bestKey] = { oneSimpleSelector: oneSimpleSelector, items: matches };
	        items = rest;
	    }
	    return groups;
	}
	function spliceSimpleSelector(item, predicate) {
	    const simpsels = item.ast.list;
	    const matches = new Array(simpsels.length);
	    let firstIndex = -1;
	    for (let i = simpsels.length; i-- > 0;) {
	        if (predicate(simpsels[i])) {
	            matches[i] = true;
	            firstIndex = i;
	        }
	    }
	    if (firstIndex == -1) {
	        throw new Error(`Couldn't find the required simple selector.`);
	    }
	    const result = simpsels[firstIndex];
	    item.ast.list = simpsels.filter((sel, i) => !matches[i]);
	    return result;
	}
	function findTopKey(items, predicate, keyCallback) {
	    const candidates = {};
	    for (const item of items) {
	        const candidates1 = {};
	        for (const node of item.ast.list.filter(predicate)) {
	            candidates1[keyCallback(node)] = true;
	        }
	        for (const key of Object.keys(candidates1)) {
	            if (candidates[key]) {
	                candidates[key]++;
	            }
	            else {
	                candidates[key] = 1;
	            }
	        }
	    }
	    let topKind = '';
	    let topCounter = 0;
	    for (const entry of Object.entries(candidates)) {
	        if (entry[1] > topCounter) {
	            topKind = entry[0];
	            topCounter = entry[1];
	        }
	    }
	    return topKind;
	}
	function partition(src, predicate) {
	    const matches = [];
	    const rest = [];
	    for (const x of src) {
	        if (predicate(x)) {
	            matches.push(x);
	        }
	        else {
	            rest.push(x);
	        }
	    }
	    return { matches, rest };
	}
	function partition1(src, predicate) {
	    const matches = [];
	    const rest = [];
	    for (const x of src) {
	        if (predicate(x)) {
	            matches.push(x);
	        }
	        else {
	            rest.push(x);
	        }
	    }
	    return { matches, rest };
	}

	/**
	 * Simple wrapper around the matcher function.
	 * Recommended return type for builder plugins.
	 *
	 * @typeParam L - the type of HTML Element in the targeted DOM AST.
	 * @typeParam V - the type of associated values.
	 */
	class Picker {
	    /**
	     * Create new Picker object.
	     *
	     * @typeParam L - the type of HTML Element in the targeted DOM AST.
	     * @typeParam V - the type of associated values.
	     *
	     * @param f - the function that matches an element
	     * and returns all associated values.
	     */
	    constructor(f) {
	        this.f = f;
	    }
	    /**
	     * Run the selectors decision tree against one HTML Element
	     * and return all matched associated values
	     * along with selector specificities.
	     *
	     * Client code then decides how to further process them
	     * (sort, filter, etc).
	     *
	     * @param el - an HTML Element.
	     *
	     * @returns all associated values along with
	     * selector specificities for all matched selectors.
	     */
	    pickAll(el) {
	        return this.f(el);
	    }
	    /**
	     * Run the selectors decision tree against one HTML Element
	     * and choose the value from the most specific mached selector.
	     *
	     * @param el - an HTML Element.
	     *
	     * @param preferFirst - option to define which value to choose
	     * when there are multiple matches with equal specificity.
	     *
	     * @returns the value from the most specific mached selector
	     * or `null` if nothing matched.
	     */
	    pick1(el, preferFirst = false) {
	        const results = this.f(el);
	        const len = results.length;
	        if (len === 0) {
	            return null;
	        }
	        if (len === 1) {
	            return results[0].value;
	        }
	        const comparator = (preferFirst)
	            ? comparatorPreferFirst
	            : comparatorPreferLast;
	        let result = results[0];
	        for (let i = 1; i < len; i++) {
	            const next = results[i];
	            if (comparator(result, next)) {
	                result = next;
	            }
	        }
	        return result.value;
	    }
	}
	function comparatorPreferFirst(acc, next) {
	    const diff = parseley.compareSpecificity(next.specificity, acc.specificity);
	    return diff > 0 || (diff === 0 && next.index < acc.index);
	}
	function comparatorPreferLast(acc, next) {
	    const diff = parseley.compareSpecificity(next.specificity, acc.specificity);
	    return diff > 0 || (diff === 0 && next.index > acc.index);
	}

	selderee$2.Ast = Ast;
	selderee$2.DecisionTree = DecisionTree;
	selderee$2.Picker = Picker;
	selderee$2.Treeify = TreeifyBuilder;
	selderee$2.Types = Types;

	Object.defineProperty(hp2Builder$2, '__esModule', { value: true });

	var domhandler = lib$5;
	var selderee$1 = selderee$2;

	/**
	 * A {@link BuilderFunction} implementation.
	 *
	 * Creates a function (in a {@link Picker} wrapper) that can run
	 * the decision tree against `htmlparser2` `Element` nodes.
	 *
	 * @typeParam V - the type of values associated with selectors.
	 *
	 * @param nodes - nodes ({@link DecisionTreeNode})
	 * from the root level of the decision tree.
	 *
	 * @returns a {@link Picker} object.
	 */
	function hp2Builder$1(nodes) {
	    return new selderee$1.Picker(handleArray(nodes));
	}
	// ==============================================
	function handleArray(nodes) {
	    const matchers = nodes.map(handleNode);
	    return (el, ...tail) => flatMap(matchers, m => m(el, ...tail));
	}
	function handleNode(node) {
	    switch (node.type) {
	        case 'terminal': {
	            const result = [node.valueContainer];
	            return (el, ...tail) => result;
	        }
	        case 'tagName':
	            return handleTagName(node);
	        case 'attrValue':
	            return handleAttrValueName(node);
	        case 'attrPresence':
	            return handleAttrPresenceName(node);
	        case 'pushElement':
	            return handlePushElementNode(node);
	        case 'popElement':
	            return handlePopElementNode(node);
	    }
	}
	function handleTagName(node) {
	    const variants = {};
	    for (const variant of node.variants) {
	        variants[variant.value] = handleArray(variant.cont);
	    }
	    return (el, ...tail) => {
	        const continuation = variants[el.name];
	        return (continuation) ? continuation(el, ...tail) : [];
	    };
	}
	function handleAttrPresenceName(node) {
	    const attrName = node.name;
	    const continuation = handleArray(node.cont);
	    return (el, ...tail) => (Object.prototype.hasOwnProperty.call(el.attribs, attrName))
	        ? continuation(el, ...tail)
	        : [];
	}
	function handleAttrValueName(node) {
	    const callbacks = [];
	    for (const matcher of node.matchers) {
	        const predicate = matcher.predicate;
	        const continuation = handleArray(matcher.cont);
	        callbacks.push((attr, el, ...tail) => (predicate(attr) ? continuation(el, ...tail) : []));
	    }
	    const attrName = node.name;
	    return (el, ...tail) => {
	        const attr = el.attribs[attrName];
	        return (attr || attr === '')
	            ? flatMap(callbacks, cb => cb(attr, el, ...tail))
	            : [];
	    };
	}
	function handlePushElementNode(node) {
	    const continuation = handleArray(node.cont);
	    const leftElementGetter = (node.combinator === '+')
	        ? getPrecedingElement
	        : getParentElement;
	    return (el, ...tail) => {
	        const next = leftElementGetter(el);
	        if (next === null) {
	            return [];
	        }
	        return continuation(next, el, ...tail);
	    };
	}
	const getPrecedingElement = (el) => {
	    const prev = el.prev;
	    if (prev === null) {
	        return null;
	    }
	    return (domhandler.isTag(prev)) ? prev : getPrecedingElement(prev);
	};
	const getParentElement = (el) => {
	    const parent = el.parent;
	    return (parent && domhandler.isTag(parent)) ? parent : null;
	};
	function handlePopElementNode(node) {
	    const continuation = handleArray(node.cont);
	    return (el, next, ...tail) => continuation(next, ...tail);
	}
	// Can be removed after transition to Node 12.
	function flatMap(items, mapper) {
	    return [].concat(...amap(items, mapper));
	}
	function amap(items, mapper) {
	    const len = items.length;
	    const res = new Array(len);
	    for (let i = 0; i < len; i++) {
	        res[i] = mapper(items[i]);
	    }
	    return res;
	}

	hp2Builder$2.hp2Builder = hp2Builder$1;

	var he$3 = {exports: {}};

	/*! https://mths.be/he v1.2.0 by @mathias | MIT license */
	he$3.exports;

	(function (module, exports) {
	(function(root) {

			// Detect free variables `exports`.
			var freeExports = exports;

			// Detect free variable `module`.
			var freeModule = module &&
				module.exports == freeExports && module;

			// Detect free variable `global`, from Node.js or Browserified code,
			// and use it as `root`.
			var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal;
			if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
				root = freeGlobal;
			}

			/*--------------------------------------------------------------------------*/

			// All astral symbols.
			var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
			// All ASCII symbols (not just printable ASCII) except those listed in the
			// first column of the overrides table.
			// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
			var regexAsciiWhitelist = /[\x01-\x7F]/g;
			// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
			// code points listed in the first column of the overrides table on
			// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
			var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;

			var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
			var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};

			var regexEscape = /["&'<>`]/g;
			var escapeMap = {
				'"': '&quot;',
				'&': '&amp;',
				'\'': '&#x27;',
				'<': '&lt;',
				// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
				// following is not strictly necessary unless it’s part of a tag or an
				// unquoted attribute value. We’re only escaping it to support those
				// situations, and for XML support.
				'>': '&gt;',
				// In Internet Explorer ≤ 8, the backtick character can be used
				// to break out of (un)quoted attribute values or HTML comments.
				// See http://html5sec.org/#102, http://html5sec.org/#108, and
				// http://html5sec.org/#133.
				'`': '&#x60;'
			};

			var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
			var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
			var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
			var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
			var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
			var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
			var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];

			/*--------------------------------------------------------------------------*/

			var stringFromCharCode = String.fromCharCode;

			var object = {};
			var hasOwnProperty = object.hasOwnProperty;
			var has = function(object, propertyName) {
				return hasOwnProperty.call(object, propertyName);
			};

			var contains = function(array, value) {
				var index = -1;
				var length = array.length;
				while (++index < length) {
					if (array[index] == value) {
						return true;
					}
				}
				return false;
			};

			var merge = function(options, defaults) {
				if (!options) {
					return defaults;
				}
				var result = {};
				var key;
				for (key in defaults) {
					// A `hasOwnProperty` check is not needed here, since only recognized
					// option names are used anyway. Any others are ignored.
					result[key] = has(options, key) ? options[key] : defaults[key];
				}
				return result;
			};

			// Modified version of `ucs2encode`; see https://mths.be/punycode.
			var codePointToSymbol = function(codePoint, strict) {
				var output = '';
				if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
					// See issue #4:
					// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
					// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
					// REPLACEMENT CHARACTER.”
					if (strict) {
						parseError('character reference outside the permissible Unicode range');
					}
					return '\uFFFD';
				}
				if (has(decodeMapNumeric, codePoint)) {
					if (strict) {
						parseError('disallowed character reference');
					}
					return decodeMapNumeric[codePoint];
				}
				if (strict && contains(invalidReferenceCodePoints, codePoint)) {
					parseError('disallowed character reference');
				}
				if (codePoint > 0xFFFF) {
					codePoint -= 0x10000;
					output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
					codePoint = 0xDC00 | codePoint & 0x3FF;
				}
				output += stringFromCharCode(codePoint);
				return output;
			};

			var hexEscape = function(codePoint) {
				return '&#x' + codePoint.toString(16).toUpperCase() + ';';
			};

			var decEscape = function(codePoint) {
				return '&#' + codePoint + ';';
			};

			var parseError = function(message) {
				throw Error('Parse error: ' + message);
			};

			/*--------------------------------------------------------------------------*/

			var encode = function(string, options) {
				options = merge(options, encode.options);
				var strict = options.strict;
				if (strict && regexInvalidRawCodePoint.test(string)) {
					parseError('forbidden code point');
				}
				var encodeEverything = options.encodeEverything;
				var useNamedReferences = options.useNamedReferences;
				var allowUnsafeSymbols = options.allowUnsafeSymbols;
				var escapeCodePoint = options.decimal ? decEscape : hexEscape;

				var escapeBmpSymbol = function(symbol) {
					return escapeCodePoint(symbol.charCodeAt(0));
				};

				if (encodeEverything) {
					// Encode ASCII symbols.
					string = string.replace(regexAsciiWhitelist, function(symbol) {
						// Use named references if requested & possible.
						if (useNamedReferences && has(encodeMap, symbol)) {
							return '&' + encodeMap[symbol] + ';';
						}
						return escapeBmpSymbol(symbol);
					});
					// Shorten a few escapes that represent two symbols, of which at least one
					// is within the ASCII range.
					if (useNamedReferences) {
						string = string
							.replace(/&gt;\u20D2/g, '&nvgt;')
							.replace(/&lt;\u20D2/g, '&nvlt;')
							.replace(/&#x66;&#x6A;/g, '&fjlig;');
					}
					// Encode non-ASCII symbols.
					if (useNamedReferences) {
						// Encode non-ASCII symbols that can be replaced with a named reference.
						string = string.replace(regexEncodeNonAscii, function(string) {
							// Note: there is no need to check `has(encodeMap, string)` here.
							return '&' + encodeMap[string] + ';';
						});
					}
					// Note: any remaining non-ASCII symbols are handled outside of the `if`.
				} else if (useNamedReferences) {
					// Apply named character references.
					// Encode `<>"'&` using named character references.
					if (!allowUnsafeSymbols) {
						string = string.replace(regexEscape, function(string) {
							return '&' + encodeMap[string] + ';'; // no need to check `has()` here
						});
					}
					// Shorten escapes that represent two symbols, of which at least one is
					// `<>"'&`.
					string = string
						.replace(/&gt;\u20D2/g, '&nvgt;')
						.replace(/&lt;\u20D2/g, '&nvlt;');
					// Encode non-ASCII symbols that can be replaced with a named reference.
					string = string.replace(regexEncodeNonAscii, function(string) {
						// Note: there is no need to check `has(encodeMap, string)` here.
						return '&' + encodeMap[string] + ';';
					});
				} else if (!allowUnsafeSymbols) {
					// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
					// using named character references.
					string = string.replace(regexEscape, escapeBmpSymbol);
				}
				return string
					// Encode astral symbols.
					.replace(regexAstralSymbols, function($0) {
						// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
						var high = $0.charCodeAt(0);
						var low = $0.charCodeAt(1);
						var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
						return escapeCodePoint(codePoint);
					})
					// Encode any remaining BMP symbols that are not printable ASCII symbols
					// using a hexadecimal escape.
					.replace(regexBmpWhitelist, escapeBmpSymbol);
			};
			// Expose default options (so they can be overridden globally).
			encode.options = {
				'allowUnsafeSymbols': false,
				'encodeEverything': false,
				'strict': false,
				'useNamedReferences': false,
				'decimal' : false
			};

			var decode = function(html, options) {
				options = merge(options, decode.options);
				var strict = options.strict;
				if (strict && regexInvalidEntity.test(html)) {
					parseError('malformed character reference');
				}
				return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
					var codePoint;
					var semicolon;
					var decDigits;
					var hexDigits;
					var reference;
					var next;

					if ($1) {
						reference = $1;
						// Note: there is no need to check `has(decodeMap, reference)`.
						return decodeMap[reference];
					}

					if ($2) {
						// Decode named character references without trailing `;`, e.g. `&amp`.
						// This is only a parse error if it gets converted to `&`, or if it is
						// followed by `=` in an attribute context.
						reference = $2;
						next = $3;
						if (next && options.isAttributeValue) {
							if (strict && next == '=') {
								parseError('`&` did not start a character reference');
							}
							return $0;
						} else {
							if (strict) {
								parseError(
									'named character reference was not terminated by a semicolon'
								);
							}
							// Note: there is no need to check `has(decodeMapLegacy, reference)`.
							return decodeMapLegacy[reference] + (next || '');
						}
					}

					if ($4) {
						// Decode decimal escapes, e.g. `&#119558;`.
						decDigits = $4;
						semicolon = $5;
						if (strict && !semicolon) {
							parseError('character reference was not terminated by a semicolon');
						}
						codePoint = parseInt(decDigits, 10);
						return codePointToSymbol(codePoint, strict);
					}

					if ($6) {
						// Decode hexadecimal escapes, e.g. `&#x1D306;`.
						hexDigits = $6;
						semicolon = $7;
						if (strict && !semicolon) {
							parseError('character reference was not terminated by a semicolon');
						}
						codePoint = parseInt(hexDigits, 16);
						return codePointToSymbol(codePoint, strict);
					}

					// If we’re still here, `if ($7)` is implied; it’s an ambiguous
					// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
					if (strict) {
						parseError(
							'named character reference was not terminated by a semicolon'
						);
					}
					return $0;
				});
			};
			// Expose default options (so they can be overridden globally).
			decode.options = {
				'isAttributeValue': false,
				'strict': false
			};

			var escape = function(string) {
				return string.replace(regexEscape, function($0) {
					// Note: there is no need to check `has(escapeMap, $0)` here.
					return escapeMap[$0];
				});
			};

			/*--------------------------------------------------------------------------*/

			var he = {
				'version': '1.2.0',
				'encode': encode,
				'decode': decode,
				'escape': escape,
				'unescape': decode
			};

			// Some AMD build optimizers, like r.js, check for specific condition patterns
			// like the following:
			if (freeExports && !freeExports.nodeType) {
				if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
					freeModule.exports = he;
				} else { // in Narwhal or RingoJS v0.7.0-
					for (var key in he) {
						has(he, key) && (freeExports[key] = he[key]);
					}
				}
			} else { // in Rhino or a web browser
				root.he = he;
			}

		}(commonjsGlobal)); 
	} (he$3, he$3.exports));

	var heExports = he$3.exports;

	var lib$3 = {};

	var Parser$3 = {};

	var Tokenizer$6 = {};

	var decode_codepoint = {};

	var require$$0$2 = {"0":65533,"128":8364,"130":8218,"131":402,"132":8222,"133":8230,"134":8224,"135":8225,"136":710,"137":8240,"138":352,"139":8249,"140":338,"142":381,"145":8216,"146":8217,"147":8220,"148":8221,"149":8226,"150":8211,"151":8212,"152":732,"153":8482,"154":353,"155":8250,"156":339,"158":382,"159":376};

	var __importDefault$6 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(decode_codepoint, "__esModule", { value: true });
	var decode_json_1 = __importDefault$6(require$$0$2);
	// modified version of https://github.com/mathiasbynens/he/blob/master/src/he.js#L94-L119
	function decodeCodePoint(codePoint) {
	    if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
	        return "\uFFFD";
	    }
	    if (codePoint in decode_json_1.default) {
	        codePoint = decode_json_1.default[codePoint];
	    }
	    var output = "";
	    if (codePoint > 0xffff) {
	        codePoint -= 0x10000;
	        output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);
	        codePoint = 0xdc00 | (codePoint & 0x3ff);
	    }
	    output += String.fromCharCode(codePoint);
	    return output;
	}
	decode_codepoint.default = decodeCodePoint;

	var entities_json_ = {"Aacute":"Á","aacute":"á","Abreve":"Ă","abreve":"ă","ac":"∾","acd":"∿","acE":"∾̳","Acirc":"Â","acirc":"â","acute":"´","Acy":"А","acy":"а","AElig":"Æ","aelig":"æ","af":"⁡","Afr":"𝔄","afr":"𝔞","Agrave":"À","agrave":"à","alefsym":"ℵ","aleph":"ℵ","Alpha":"Α","alpha":"α","Amacr":"Ā","amacr":"ā","amalg":"⨿","amp":"&","AMP":"&","andand":"⩕","And":"⩓","and":"∧","andd":"⩜","andslope":"⩘","andv":"⩚","ang":"∠","ange":"⦤","angle":"∠","angmsdaa":"⦨","angmsdab":"⦩","angmsdac":"⦪","angmsdad":"⦫","angmsdae":"⦬","angmsdaf":"⦭","angmsdag":"⦮","angmsdah":"⦯","angmsd":"∡","angrt":"∟","angrtvb":"⊾","angrtvbd":"⦝","angsph":"∢","angst":"Å","angzarr":"⍼","Aogon":"Ą","aogon":"ą","Aopf":"𝔸","aopf":"𝕒","apacir":"⩯","ap":"≈","apE":"⩰","ape":"≊","apid":"≋","apos":"'","ApplyFunction":"⁡","approx":"≈","approxeq":"≊","Aring":"Å","aring":"å","Ascr":"𝒜","ascr":"𝒶","Assign":"≔","ast":"*","asymp":"≈","asympeq":"≍","Atilde":"Ã","atilde":"ã","Auml":"Ä","auml":"ä","awconint":"∳","awint":"⨑","backcong":"≌","backepsilon":"϶","backprime":"‵","backsim":"∽","backsimeq":"⋍","Backslash":"∖","Barv":"⫧","barvee":"⊽","barwed":"⌅","Barwed":"⌆","barwedge":"⌅","bbrk":"⎵","bbrktbrk":"⎶","bcong":"≌","Bcy":"Б","bcy":"б","bdquo":"„","becaus":"∵","because":"∵","Because":"∵","bemptyv":"⦰","bepsi":"϶","bernou":"ℬ","Bernoullis":"ℬ","Beta":"Β","beta":"β","beth":"ℶ","between":"≬","Bfr":"𝔅","bfr":"𝔟","bigcap":"⋂","bigcirc":"◯","bigcup":"⋃","bigodot":"⨀","bigoplus":"⨁","bigotimes":"⨂","bigsqcup":"⨆","bigstar":"★","bigtriangledown":"▽","bigtriangleup":"△","biguplus":"⨄","bigvee":"⋁","bigwedge":"⋀","bkarow":"⤍","blacklozenge":"⧫","blacksquare":"▪","blacktriangle":"▴","blacktriangledown":"▾","blacktriangleleft":"◂","blacktriangleright":"▸","blank":"␣","blk12":"▒","blk14":"░","blk34":"▓","block":"█","bne":"=⃥","bnequiv":"≡⃥","bNot":"⫭","bnot":"⌐","Bopf":"𝔹","bopf":"𝕓","bot":"⊥","bottom":"⊥","bowtie":"⋈","boxbox":"⧉","boxdl":"┐","boxdL":"╕","boxDl":"╖","boxDL":"╗","boxdr":"┌","boxdR":"╒","boxDr":"╓","boxDR":"╔","boxh":"─","boxH":"═","boxhd":"┬","boxHd":"╤","boxhD":"╥","boxHD":"╦","boxhu":"┴","boxHu":"╧","boxhU":"╨","boxHU":"╩","boxminus":"⊟","boxplus":"⊞","boxtimes":"⊠","boxul":"┘","boxuL":"╛","boxUl":"╜","boxUL":"╝","boxur":"└","boxuR":"╘","boxUr":"╙","boxUR":"╚","boxv":"│","boxV":"║","boxvh":"┼","boxvH":"╪","boxVh":"╫","boxVH":"╬","boxvl":"┤","boxvL":"╡","boxVl":"╢","boxVL":"╣","boxvr":"├","boxvR":"╞","boxVr":"╟","boxVR":"╠","bprime":"‵","breve":"˘","Breve":"˘","brvbar":"¦","bscr":"𝒷","Bscr":"ℬ","bsemi":"⁏","bsim":"∽","bsime":"⋍","bsolb":"⧅","bsol":"\\","bsolhsub":"⟈","bull":"•","bullet":"•","bump":"≎","bumpE":"⪮","bumpe":"≏","Bumpeq":"≎","bumpeq":"≏","Cacute":"Ć","cacute":"ć","capand":"⩄","capbrcup":"⩉","capcap":"⩋","cap":"∩","Cap":"⋒","capcup":"⩇","capdot":"⩀","CapitalDifferentialD":"ⅅ","caps":"∩︀","caret":"⁁","caron":"ˇ","Cayleys":"ℭ","ccaps":"⩍","Ccaron":"Č","ccaron":"č","Ccedil":"Ç","ccedil":"ç","Ccirc":"Ĉ","ccirc":"ĉ","Cconint":"∰","ccups":"⩌","ccupssm":"⩐","Cdot":"Ċ","cdot":"ċ","cedil":"¸","Cedilla":"¸","cemptyv":"⦲","cent":"¢","centerdot":"·","CenterDot":"·","cfr":"𝔠","Cfr":"ℭ","CHcy":"Ч","chcy":"ч","check":"✓","checkmark":"✓","Chi":"Χ","chi":"χ","circ":"ˆ","circeq":"≗","circlearrowleft":"↺","circlearrowright":"↻","circledast":"⊛","circledcirc":"⊚","circleddash":"⊝","CircleDot":"⊙","circledR":"®","circledS":"Ⓢ","CircleMinus":"⊖","CirclePlus":"⊕","CircleTimes":"⊗","cir":"○","cirE":"⧃","cire":"≗","cirfnint":"⨐","cirmid":"⫯","cirscir":"⧂","ClockwiseContourIntegral":"∲","CloseCurlyDoubleQuote":"”","CloseCurlyQuote":"’","clubs":"♣","clubsuit":"♣","colon":":","Colon":"∷","Colone":"⩴","colone":"≔","coloneq":"≔","comma":",","commat":"@","comp":"∁","compfn":"∘","complement":"∁","complexes":"ℂ","cong":"≅","congdot":"⩭","Congruent":"≡","conint":"∮","Conint":"∯","ContourIntegral":"∮","copf":"𝕔","Copf":"ℂ","coprod":"∐","Coproduct":"∐","copy":"©","COPY":"©","copysr":"℗","CounterClockwiseContourIntegral":"∳","crarr":"↵","cross":"✗","Cross":"⨯","Cscr":"𝒞","cscr":"𝒸","csub":"⫏","csube":"⫑","csup":"⫐","csupe":"⫒","ctdot":"⋯","cudarrl":"⤸","cudarrr":"⤵","cuepr":"⋞","cuesc":"⋟","cularr":"↶","cularrp":"⤽","cupbrcap":"⩈","cupcap":"⩆","CupCap":"≍","cup":"∪","Cup":"⋓","cupcup":"⩊","cupdot":"⊍","cupor":"⩅","cups":"∪︀","curarr":"↷","curarrm":"⤼","curlyeqprec":"⋞","curlyeqsucc":"⋟","curlyvee":"⋎","curlywedge":"⋏","curren":"¤","curvearrowleft":"↶","curvearrowright":"↷","cuvee":"⋎","cuwed":"⋏","cwconint":"∲","cwint":"∱","cylcty":"⌭","dagger":"†","Dagger":"‡","daleth":"ℸ","darr":"↓","Darr":"↡","dArr":"⇓","dash":"‐","Dashv":"⫤","dashv":"⊣","dbkarow":"⤏","dblac":"˝","Dcaron":"Ď","dcaron":"ď","Dcy":"Д","dcy":"д","ddagger":"‡","ddarr":"⇊","DD":"ⅅ","dd":"ⅆ","DDotrahd":"⤑","ddotseq":"⩷","deg":"°","Del":"∇","Delta":"Δ","delta":"δ","demptyv":"⦱","dfisht":"⥿","Dfr":"𝔇","dfr":"𝔡","dHar":"⥥","dharl":"⇃","dharr":"⇂","DiacriticalAcute":"´","DiacriticalDot":"˙","DiacriticalDoubleAcute":"˝","DiacriticalGrave":"`","DiacriticalTilde":"˜","diam":"⋄","diamond":"⋄","Diamond":"⋄","diamondsuit":"♦","diams":"♦","die":"¨","DifferentialD":"ⅆ","digamma":"ϝ","disin":"⋲","div":"÷","divide":"÷","divideontimes":"⋇","divonx":"⋇","DJcy":"Ђ","djcy":"ђ","dlcorn":"⌞","dlcrop":"⌍","dollar":"$","Dopf":"𝔻","dopf":"𝕕","Dot":"¨","dot":"˙","DotDot":"⃜","doteq":"≐","doteqdot":"≑","DotEqual":"≐","dotminus":"∸","dotplus":"∔","dotsquare":"⊡","doublebarwedge":"⌆","DoubleContourIntegral":"∯","DoubleDot":"¨","DoubleDownArrow":"⇓","DoubleLeftArrow":"⇐","DoubleLeftRightArrow":"⇔","DoubleLeftTee":"⫤","DoubleLongLeftArrow":"⟸","DoubleLongLeftRightArrow":"⟺","DoubleLongRightArrow":"⟹","DoubleRightArrow":"⇒","DoubleRightTee":"⊨","DoubleUpArrow":"⇑","DoubleUpDownArrow":"⇕","DoubleVerticalBar":"∥","DownArrowBar":"⤓","downarrow":"↓","DownArrow":"↓","Downarrow":"⇓","DownArrowUpArrow":"⇵","DownBreve":"̑","downdownarrows":"⇊","downharpoonleft":"⇃","downharpoonright":"⇂","DownLeftRightVector":"⥐","DownLeftTeeVector":"⥞","DownLeftVectorBar":"⥖","DownLeftVector":"↽","DownRightTeeVector":"⥟","DownRightVectorBar":"⥗","DownRightVector":"⇁","DownTeeArrow":"↧","DownTee":"⊤","drbkarow":"⤐","drcorn":"⌟","drcrop":"⌌","Dscr":"𝒟","dscr":"𝒹","DScy":"Ѕ","dscy":"ѕ","dsol":"⧶","Dstrok":"Đ","dstrok":"đ","dtdot":"⋱","dtri":"▿","dtrif":"▾","duarr":"⇵","duhar":"⥯","dwangle":"⦦","DZcy":"Џ","dzcy":"џ","dzigrarr":"⟿","Eacute":"É","eacute":"é","easter":"⩮","Ecaron":"Ě","ecaron":"ě","Ecirc":"Ê","ecirc":"ê","ecir":"≖","ecolon":"≕","Ecy":"Э","ecy":"э","eDDot":"⩷","Edot":"Ė","edot":"ė","eDot":"≑","ee":"ⅇ","efDot":"≒","Efr":"𝔈","efr":"𝔢","eg":"⪚","Egrave":"È","egrave":"è","egs":"⪖","egsdot":"⪘","el":"⪙","Element":"∈","elinters":"⏧","ell":"ℓ","els":"⪕","elsdot":"⪗","Emacr":"Ē","emacr":"ē","empty":"∅","emptyset":"∅","EmptySmallSquare":"◻","emptyv":"∅","EmptyVerySmallSquare":"▫","emsp13":" ","emsp14":" ","emsp":" ","ENG":"Ŋ","eng":"ŋ","ensp":" ","Eogon":"Ę","eogon":"ę","Eopf":"𝔼","eopf":"𝕖","epar":"⋕","eparsl":"⧣","eplus":"⩱","epsi":"ε","Epsilon":"Ε","epsilon":"ε","epsiv":"ϵ","eqcirc":"≖","eqcolon":"≕","eqsim":"≂","eqslantgtr":"⪖","eqslantless":"⪕","Equal":"⩵","equals":"=","EqualTilde":"≂","equest":"≟","Equilibrium":"⇌","equiv":"≡","equivDD":"⩸","eqvparsl":"⧥","erarr":"⥱","erDot":"≓","escr":"ℯ","Escr":"ℰ","esdot":"≐","Esim":"⩳","esim":"≂","Eta":"Η","eta":"η","ETH":"Ð","eth":"ð","Euml":"Ë","euml":"ë","euro":"€","excl":"!","exist":"∃","Exists":"∃","expectation":"ℰ","exponentiale":"ⅇ","ExponentialE":"ⅇ","fallingdotseq":"≒","Fcy":"Ф","fcy":"ф","female":"♀","ffilig":"ffi","fflig":"ff","ffllig":"ffl","Ffr":"𝔉","ffr":"𝔣","filig":"fi","FilledSmallSquare":"◼","FilledVerySmallSquare":"▪","fjlig":"fj","flat":"♭","fllig":"fl","fltns":"▱","fnof":"ƒ","Fopf":"𝔽","fopf":"𝕗","forall":"∀","ForAll":"∀","fork":"⋔","forkv":"⫙","Fouriertrf":"ℱ","fpartint":"⨍","frac12":"½","frac13":"⅓","frac14":"¼","frac15":"⅕","frac16":"⅙","frac18":"⅛","frac23":"⅔","frac25":"⅖","frac34":"¾","frac35":"⅗","frac38":"⅜","frac45":"⅘","frac56":"⅚","frac58":"⅝","frac78":"⅞","frasl":"⁄","frown":"⌢","fscr":"𝒻","Fscr":"ℱ","gacute":"ǵ","Gamma":"Γ","gamma":"γ","Gammad":"Ϝ","gammad":"ϝ","gap":"⪆","Gbreve":"Ğ","gbreve":"ğ","Gcedil":"Ģ","Gcirc":"Ĝ","gcirc":"ĝ","Gcy":"Г","gcy":"г","Gdot":"Ġ","gdot":"ġ","ge":"≥","gE":"≧","gEl":"⪌","gel":"⋛","geq":"≥","geqq":"≧","geqslant":"⩾","gescc":"⪩","ges":"⩾","gesdot":"⪀","gesdoto":"⪂","gesdotol":"⪄","gesl":"⋛︀","gesles":"⪔","Gfr":"𝔊","gfr":"𝔤","gg":"≫","Gg":"⋙","ggg":"⋙","gimel":"ℷ","GJcy":"Ѓ","gjcy":"ѓ","gla":"⪥","gl":"≷","glE":"⪒","glj":"⪤","gnap":"⪊","gnapprox":"⪊","gne":"⪈","gnE":"≩","gneq":"⪈","gneqq":"≩","gnsim":"⋧","Gopf":"𝔾","gopf":"𝕘","grave":"`","GreaterEqual":"≥","GreaterEqualLess":"⋛","GreaterFullEqual":"≧","GreaterGreater":"⪢","GreaterLess":"≷","GreaterSlantEqual":"⩾","GreaterTilde":"≳","Gscr":"𝒢","gscr":"ℊ","gsim":"≳","gsime":"⪎","gsiml":"⪐","gtcc":"⪧","gtcir":"⩺","gt":">","GT":">","Gt":"≫","gtdot":"⋗","gtlPar":"⦕","gtquest":"⩼","gtrapprox":"⪆","gtrarr":"⥸","gtrdot":"⋗","gtreqless":"⋛","gtreqqless":"⪌","gtrless":"≷","gtrsim":"≳","gvertneqq":"≩︀","gvnE":"≩︀","Hacek":"ˇ","hairsp":" ","half":"½","hamilt":"ℋ","HARDcy":"Ъ","hardcy":"ъ","harrcir":"⥈","harr":"↔","hArr":"⇔","harrw":"↭","Hat":"^","hbar":"ℏ","Hcirc":"Ĥ","hcirc":"ĥ","hearts":"♥","heartsuit":"♥","hellip":"…","hercon":"⊹","hfr":"𝔥","Hfr":"ℌ","HilbertSpace":"ℋ","hksearow":"⤥","hkswarow":"⤦","hoarr":"⇿","homtht":"∻","hookleftarrow":"↩","hookrightarrow":"↪","hopf":"𝕙","Hopf":"ℍ","horbar":"―","HorizontalLine":"─","hscr":"𝒽","Hscr":"ℋ","hslash":"ℏ","Hstrok":"Ħ","hstrok":"ħ","HumpDownHump":"≎","HumpEqual":"≏","hybull":"⁃","hyphen":"‐","Iacute":"Í","iacute":"í","ic":"⁣","Icirc":"Î","icirc":"î","Icy":"И","icy":"и","Idot":"İ","IEcy":"Е","iecy":"е","iexcl":"¡","iff":"⇔","ifr":"𝔦","Ifr":"ℑ","Igrave":"Ì","igrave":"ì","ii":"ⅈ","iiiint":"⨌","iiint":"∭","iinfin":"⧜","iiota":"℩","IJlig":"IJ","ijlig":"ij","Imacr":"Ī","imacr":"ī","image":"ℑ","ImaginaryI":"ⅈ","imagline":"ℐ","imagpart":"ℑ","imath":"ı","Im":"ℑ","imof":"⊷","imped":"Ƶ","Implies":"⇒","incare":"℅","in":"∈","infin":"∞","infintie":"⧝","inodot":"ı","intcal":"⊺","int":"∫","Int":"∬","integers":"ℤ","Integral":"∫","intercal":"⊺","Intersection":"⋂","intlarhk":"⨗","intprod":"⨼","InvisibleComma":"⁣","InvisibleTimes":"⁢","IOcy":"Ё","iocy":"ё","Iogon":"Į","iogon":"į","Iopf":"𝕀","iopf":"𝕚","Iota":"Ι","iota":"ι","iprod":"⨼","iquest":"¿","iscr":"𝒾","Iscr":"ℐ","isin":"∈","isindot":"⋵","isinE":"⋹","isins":"⋴","isinsv":"⋳","isinv":"∈","it":"⁢","Itilde":"Ĩ","itilde":"ĩ","Iukcy":"І","iukcy":"і","Iuml":"Ï","iuml":"ï","Jcirc":"Ĵ","jcirc":"ĵ","Jcy":"Й","jcy":"й","Jfr":"𝔍","jfr":"𝔧","jmath":"ȷ","Jopf":"𝕁","jopf":"𝕛","Jscr":"𝒥","jscr":"𝒿","Jsercy":"Ј","jsercy":"ј","Jukcy":"Є","jukcy":"є","Kappa":"Κ","kappa":"κ","kappav":"ϰ","Kcedil":"Ķ","kcedil":"ķ","Kcy":"К","kcy":"к","Kfr":"𝔎","kfr":"𝔨","kgreen":"ĸ","KHcy":"Х","khcy":"х","KJcy":"Ќ","kjcy":"ќ","Kopf":"𝕂","kopf":"𝕜","Kscr":"𝒦","kscr":"𝓀","lAarr":"⇚","Lacute":"Ĺ","lacute":"ĺ","laemptyv":"⦴","lagran":"ℒ","Lambda":"Λ","lambda":"λ","lang":"⟨","Lang":"⟪","langd":"⦑","langle":"⟨","lap":"⪅","Laplacetrf":"ℒ","laquo":"«","larrb":"⇤","larrbfs":"⤟","larr":"←","Larr":"↞","lArr":"⇐","larrfs":"⤝","larrhk":"↩","larrlp":"↫","larrpl":"⤹","larrsim":"⥳","larrtl":"↢","latail":"⤙","lAtail":"⤛","lat":"⪫","late":"⪭","lates":"⪭︀","lbarr":"⤌","lBarr":"⤎","lbbrk":"❲","lbrace":"{","lbrack":"[","lbrke":"⦋","lbrksld":"⦏","lbrkslu":"⦍","Lcaron":"Ľ","lcaron":"ľ","Lcedil":"Ļ","lcedil":"ļ","lceil":"⌈","lcub":"{","Lcy":"Л","lcy":"л","ldca":"⤶","ldquo":"“","ldquor":"„","ldrdhar":"⥧","ldrushar":"⥋","ldsh":"↲","le":"≤","lE":"≦","LeftAngleBracket":"⟨","LeftArrowBar":"⇤","leftarrow":"←","LeftArrow":"←","Leftarrow":"⇐","LeftArrowRightArrow":"⇆","leftarrowtail":"↢","LeftCeiling":"⌈","LeftDoubleBracket":"⟦","LeftDownTeeVector":"⥡","LeftDownVectorBar":"⥙","LeftDownVector":"⇃","LeftFloor":"⌊","leftharpoondown":"↽","leftharpoonup":"↼","leftleftarrows":"⇇","leftrightarrow":"↔","LeftRightArrow":"↔","Leftrightarrow":"⇔","leftrightarrows":"⇆","leftrightharpoons":"⇋","leftrightsquigarrow":"↭","LeftRightVector":"⥎","LeftTeeArrow":"↤","LeftTee":"⊣","LeftTeeVector":"⥚","leftthreetimes":"⋋","LeftTriangleBar":"⧏","LeftTriangle":"⊲","LeftTriangleEqual":"⊴","LeftUpDownVector":"⥑","LeftUpTeeVector":"⥠","LeftUpVectorBar":"⥘","LeftUpVector":"↿","LeftVectorBar":"⥒","LeftVector":"↼","lEg":"⪋","leg":"⋚","leq":"≤","leqq":"≦","leqslant":"⩽","lescc":"⪨","les":"⩽","lesdot":"⩿","lesdoto":"⪁","lesdotor":"⪃","lesg":"⋚︀","lesges":"⪓","lessapprox":"⪅","lessdot":"⋖","lesseqgtr":"⋚","lesseqqgtr":"⪋","LessEqualGreater":"⋚","LessFullEqual":"≦","LessGreater":"≶","lessgtr":"≶","LessLess":"⪡","lesssim":"≲","LessSlantEqual":"⩽","LessTilde":"≲","lfisht":"⥼","lfloor":"⌊","Lfr":"𝔏","lfr":"𝔩","lg":"≶","lgE":"⪑","lHar":"⥢","lhard":"↽","lharu":"↼","lharul":"⥪","lhblk":"▄","LJcy":"Љ","ljcy":"љ","llarr":"⇇","ll":"≪","Ll":"⋘","llcorner":"⌞","Lleftarrow":"⇚","llhard":"⥫","lltri":"◺","Lmidot":"Ŀ","lmidot":"ŀ","lmoustache":"⎰","lmoust":"⎰","lnap":"⪉","lnapprox":"⪉","lne":"⪇","lnE":"≨","lneq":"⪇","lneqq":"≨","lnsim":"⋦","loang":"⟬","loarr":"⇽","lobrk":"⟦","longleftarrow":"⟵","LongLeftArrow":"⟵","Longleftarrow":"⟸","longleftrightarrow":"⟷","LongLeftRightArrow":"⟷","Longleftrightarrow":"⟺","longmapsto":"⟼","longrightarrow":"⟶","LongRightArrow":"⟶","Longrightarrow":"⟹","looparrowleft":"↫","looparrowright":"↬","lopar":"⦅","Lopf":"𝕃","lopf":"𝕝","loplus":"⨭","lotimes":"⨴","lowast":"∗","lowbar":"_","LowerLeftArrow":"↙","LowerRightArrow":"↘","loz":"◊","lozenge":"◊","lozf":"⧫","lpar":"(","lparlt":"⦓","lrarr":"⇆","lrcorner":"⌟","lrhar":"⇋","lrhard":"⥭","lrm":"‎","lrtri":"⊿","lsaquo":"‹","lscr":"𝓁","Lscr":"ℒ","lsh":"↰","Lsh":"↰","lsim":"≲","lsime":"⪍","lsimg":"⪏","lsqb":"[","lsquo":"‘","lsquor":"‚","Lstrok":"Ł","lstrok":"ł","ltcc":"⪦","ltcir":"⩹","lt":"<","LT":"<","Lt":"≪","ltdot":"⋖","lthree":"⋋","ltimes":"⋉","ltlarr":"⥶","ltquest":"⩻","ltri":"◃","ltrie":"⊴","ltrif":"◂","ltrPar":"⦖","lurdshar":"⥊","luruhar":"⥦","lvertneqq":"≨︀","lvnE":"≨︀","macr":"¯","male":"♂","malt":"✠","maltese":"✠","Map":"⤅","map":"↦","mapsto":"↦","mapstodown":"↧","mapstoleft":"↤","mapstoup":"↥","marker":"▮","mcomma":"⨩","Mcy":"М","mcy":"м","mdash":"—","mDDot":"∺","measuredangle":"∡","MediumSpace":" ","Mellintrf":"ℳ","Mfr":"𝔐","mfr":"𝔪","mho":"℧","micro":"µ","midast":"*","midcir":"⫰","mid":"∣","middot":"·","minusb":"⊟","minus":"−","minusd":"∸","minusdu":"⨪","MinusPlus":"∓","mlcp":"⫛","mldr":"…","mnplus":"∓","models":"⊧","Mopf":"𝕄","mopf":"𝕞","mp":"∓","mscr":"𝓂","Mscr":"ℳ","mstpos":"∾","Mu":"Μ","mu":"μ","multimap":"⊸","mumap":"⊸","nabla":"∇","Nacute":"Ń","nacute":"ń","nang":"∠⃒","nap":"≉","napE":"⩰̸","napid":"≋̸","napos":"ʼn","napprox":"≉","natural":"♮","naturals":"ℕ","natur":"♮","nbsp":" ","nbump":"≎̸","nbumpe":"≏̸","ncap":"⩃","Ncaron":"Ň","ncaron":"ň","Ncedil":"Ņ","ncedil":"ņ","ncong":"≇","ncongdot":"⩭̸","ncup":"⩂","Ncy":"Н","ncy":"н","ndash":"–","nearhk":"⤤","nearr":"↗","neArr":"⇗","nearrow":"↗","ne":"≠","nedot":"≐̸","NegativeMediumSpace":"​","NegativeThickSpace":"​","NegativeThinSpace":"​","NegativeVeryThinSpace":"​","nequiv":"≢","nesear":"⤨","nesim":"≂̸","NestedGreaterGreater":"≫","NestedLessLess":"≪","NewLine":"\n","nexist":"∄","nexists":"∄","Nfr":"𝔑","nfr":"𝔫","ngE":"≧̸","nge":"≱","ngeq":"≱","ngeqq":"≧̸","ngeqslant":"⩾̸","nges":"⩾̸","nGg":"⋙̸","ngsim":"≵","nGt":"≫⃒","ngt":"≯","ngtr":"≯","nGtv":"≫̸","nharr":"↮","nhArr":"⇎","nhpar":"⫲","ni":"∋","nis":"⋼","nisd":"⋺","niv":"∋","NJcy":"Њ","njcy":"њ","nlarr":"↚","nlArr":"⇍","nldr":"‥","nlE":"≦̸","nle":"≰","nleftarrow":"↚","nLeftarrow":"⇍","nleftrightarrow":"↮","nLeftrightarrow":"⇎","nleq":"≰","nleqq":"≦̸","nleqslant":"⩽̸","nles":"⩽̸","nless":"≮","nLl":"⋘̸","nlsim":"≴","nLt":"≪⃒","nlt":"≮","nltri":"⋪","nltrie":"⋬","nLtv":"≪̸","nmid":"∤","NoBreak":"⁠","NonBreakingSpace":" ","nopf":"𝕟","Nopf":"ℕ","Not":"⫬","not":"¬","NotCongruent":"≢","NotCupCap":"≭","NotDoubleVerticalBar":"∦","NotElement":"∉","NotEqual":"≠","NotEqualTilde":"≂̸","NotExists":"∄","NotGreater":"≯","NotGreaterEqual":"≱","NotGreaterFullEqual":"≧̸","NotGreaterGreater":"≫̸","NotGreaterLess":"≹","NotGreaterSlantEqual":"⩾̸","NotGreaterTilde":"≵","NotHumpDownHump":"≎̸","NotHumpEqual":"≏̸","notin":"∉","notindot":"⋵̸","notinE":"⋹̸","notinva":"∉","notinvb":"⋷","notinvc":"⋶","NotLeftTriangleBar":"⧏̸","NotLeftTriangle":"⋪","NotLeftTriangleEqual":"⋬","NotLess":"≮","NotLessEqual":"≰","NotLessGreater":"≸","NotLessLess":"≪̸","NotLessSlantEqual":"⩽̸","NotLessTilde":"≴","NotNestedGreaterGreater":"⪢̸","NotNestedLessLess":"⪡̸","notni":"∌","notniva":"∌","notnivb":"⋾","notnivc":"⋽","NotPrecedes":"⊀","NotPrecedesEqual":"⪯̸","NotPrecedesSlantEqual":"⋠","NotReverseElement":"∌","NotRightTriangleBar":"⧐̸","NotRightTriangle":"⋫","NotRightTriangleEqual":"⋭","NotSquareSubset":"⊏̸","NotSquareSubsetEqual":"⋢","NotSquareSuperset":"⊐̸","NotSquareSupersetEqual":"⋣","NotSubset":"⊂⃒","NotSubsetEqual":"⊈","NotSucceeds":"⊁","NotSucceedsEqual":"⪰̸","NotSucceedsSlantEqual":"⋡","NotSucceedsTilde":"≿̸","NotSuperset":"⊃⃒","NotSupersetEqual":"⊉","NotTilde":"≁","NotTildeEqual":"≄","NotTildeFullEqual":"≇","NotTildeTilde":"≉","NotVerticalBar":"∤","nparallel":"∦","npar":"∦","nparsl":"⫽⃥","npart":"∂̸","npolint":"⨔","npr":"⊀","nprcue":"⋠","nprec":"⊀","npreceq":"⪯̸","npre":"⪯̸","nrarrc":"⤳̸","nrarr":"↛","nrArr":"⇏","nrarrw":"↝̸","nrightarrow":"↛","nRightarrow":"⇏","nrtri":"⋫","nrtrie":"⋭","nsc":"⊁","nsccue":"⋡","nsce":"⪰̸","Nscr":"𝒩","nscr":"𝓃","nshortmid":"∤","nshortparallel":"∦","nsim":"≁","nsime":"≄","nsimeq":"≄","nsmid":"∤","nspar":"∦","nsqsube":"⋢","nsqsupe":"⋣","nsub":"⊄","nsubE":"⫅̸","nsube":"⊈","nsubset":"⊂⃒","nsubseteq":"⊈","nsubseteqq":"⫅̸","nsucc":"⊁","nsucceq":"⪰̸","nsup":"⊅","nsupE":"⫆̸","nsupe":"⊉","nsupset":"⊃⃒","nsupseteq":"⊉","nsupseteqq":"⫆̸","ntgl":"≹","Ntilde":"Ñ","ntilde":"ñ","ntlg":"≸","ntriangleleft":"⋪","ntrianglelefteq":"⋬","ntriangleright":"⋫","ntrianglerighteq":"⋭","Nu":"Ν","nu":"ν","num":"#","numero":"№","numsp":" ","nvap":"≍⃒","nvdash":"⊬","nvDash":"⊭","nVdash":"⊮","nVDash":"⊯","nvge":"≥⃒","nvgt":">⃒","nvHarr":"⤄","nvinfin":"⧞","nvlArr":"⤂","nvle":"≤⃒","nvlt":"<⃒","nvltrie":"⊴⃒","nvrArr":"⤃","nvrtrie":"⊵⃒","nvsim":"∼⃒","nwarhk":"⤣","nwarr":"↖","nwArr":"⇖","nwarrow":"↖","nwnear":"⤧","Oacute":"Ó","oacute":"ó","oast":"⊛","Ocirc":"Ô","ocirc":"ô","ocir":"⊚","Ocy":"О","ocy":"о","odash":"⊝","Odblac":"Ő","odblac":"ő","odiv":"⨸","odot":"⊙","odsold":"⦼","OElig":"Œ","oelig":"œ","ofcir":"⦿","Ofr":"𝔒","ofr":"𝔬","ogon":"˛","Ograve":"Ò","ograve":"ò","ogt":"⧁","ohbar":"⦵","ohm":"Ω","oint":"∮","olarr":"↺","olcir":"⦾","olcross":"⦻","oline":"‾","olt":"⧀","Omacr":"Ō","omacr":"ō","Omega":"Ω","omega":"ω","Omicron":"Ο","omicron":"ο","omid":"⦶","ominus":"⊖","Oopf":"𝕆","oopf":"𝕠","opar":"⦷","OpenCurlyDoubleQuote":"“","OpenCurlyQuote":"‘","operp":"⦹","oplus":"⊕","orarr":"↻","Or":"⩔","or":"∨","ord":"⩝","order":"ℴ","orderof":"ℴ","ordf":"ª","ordm":"º","origof":"⊶","oror":"⩖","orslope":"⩗","orv":"⩛","oS":"Ⓢ","Oscr":"𝒪","oscr":"ℴ","Oslash":"Ø","oslash":"ø","osol":"⊘","Otilde":"Õ","otilde":"õ","otimesas":"⨶","Otimes":"⨷","otimes":"⊗","Ouml":"Ö","ouml":"ö","ovbar":"⌽","OverBar":"‾","OverBrace":"⏞","OverBracket":"⎴","OverParenthesis":"⏜","para":"¶","parallel":"∥","par":"∥","parsim":"⫳","parsl":"⫽","part":"∂","PartialD":"∂","Pcy":"П","pcy":"п","percnt":"%","period":".","permil":"‰","perp":"⊥","pertenk":"‱","Pfr":"𝔓","pfr":"𝔭","Phi":"Φ","phi":"φ","phiv":"ϕ","phmmat":"ℳ","phone":"☎","Pi":"Π","pi":"π","pitchfork":"⋔","piv":"ϖ","planck":"ℏ","planckh":"ℎ","plankv":"ℏ","plusacir":"⨣","plusb":"⊞","pluscir":"⨢","plus":"+","plusdo":"∔","plusdu":"⨥","pluse":"⩲","PlusMinus":"±","plusmn":"±","plussim":"⨦","plustwo":"⨧","pm":"±","Poincareplane":"ℌ","pointint":"⨕","popf":"𝕡","Popf":"ℙ","pound":"£","prap":"⪷","Pr":"⪻","pr":"≺","prcue":"≼","precapprox":"⪷","prec":"≺","preccurlyeq":"≼","Precedes":"≺","PrecedesEqual":"⪯","PrecedesSlantEqual":"≼","PrecedesTilde":"≾","preceq":"⪯","precnapprox":"⪹","precneqq":"⪵","precnsim":"⋨","pre":"⪯","prE":"⪳","precsim":"≾","prime":"′","Prime":"″","primes":"ℙ","prnap":"⪹","prnE":"⪵","prnsim":"⋨","prod":"∏","Product":"∏","profalar":"⌮","profline":"⌒","profsurf":"⌓","prop":"∝","Proportional":"∝","Proportion":"∷","propto":"∝","prsim":"≾","prurel":"⊰","Pscr":"𝒫","pscr":"𝓅","Psi":"Ψ","psi":"ψ","puncsp":" ","Qfr":"𝔔","qfr":"𝔮","qint":"⨌","qopf":"𝕢","Qopf":"ℚ","qprime":"⁗","Qscr":"𝒬","qscr":"𝓆","quaternions":"ℍ","quatint":"⨖","quest":"?","questeq":"≟","quot":"\"","QUOT":"\"","rAarr":"⇛","race":"∽̱","Racute":"Ŕ","racute":"ŕ","radic":"√","raemptyv":"⦳","rang":"⟩","Rang":"⟫","rangd":"⦒","range":"⦥","rangle":"⟩","raquo":"»","rarrap":"⥵","rarrb":"⇥","rarrbfs":"⤠","rarrc":"⤳","rarr":"→","Rarr":"↠","rArr":"⇒","rarrfs":"⤞","rarrhk":"↪","rarrlp":"↬","rarrpl":"⥅","rarrsim":"⥴","Rarrtl":"⤖","rarrtl":"↣","rarrw":"↝","ratail":"⤚","rAtail":"⤜","ratio":"∶","rationals":"ℚ","rbarr":"⤍","rBarr":"⤏","RBarr":"⤐","rbbrk":"❳","rbrace":"}","rbrack":"]","rbrke":"⦌","rbrksld":"⦎","rbrkslu":"⦐","Rcaron":"Ř","rcaron":"ř","Rcedil":"Ŗ","rcedil":"ŗ","rceil":"⌉","rcub":"}","Rcy":"Р","rcy":"р","rdca":"⤷","rdldhar":"⥩","rdquo":"”","rdquor":"”","rdsh":"↳","real":"ℜ","realine":"ℛ","realpart":"ℜ","reals":"ℝ","Re":"ℜ","rect":"▭","reg":"®","REG":"®","ReverseElement":"∋","ReverseEquilibrium":"⇋","ReverseUpEquilibrium":"⥯","rfisht":"⥽","rfloor":"⌋","rfr":"𝔯","Rfr":"ℜ","rHar":"⥤","rhard":"⇁","rharu":"⇀","rharul":"⥬","Rho":"Ρ","rho":"ρ","rhov":"ϱ","RightAngleBracket":"⟩","RightArrowBar":"⇥","rightarrow":"→","RightArrow":"→","Rightarrow":"⇒","RightArrowLeftArrow":"⇄","rightarrowtail":"↣","RightCeiling":"⌉","RightDoubleBracket":"⟧","RightDownTeeVector":"⥝","RightDownVectorBar":"⥕","RightDownVector":"⇂","RightFloor":"⌋","rightharpoondown":"⇁","rightharpoonup":"⇀","rightleftarrows":"⇄","rightleftharpoons":"⇌","rightrightarrows":"⇉","rightsquigarrow":"↝","RightTeeArrow":"↦","RightTee":"⊢","RightTeeVector":"⥛","rightthreetimes":"⋌","RightTriangleBar":"⧐","RightTriangle":"⊳","RightTriangleEqual":"⊵","RightUpDownVector":"⥏","RightUpTeeVector":"⥜","RightUpVectorBar":"⥔","RightUpVector":"↾","RightVectorBar":"⥓","RightVector":"⇀","ring":"˚","risingdotseq":"≓","rlarr":"⇄","rlhar":"⇌","rlm":"‏","rmoustache":"⎱","rmoust":"⎱","rnmid":"⫮","roang":"⟭","roarr":"⇾","robrk":"⟧","ropar":"⦆","ropf":"𝕣","Ropf":"ℝ","roplus":"⨮","rotimes":"⨵","RoundImplies":"⥰","rpar":")","rpargt":"⦔","rppolint":"⨒","rrarr":"⇉","Rrightarrow":"⇛","rsaquo":"›","rscr":"𝓇","Rscr":"ℛ","rsh":"↱","Rsh":"↱","rsqb":"]","rsquo":"’","rsquor":"’","rthree":"⋌","rtimes":"⋊","rtri":"▹","rtrie":"⊵","rtrif":"▸","rtriltri":"⧎","RuleDelayed":"⧴","ruluhar":"⥨","rx":"℞","Sacute":"Ś","sacute":"ś","sbquo":"‚","scap":"⪸","Scaron":"Š","scaron":"š","Sc":"⪼","sc":"≻","sccue":"≽","sce":"⪰","scE":"⪴","Scedil":"Ş","scedil":"ş","Scirc":"Ŝ","scirc":"ŝ","scnap":"⪺","scnE":"⪶","scnsim":"⋩","scpolint":"⨓","scsim":"≿","Scy":"С","scy":"с","sdotb":"⊡","sdot":"⋅","sdote":"⩦","searhk":"⤥","searr":"↘","seArr":"⇘","searrow":"↘","sect":"§","semi":";","seswar":"⤩","setminus":"∖","setmn":"∖","sext":"✶","Sfr":"𝔖","sfr":"𝔰","sfrown":"⌢","sharp":"♯","SHCHcy":"Щ","shchcy":"щ","SHcy":"Ш","shcy":"ш","ShortDownArrow":"↓","ShortLeftArrow":"←","shortmid":"∣","shortparallel":"∥","ShortRightArrow":"→","ShortUpArrow":"↑","shy":"­","Sigma":"Σ","sigma":"σ","sigmaf":"ς","sigmav":"ς","sim":"∼","simdot":"⩪","sime":"≃","simeq":"≃","simg":"⪞","simgE":"⪠","siml":"⪝","simlE":"⪟","simne":"≆","simplus":"⨤","simrarr":"⥲","slarr":"←","SmallCircle":"∘","smallsetminus":"∖","smashp":"⨳","smeparsl":"⧤","smid":"∣","smile":"⌣","smt":"⪪","smte":"⪬","smtes":"⪬︀","SOFTcy":"Ь","softcy":"ь","solbar":"⌿","solb":"⧄","sol":"/","Sopf":"𝕊","sopf":"𝕤","spades":"♠","spadesuit":"♠","spar":"∥","sqcap":"⊓","sqcaps":"⊓︀","sqcup":"⊔","sqcups":"⊔︀","Sqrt":"√","sqsub":"⊏","sqsube":"⊑","sqsubset":"⊏","sqsubseteq":"⊑","sqsup":"⊐","sqsupe":"⊒","sqsupset":"⊐","sqsupseteq":"⊒","square":"□","Square":"□","SquareIntersection":"⊓","SquareSubset":"⊏","SquareSubsetEqual":"⊑","SquareSuperset":"⊐","SquareSupersetEqual":"⊒","SquareUnion":"⊔","squarf":"▪","squ":"□","squf":"▪","srarr":"→","Sscr":"𝒮","sscr":"𝓈","ssetmn":"∖","ssmile":"⌣","sstarf":"⋆","Star":"⋆","star":"☆","starf":"★","straightepsilon":"ϵ","straightphi":"ϕ","strns":"¯","sub":"⊂","Sub":"⋐","subdot":"⪽","subE":"⫅","sube":"⊆","subedot":"⫃","submult":"⫁","subnE":"⫋","subne":"⊊","subplus":"⪿","subrarr":"⥹","subset":"⊂","Subset":"⋐","subseteq":"⊆","subseteqq":"⫅","SubsetEqual":"⊆","subsetneq":"⊊","subsetneqq":"⫋","subsim":"⫇","subsub":"⫕","subsup":"⫓","succapprox":"⪸","succ":"≻","succcurlyeq":"≽","Succeeds":"≻","SucceedsEqual":"⪰","SucceedsSlantEqual":"≽","SucceedsTilde":"≿","succeq":"⪰","succnapprox":"⪺","succneqq":"⪶","succnsim":"⋩","succsim":"≿","SuchThat":"∋","sum":"∑","Sum":"∑","sung":"♪","sup1":"¹","sup2":"²","sup3":"³","sup":"⊃","Sup":"⋑","supdot":"⪾","supdsub":"⫘","supE":"⫆","supe":"⊇","supedot":"⫄","Superset":"⊃","SupersetEqual":"⊇","suphsol":"⟉","suphsub":"⫗","suplarr":"⥻","supmult":"⫂","supnE":"⫌","supne":"⊋","supplus":"⫀","supset":"⊃","Supset":"⋑","supseteq":"⊇","supseteqq":"⫆","supsetneq":"⊋","supsetneqq":"⫌","supsim":"⫈","supsub":"⫔","supsup":"⫖","swarhk":"⤦","swarr":"↙","swArr":"⇙","swarrow":"↙","swnwar":"⤪","szlig":"ß","Tab":"\t","target":"⌖","Tau":"Τ","tau":"τ","tbrk":"⎴","Tcaron":"Ť","tcaron":"ť","Tcedil":"Ţ","tcedil":"ţ","Tcy":"Т","tcy":"т","tdot":"⃛","telrec":"⌕","Tfr":"𝔗","tfr":"𝔱","there4":"∴","therefore":"∴","Therefore":"∴","Theta":"Θ","theta":"θ","thetasym":"ϑ","thetav":"ϑ","thickapprox":"≈","thicksim":"∼","ThickSpace":"  ","ThinSpace":" ","thinsp":" ","thkap":"≈","thksim":"∼","THORN":"Þ","thorn":"þ","tilde":"˜","Tilde":"∼","TildeEqual":"≃","TildeFullEqual":"≅","TildeTilde":"≈","timesbar":"⨱","timesb":"⊠","times":"×","timesd":"⨰","tint":"∭","toea":"⤨","topbot":"⌶","topcir":"⫱","top":"⊤","Topf":"𝕋","topf":"𝕥","topfork":"⫚","tosa":"⤩","tprime":"‴","trade":"™","TRADE":"™","triangle":"▵","triangledown":"▿","triangleleft":"◃","trianglelefteq":"⊴","triangleq":"≜","triangleright":"▹","trianglerighteq":"⊵","tridot":"◬","trie":"≜","triminus":"⨺","TripleDot":"⃛","triplus":"⨹","trisb":"⧍","tritime":"⨻","trpezium":"⏢","Tscr":"𝒯","tscr":"𝓉","TScy":"Ц","tscy":"ц","TSHcy":"Ћ","tshcy":"ћ","Tstrok":"Ŧ","tstrok":"ŧ","twixt":"≬","twoheadleftarrow":"↞","twoheadrightarrow":"↠","Uacute":"Ú","uacute":"ú","uarr":"↑","Uarr":"↟","uArr":"⇑","Uarrocir":"⥉","Ubrcy":"Ў","ubrcy":"ў","Ubreve":"Ŭ","ubreve":"ŭ","Ucirc":"Û","ucirc":"û","Ucy":"У","ucy":"у","udarr":"⇅","Udblac":"Ű","udblac":"ű","udhar":"⥮","ufisht":"⥾","Ufr":"𝔘","ufr":"𝔲","Ugrave":"Ù","ugrave":"ù","uHar":"⥣","uharl":"↿","uharr":"↾","uhblk":"▀","ulcorn":"⌜","ulcorner":"⌜","ulcrop":"⌏","ultri":"◸","Umacr":"Ū","umacr":"ū","uml":"¨","UnderBar":"_","UnderBrace":"⏟","UnderBracket":"⎵","UnderParenthesis":"⏝","Union":"⋃","UnionPlus":"⊎","Uogon":"Ų","uogon":"ų","Uopf":"𝕌","uopf":"𝕦","UpArrowBar":"⤒","uparrow":"↑","UpArrow":"↑","Uparrow":"⇑","UpArrowDownArrow":"⇅","updownarrow":"↕","UpDownArrow":"↕","Updownarrow":"⇕","UpEquilibrium":"⥮","upharpoonleft":"↿","upharpoonright":"↾","uplus":"⊎","UpperLeftArrow":"↖","UpperRightArrow":"↗","upsi":"υ","Upsi":"ϒ","upsih":"ϒ","Upsilon":"Υ","upsilon":"υ","UpTeeArrow":"↥","UpTee":"⊥","upuparrows":"⇈","urcorn":"⌝","urcorner":"⌝","urcrop":"⌎","Uring":"Ů","uring":"ů","urtri":"◹","Uscr":"𝒰","uscr":"𝓊","utdot":"⋰","Utilde":"Ũ","utilde":"ũ","utri":"▵","utrif":"▴","uuarr":"⇈","Uuml":"Ü","uuml":"ü","uwangle":"⦧","vangrt":"⦜","varepsilon":"ϵ","varkappa":"ϰ","varnothing":"∅","varphi":"ϕ","varpi":"ϖ","varpropto":"∝","varr":"↕","vArr":"⇕","varrho":"ϱ","varsigma":"ς","varsubsetneq":"⊊︀","varsubsetneqq":"⫋︀","varsupsetneq":"⊋︀","varsupsetneqq":"⫌︀","vartheta":"ϑ","vartriangleleft":"⊲","vartriangleright":"⊳","vBar":"⫨","Vbar":"⫫","vBarv":"⫩","Vcy":"В","vcy":"в","vdash":"⊢","vDash":"⊨","Vdash":"⊩","VDash":"⊫","Vdashl":"⫦","veebar":"⊻","vee":"∨","Vee":"⋁","veeeq":"≚","vellip":"⋮","verbar":"|","Verbar":"‖","vert":"|","Vert":"‖","VerticalBar":"∣","VerticalLine":"|","VerticalSeparator":"❘","VerticalTilde":"≀","VeryThinSpace":" ","Vfr":"𝔙","vfr":"𝔳","vltri":"⊲","vnsub":"⊂⃒","vnsup":"⊃⃒","Vopf":"𝕍","vopf":"𝕧","vprop":"∝","vrtri":"⊳","Vscr":"𝒱","vscr":"𝓋","vsubnE":"⫋︀","vsubne":"⊊︀","vsupnE":"⫌︀","vsupne":"⊋︀","Vvdash":"⊪","vzigzag":"⦚","Wcirc":"Ŵ","wcirc":"ŵ","wedbar":"⩟","wedge":"∧","Wedge":"⋀","wedgeq":"≙","weierp":"℘","Wfr":"𝔚","wfr":"𝔴","Wopf":"𝕎","wopf":"𝕨","wp":"℘","wr":"≀","wreath":"≀","Wscr":"𝒲","wscr":"𝓌","xcap":"⋂","xcirc":"◯","xcup":"⋃","xdtri":"▽","Xfr":"𝔛","xfr":"𝔵","xharr":"⟷","xhArr":"⟺","Xi":"Ξ","xi":"ξ","xlarr":"⟵","xlArr":"⟸","xmap":"⟼","xnis":"⋻","xodot":"⨀","Xopf":"𝕏","xopf":"𝕩","xoplus":"⨁","xotime":"⨂","xrarr":"⟶","xrArr":"⟹","Xscr":"𝒳","xscr":"𝓍","xsqcup":"⨆","xuplus":"⨄","xutri":"△","xvee":"⋁","xwedge":"⋀","Yacute":"Ý","yacute":"ý","YAcy":"Я","yacy":"я","Ycirc":"Ŷ","ycirc":"ŷ","Ycy":"Ы","ycy":"ы","yen":"¥","Yfr":"𝔜","yfr":"𝔶","YIcy":"Ї","yicy":"ї","Yopf":"𝕐","yopf":"𝕪","Yscr":"𝒴","yscr":"𝓎","YUcy":"Ю","yucy":"ю","yuml":"ÿ","Yuml":"Ÿ","Zacute":"Ź","zacute":"ź","Zcaron":"Ž","zcaron":"ž","Zcy":"З","zcy":"з","Zdot":"Ż","zdot":"ż","zeetrf":"ℨ","ZeroWidthSpace":"​","Zeta":"Ζ","zeta":"ζ","zfr":"𝔷","Zfr":"ℨ","ZHcy":"Ж","zhcy":"ж","zigrarr":"⇝","zopf":"𝕫","Zopf":"ℤ","Zscr":"𝒵","zscr":"𝓏","zwj":"‍","zwnj":"‌"};

	var entities_json_$1 = /*#__PURE__*/Object.freeze({
		__proto__: null,
		default: entities_json_
	});

	var require$$1$2 = /*@__PURE__*/getAugmentedNamespace(entities_json_$1);

	var legacy_json_ = {"Aacute":"Á","aacute":"á","Acirc":"Â","acirc":"â","acute":"´","AElig":"Æ","aelig":"æ","Agrave":"À","agrave":"à","amp":"&","AMP":"&","Aring":"Å","aring":"å","Atilde":"Ã","atilde":"ã","Auml":"Ä","auml":"ä","brvbar":"¦","Ccedil":"Ç","ccedil":"ç","cedil":"¸","cent":"¢","copy":"©","COPY":"©","curren":"¤","deg":"°","divide":"÷","Eacute":"É","eacute":"é","Ecirc":"Ê","ecirc":"ê","Egrave":"È","egrave":"è","ETH":"Ð","eth":"ð","Euml":"Ë","euml":"ë","frac12":"½","frac14":"¼","frac34":"¾","gt":">","GT":">","Iacute":"Í","iacute":"í","Icirc":"Î","icirc":"î","iexcl":"¡","Igrave":"Ì","igrave":"ì","iquest":"¿","Iuml":"Ï","iuml":"ï","laquo":"«","lt":"<","LT":"<","macr":"¯","micro":"µ","middot":"·","nbsp":" ","not":"¬","Ntilde":"Ñ","ntilde":"ñ","Oacute":"Ó","oacute":"ó","Ocirc":"Ô","ocirc":"ô","Ograve":"Ò","ograve":"ò","ordf":"ª","ordm":"º","Oslash":"Ø","oslash":"ø","Otilde":"Õ","otilde":"õ","Ouml":"Ö","ouml":"ö","para":"¶","plusmn":"±","pound":"£","quot":"\"","QUOT":"\"","raquo":"»","reg":"®","REG":"®","sect":"§","shy":"­","sup1":"¹","sup2":"²","sup3":"³","szlig":"ß","THORN":"Þ","thorn":"þ","times":"×","Uacute":"Ú","uacute":"ú","Ucirc":"Û","ucirc":"û","Ugrave":"Ù","ugrave":"ù","uml":"¨","Uuml":"Ü","uuml":"ü","Yacute":"Ý","yacute":"ý","yen":"¥","yuml":"ÿ"};

	var legacy_json_$1 = /*#__PURE__*/Object.freeze({
		__proto__: null,
		default: legacy_json_
	});

	var require$$2 = /*@__PURE__*/getAugmentedNamespace(legacy_json_$1);

	var xml_json_ = {"amp":"&","apos":"'","gt":">","lt":"<","quot":"\""};

	var xml_json_$1 = /*#__PURE__*/Object.freeze({
		__proto__: null,
		default: xml_json_
	});

	var require$$3 = /*@__PURE__*/getAugmentedNamespace(xml_json_$1);

	var __importDefault$5 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(Tokenizer$6, "__esModule", { value: true });
	var decode_codepoint_1$1 = __importDefault$5(decode_codepoint);
	var entities_json_1$2 = __importDefault$5(require$$1$2);
	var legacy_json_1$1 = __importDefault$5(require$$2);
	var xml_json_1$2 = __importDefault$5(require$$3);
	function whitespace$1(c) {
	    return c === " " || c === "\n" || c === "\t" || c === "\f" || c === "\r";
	}
	function isASCIIAlpha(c) {
	    return (c >= "a" && c <= "z") || (c >= "A" && c <= "Z");
	}
	function ifElseState(upper, SUCCESS, FAILURE) {
	    var lower = upper.toLowerCase();
	    if (upper === lower) {
	        return function (t, c) {
	            if (c === lower) {
	                t._state = SUCCESS;
	            }
	            else {
	                t._state = FAILURE;
	                t._index--;
	            }
	        };
	    }
	    return function (t, c) {
	        if (c === lower || c === upper) {
	            t._state = SUCCESS;
	        }
	        else {
	            t._state = FAILURE;
	            t._index--;
	        }
	    };
	}
	function consumeSpecialNameChar(upper, NEXT_STATE) {
	    var lower = upper.toLowerCase();
	    return function (t, c) {
	        if (c === lower || c === upper) {
	            t._state = NEXT_STATE;
	        }
	        else {
	            t._state = 3 /* InTagName */;
	            t._index--; // Consume the token again
	        }
	    };
	}
	var stateBeforeCdata1 = ifElseState("C", 24 /* BeforeCdata2 */, 16 /* InDeclaration */);
	var stateBeforeCdata2 = ifElseState("D", 25 /* BeforeCdata3 */, 16 /* InDeclaration */);
	var stateBeforeCdata3 = ifElseState("A", 26 /* BeforeCdata4 */, 16 /* InDeclaration */);
	var stateBeforeCdata4 = ifElseState("T", 27 /* BeforeCdata5 */, 16 /* InDeclaration */);
	var stateBeforeCdata5 = ifElseState("A", 28 /* BeforeCdata6 */, 16 /* InDeclaration */);
	var stateBeforeScript1 = consumeSpecialNameChar("R", 35 /* BeforeScript2 */);
	var stateBeforeScript2 = consumeSpecialNameChar("I", 36 /* BeforeScript3 */);
	var stateBeforeScript3 = consumeSpecialNameChar("P", 37 /* BeforeScript4 */);
	var stateBeforeScript4 = consumeSpecialNameChar("T", 38 /* BeforeScript5 */);
	var stateAfterScript1 = ifElseState("R", 40 /* AfterScript2 */, 1 /* Text */);
	var stateAfterScript2 = ifElseState("I", 41 /* AfterScript3 */, 1 /* Text */);
	var stateAfterScript3 = ifElseState("P", 42 /* AfterScript4 */, 1 /* Text */);
	var stateAfterScript4 = ifElseState("T", 43 /* AfterScript5 */, 1 /* Text */);
	var stateBeforeStyle1 = consumeSpecialNameChar("Y", 45 /* BeforeStyle2 */);
	var stateBeforeStyle2 = consumeSpecialNameChar("L", 46 /* BeforeStyle3 */);
	var stateBeforeStyle3 = consumeSpecialNameChar("E", 47 /* BeforeStyle4 */);
	var stateAfterStyle1 = ifElseState("Y", 49 /* AfterStyle2 */, 1 /* Text */);
	var stateAfterStyle2 = ifElseState("L", 50 /* AfterStyle3 */, 1 /* Text */);
	var stateAfterStyle3 = ifElseState("E", 51 /* AfterStyle4 */, 1 /* Text */);
	var stateBeforeSpecialT = consumeSpecialNameChar("I", 54 /* BeforeTitle1 */);
	var stateBeforeTitle1 = consumeSpecialNameChar("T", 55 /* BeforeTitle2 */);
	var stateBeforeTitle2 = consumeSpecialNameChar("L", 56 /* BeforeTitle3 */);
	var stateBeforeTitle3 = consumeSpecialNameChar("E", 57 /* BeforeTitle4 */);
	var stateAfterSpecialTEnd = ifElseState("I", 58 /* AfterTitle1 */, 1 /* Text */);
	var stateAfterTitle1 = ifElseState("T", 59 /* AfterTitle2 */, 1 /* Text */);
	var stateAfterTitle2 = ifElseState("L", 60 /* AfterTitle3 */, 1 /* Text */);
	var stateAfterTitle3 = ifElseState("E", 61 /* AfterTitle4 */, 1 /* Text */);
	var stateBeforeEntity = ifElseState("#", 63 /* BeforeNumericEntity */, 64 /* InNamedEntity */);
	var stateBeforeNumericEntity = ifElseState("X", 66 /* InHexEntity */, 65 /* InNumericEntity */);
	var Tokenizer$5 = /** @class */ (function () {
	    function Tokenizer(options, cbs) {
	        var _a;
	        /** The current state the tokenizer is in. */
	        this._state = 1 /* Text */;
	        /** The read buffer. */
	        this.buffer = "";
	        /** The beginning of the section that is currently being read. */
	        this.sectionStart = 0;
	        /** The index within the buffer that we are currently looking at. */
	        this._index = 0;
	        /**
	         * Data that has already been processed will be removed from the buffer occasionally.
	         * `_bufferOffset` keeps track of how many characters have been removed, to make sure position information is accurate.
	         */
	        this.bufferOffset = 0;
	        /** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */
	        this.baseState = 1 /* Text */;
	        /** For special parsing behavior inside of script and style tags. */
	        this.special = 1 /* None */;
	        /** Indicates whether the tokenizer has been paused. */
	        this.running = true;
	        /** Indicates whether the tokenizer has finished running / `.end` has been called. */
	        this.ended = false;
	        this.cbs = cbs;
	        this.xmlMode = !!(options === null || options === void 0 ? void 0 : options.xmlMode);
	        this.decodeEntities = (_a = options === null || options === void 0 ? void 0 : options.decodeEntities) !== null && _a !== void 0 ? _a : true;
	    }
	    Tokenizer.prototype.reset = function () {
	        this._state = 1 /* Text */;
	        this.buffer = "";
	        this.sectionStart = 0;
	        this._index = 0;
	        this.bufferOffset = 0;
	        this.baseState = 1 /* Text */;
	        this.special = 1 /* None */;
	        this.running = true;
	        this.ended = false;
	    };
	    Tokenizer.prototype.write = function (chunk) {
	        if (this.ended)
	            this.cbs.onerror(Error(".write() after done!"));
	        this.buffer += chunk;
	        this.parse();
	    };
	    Tokenizer.prototype.end = function (chunk) {
	        if (this.ended)
	            this.cbs.onerror(Error(".end() after done!"));
	        if (chunk)
	            this.write(chunk);
	        this.ended = true;
	        if (this.running)
	            this.finish();
	    };
	    Tokenizer.prototype.pause = function () {
	        this.running = false;
	    };
	    Tokenizer.prototype.resume = function () {
	        this.running = true;
	        if (this._index < this.buffer.length) {
	            this.parse();
	        }
	        if (this.ended) {
	            this.finish();
	        }
	    };
	    /**
	     * The current index within all of the written data.
	     */
	    Tokenizer.prototype.getAbsoluteIndex = function () {
	        return this.bufferOffset + this._index;
	    };
	    Tokenizer.prototype.stateText = function (c) {
	        if (c === "<") {
	            if (this._index > this.sectionStart) {
	                this.cbs.ontext(this.getSection());
	            }
	            this._state = 2 /* BeforeTagName */;
	            this.sectionStart = this._index;
	        }
	        else if (this.decodeEntities &&
	            c === "&" &&
	            (this.special === 1 /* None */ || this.special === 4 /* Title */)) {
	            if (this._index > this.sectionStart) {
	                this.cbs.ontext(this.getSection());
	            }
	            this.baseState = 1 /* Text */;
	            this._state = 62 /* BeforeEntity */;
	            this.sectionStart = this._index;
	        }
	    };
	    /**
	     * HTML only allows ASCII alpha characters (a-z and A-Z) at the beginning of a tag name.
	     *
	     * XML allows a lot more characters here (@see https://www.w3.org/TR/REC-xml/#NT-NameStartChar).
	     * We allow anything that wouldn't end the tag.
	     */
	    Tokenizer.prototype.isTagStartChar = function (c) {
	        return (isASCIIAlpha(c) ||
	            (this.xmlMode && !whitespace$1(c) && c !== "/" && c !== ">"));
	    };
	    Tokenizer.prototype.stateBeforeTagName = function (c) {
	        if (c === "/") {
	            this._state = 5 /* BeforeClosingTagName */;
	        }
	        else if (c === "<") {
	            this.cbs.ontext(this.getSection());
	            this.sectionStart = this._index;
	        }
	        else if (c === ">" ||
	            this.special !== 1 /* None */ ||
	            whitespace$1(c)) {
	            this._state = 1 /* Text */;
	        }
	        else if (c === "!") {
	            this._state = 15 /* BeforeDeclaration */;
	            this.sectionStart = this._index + 1;
	        }
	        else if (c === "?") {
	            this._state = 17 /* InProcessingInstruction */;
	            this.sectionStart = this._index + 1;
	        }
	        else if (!this.isTagStartChar(c)) {
	            this._state = 1 /* Text */;
	        }
	        else {
	            this._state =
	                !this.xmlMode && (c === "s" || c === "S")
	                    ? 32 /* BeforeSpecialS */
	                    : !this.xmlMode && (c === "t" || c === "T")
	                        ? 52 /* BeforeSpecialT */
	                        : 3 /* InTagName */;
	            this.sectionStart = this._index;
	        }
	    };
	    Tokenizer.prototype.stateInTagName = function (c) {
	        if (c === "/" || c === ">" || whitespace$1(c)) {
	            this.emitToken("onopentagname");
	            this._state = 8 /* BeforeAttributeName */;
	            this._index--;
	        }
	    };
	    Tokenizer.prototype.stateBeforeClosingTagName = function (c) {
	        if (whitespace$1(c)) ;
	        else if (c === ">") {
	            this._state = 1 /* Text */;
	        }
	        else if (this.special !== 1 /* None */) {
	            if (this.special !== 4 /* Title */ && (c === "s" || c === "S")) {
	                this._state = 33 /* BeforeSpecialSEnd */;
	            }
	            else if (this.special === 4 /* Title */ &&
	                (c === "t" || c === "T")) {
	                this._state = 53 /* BeforeSpecialTEnd */;
	            }
	            else {
	                this._state = 1 /* Text */;
	                this._index--;
	            }
	        }
	        else if (!this.isTagStartChar(c)) {
	            this._state = 20 /* InSpecialComment */;
	            this.sectionStart = this._index;
	        }
	        else {
	            this._state = 6 /* InClosingTagName */;
	            this.sectionStart = this._index;
	        }
	    };
	    Tokenizer.prototype.stateInClosingTagName = function (c) {
	        if (c === ">" || whitespace$1(c)) {
	            this.emitToken("onclosetag");
	            this._state = 7 /* AfterClosingTagName */;
	            this._index--;
	        }
	    };
	    Tokenizer.prototype.stateAfterClosingTagName = function (c) {
	        // Skip everything until ">"
	        if (c === ">") {
	            this._state = 1 /* Text */;
	            this.sectionStart = this._index + 1;
	        }
	    };
	    Tokenizer.prototype.stateBeforeAttributeName = function (c) {
	        if (c === ">") {
	            this.cbs.onopentagend();
	            this._state = 1 /* Text */;
	            this.sectionStart = this._index + 1;
	        }
	        else if (c === "/") {
	            this._state = 4 /* InSelfClosingTag */;
	        }
	        else if (!whitespace$1(c)) {
	            this._state = 9 /* InAttributeName */;
	            this.sectionStart = this._index;
	        }
	    };
	    Tokenizer.prototype.stateInSelfClosingTag = function (c) {
	        if (c === ">") {
	            this.cbs.onselfclosingtag();
	            this._state = 1 /* Text */;
	            this.sectionStart = this._index + 1;
	            this.special = 1 /* None */; // Reset special state, in case of self-closing special tags
	        }
	        else if (!whitespace$1(c)) {
	            this._state = 8 /* BeforeAttributeName */;
	            this._index--;
	        }
	    };
	    Tokenizer.prototype.stateInAttributeName = function (c) {
	        if (c === "=" || c === "/" || c === ">" || whitespace$1(c)) {
	            this.cbs.onattribname(this.getSection());
	            this.sectionStart = -1;
	            this._state = 10 /* AfterAttributeName */;
	            this._index--;
	        }
	    };
	    Tokenizer.prototype.stateAfterAttributeName = function (c) {
	        if (c === "=") {
	            this._state = 11 /* BeforeAttributeValue */;
	        }
	        else if (c === "/" || c === ">") {
	            this.cbs.onattribend(undefined);
	            this._state = 8 /* BeforeAttributeName */;
	            this._index--;
	        }
	        else if (!whitespace$1(c)) {
	            this.cbs.onattribend(undefined);
	            this._state = 9 /* InAttributeName */;
	            this.sectionStart = this._index;
	        }
	    };
	    Tokenizer.prototype.stateBeforeAttributeValue = function (c) {
	        if (c === '"') {
	            this._state = 12 /* InAttributeValueDq */;
	            this.sectionStart = this._index + 1;
	        }
	        else if (c === "'") {
	            this._state = 13 /* InAttributeValueSq */;
	            this.sectionStart = this._index + 1;
	        }
	        else if (!whitespace$1(c)) {
	            this._state = 14 /* InAttributeValueNq */;
	            this.sectionStart = this._index;
	            this._index--; // Reconsume token
	        }
	    };
	    Tokenizer.prototype.handleInAttributeValue = function (c, quote) {
	        if (c === quote) {
	            this.emitToken("onattribdata");
	            this.cbs.onattribend(quote);
	            this._state = 8 /* BeforeAttributeName */;
	        }
	        else if (this.decodeEntities && c === "&") {
	            this.emitToken("onattribdata");
	            this.baseState = this._state;
	            this._state = 62 /* BeforeEntity */;
	            this.sectionStart = this._index;
	        }
	    };
	    Tokenizer.prototype.stateInAttributeValueDoubleQuotes = function (c) {
	        this.handleInAttributeValue(c, '"');
	    };
	    Tokenizer.prototype.stateInAttributeValueSingleQuotes = function (c) {
	        this.handleInAttributeValue(c, "'");
	    };
	    Tokenizer.prototype.stateInAttributeValueNoQuotes = function (c) {
	        if (whitespace$1(c) || c === ">") {
	            this.emitToken("onattribdata");
	            this.cbs.onattribend(null);
	            this._state = 8 /* BeforeAttributeName */;
	            this._index--;
	        }
	        else if (this.decodeEntities && c === "&") {
	            this.emitToken("onattribdata");
	            this.baseState = this._state;
	            this._state = 62 /* BeforeEntity */;
	            this.sectionStart = this._index;
	        }
	    };
	    Tokenizer.prototype.stateBeforeDeclaration = function (c) {
	        this._state =
	            c === "["
	                ? 23 /* BeforeCdata1 */
	                : c === "-"
	                    ? 18 /* BeforeComment */
	                    : 16 /* InDeclaration */;
	    };
	    Tokenizer.prototype.stateInDeclaration = function (c) {
	        if (c === ">") {
	            this.cbs.ondeclaration(this.getSection());
	            this._state = 1 /* Text */;
	            this.sectionStart = this._index + 1;
	        }
	    };
	    Tokenizer.prototype.stateInProcessingInstruction = function (c) {
	        if (c === ">") {
	            this.cbs.onprocessinginstruction(this.getSection());
	            this._state = 1 /* Text */;
	            this.sectionStart = this._index + 1;
	        }
	    };
	    Tokenizer.prototype.stateBeforeComment = function (c) {
	        if (c === "-") {
	            this._state = 19 /* InComment */;
	            this.sectionStart = this._index + 1;
	        }
	        else {
	            this._state = 16 /* InDeclaration */;
	        }
	    };
	    Tokenizer.prototype.stateInComment = function (c) {
	        if (c === "-")
	            this._state = 21 /* AfterComment1 */;
	    };
	    Tokenizer.prototype.stateInSpecialComment = function (c) {
	        if (c === ">") {
	            this.cbs.oncomment(this.buffer.substring(this.sectionStart, this._index));
	            this._state = 1 /* Text */;
	            this.sectionStart = this._index + 1;
	        }
	    };
	    Tokenizer.prototype.stateAfterComment1 = function (c) {
	        if (c === "-") {
	            this._state = 22 /* AfterComment2 */;
	        }
	        else {
	            this._state = 19 /* InComment */;
	        }
	    };
	    Tokenizer.prototype.stateAfterComment2 = function (c) {
	        if (c === ">") {
	            // Remove 2 trailing chars
	            this.cbs.oncomment(this.buffer.substring(this.sectionStart, this._index - 2));
	            this._state = 1 /* Text */;
	            this.sectionStart = this._index + 1;
	        }
	        else if (c !== "-") {
	            this._state = 19 /* InComment */;
	        }
	        // Else: stay in AFTER_COMMENT_2 (`--->`)
	    };
	    Tokenizer.prototype.stateBeforeCdata6 = function (c) {
	        if (c === "[") {
	            this._state = 29 /* InCdata */;
	            this.sectionStart = this._index + 1;
	        }
	        else {
	            this._state = 16 /* InDeclaration */;
	            this._index--;
	        }
	    };
	    Tokenizer.prototype.stateInCdata = function (c) {
	        if (c === "]")
	            this._state = 30 /* AfterCdata1 */;
	    };
	    Tokenizer.prototype.stateAfterCdata1 = function (c) {
	        if (c === "]")
	            this._state = 31 /* AfterCdata2 */;
	        else
	            this._state = 29 /* InCdata */;
	    };
	    Tokenizer.prototype.stateAfterCdata2 = function (c) {
	        if (c === ">") {
	            // Remove 2 trailing chars
	            this.cbs.oncdata(this.buffer.substring(this.sectionStart, this._index - 2));
	            this._state = 1 /* Text */;
	            this.sectionStart = this._index + 1;
	        }
	        else if (c !== "]") {
	            this._state = 29 /* InCdata */;
	        }
	        // Else: stay in AFTER_CDATA_2 (`]]]>`)
	    };
	    Tokenizer.prototype.stateBeforeSpecialS = function (c) {
	        if (c === "c" || c === "C") {
	            this._state = 34 /* BeforeScript1 */;
	        }
	        else if (c === "t" || c === "T") {
	            this._state = 44 /* BeforeStyle1 */;
	        }
	        else {
	            this._state = 3 /* InTagName */;
	            this._index--; // Consume the token again
	        }
	    };
	    Tokenizer.prototype.stateBeforeSpecialSEnd = function (c) {
	        if (this.special === 2 /* Script */ && (c === "c" || c === "C")) {
	            this._state = 39 /* AfterScript1 */;
	        }
	        else if (this.special === 3 /* Style */ && (c === "t" || c === "T")) {
	            this._state = 48 /* AfterStyle1 */;
	        }
	        else
	            this._state = 1 /* Text */;
	    };
	    Tokenizer.prototype.stateBeforeSpecialLast = function (c, special) {
	        if (c === "/" || c === ">" || whitespace$1(c)) {
	            this.special = special;
	        }
	        this._state = 3 /* InTagName */;
	        this._index--; // Consume the token again
	    };
	    Tokenizer.prototype.stateAfterSpecialLast = function (c, sectionStartOffset) {
	        if (c === ">" || whitespace$1(c)) {
	            this.special = 1 /* None */;
	            this._state = 6 /* InClosingTagName */;
	            this.sectionStart = this._index - sectionStartOffset;
	            this._index--; // Reconsume the token
	        }
	        else
	            this._state = 1 /* Text */;
	    };
	    // For entities terminated with a semicolon
	    Tokenizer.prototype.parseFixedEntity = function (map) {
	        if (map === void 0) { map = this.xmlMode ? xml_json_1$2.default : entities_json_1$2.default; }
	        // Offset = 1
	        if (this.sectionStart + 1 < this._index) {
	            var entity = this.buffer.substring(this.sectionStart + 1, this._index);
	            if (Object.prototype.hasOwnProperty.call(map, entity)) {
	                this.emitPartial(map[entity]);
	                this.sectionStart = this._index + 1;
	            }
	        }
	    };
	    // Parses legacy entities (without trailing semicolon)
	    Tokenizer.prototype.parseLegacyEntity = function () {
	        var start = this.sectionStart + 1;
	        // The max length of legacy entities is 6
	        var limit = Math.min(this._index - start, 6);
	        while (limit >= 2) {
	            // The min length of legacy entities is 2
	            var entity = this.buffer.substr(start, limit);
	            if (Object.prototype.hasOwnProperty.call(legacy_json_1$1.default, entity)) {
	                this.emitPartial(legacy_json_1$1.default[entity]);
	                this.sectionStart += limit + 1;
	                return;
	            }
	            limit--;
	        }
	    };
	    Tokenizer.prototype.stateInNamedEntity = function (c) {
	        if (c === ";") {
	            this.parseFixedEntity();
	            // Retry as legacy entity if entity wasn't parsed
	            if (this.baseState === 1 /* Text */ &&
	                this.sectionStart + 1 < this._index &&
	                !this.xmlMode) {
	                this.parseLegacyEntity();
	            }
	            this._state = this.baseState;
	        }
	        else if ((c < "0" || c > "9") && !isASCIIAlpha(c)) {
	            if (this.xmlMode || this.sectionStart + 1 === this._index) ;
	            else if (this.baseState !== 1 /* Text */) {
	                if (c !== "=") {
	                    // Parse as legacy entity, without allowing additional characters.
	                    this.parseFixedEntity(legacy_json_1$1.default);
	                }
	            }
	            else {
	                this.parseLegacyEntity();
	            }
	            this._state = this.baseState;
	            this._index--;
	        }
	    };
	    Tokenizer.prototype.decodeNumericEntity = function (offset, base, strict) {
	        var sectionStart = this.sectionStart + offset;
	        if (sectionStart !== this._index) {
	            // Parse entity
	            var entity = this.buffer.substring(sectionStart, this._index);
	            var parsed = parseInt(entity, base);
	            this.emitPartial(decode_codepoint_1$1.default(parsed));
	            this.sectionStart = strict ? this._index + 1 : this._index;
	        }
	        this._state = this.baseState;
	    };
	    Tokenizer.prototype.stateInNumericEntity = function (c) {
	        if (c === ";") {
	            this.decodeNumericEntity(2, 10, true);
	        }
	        else if (c < "0" || c > "9") {
	            if (!this.xmlMode) {
	                this.decodeNumericEntity(2, 10, false);
	            }
	            else {
	                this._state = this.baseState;
	            }
	            this._index--;
	        }
	    };
	    Tokenizer.prototype.stateInHexEntity = function (c) {
	        if (c === ";") {
	            this.decodeNumericEntity(3, 16, true);
	        }
	        else if ((c < "a" || c > "f") &&
	            (c < "A" || c > "F") &&
	            (c < "0" || c > "9")) {
	            if (!this.xmlMode) {
	                this.decodeNumericEntity(3, 16, false);
	            }
	            else {
	                this._state = this.baseState;
	            }
	            this._index--;
	        }
	    };
	    Tokenizer.prototype.cleanup = function () {
	        if (this.sectionStart < 0) {
	            this.buffer = "";
	            this.bufferOffset += this._index;
	            this._index = 0;
	        }
	        else if (this.running) {
	            if (this._state === 1 /* Text */) {
	                if (this.sectionStart !== this._index) {
	                    this.cbs.ontext(this.buffer.substr(this.sectionStart));
	                }
	                this.buffer = "";
	                this.bufferOffset += this._index;
	                this._index = 0;
	            }
	            else if (this.sectionStart === this._index) {
	                // The section just started
	                this.buffer = "";
	                this.bufferOffset += this._index;
	                this._index = 0;
	            }
	            else {
	                // Remove everything unnecessary
	                this.buffer = this.buffer.substr(this.sectionStart);
	                this._index -= this.sectionStart;
	                this.bufferOffset += this.sectionStart;
	            }
	            this.sectionStart = 0;
	        }
	    };
	    /**
	     * Iterates through the buffer, calling the function corresponding to the current state.
	     *
	     * States that are more likely to be hit are higher up, as a performance improvement.
	     */
	    Tokenizer.prototype.parse = function () {
	        while (this._index < this.buffer.length && this.running) {
	            var c = this.buffer.charAt(this._index);
	            if (this._state === 1 /* Text */) {
	                this.stateText(c);
	            }
	            else if (this._state === 12 /* InAttributeValueDq */) {
	                this.stateInAttributeValueDoubleQuotes(c);
	            }
	            else if (this._state === 9 /* InAttributeName */) {
	                this.stateInAttributeName(c);
	            }
	            else if (this._state === 19 /* InComment */) {
	                this.stateInComment(c);
	            }
	            else if (this._state === 20 /* InSpecialComment */) {
	                this.stateInSpecialComment(c);
	            }
	            else if (this._state === 8 /* BeforeAttributeName */) {
	                this.stateBeforeAttributeName(c);
	            }
	            else if (this._state === 3 /* InTagName */) {
	                this.stateInTagName(c);
	            }
	            else if (this._state === 6 /* InClosingTagName */) {
	                this.stateInClosingTagName(c);
	            }
	            else if (this._state === 2 /* BeforeTagName */) {
	                this.stateBeforeTagName(c);
	            }
	            else if (this._state === 10 /* AfterAttributeName */) {
	                this.stateAfterAttributeName(c);
	            }
	            else if (this._state === 13 /* InAttributeValueSq */) {
	                this.stateInAttributeValueSingleQuotes(c);
	            }
	            else if (this._state === 11 /* BeforeAttributeValue */) {
	                this.stateBeforeAttributeValue(c);
	            }
	            else if (this._state === 5 /* BeforeClosingTagName */) {
	                this.stateBeforeClosingTagName(c);
	            }
	            else if (this._state === 7 /* AfterClosingTagName */) {
	                this.stateAfterClosingTagName(c);
	            }
	            else if (this._state === 32 /* BeforeSpecialS */) {
	                this.stateBeforeSpecialS(c);
	            }
	            else if (this._state === 21 /* AfterComment1 */) {
	                this.stateAfterComment1(c);
	            }
	            else if (this._state === 14 /* InAttributeValueNq */) {
	                this.stateInAttributeValueNoQuotes(c);
	            }
	            else if (this._state === 4 /* InSelfClosingTag */) {
	                this.stateInSelfClosingTag(c);
	            }
	            else if (this._state === 16 /* InDeclaration */) {
	                this.stateInDeclaration(c);
	            }
	            else if (this._state === 15 /* BeforeDeclaration */) {
	                this.stateBeforeDeclaration(c);
	            }
	            else if (this._state === 22 /* AfterComment2 */) {
	                this.stateAfterComment2(c);
	            }
	            else if (this._state === 18 /* BeforeComment */) {
	                this.stateBeforeComment(c);
	            }
	            else if (this._state === 33 /* BeforeSpecialSEnd */) {
	                this.stateBeforeSpecialSEnd(c);
	            }
	            else if (this._state === 53 /* BeforeSpecialTEnd */) {
	                stateAfterSpecialTEnd(this, c);
	            }
	            else if (this._state === 39 /* AfterScript1 */) {
	                stateAfterScript1(this, c);
	            }
	            else if (this._state === 40 /* AfterScript2 */) {
	                stateAfterScript2(this, c);
	            }
	            else if (this._state === 41 /* AfterScript3 */) {
	                stateAfterScript3(this, c);
	            }
	            else if (this._state === 34 /* BeforeScript1 */) {
	                stateBeforeScript1(this, c);
	            }
	            else if (this._state === 35 /* BeforeScript2 */) {
	                stateBeforeScript2(this, c);
	            }
	            else if (this._state === 36 /* BeforeScript3 */) {
	                stateBeforeScript3(this, c);
	            }
	            else if (this._state === 37 /* BeforeScript4 */) {
	                stateBeforeScript4(this, c);
	            }
	            else if (this._state === 38 /* BeforeScript5 */) {
	                this.stateBeforeSpecialLast(c, 2 /* Script */);
	            }
	            else if (this._state === 42 /* AfterScript4 */) {
	                stateAfterScript4(this, c);
	            }
	            else if (this._state === 43 /* AfterScript5 */) {
	                this.stateAfterSpecialLast(c, 6);
	            }
	            else if (this._state === 44 /* BeforeStyle1 */) {
	                stateBeforeStyle1(this, c);
	            }
	            else if (this._state === 29 /* InCdata */) {
	                this.stateInCdata(c);
	            }
	            else if (this._state === 45 /* BeforeStyle2 */) {
	                stateBeforeStyle2(this, c);
	            }
	            else if (this._state === 46 /* BeforeStyle3 */) {
	                stateBeforeStyle3(this, c);
	            }
	            else if (this._state === 47 /* BeforeStyle4 */) {
	                this.stateBeforeSpecialLast(c, 3 /* Style */);
	            }
	            else if (this._state === 48 /* AfterStyle1 */) {
	                stateAfterStyle1(this, c);
	            }
	            else if (this._state === 49 /* AfterStyle2 */) {
	                stateAfterStyle2(this, c);
	            }
	            else if (this._state === 50 /* AfterStyle3 */) {
	                stateAfterStyle3(this, c);
	            }
	            else if (this._state === 51 /* AfterStyle4 */) {
	                this.stateAfterSpecialLast(c, 5);
	            }
	            else if (this._state === 52 /* BeforeSpecialT */) {
	                stateBeforeSpecialT(this, c);
	            }
	            else if (this._state === 54 /* BeforeTitle1 */) {
	                stateBeforeTitle1(this, c);
	            }
	            else if (this._state === 55 /* BeforeTitle2 */) {
	                stateBeforeTitle2(this, c);
	            }
	            else if (this._state === 56 /* BeforeTitle3 */) {
	                stateBeforeTitle3(this, c);
	            }
	            else if (this._state === 57 /* BeforeTitle4 */) {
	                this.stateBeforeSpecialLast(c, 4 /* Title */);
	            }
	            else if (this._state === 58 /* AfterTitle1 */) {
	                stateAfterTitle1(this, c);
	            }
	            else if (this._state === 59 /* AfterTitle2 */) {
	                stateAfterTitle2(this, c);
	            }
	            else if (this._state === 60 /* AfterTitle3 */) {
	                stateAfterTitle3(this, c);
	            }
	            else if (this._state === 61 /* AfterTitle4 */) {
	                this.stateAfterSpecialLast(c, 5);
	            }
	            else if (this._state === 17 /* InProcessingInstruction */) {
	                this.stateInProcessingInstruction(c);
	            }
	            else if (this._state === 64 /* InNamedEntity */) {
	                this.stateInNamedEntity(c);
	            }
	            else if (this._state === 23 /* BeforeCdata1 */) {
	                stateBeforeCdata1(this, c);
	            }
	            else if (this._state === 62 /* BeforeEntity */) {
	                stateBeforeEntity(this, c);
	            }
	            else if (this._state === 24 /* BeforeCdata2 */) {
	                stateBeforeCdata2(this, c);
	            }
	            else if (this._state === 25 /* BeforeCdata3 */) {
	                stateBeforeCdata3(this, c);
	            }
	            else if (this._state === 30 /* AfterCdata1 */) {
	                this.stateAfterCdata1(c);
	            }
	            else if (this._state === 31 /* AfterCdata2 */) {
	                this.stateAfterCdata2(c);
	            }
	            else if (this._state === 26 /* BeforeCdata4 */) {
	                stateBeforeCdata4(this, c);
	            }
	            else if (this._state === 27 /* BeforeCdata5 */) {
	                stateBeforeCdata5(this, c);
	            }
	            else if (this._state === 28 /* BeforeCdata6 */) {
	                this.stateBeforeCdata6(c);
	            }
	            else if (this._state === 66 /* InHexEntity */) {
	                this.stateInHexEntity(c);
	            }
	            else if (this._state === 65 /* InNumericEntity */) {
	                this.stateInNumericEntity(c);
	                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
	            }
	            else if (this._state === 63 /* BeforeNumericEntity */) {
	                stateBeforeNumericEntity(this, c);
	            }
	            else {
	                this.cbs.onerror(Error("unknown _state"), this._state);
	            }
	            this._index++;
	        }
	        this.cleanup();
	    };
	    Tokenizer.prototype.finish = function () {
	        // If there is remaining data, emit it in a reasonable way
	        if (this.sectionStart < this._index) {
	            this.handleTrailingData();
	        }
	        this.cbs.onend();
	    };
	    Tokenizer.prototype.handleTrailingData = function () {
	        var data = this.buffer.substr(this.sectionStart);
	        if (this._state === 29 /* InCdata */ ||
	            this._state === 30 /* AfterCdata1 */ ||
	            this._state === 31 /* AfterCdata2 */) {
	            this.cbs.oncdata(data);
	        }
	        else if (this._state === 19 /* InComment */ ||
	            this._state === 21 /* AfterComment1 */ ||
	            this._state === 22 /* AfterComment2 */) {
	            this.cbs.oncomment(data);
	        }
	        else if (this._state === 64 /* InNamedEntity */ && !this.xmlMode) {
	            this.parseLegacyEntity();
	            if (this.sectionStart < this._index) {
	                this._state = this.baseState;
	                this.handleTrailingData();
	            }
	        }
	        else if (this._state === 65 /* InNumericEntity */ && !this.xmlMode) {
	            this.decodeNumericEntity(2, 10, false);
	            if (this.sectionStart < this._index) {
	                this._state = this.baseState;
	                this.handleTrailingData();
	            }
	        }
	        else if (this._state === 66 /* InHexEntity */ && !this.xmlMode) {
	            this.decodeNumericEntity(3, 16, false);
	            if (this.sectionStart < this._index) {
	                this._state = this.baseState;
	                this.handleTrailingData();
	            }
	        }
	        else if (this._state !== 3 /* InTagName */ &&
	            this._state !== 8 /* BeforeAttributeName */ &&
	            this._state !== 11 /* BeforeAttributeValue */ &&
	            this._state !== 10 /* AfterAttributeName */ &&
	            this._state !== 9 /* InAttributeName */ &&
	            this._state !== 13 /* InAttributeValueSq */ &&
	            this._state !== 12 /* InAttributeValueDq */ &&
	            this._state !== 14 /* InAttributeValueNq */ &&
	            this._state !== 6 /* InClosingTagName */) {
	            this.cbs.ontext(data);
	        }
	        /*
	         * Else, ignore remaining data
	         * TODO add a way to remove current tag
	         */
	    };
	    Tokenizer.prototype.getSection = function () {
	        return this.buffer.substring(this.sectionStart, this._index);
	    };
	    Tokenizer.prototype.emitToken = function (name) {
	        this.cbs[name](this.getSection());
	        this.sectionStart = -1;
	    };
	    Tokenizer.prototype.emitPartial = function (value) {
	        if (this.baseState !== 1 /* Text */) {
	            this.cbs.onattribdata(value); // TODO implement the new event
	        }
	        else {
	            this.cbs.ontext(value);
	        }
	    };
	    return Tokenizer;
	}());
	Tokenizer$6.default = Tokenizer$5;

	var __importDefault$4 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(Parser$3, "__esModule", { value: true });
	Parser$3.Parser = void 0;
	var Tokenizer_1 = __importDefault$4(Tokenizer$6);
	var formTags = new Set([
	    "input",
	    "option",
	    "optgroup",
	    "select",
	    "button",
	    "datalist",
	    "textarea",
	]);
	var pTag = new Set(["p"]);
	var openImpliesClose = {
	    tr: new Set(["tr", "th", "td"]),
	    th: new Set(["th"]),
	    td: new Set(["thead", "th", "td"]),
	    body: new Set(["head", "link", "script"]),
	    li: new Set(["li"]),
	    p: pTag,
	    h1: pTag,
	    h2: pTag,
	    h3: pTag,
	    h4: pTag,
	    h5: pTag,
	    h6: pTag,
	    select: formTags,
	    input: formTags,
	    output: formTags,
	    button: formTags,
	    datalist: formTags,
	    textarea: formTags,
	    option: new Set(["option"]),
	    optgroup: new Set(["optgroup", "option"]),
	    dd: new Set(["dt", "dd"]),
	    dt: new Set(["dt", "dd"]),
	    address: pTag,
	    article: pTag,
	    aside: pTag,
	    blockquote: pTag,
	    details: pTag,
	    div: pTag,
	    dl: pTag,
	    fieldset: pTag,
	    figcaption: pTag,
	    figure: pTag,
	    footer: pTag,
	    form: pTag,
	    header: pTag,
	    hr: pTag,
	    main: pTag,
	    nav: pTag,
	    ol: pTag,
	    pre: pTag,
	    section: pTag,
	    table: pTag,
	    ul: pTag,
	    rt: new Set(["rt", "rp"]),
	    rp: new Set(["rt", "rp"]),
	    tbody: new Set(["thead", "tbody"]),
	    tfoot: new Set(["thead", "tbody"]),
	};
	var voidElements = new Set([
	    "area",
	    "base",
	    "basefont",
	    "br",
	    "col",
	    "command",
	    "embed",
	    "frame",
	    "hr",
	    "img",
	    "input",
	    "isindex",
	    "keygen",
	    "link",
	    "meta",
	    "param",
	    "source",
	    "track",
	    "wbr",
	]);
	var foreignContextElements = new Set(["math", "svg"]);
	var htmlIntegrationElements = new Set([
	    "mi",
	    "mo",
	    "mn",
	    "ms",
	    "mtext",
	    "annotation-xml",
	    "foreignObject",
	    "desc",
	    "title",
	]);
	var reNameEnd = /\s|\//;
	var Parser$2 = /** @class */ (function () {
	    function Parser(cbs, options) {
	        if (options === void 0) { options = {}; }
	        var _a, _b, _c, _d, _e;
	        /** The start index of the last event. */
	        this.startIndex = 0;
	        /** The end index of the last event. */
	        this.endIndex = null;
	        this.tagname = "";
	        this.attribname = "";
	        this.attribvalue = "";
	        this.attribs = null;
	        this.stack = [];
	        this.foreignContext = [];
	        this.options = options;
	        this.cbs = cbs !== null && cbs !== void 0 ? cbs : {};
	        this.lowerCaseTagNames = (_a = options.lowerCaseTags) !== null && _a !== void 0 ? _a : !options.xmlMode;
	        this.lowerCaseAttributeNames =
	            (_b = options.lowerCaseAttributeNames) !== null && _b !== void 0 ? _b : !options.xmlMode;
	        this.tokenizer = new ((_c = options.Tokenizer) !== null && _c !== void 0 ? _c : Tokenizer_1.default)(this.options, this);
	        (_e = (_d = this.cbs).onparserinit) === null || _e === void 0 ? void 0 : _e.call(_d, this);
	    }
	    Parser.prototype.updatePosition = function (initialOffset) {
	        if (this.endIndex === null) {
	            if (this.tokenizer.sectionStart <= initialOffset) {
	                this.startIndex = 0;
	            }
	            else {
	                this.startIndex = this.tokenizer.sectionStart - initialOffset;
	            }
	        }
	        else {
	            this.startIndex = this.endIndex + 1;
	        }
	        this.endIndex = this.tokenizer.getAbsoluteIndex();
	    };
	    // Tokenizer event handlers
	    Parser.prototype.ontext = function (data) {
	        var _a, _b;
	        this.updatePosition(1);
	        this.endIndex--;
	        (_b = (_a = this.cbs).ontext) === null || _b === void 0 ? void 0 : _b.call(_a, data);
	    };
	    Parser.prototype.onopentagname = function (name) {
	        var _a, _b;
	        if (this.lowerCaseTagNames) {
	            name = name.toLowerCase();
	        }
	        this.tagname = name;
	        if (!this.options.xmlMode &&
	            Object.prototype.hasOwnProperty.call(openImpliesClose, name)) {
	            var el = void 0;
	            while (this.stack.length > 0 &&
	                openImpliesClose[name].has((el = this.stack[this.stack.length - 1]))) {
	                this.onclosetag(el);
	            }
	        }
	        if (this.options.xmlMode || !voidElements.has(name)) {
	            this.stack.push(name);
	            if (foreignContextElements.has(name)) {
	                this.foreignContext.push(true);
	            }
	            else if (htmlIntegrationElements.has(name)) {
	                this.foreignContext.push(false);
	            }
	        }
	        (_b = (_a = this.cbs).onopentagname) === null || _b === void 0 ? void 0 : _b.call(_a, name);
	        if (this.cbs.onopentag)
	            this.attribs = {};
	    };
	    Parser.prototype.onopentagend = function () {
	        var _a, _b;
	        this.updatePosition(1);
	        if (this.attribs) {
	            (_b = (_a = this.cbs).onopentag) === null || _b === void 0 ? void 0 : _b.call(_a, this.tagname, this.attribs);
	            this.attribs = null;
	        }
	        if (!this.options.xmlMode &&
	            this.cbs.onclosetag &&
	            voidElements.has(this.tagname)) {
	            this.cbs.onclosetag(this.tagname);
	        }
	        this.tagname = "";
	    };
	    Parser.prototype.onclosetag = function (name) {
	        this.updatePosition(1);
	        if (this.lowerCaseTagNames) {
	            name = name.toLowerCase();
	        }
	        if (foreignContextElements.has(name) ||
	            htmlIntegrationElements.has(name)) {
	            this.foreignContext.pop();
	        }
	        if (this.stack.length &&
	            (this.options.xmlMode || !voidElements.has(name))) {
	            var pos = this.stack.lastIndexOf(name);
	            if (pos !== -1) {
	                if (this.cbs.onclosetag) {
	                    pos = this.stack.length - pos;
	                    while (pos--) {
	                        // We know the stack has sufficient elements.
	                        this.cbs.onclosetag(this.stack.pop());
	                    }
	                }
	                else
	                    this.stack.length = pos;
	            }
	            else if (name === "p" && !this.options.xmlMode) {
	                this.onopentagname(name);
	                this.closeCurrentTag();
	            }
	        }
	        else if (!this.options.xmlMode && (name === "br" || name === "p")) {
	            this.onopentagname(name);
	            this.closeCurrentTag();
	        }
	    };
	    Parser.prototype.onselfclosingtag = function () {
	        if (this.options.xmlMode ||
	            this.options.recognizeSelfClosing ||
	            this.foreignContext[this.foreignContext.length - 1]) {
	            this.closeCurrentTag();
	        }
	        else {
	            this.onopentagend();
	        }
	    };
	    Parser.prototype.closeCurrentTag = function () {
	        var _a, _b;
	        var name = this.tagname;
	        this.onopentagend();
	        /*
	         * Self-closing tags will be on the top of the stack
	         * (cheaper check than in onclosetag)
	         */
	        if (this.stack[this.stack.length - 1] === name) {
	            (_b = (_a = this.cbs).onclosetag) === null || _b === void 0 ? void 0 : _b.call(_a, name);
	            this.stack.pop();
	        }
	    };
	    Parser.prototype.onattribname = function (name) {
	        if (this.lowerCaseAttributeNames) {
	            name = name.toLowerCase();
	        }
	        this.attribname = name;
	    };
	    Parser.prototype.onattribdata = function (value) {
	        this.attribvalue += value;
	    };
	    Parser.prototype.onattribend = function (quote) {
	        var _a, _b;
	        (_b = (_a = this.cbs).onattribute) === null || _b === void 0 ? void 0 : _b.call(_a, this.attribname, this.attribvalue, quote);
	        if (this.attribs &&
	            !Object.prototype.hasOwnProperty.call(this.attribs, this.attribname)) {
	            this.attribs[this.attribname] = this.attribvalue;
	        }
	        this.attribname = "";
	        this.attribvalue = "";
	    };
	    Parser.prototype.getInstructionName = function (value) {
	        var idx = value.search(reNameEnd);
	        var name = idx < 0 ? value : value.substr(0, idx);
	        if (this.lowerCaseTagNames) {
	            name = name.toLowerCase();
	        }
	        return name;
	    };
	    Parser.prototype.ondeclaration = function (value) {
	        if (this.cbs.onprocessinginstruction) {
	            var name_1 = this.getInstructionName(value);
	            this.cbs.onprocessinginstruction("!" + name_1, "!" + value);
	        }
	    };
	    Parser.prototype.onprocessinginstruction = function (value) {
	        if (this.cbs.onprocessinginstruction) {
	            var name_2 = this.getInstructionName(value);
	            this.cbs.onprocessinginstruction("?" + name_2, "?" + value);
	        }
	    };
	    Parser.prototype.oncomment = function (value) {
	        var _a, _b, _c, _d;
	        this.updatePosition(4);
	        (_b = (_a = this.cbs).oncomment) === null || _b === void 0 ? void 0 : _b.call(_a, value);
	        (_d = (_c = this.cbs).oncommentend) === null || _d === void 0 ? void 0 : _d.call(_c);
	    };
	    Parser.prototype.oncdata = function (value) {
	        var _a, _b, _c, _d, _e, _f;
	        this.updatePosition(1);
	        if (this.options.xmlMode || this.options.recognizeCDATA) {
	            (_b = (_a = this.cbs).oncdatastart) === null || _b === void 0 ? void 0 : _b.call(_a);
	            (_d = (_c = this.cbs).ontext) === null || _d === void 0 ? void 0 : _d.call(_c, value);
	            (_f = (_e = this.cbs).oncdataend) === null || _f === void 0 ? void 0 : _f.call(_e);
	        }
	        else {
	            this.oncomment("[CDATA[" + value + "]]");
	        }
	    };
	    Parser.prototype.onerror = function (err) {
	        var _a, _b;
	        (_b = (_a = this.cbs).onerror) === null || _b === void 0 ? void 0 : _b.call(_a, err);
	    };
	    Parser.prototype.onend = function () {
	        var _a, _b;
	        if (this.cbs.onclosetag) {
	            for (var i = this.stack.length; i > 0; this.cbs.onclosetag(this.stack[--i]))
	                ;
	        }
	        (_b = (_a = this.cbs).onend) === null || _b === void 0 ? void 0 : _b.call(_a);
	    };
	    /**
	     * Resets the parser to a blank state, ready to parse a new HTML document
	     */
	    Parser.prototype.reset = function () {
	        var _a, _b, _c, _d;
	        (_b = (_a = this.cbs).onreset) === null || _b === void 0 ? void 0 : _b.call(_a);
	        this.tokenizer.reset();
	        this.tagname = "";
	        this.attribname = "";
	        this.attribs = null;
	        this.stack = [];
	        (_d = (_c = this.cbs).onparserinit) === null || _d === void 0 ? void 0 : _d.call(_c, this);
	    };
	    /**
	     * Resets the parser, then parses a complete document and
	     * pushes it to the handler.
	     *
	     * @param data Document to parse.
	     */
	    Parser.prototype.parseComplete = function (data) {
	        this.reset();
	        this.end(data);
	    };
	    /**
	     * Parses a chunk of data and calls the corresponding callbacks.
	     *
	     * @param chunk Chunk to parse.
	     */
	    Parser.prototype.write = function (chunk) {
	        this.tokenizer.write(chunk);
	    };
	    /**
	     * Parses the end of the buffer and clears the stack, calls onend.
	     *
	     * @param chunk Optional final chunk to parse.
	     */
	    Parser.prototype.end = function (chunk) {
	        this.tokenizer.end(chunk);
	    };
	    /**
	     * Pauses parsing. The parser won't emit events until `resume` is called.
	     */
	    Parser.prototype.pause = function () {
	        this.tokenizer.pause();
	    };
	    /**
	     * Resumes parsing after `pause` was called.
	     */
	    Parser.prototype.resume = function () {
	        this.tokenizer.resume();
	    };
	    /**
	     * Alias of `write`, for backwards compatibility.
	     *
	     * @param chunk Chunk to parse.
	     * @deprecated
	     */
	    Parser.prototype.parseChunk = function (chunk) {
	        this.write(chunk);
	    };
	    /**
	     * Alias of `end`, for backwards compatibility.
	     *
	     * @param chunk Optional final chunk to parse.
	     * @deprecated
	     */
	    Parser.prototype.done = function (chunk) {
	        this.end(chunk);
	    };
	    return Parser;
	}());
	Parser$3.Parser = Parser$2;

	var FeedHandler$1 = {};

	var lib$2 = {};

	var stringify$2 = {};

	var lib$1 = {};

	var lib = {};

	var decode$1 = {};

	var require$$1$1 = {"Aacute":"Á","aacute":"á","Abreve":"Ă","abreve":"ă","ac":"∾","acd":"∿","acE":"∾̳","Acirc":"Â","acirc":"â","acute":"´","Acy":"А","acy":"а","AElig":"Æ","aelig":"æ","af":"⁡","Afr":"𝔄","afr":"𝔞","Agrave":"À","agrave":"à","alefsym":"ℵ","aleph":"ℵ","Alpha":"Α","alpha":"α","Amacr":"Ā","amacr":"ā","amalg":"⨿","amp":"&","AMP":"&","andand":"⩕","And":"⩓","and":"∧","andd":"⩜","andslope":"⩘","andv":"⩚","ang":"∠","ange":"⦤","angle":"∠","angmsdaa":"⦨","angmsdab":"⦩","angmsdac":"⦪","angmsdad":"⦫","angmsdae":"⦬","angmsdaf":"⦭","angmsdag":"⦮","angmsdah":"⦯","angmsd":"∡","angrt":"∟","angrtvb":"⊾","angrtvbd":"⦝","angsph":"∢","angst":"Å","angzarr":"⍼","Aogon":"Ą","aogon":"ą","Aopf":"𝔸","aopf":"𝕒","apacir":"⩯","ap":"≈","apE":"⩰","ape":"≊","apid":"≋","apos":"'","ApplyFunction":"⁡","approx":"≈","approxeq":"≊","Aring":"Å","aring":"å","Ascr":"𝒜","ascr":"𝒶","Assign":"≔","ast":"*","asymp":"≈","asympeq":"≍","Atilde":"Ã","atilde":"ã","Auml":"Ä","auml":"ä","awconint":"∳","awint":"⨑","backcong":"≌","backepsilon":"϶","backprime":"‵","backsim":"∽","backsimeq":"⋍","Backslash":"∖","Barv":"⫧","barvee":"⊽","barwed":"⌅","Barwed":"⌆","barwedge":"⌅","bbrk":"⎵","bbrktbrk":"⎶","bcong":"≌","Bcy":"Б","bcy":"б","bdquo":"„","becaus":"∵","because":"∵","Because":"∵","bemptyv":"⦰","bepsi":"϶","bernou":"ℬ","Bernoullis":"ℬ","Beta":"Β","beta":"β","beth":"ℶ","between":"≬","Bfr":"𝔅","bfr":"𝔟","bigcap":"⋂","bigcirc":"◯","bigcup":"⋃","bigodot":"⨀","bigoplus":"⨁","bigotimes":"⨂","bigsqcup":"⨆","bigstar":"★","bigtriangledown":"▽","bigtriangleup":"△","biguplus":"⨄","bigvee":"⋁","bigwedge":"⋀","bkarow":"⤍","blacklozenge":"⧫","blacksquare":"▪","blacktriangle":"▴","blacktriangledown":"▾","blacktriangleleft":"◂","blacktriangleright":"▸","blank":"␣","blk12":"▒","blk14":"░","blk34":"▓","block":"█","bne":"=⃥","bnequiv":"≡⃥","bNot":"⫭","bnot":"⌐","Bopf":"𝔹","bopf":"𝕓","bot":"⊥","bottom":"⊥","bowtie":"⋈","boxbox":"⧉","boxdl":"┐","boxdL":"╕","boxDl":"╖","boxDL":"╗","boxdr":"┌","boxdR":"╒","boxDr":"╓","boxDR":"╔","boxh":"─","boxH":"═","boxhd":"┬","boxHd":"╤","boxhD":"╥","boxHD":"╦","boxhu":"┴","boxHu":"╧","boxhU":"╨","boxHU":"╩","boxminus":"⊟","boxplus":"⊞","boxtimes":"⊠","boxul":"┘","boxuL":"╛","boxUl":"╜","boxUL":"╝","boxur":"└","boxuR":"╘","boxUr":"╙","boxUR":"╚","boxv":"│","boxV":"║","boxvh":"┼","boxvH":"╪","boxVh":"╫","boxVH":"╬","boxvl":"┤","boxvL":"╡","boxVl":"╢","boxVL":"╣","boxvr":"├","boxvR":"╞","boxVr":"╟","boxVR":"╠","bprime":"‵","breve":"˘","Breve":"˘","brvbar":"¦","bscr":"𝒷","Bscr":"ℬ","bsemi":"⁏","bsim":"∽","bsime":"⋍","bsolb":"⧅","bsol":"\\","bsolhsub":"⟈","bull":"•","bullet":"•","bump":"≎","bumpE":"⪮","bumpe":"≏","Bumpeq":"≎","bumpeq":"≏","Cacute":"Ć","cacute":"ć","capand":"⩄","capbrcup":"⩉","capcap":"⩋","cap":"∩","Cap":"⋒","capcup":"⩇","capdot":"⩀","CapitalDifferentialD":"ⅅ","caps":"∩︀","caret":"⁁","caron":"ˇ","Cayleys":"ℭ","ccaps":"⩍","Ccaron":"Č","ccaron":"č","Ccedil":"Ç","ccedil":"ç","Ccirc":"Ĉ","ccirc":"ĉ","Cconint":"∰","ccups":"⩌","ccupssm":"⩐","Cdot":"Ċ","cdot":"ċ","cedil":"¸","Cedilla":"¸","cemptyv":"⦲","cent":"¢","centerdot":"·","CenterDot":"·","cfr":"𝔠","Cfr":"ℭ","CHcy":"Ч","chcy":"ч","check":"✓","checkmark":"✓","Chi":"Χ","chi":"χ","circ":"ˆ","circeq":"≗","circlearrowleft":"↺","circlearrowright":"↻","circledast":"⊛","circledcirc":"⊚","circleddash":"⊝","CircleDot":"⊙","circledR":"®","circledS":"Ⓢ","CircleMinus":"⊖","CirclePlus":"⊕","CircleTimes":"⊗","cir":"○","cirE":"⧃","cire":"≗","cirfnint":"⨐","cirmid":"⫯","cirscir":"⧂","ClockwiseContourIntegral":"∲","CloseCurlyDoubleQuote":"”","CloseCurlyQuote":"’","clubs":"♣","clubsuit":"♣","colon":":","Colon":"∷","Colone":"⩴","colone":"≔","coloneq":"≔","comma":",","commat":"@","comp":"∁","compfn":"∘","complement":"∁","complexes":"ℂ","cong":"≅","congdot":"⩭","Congruent":"≡","conint":"∮","Conint":"∯","ContourIntegral":"∮","copf":"𝕔","Copf":"ℂ","coprod":"∐","Coproduct":"∐","copy":"©","COPY":"©","copysr":"℗","CounterClockwiseContourIntegral":"∳","crarr":"↵","cross":"✗","Cross":"⨯","Cscr":"𝒞","cscr":"𝒸","csub":"⫏","csube":"⫑","csup":"⫐","csupe":"⫒","ctdot":"⋯","cudarrl":"⤸","cudarrr":"⤵","cuepr":"⋞","cuesc":"⋟","cularr":"↶","cularrp":"⤽","cupbrcap":"⩈","cupcap":"⩆","CupCap":"≍","cup":"∪","Cup":"⋓","cupcup":"⩊","cupdot":"⊍","cupor":"⩅","cups":"∪︀","curarr":"↷","curarrm":"⤼","curlyeqprec":"⋞","curlyeqsucc":"⋟","curlyvee":"⋎","curlywedge":"⋏","curren":"¤","curvearrowleft":"↶","curvearrowright":"↷","cuvee":"⋎","cuwed":"⋏","cwconint":"∲","cwint":"∱","cylcty":"⌭","dagger":"†","Dagger":"‡","daleth":"ℸ","darr":"↓","Darr":"↡","dArr":"⇓","dash":"‐","Dashv":"⫤","dashv":"⊣","dbkarow":"⤏","dblac":"˝","Dcaron":"Ď","dcaron":"ď","Dcy":"Д","dcy":"д","ddagger":"‡","ddarr":"⇊","DD":"ⅅ","dd":"ⅆ","DDotrahd":"⤑","ddotseq":"⩷","deg":"°","Del":"∇","Delta":"Δ","delta":"δ","demptyv":"⦱","dfisht":"⥿","Dfr":"𝔇","dfr":"𝔡","dHar":"⥥","dharl":"⇃","dharr":"⇂","DiacriticalAcute":"´","DiacriticalDot":"˙","DiacriticalDoubleAcute":"˝","DiacriticalGrave":"`","DiacriticalTilde":"˜","diam":"⋄","diamond":"⋄","Diamond":"⋄","diamondsuit":"♦","diams":"♦","die":"¨","DifferentialD":"ⅆ","digamma":"ϝ","disin":"⋲","div":"÷","divide":"÷","divideontimes":"⋇","divonx":"⋇","DJcy":"Ђ","djcy":"ђ","dlcorn":"⌞","dlcrop":"⌍","dollar":"$","Dopf":"𝔻","dopf":"𝕕","Dot":"¨","dot":"˙","DotDot":"⃜","doteq":"≐","doteqdot":"≑","DotEqual":"≐","dotminus":"∸","dotplus":"∔","dotsquare":"⊡","doublebarwedge":"⌆","DoubleContourIntegral":"∯","DoubleDot":"¨","DoubleDownArrow":"⇓","DoubleLeftArrow":"⇐","DoubleLeftRightArrow":"⇔","DoubleLeftTee":"⫤","DoubleLongLeftArrow":"⟸","DoubleLongLeftRightArrow":"⟺","DoubleLongRightArrow":"⟹","DoubleRightArrow":"⇒","DoubleRightTee":"⊨","DoubleUpArrow":"⇑","DoubleUpDownArrow":"⇕","DoubleVerticalBar":"∥","DownArrowBar":"⤓","downarrow":"↓","DownArrow":"↓","Downarrow":"⇓","DownArrowUpArrow":"⇵","DownBreve":"̑","downdownarrows":"⇊","downharpoonleft":"⇃","downharpoonright":"⇂","DownLeftRightVector":"⥐","DownLeftTeeVector":"⥞","DownLeftVectorBar":"⥖","DownLeftVector":"↽","DownRightTeeVector":"⥟","DownRightVectorBar":"⥗","DownRightVector":"⇁","DownTeeArrow":"↧","DownTee":"⊤","drbkarow":"⤐","drcorn":"⌟","drcrop":"⌌","Dscr":"𝒟","dscr":"𝒹","DScy":"Ѕ","dscy":"ѕ","dsol":"⧶","Dstrok":"Đ","dstrok":"đ","dtdot":"⋱","dtri":"▿","dtrif":"▾","duarr":"⇵","duhar":"⥯","dwangle":"⦦","DZcy":"Џ","dzcy":"џ","dzigrarr":"⟿","Eacute":"É","eacute":"é","easter":"⩮","Ecaron":"Ě","ecaron":"ě","Ecirc":"Ê","ecirc":"ê","ecir":"≖","ecolon":"≕","Ecy":"Э","ecy":"э","eDDot":"⩷","Edot":"Ė","edot":"ė","eDot":"≑","ee":"ⅇ","efDot":"≒","Efr":"𝔈","efr":"𝔢","eg":"⪚","Egrave":"È","egrave":"è","egs":"⪖","egsdot":"⪘","el":"⪙","Element":"∈","elinters":"⏧","ell":"ℓ","els":"⪕","elsdot":"⪗","Emacr":"Ē","emacr":"ē","empty":"∅","emptyset":"∅","EmptySmallSquare":"◻","emptyv":"∅","EmptyVerySmallSquare":"▫","emsp13":" ","emsp14":" ","emsp":" ","ENG":"Ŋ","eng":"ŋ","ensp":" ","Eogon":"Ę","eogon":"ę","Eopf":"𝔼","eopf":"𝕖","epar":"⋕","eparsl":"⧣","eplus":"⩱","epsi":"ε","Epsilon":"Ε","epsilon":"ε","epsiv":"ϵ","eqcirc":"≖","eqcolon":"≕","eqsim":"≂","eqslantgtr":"⪖","eqslantless":"⪕","Equal":"⩵","equals":"=","EqualTilde":"≂","equest":"≟","Equilibrium":"⇌","equiv":"≡","equivDD":"⩸","eqvparsl":"⧥","erarr":"⥱","erDot":"≓","escr":"ℯ","Escr":"ℰ","esdot":"≐","Esim":"⩳","esim":"≂","Eta":"Η","eta":"η","ETH":"Ð","eth":"ð","Euml":"Ë","euml":"ë","euro":"€","excl":"!","exist":"∃","Exists":"∃","expectation":"ℰ","exponentiale":"ⅇ","ExponentialE":"ⅇ","fallingdotseq":"≒","Fcy":"Ф","fcy":"ф","female":"♀","ffilig":"ffi","fflig":"ff","ffllig":"ffl","Ffr":"𝔉","ffr":"𝔣","filig":"fi","FilledSmallSquare":"◼","FilledVerySmallSquare":"▪","fjlig":"fj","flat":"♭","fllig":"fl","fltns":"▱","fnof":"ƒ","Fopf":"𝔽","fopf":"𝕗","forall":"∀","ForAll":"∀","fork":"⋔","forkv":"⫙","Fouriertrf":"ℱ","fpartint":"⨍","frac12":"½","frac13":"⅓","frac14":"¼","frac15":"⅕","frac16":"⅙","frac18":"⅛","frac23":"⅔","frac25":"⅖","frac34":"¾","frac35":"⅗","frac38":"⅜","frac45":"⅘","frac56":"⅚","frac58":"⅝","frac78":"⅞","frasl":"⁄","frown":"⌢","fscr":"𝒻","Fscr":"ℱ","gacute":"ǵ","Gamma":"Γ","gamma":"γ","Gammad":"Ϝ","gammad":"ϝ","gap":"⪆","Gbreve":"Ğ","gbreve":"ğ","Gcedil":"Ģ","Gcirc":"Ĝ","gcirc":"ĝ","Gcy":"Г","gcy":"г","Gdot":"Ġ","gdot":"ġ","ge":"≥","gE":"≧","gEl":"⪌","gel":"⋛","geq":"≥","geqq":"≧","geqslant":"⩾","gescc":"⪩","ges":"⩾","gesdot":"⪀","gesdoto":"⪂","gesdotol":"⪄","gesl":"⋛︀","gesles":"⪔","Gfr":"𝔊","gfr":"𝔤","gg":"≫","Gg":"⋙","ggg":"⋙","gimel":"ℷ","GJcy":"Ѓ","gjcy":"ѓ","gla":"⪥","gl":"≷","glE":"⪒","glj":"⪤","gnap":"⪊","gnapprox":"⪊","gne":"⪈","gnE":"≩","gneq":"⪈","gneqq":"≩","gnsim":"⋧","Gopf":"𝔾","gopf":"𝕘","grave":"`","GreaterEqual":"≥","GreaterEqualLess":"⋛","GreaterFullEqual":"≧","GreaterGreater":"⪢","GreaterLess":"≷","GreaterSlantEqual":"⩾","GreaterTilde":"≳","Gscr":"𝒢","gscr":"ℊ","gsim":"≳","gsime":"⪎","gsiml":"⪐","gtcc":"⪧","gtcir":"⩺","gt":">","GT":">","Gt":"≫","gtdot":"⋗","gtlPar":"⦕","gtquest":"⩼","gtrapprox":"⪆","gtrarr":"⥸","gtrdot":"⋗","gtreqless":"⋛","gtreqqless":"⪌","gtrless":"≷","gtrsim":"≳","gvertneqq":"≩︀","gvnE":"≩︀","Hacek":"ˇ","hairsp":" ","half":"½","hamilt":"ℋ","HARDcy":"Ъ","hardcy":"ъ","harrcir":"⥈","harr":"↔","hArr":"⇔","harrw":"↭","Hat":"^","hbar":"ℏ","Hcirc":"Ĥ","hcirc":"ĥ","hearts":"♥","heartsuit":"♥","hellip":"…","hercon":"⊹","hfr":"𝔥","Hfr":"ℌ","HilbertSpace":"ℋ","hksearow":"⤥","hkswarow":"⤦","hoarr":"⇿","homtht":"∻","hookleftarrow":"↩","hookrightarrow":"↪","hopf":"𝕙","Hopf":"ℍ","horbar":"―","HorizontalLine":"─","hscr":"𝒽","Hscr":"ℋ","hslash":"ℏ","Hstrok":"Ħ","hstrok":"ħ","HumpDownHump":"≎","HumpEqual":"≏","hybull":"⁃","hyphen":"‐","Iacute":"Í","iacute":"í","ic":"⁣","Icirc":"Î","icirc":"î","Icy":"И","icy":"и","Idot":"İ","IEcy":"Е","iecy":"е","iexcl":"¡","iff":"⇔","ifr":"𝔦","Ifr":"ℑ","Igrave":"Ì","igrave":"ì","ii":"ⅈ","iiiint":"⨌","iiint":"∭","iinfin":"⧜","iiota":"℩","IJlig":"IJ","ijlig":"ij","Imacr":"Ī","imacr":"ī","image":"ℑ","ImaginaryI":"ⅈ","imagline":"ℐ","imagpart":"ℑ","imath":"ı","Im":"ℑ","imof":"⊷","imped":"Ƶ","Implies":"⇒","incare":"℅","in":"∈","infin":"∞","infintie":"⧝","inodot":"ı","intcal":"⊺","int":"∫","Int":"∬","integers":"ℤ","Integral":"∫","intercal":"⊺","Intersection":"⋂","intlarhk":"⨗","intprod":"⨼","InvisibleComma":"⁣","InvisibleTimes":"⁢","IOcy":"Ё","iocy":"ё","Iogon":"Į","iogon":"į","Iopf":"𝕀","iopf":"𝕚","Iota":"Ι","iota":"ι","iprod":"⨼","iquest":"¿","iscr":"𝒾","Iscr":"ℐ","isin":"∈","isindot":"⋵","isinE":"⋹","isins":"⋴","isinsv":"⋳","isinv":"∈","it":"⁢","Itilde":"Ĩ","itilde":"ĩ","Iukcy":"І","iukcy":"і","Iuml":"Ï","iuml":"ï","Jcirc":"Ĵ","jcirc":"ĵ","Jcy":"Й","jcy":"й","Jfr":"𝔍","jfr":"𝔧","jmath":"ȷ","Jopf":"𝕁","jopf":"𝕛","Jscr":"𝒥","jscr":"𝒿","Jsercy":"Ј","jsercy":"ј","Jukcy":"Є","jukcy":"є","Kappa":"Κ","kappa":"κ","kappav":"ϰ","Kcedil":"Ķ","kcedil":"ķ","Kcy":"К","kcy":"к","Kfr":"𝔎","kfr":"𝔨","kgreen":"ĸ","KHcy":"Х","khcy":"х","KJcy":"Ќ","kjcy":"ќ","Kopf":"𝕂","kopf":"𝕜","Kscr":"𝒦","kscr":"𝓀","lAarr":"⇚","Lacute":"Ĺ","lacute":"ĺ","laemptyv":"⦴","lagran":"ℒ","Lambda":"Λ","lambda":"λ","lang":"⟨","Lang":"⟪","langd":"⦑","langle":"⟨","lap":"⪅","Laplacetrf":"ℒ","laquo":"«","larrb":"⇤","larrbfs":"⤟","larr":"←","Larr":"↞","lArr":"⇐","larrfs":"⤝","larrhk":"↩","larrlp":"↫","larrpl":"⤹","larrsim":"⥳","larrtl":"↢","latail":"⤙","lAtail":"⤛","lat":"⪫","late":"⪭","lates":"⪭︀","lbarr":"⤌","lBarr":"⤎","lbbrk":"❲","lbrace":"{","lbrack":"[","lbrke":"⦋","lbrksld":"⦏","lbrkslu":"⦍","Lcaron":"Ľ","lcaron":"ľ","Lcedil":"Ļ","lcedil":"ļ","lceil":"⌈","lcub":"{","Lcy":"Л","lcy":"л","ldca":"⤶","ldquo":"“","ldquor":"„","ldrdhar":"⥧","ldrushar":"⥋","ldsh":"↲","le":"≤","lE":"≦","LeftAngleBracket":"⟨","LeftArrowBar":"⇤","leftarrow":"←","LeftArrow":"←","Leftarrow":"⇐","LeftArrowRightArrow":"⇆","leftarrowtail":"↢","LeftCeiling":"⌈","LeftDoubleBracket":"⟦","LeftDownTeeVector":"⥡","LeftDownVectorBar":"⥙","LeftDownVector":"⇃","LeftFloor":"⌊","leftharpoondown":"↽","leftharpoonup":"↼","leftleftarrows":"⇇","leftrightarrow":"↔","LeftRightArrow":"↔","Leftrightarrow":"⇔","leftrightarrows":"⇆","leftrightharpoons":"⇋","leftrightsquigarrow":"↭","LeftRightVector":"⥎","LeftTeeArrow":"↤","LeftTee":"⊣","LeftTeeVector":"⥚","leftthreetimes":"⋋","LeftTriangleBar":"⧏","LeftTriangle":"⊲","LeftTriangleEqual":"⊴","LeftUpDownVector":"⥑","LeftUpTeeVector":"⥠","LeftUpVectorBar":"⥘","LeftUpVector":"↿","LeftVectorBar":"⥒","LeftVector":"↼","lEg":"⪋","leg":"⋚","leq":"≤","leqq":"≦","leqslant":"⩽","lescc":"⪨","les":"⩽","lesdot":"⩿","lesdoto":"⪁","lesdotor":"⪃","lesg":"⋚︀","lesges":"⪓","lessapprox":"⪅","lessdot":"⋖","lesseqgtr":"⋚","lesseqqgtr":"⪋","LessEqualGreater":"⋚","LessFullEqual":"≦","LessGreater":"≶","lessgtr":"≶","LessLess":"⪡","lesssim":"≲","LessSlantEqual":"⩽","LessTilde":"≲","lfisht":"⥼","lfloor":"⌊","Lfr":"𝔏","lfr":"𝔩","lg":"≶","lgE":"⪑","lHar":"⥢","lhard":"↽","lharu":"↼","lharul":"⥪","lhblk":"▄","LJcy":"Љ","ljcy":"љ","llarr":"⇇","ll":"≪","Ll":"⋘","llcorner":"⌞","Lleftarrow":"⇚","llhard":"⥫","lltri":"◺","Lmidot":"Ŀ","lmidot":"ŀ","lmoustache":"⎰","lmoust":"⎰","lnap":"⪉","lnapprox":"⪉","lne":"⪇","lnE":"≨","lneq":"⪇","lneqq":"≨","lnsim":"⋦","loang":"⟬","loarr":"⇽","lobrk":"⟦","longleftarrow":"⟵","LongLeftArrow":"⟵","Longleftarrow":"⟸","longleftrightarrow":"⟷","LongLeftRightArrow":"⟷","Longleftrightarrow":"⟺","longmapsto":"⟼","longrightarrow":"⟶","LongRightArrow":"⟶","Longrightarrow":"⟹","looparrowleft":"↫","looparrowright":"↬","lopar":"⦅","Lopf":"𝕃","lopf":"𝕝","loplus":"⨭","lotimes":"⨴","lowast":"∗","lowbar":"_","LowerLeftArrow":"↙","LowerRightArrow":"↘","loz":"◊","lozenge":"◊","lozf":"⧫","lpar":"(","lparlt":"⦓","lrarr":"⇆","lrcorner":"⌟","lrhar":"⇋","lrhard":"⥭","lrm":"‎","lrtri":"⊿","lsaquo":"‹","lscr":"𝓁","Lscr":"ℒ","lsh":"↰","Lsh":"↰","lsim":"≲","lsime":"⪍","lsimg":"⪏","lsqb":"[","lsquo":"‘","lsquor":"‚","Lstrok":"Ł","lstrok":"ł","ltcc":"⪦","ltcir":"⩹","lt":"<","LT":"<","Lt":"≪","ltdot":"⋖","lthree":"⋋","ltimes":"⋉","ltlarr":"⥶","ltquest":"⩻","ltri":"◃","ltrie":"⊴","ltrif":"◂","ltrPar":"⦖","lurdshar":"⥊","luruhar":"⥦","lvertneqq":"≨︀","lvnE":"≨︀","macr":"¯","male":"♂","malt":"✠","maltese":"✠","Map":"⤅","map":"↦","mapsto":"↦","mapstodown":"↧","mapstoleft":"↤","mapstoup":"↥","marker":"▮","mcomma":"⨩","Mcy":"М","mcy":"м","mdash":"—","mDDot":"∺","measuredangle":"∡","MediumSpace":" ","Mellintrf":"ℳ","Mfr":"𝔐","mfr":"𝔪","mho":"℧","micro":"µ","midast":"*","midcir":"⫰","mid":"∣","middot":"·","minusb":"⊟","minus":"−","minusd":"∸","minusdu":"⨪","MinusPlus":"∓","mlcp":"⫛","mldr":"…","mnplus":"∓","models":"⊧","Mopf":"𝕄","mopf":"𝕞","mp":"∓","mscr":"𝓂","Mscr":"ℳ","mstpos":"∾","Mu":"Μ","mu":"μ","multimap":"⊸","mumap":"⊸","nabla":"∇","Nacute":"Ń","nacute":"ń","nang":"∠⃒","nap":"≉","napE":"⩰̸","napid":"≋̸","napos":"ʼn","napprox":"≉","natural":"♮","naturals":"ℕ","natur":"♮","nbsp":" ","nbump":"≎̸","nbumpe":"≏̸","ncap":"⩃","Ncaron":"Ň","ncaron":"ň","Ncedil":"Ņ","ncedil":"ņ","ncong":"≇","ncongdot":"⩭̸","ncup":"⩂","Ncy":"Н","ncy":"н","ndash":"–","nearhk":"⤤","nearr":"↗","neArr":"⇗","nearrow":"↗","ne":"≠","nedot":"≐̸","NegativeMediumSpace":"​","NegativeThickSpace":"​","NegativeThinSpace":"​","NegativeVeryThinSpace":"​","nequiv":"≢","nesear":"⤨","nesim":"≂̸","NestedGreaterGreater":"≫","NestedLessLess":"≪","NewLine":"\n","nexist":"∄","nexists":"∄","Nfr":"𝔑","nfr":"𝔫","ngE":"≧̸","nge":"≱","ngeq":"≱","ngeqq":"≧̸","ngeqslant":"⩾̸","nges":"⩾̸","nGg":"⋙̸","ngsim":"≵","nGt":"≫⃒","ngt":"≯","ngtr":"≯","nGtv":"≫̸","nharr":"↮","nhArr":"⇎","nhpar":"⫲","ni":"∋","nis":"⋼","nisd":"⋺","niv":"∋","NJcy":"Њ","njcy":"њ","nlarr":"↚","nlArr":"⇍","nldr":"‥","nlE":"≦̸","nle":"≰","nleftarrow":"↚","nLeftarrow":"⇍","nleftrightarrow":"↮","nLeftrightarrow":"⇎","nleq":"≰","nleqq":"≦̸","nleqslant":"⩽̸","nles":"⩽̸","nless":"≮","nLl":"⋘̸","nlsim":"≴","nLt":"≪⃒","nlt":"≮","nltri":"⋪","nltrie":"⋬","nLtv":"≪̸","nmid":"∤","NoBreak":"⁠","NonBreakingSpace":" ","nopf":"𝕟","Nopf":"ℕ","Not":"⫬","not":"¬","NotCongruent":"≢","NotCupCap":"≭","NotDoubleVerticalBar":"∦","NotElement":"∉","NotEqual":"≠","NotEqualTilde":"≂̸","NotExists":"∄","NotGreater":"≯","NotGreaterEqual":"≱","NotGreaterFullEqual":"≧̸","NotGreaterGreater":"≫̸","NotGreaterLess":"≹","NotGreaterSlantEqual":"⩾̸","NotGreaterTilde":"≵","NotHumpDownHump":"≎̸","NotHumpEqual":"≏̸","notin":"∉","notindot":"⋵̸","notinE":"⋹̸","notinva":"∉","notinvb":"⋷","notinvc":"⋶","NotLeftTriangleBar":"⧏̸","NotLeftTriangle":"⋪","NotLeftTriangleEqual":"⋬","NotLess":"≮","NotLessEqual":"≰","NotLessGreater":"≸","NotLessLess":"≪̸","NotLessSlantEqual":"⩽̸","NotLessTilde":"≴","NotNestedGreaterGreater":"⪢̸","NotNestedLessLess":"⪡̸","notni":"∌","notniva":"∌","notnivb":"⋾","notnivc":"⋽","NotPrecedes":"⊀","NotPrecedesEqual":"⪯̸","NotPrecedesSlantEqual":"⋠","NotReverseElement":"∌","NotRightTriangleBar":"⧐̸","NotRightTriangle":"⋫","NotRightTriangleEqual":"⋭","NotSquareSubset":"⊏̸","NotSquareSubsetEqual":"⋢","NotSquareSuperset":"⊐̸","NotSquareSupersetEqual":"⋣","NotSubset":"⊂⃒","NotSubsetEqual":"⊈","NotSucceeds":"⊁","NotSucceedsEqual":"⪰̸","NotSucceedsSlantEqual":"⋡","NotSucceedsTilde":"≿̸","NotSuperset":"⊃⃒","NotSupersetEqual":"⊉","NotTilde":"≁","NotTildeEqual":"≄","NotTildeFullEqual":"≇","NotTildeTilde":"≉","NotVerticalBar":"∤","nparallel":"∦","npar":"∦","nparsl":"⫽⃥","npart":"∂̸","npolint":"⨔","npr":"⊀","nprcue":"⋠","nprec":"⊀","npreceq":"⪯̸","npre":"⪯̸","nrarrc":"⤳̸","nrarr":"↛","nrArr":"⇏","nrarrw":"↝̸","nrightarrow":"↛","nRightarrow":"⇏","nrtri":"⋫","nrtrie":"⋭","nsc":"⊁","nsccue":"⋡","nsce":"⪰̸","Nscr":"𝒩","nscr":"𝓃","nshortmid":"∤","nshortparallel":"∦","nsim":"≁","nsime":"≄","nsimeq":"≄","nsmid":"∤","nspar":"∦","nsqsube":"⋢","nsqsupe":"⋣","nsub":"⊄","nsubE":"⫅̸","nsube":"⊈","nsubset":"⊂⃒","nsubseteq":"⊈","nsubseteqq":"⫅̸","nsucc":"⊁","nsucceq":"⪰̸","nsup":"⊅","nsupE":"⫆̸","nsupe":"⊉","nsupset":"⊃⃒","nsupseteq":"⊉","nsupseteqq":"⫆̸","ntgl":"≹","Ntilde":"Ñ","ntilde":"ñ","ntlg":"≸","ntriangleleft":"⋪","ntrianglelefteq":"⋬","ntriangleright":"⋫","ntrianglerighteq":"⋭","Nu":"Ν","nu":"ν","num":"#","numero":"№","numsp":" ","nvap":"≍⃒","nvdash":"⊬","nvDash":"⊭","nVdash":"⊮","nVDash":"⊯","nvge":"≥⃒","nvgt":">⃒","nvHarr":"⤄","nvinfin":"⧞","nvlArr":"⤂","nvle":"≤⃒","nvlt":"<⃒","nvltrie":"⊴⃒","nvrArr":"⤃","nvrtrie":"⊵⃒","nvsim":"∼⃒","nwarhk":"⤣","nwarr":"↖","nwArr":"⇖","nwarrow":"↖","nwnear":"⤧","Oacute":"Ó","oacute":"ó","oast":"⊛","Ocirc":"Ô","ocirc":"ô","ocir":"⊚","Ocy":"О","ocy":"о","odash":"⊝","Odblac":"Ő","odblac":"ő","odiv":"⨸","odot":"⊙","odsold":"⦼","OElig":"Œ","oelig":"œ","ofcir":"⦿","Ofr":"𝔒","ofr":"𝔬","ogon":"˛","Ograve":"Ò","ograve":"ò","ogt":"⧁","ohbar":"⦵","ohm":"Ω","oint":"∮","olarr":"↺","olcir":"⦾","olcross":"⦻","oline":"‾","olt":"⧀","Omacr":"Ō","omacr":"ō","Omega":"Ω","omega":"ω","Omicron":"Ο","omicron":"ο","omid":"⦶","ominus":"⊖","Oopf":"𝕆","oopf":"𝕠","opar":"⦷","OpenCurlyDoubleQuote":"“","OpenCurlyQuote":"‘","operp":"⦹","oplus":"⊕","orarr":"↻","Or":"⩔","or":"∨","ord":"⩝","order":"ℴ","orderof":"ℴ","ordf":"ª","ordm":"º","origof":"⊶","oror":"⩖","orslope":"⩗","orv":"⩛","oS":"Ⓢ","Oscr":"𝒪","oscr":"ℴ","Oslash":"Ø","oslash":"ø","osol":"⊘","Otilde":"Õ","otilde":"õ","otimesas":"⨶","Otimes":"⨷","otimes":"⊗","Ouml":"Ö","ouml":"ö","ovbar":"⌽","OverBar":"‾","OverBrace":"⏞","OverBracket":"⎴","OverParenthesis":"⏜","para":"¶","parallel":"∥","par":"∥","parsim":"⫳","parsl":"⫽","part":"∂","PartialD":"∂","Pcy":"П","pcy":"п","percnt":"%","period":".","permil":"‰","perp":"⊥","pertenk":"‱","Pfr":"𝔓","pfr":"𝔭","Phi":"Φ","phi":"φ","phiv":"ϕ","phmmat":"ℳ","phone":"☎","Pi":"Π","pi":"π","pitchfork":"⋔","piv":"ϖ","planck":"ℏ","planckh":"ℎ","plankv":"ℏ","plusacir":"⨣","plusb":"⊞","pluscir":"⨢","plus":"+","plusdo":"∔","plusdu":"⨥","pluse":"⩲","PlusMinus":"±","plusmn":"±","plussim":"⨦","plustwo":"⨧","pm":"±","Poincareplane":"ℌ","pointint":"⨕","popf":"𝕡","Popf":"ℙ","pound":"£","prap":"⪷","Pr":"⪻","pr":"≺","prcue":"≼","precapprox":"⪷","prec":"≺","preccurlyeq":"≼","Precedes":"≺","PrecedesEqual":"⪯","PrecedesSlantEqual":"≼","PrecedesTilde":"≾","preceq":"⪯","precnapprox":"⪹","precneqq":"⪵","precnsim":"⋨","pre":"⪯","prE":"⪳","precsim":"≾","prime":"′","Prime":"″","primes":"ℙ","prnap":"⪹","prnE":"⪵","prnsim":"⋨","prod":"∏","Product":"∏","profalar":"⌮","profline":"⌒","profsurf":"⌓","prop":"∝","Proportional":"∝","Proportion":"∷","propto":"∝","prsim":"≾","prurel":"⊰","Pscr":"𝒫","pscr":"𝓅","Psi":"Ψ","psi":"ψ","puncsp":" ","Qfr":"𝔔","qfr":"𝔮","qint":"⨌","qopf":"𝕢","Qopf":"ℚ","qprime":"⁗","Qscr":"𝒬","qscr":"𝓆","quaternions":"ℍ","quatint":"⨖","quest":"?","questeq":"≟","quot":"\"","QUOT":"\"","rAarr":"⇛","race":"∽̱","Racute":"Ŕ","racute":"ŕ","radic":"√","raemptyv":"⦳","rang":"⟩","Rang":"⟫","rangd":"⦒","range":"⦥","rangle":"⟩","raquo":"»","rarrap":"⥵","rarrb":"⇥","rarrbfs":"⤠","rarrc":"⤳","rarr":"→","Rarr":"↠","rArr":"⇒","rarrfs":"⤞","rarrhk":"↪","rarrlp":"↬","rarrpl":"⥅","rarrsim":"⥴","Rarrtl":"⤖","rarrtl":"↣","rarrw":"↝","ratail":"⤚","rAtail":"⤜","ratio":"∶","rationals":"ℚ","rbarr":"⤍","rBarr":"⤏","RBarr":"⤐","rbbrk":"❳","rbrace":"}","rbrack":"]","rbrke":"⦌","rbrksld":"⦎","rbrkslu":"⦐","Rcaron":"Ř","rcaron":"ř","Rcedil":"Ŗ","rcedil":"ŗ","rceil":"⌉","rcub":"}","Rcy":"Р","rcy":"р","rdca":"⤷","rdldhar":"⥩","rdquo":"”","rdquor":"”","rdsh":"↳","real":"ℜ","realine":"ℛ","realpart":"ℜ","reals":"ℝ","Re":"ℜ","rect":"▭","reg":"®","REG":"®","ReverseElement":"∋","ReverseEquilibrium":"⇋","ReverseUpEquilibrium":"⥯","rfisht":"⥽","rfloor":"⌋","rfr":"𝔯","Rfr":"ℜ","rHar":"⥤","rhard":"⇁","rharu":"⇀","rharul":"⥬","Rho":"Ρ","rho":"ρ","rhov":"ϱ","RightAngleBracket":"⟩","RightArrowBar":"⇥","rightarrow":"→","RightArrow":"→","Rightarrow":"⇒","RightArrowLeftArrow":"⇄","rightarrowtail":"↣","RightCeiling":"⌉","RightDoubleBracket":"⟧","RightDownTeeVector":"⥝","RightDownVectorBar":"⥕","RightDownVector":"⇂","RightFloor":"⌋","rightharpoondown":"⇁","rightharpoonup":"⇀","rightleftarrows":"⇄","rightleftharpoons":"⇌","rightrightarrows":"⇉","rightsquigarrow":"↝","RightTeeArrow":"↦","RightTee":"⊢","RightTeeVector":"⥛","rightthreetimes":"⋌","RightTriangleBar":"⧐","RightTriangle":"⊳","RightTriangleEqual":"⊵","RightUpDownVector":"⥏","RightUpTeeVector":"⥜","RightUpVectorBar":"⥔","RightUpVector":"↾","RightVectorBar":"⥓","RightVector":"⇀","ring":"˚","risingdotseq":"≓","rlarr":"⇄","rlhar":"⇌","rlm":"‏","rmoustache":"⎱","rmoust":"⎱","rnmid":"⫮","roang":"⟭","roarr":"⇾","robrk":"⟧","ropar":"⦆","ropf":"𝕣","Ropf":"ℝ","roplus":"⨮","rotimes":"⨵","RoundImplies":"⥰","rpar":")","rpargt":"⦔","rppolint":"⨒","rrarr":"⇉","Rrightarrow":"⇛","rsaquo":"›","rscr":"𝓇","Rscr":"ℛ","rsh":"↱","Rsh":"↱","rsqb":"]","rsquo":"’","rsquor":"’","rthree":"⋌","rtimes":"⋊","rtri":"▹","rtrie":"⊵","rtrif":"▸","rtriltri":"⧎","RuleDelayed":"⧴","ruluhar":"⥨","rx":"℞","Sacute":"Ś","sacute":"ś","sbquo":"‚","scap":"⪸","Scaron":"Š","scaron":"š","Sc":"⪼","sc":"≻","sccue":"≽","sce":"⪰","scE":"⪴","Scedil":"Ş","scedil":"ş","Scirc":"Ŝ","scirc":"ŝ","scnap":"⪺","scnE":"⪶","scnsim":"⋩","scpolint":"⨓","scsim":"≿","Scy":"С","scy":"с","sdotb":"⊡","sdot":"⋅","sdote":"⩦","searhk":"⤥","searr":"↘","seArr":"⇘","searrow":"↘","sect":"§","semi":";","seswar":"⤩","setminus":"∖","setmn":"∖","sext":"✶","Sfr":"𝔖","sfr":"𝔰","sfrown":"⌢","sharp":"♯","SHCHcy":"Щ","shchcy":"щ","SHcy":"Ш","shcy":"ш","ShortDownArrow":"↓","ShortLeftArrow":"←","shortmid":"∣","shortparallel":"∥","ShortRightArrow":"→","ShortUpArrow":"↑","shy":"­","Sigma":"Σ","sigma":"σ","sigmaf":"ς","sigmav":"ς","sim":"∼","simdot":"⩪","sime":"≃","simeq":"≃","simg":"⪞","simgE":"⪠","siml":"⪝","simlE":"⪟","simne":"≆","simplus":"⨤","simrarr":"⥲","slarr":"←","SmallCircle":"∘","smallsetminus":"∖","smashp":"⨳","smeparsl":"⧤","smid":"∣","smile":"⌣","smt":"⪪","smte":"⪬","smtes":"⪬︀","SOFTcy":"Ь","softcy":"ь","solbar":"⌿","solb":"⧄","sol":"/","Sopf":"𝕊","sopf":"𝕤","spades":"♠","spadesuit":"♠","spar":"∥","sqcap":"⊓","sqcaps":"⊓︀","sqcup":"⊔","sqcups":"⊔︀","Sqrt":"√","sqsub":"⊏","sqsube":"⊑","sqsubset":"⊏","sqsubseteq":"⊑","sqsup":"⊐","sqsupe":"⊒","sqsupset":"⊐","sqsupseteq":"⊒","square":"□","Square":"□","SquareIntersection":"⊓","SquareSubset":"⊏","SquareSubsetEqual":"⊑","SquareSuperset":"⊐","SquareSupersetEqual":"⊒","SquareUnion":"⊔","squarf":"▪","squ":"□","squf":"▪","srarr":"→","Sscr":"𝒮","sscr":"𝓈","ssetmn":"∖","ssmile":"⌣","sstarf":"⋆","Star":"⋆","star":"☆","starf":"★","straightepsilon":"ϵ","straightphi":"ϕ","strns":"¯","sub":"⊂","Sub":"⋐","subdot":"⪽","subE":"⫅","sube":"⊆","subedot":"⫃","submult":"⫁","subnE":"⫋","subne":"⊊","subplus":"⪿","subrarr":"⥹","subset":"⊂","Subset":"⋐","subseteq":"⊆","subseteqq":"⫅","SubsetEqual":"⊆","subsetneq":"⊊","subsetneqq":"⫋","subsim":"⫇","subsub":"⫕","subsup":"⫓","succapprox":"⪸","succ":"≻","succcurlyeq":"≽","Succeeds":"≻","SucceedsEqual":"⪰","SucceedsSlantEqual":"≽","SucceedsTilde":"≿","succeq":"⪰","succnapprox":"⪺","succneqq":"⪶","succnsim":"⋩","succsim":"≿","SuchThat":"∋","sum":"∑","Sum":"∑","sung":"♪","sup1":"¹","sup2":"²","sup3":"³","sup":"⊃","Sup":"⋑","supdot":"⪾","supdsub":"⫘","supE":"⫆","supe":"⊇","supedot":"⫄","Superset":"⊃","SupersetEqual":"⊇","suphsol":"⟉","suphsub":"⫗","suplarr":"⥻","supmult":"⫂","supnE":"⫌","supne":"⊋","supplus":"⫀","supset":"⊃","Supset":"⋑","supseteq":"⊇","supseteqq":"⫆","supsetneq":"⊋","supsetneqq":"⫌","supsim":"⫈","supsub":"⫔","supsup":"⫖","swarhk":"⤦","swarr":"↙","swArr":"⇙","swarrow":"↙","swnwar":"⤪","szlig":"ß","Tab":"\t","target":"⌖","Tau":"Τ","tau":"τ","tbrk":"⎴","Tcaron":"Ť","tcaron":"ť","Tcedil":"Ţ","tcedil":"ţ","Tcy":"Т","tcy":"т","tdot":"⃛","telrec":"⌕","Tfr":"𝔗","tfr":"𝔱","there4":"∴","therefore":"∴","Therefore":"∴","Theta":"Θ","theta":"θ","thetasym":"ϑ","thetav":"ϑ","thickapprox":"≈","thicksim":"∼","ThickSpace":"  ","ThinSpace":" ","thinsp":" ","thkap":"≈","thksim":"∼","THORN":"Þ","thorn":"þ","tilde":"˜","Tilde":"∼","TildeEqual":"≃","TildeFullEqual":"≅","TildeTilde":"≈","timesbar":"⨱","timesb":"⊠","times":"×","timesd":"⨰","tint":"∭","toea":"⤨","topbot":"⌶","topcir":"⫱","top":"⊤","Topf":"𝕋","topf":"𝕥","topfork":"⫚","tosa":"⤩","tprime":"‴","trade":"™","TRADE":"™","triangle":"▵","triangledown":"▿","triangleleft":"◃","trianglelefteq":"⊴","triangleq":"≜","triangleright":"▹","trianglerighteq":"⊵","tridot":"◬","trie":"≜","triminus":"⨺","TripleDot":"⃛","triplus":"⨹","trisb":"⧍","tritime":"⨻","trpezium":"⏢","Tscr":"𝒯","tscr":"𝓉","TScy":"Ц","tscy":"ц","TSHcy":"Ћ","tshcy":"ћ","Tstrok":"Ŧ","tstrok":"ŧ","twixt":"≬","twoheadleftarrow":"↞","twoheadrightarrow":"↠","Uacute":"Ú","uacute":"ú","uarr":"↑","Uarr":"↟","uArr":"⇑","Uarrocir":"⥉","Ubrcy":"Ў","ubrcy":"ў","Ubreve":"Ŭ","ubreve":"ŭ","Ucirc":"Û","ucirc":"û","Ucy":"У","ucy":"у","udarr":"⇅","Udblac":"Ű","udblac":"ű","udhar":"⥮","ufisht":"⥾","Ufr":"𝔘","ufr":"𝔲","Ugrave":"Ù","ugrave":"ù","uHar":"⥣","uharl":"↿","uharr":"↾","uhblk":"▀","ulcorn":"⌜","ulcorner":"⌜","ulcrop":"⌏","ultri":"◸","Umacr":"Ū","umacr":"ū","uml":"¨","UnderBar":"_","UnderBrace":"⏟","UnderBracket":"⎵","UnderParenthesis":"⏝","Union":"⋃","UnionPlus":"⊎","Uogon":"Ų","uogon":"ų","Uopf":"𝕌","uopf":"𝕦","UpArrowBar":"⤒","uparrow":"↑","UpArrow":"↑","Uparrow":"⇑","UpArrowDownArrow":"⇅","updownarrow":"↕","UpDownArrow":"↕","Updownarrow":"⇕","UpEquilibrium":"⥮","upharpoonleft":"↿","upharpoonright":"↾","uplus":"⊎","UpperLeftArrow":"↖","UpperRightArrow":"↗","upsi":"υ","Upsi":"ϒ","upsih":"ϒ","Upsilon":"Υ","upsilon":"υ","UpTeeArrow":"↥","UpTee":"⊥","upuparrows":"⇈","urcorn":"⌝","urcorner":"⌝","urcrop":"⌎","Uring":"Ů","uring":"ů","urtri":"◹","Uscr":"𝒰","uscr":"𝓊","utdot":"⋰","Utilde":"Ũ","utilde":"ũ","utri":"▵","utrif":"▴","uuarr":"⇈","Uuml":"Ü","uuml":"ü","uwangle":"⦧","vangrt":"⦜","varepsilon":"ϵ","varkappa":"ϰ","varnothing":"∅","varphi":"ϕ","varpi":"ϖ","varpropto":"∝","varr":"↕","vArr":"⇕","varrho":"ϱ","varsigma":"ς","varsubsetneq":"⊊︀","varsubsetneqq":"⫋︀","varsupsetneq":"⊋︀","varsupsetneqq":"⫌︀","vartheta":"ϑ","vartriangleleft":"⊲","vartriangleright":"⊳","vBar":"⫨","Vbar":"⫫","vBarv":"⫩","Vcy":"В","vcy":"в","vdash":"⊢","vDash":"⊨","Vdash":"⊩","VDash":"⊫","Vdashl":"⫦","veebar":"⊻","vee":"∨","Vee":"⋁","veeeq":"≚","vellip":"⋮","verbar":"|","Verbar":"‖","vert":"|","Vert":"‖","VerticalBar":"∣","VerticalLine":"|","VerticalSeparator":"❘","VerticalTilde":"≀","VeryThinSpace":" ","Vfr":"𝔙","vfr":"𝔳","vltri":"⊲","vnsub":"⊂⃒","vnsup":"⊃⃒","Vopf":"𝕍","vopf":"𝕧","vprop":"∝","vrtri":"⊳","Vscr":"𝒱","vscr":"𝓋","vsubnE":"⫋︀","vsubne":"⊊︀","vsupnE":"⫌︀","vsupne":"⊋︀","Vvdash":"⊪","vzigzag":"⦚","Wcirc":"Ŵ","wcirc":"ŵ","wedbar":"⩟","wedge":"∧","Wedge":"⋀","wedgeq":"≙","weierp":"℘","Wfr":"𝔚","wfr":"𝔴","Wopf":"𝕎","wopf":"𝕨","wp":"℘","wr":"≀","wreath":"≀","Wscr":"𝒲","wscr":"𝓌","xcap":"⋂","xcirc":"◯","xcup":"⋃","xdtri":"▽","Xfr":"𝔛","xfr":"𝔵","xharr":"⟷","xhArr":"⟺","Xi":"Ξ","xi":"ξ","xlarr":"⟵","xlArr":"⟸","xmap":"⟼","xnis":"⋻","xodot":"⨀","Xopf":"𝕏","xopf":"𝕩","xoplus":"⨁","xotime":"⨂","xrarr":"⟶","xrArr":"⟹","Xscr":"𝒳","xscr":"𝓍","xsqcup":"⨆","xuplus":"⨄","xutri":"△","xvee":"⋁","xwedge":"⋀","Yacute":"Ý","yacute":"ý","YAcy":"Я","yacy":"я","Ycirc":"Ŷ","ycirc":"ŷ","Ycy":"Ы","ycy":"ы","yen":"¥","Yfr":"𝔜","yfr":"𝔶","YIcy":"Ї","yicy":"ї","Yopf":"𝕐","yopf":"𝕪","Yscr":"𝒴","yscr":"𝓎","YUcy":"Ю","yucy":"ю","yuml":"ÿ","Yuml":"Ÿ","Zacute":"Ź","zacute":"ź","Zcaron":"Ž","zcaron":"ž","Zcy":"З","zcy":"з","Zdot":"Ż","zdot":"ż","zeetrf":"ℨ","ZeroWidthSpace":"​","Zeta":"Ζ","zeta":"ζ","zfr":"𝔷","Zfr":"ℨ","ZHcy":"Ж","zhcy":"ж","zigrarr":"⇝","zopf":"𝕫","Zopf":"ℤ","Zscr":"𝒵","zscr":"𝓏","zwj":"‍","zwnj":"‌"};

	var require$$1 = {"Aacute":"Á","aacute":"á","Acirc":"Â","acirc":"â","acute":"´","AElig":"Æ","aelig":"æ","Agrave":"À","agrave":"à","amp":"&","AMP":"&","Aring":"Å","aring":"å","Atilde":"Ã","atilde":"ã","Auml":"Ä","auml":"ä","brvbar":"¦","Ccedil":"Ç","ccedil":"ç","cedil":"¸","cent":"¢","copy":"©","COPY":"©","curren":"¤","deg":"°","divide":"÷","Eacute":"É","eacute":"é","Ecirc":"Ê","ecirc":"ê","Egrave":"È","egrave":"è","ETH":"Ð","eth":"ð","Euml":"Ë","euml":"ë","frac12":"½","frac14":"¼","frac34":"¾","gt":">","GT":">","Iacute":"Í","iacute":"í","Icirc":"Î","icirc":"î","iexcl":"¡","Igrave":"Ì","igrave":"ì","iquest":"¿","Iuml":"Ï","iuml":"ï","laquo":"«","lt":"<","LT":"<","macr":"¯","micro":"µ","middot":"·","nbsp":" ","not":"¬","Ntilde":"Ñ","ntilde":"ñ","Oacute":"Ó","oacute":"ó","Ocirc":"Ô","ocirc":"ô","Ograve":"Ò","ograve":"ò","ordf":"ª","ordm":"º","Oslash":"Ø","oslash":"ø","Otilde":"Õ","otilde":"õ","Ouml":"Ö","ouml":"ö","para":"¶","plusmn":"±","pound":"£","quot":"\"","QUOT":"\"","raquo":"»","reg":"®","REG":"®","sect":"§","shy":"­","sup1":"¹","sup2":"²","sup3":"³","szlig":"ß","THORN":"Þ","thorn":"þ","times":"×","Uacute":"Ú","uacute":"ú","Ucirc":"Û","ucirc":"û","Ugrave":"Ù","ugrave":"ù","uml":"¨","Uuml":"Ü","uuml":"ü","Yacute":"Ý","yacute":"ý","yen":"¥","yuml":"ÿ"};

	var require$$0$1 = {"amp":"&","apos":"'","gt":">","lt":"<","quot":"\""};

	var __importDefault$3 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(decode$1, "__esModule", { value: true });
	decode$1.decodeHTML = decode$1.decodeHTMLStrict = decode$1.decodeXML = void 0;
	var entities_json_1$1 = __importDefault$3(require$$1$1);
	var legacy_json_1 = __importDefault$3(require$$1);
	var xml_json_1$1 = __importDefault$3(require$$0$1);
	var decode_codepoint_1 = __importDefault$3(decode_codepoint);
	decode$1.decodeXML = getStrictDecoder(xml_json_1$1.default);
	decode$1.decodeHTMLStrict = getStrictDecoder(entities_json_1$1.default);
	function getStrictDecoder(map) {
	    var keys = Object.keys(map).join("|");
	    var replace = getReplacer(map);
	    keys += "|#[xX][\\da-fA-F]+|#\\d+";
	    var re = new RegExp("&(?:" + keys + ");", "g");
	    return function (str) { return String(str).replace(re, replace); };
	}
	var sorter = function (a, b) { return (a < b ? 1 : -1); };
	decode$1.decodeHTML = (function () {
	    var legacy = Object.keys(legacy_json_1.default).sort(sorter);
	    var keys = Object.keys(entities_json_1$1.default).sort(sorter);
	    for (var i = 0, j = 0; i < keys.length; i++) {
	        if (legacy[j] === keys[i]) {
	            keys[i] += ";?";
	            j++;
	        }
	        else {
	            keys[i] += ";";
	        }
	    }
	    var re = new RegExp("&(?:" + keys.join("|") + "|#[xX][\\da-fA-F]+;?|#\\d+;?)", "g");
	    var replace = getReplacer(entities_json_1$1.default);
	    function replacer(str) {
	        if (str.substr(-1) !== ";")
	            str += ";";
	        return replace(str);
	    }
	    //TODO consider creating a merged map
	    return function (str) { return String(str).replace(re, replacer); };
	})();
	function getReplacer(map) {
	    return function replace(str) {
	        if (str.charAt(1) === "#") {
	            var secondChar = str.charAt(2);
	            if (secondChar === "X" || secondChar === "x") {
	                return decode_codepoint_1.default(parseInt(str.substr(3), 16));
	            }
	            return decode_codepoint_1.default(parseInt(str.substr(2), 10));
	        }
	        return map[str.slice(1, -1)];
	    };
	}

	var encode$2 = {};

	var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(encode$2, "__esModule", { value: true });
	encode$2.escape = encode$2.encodeHTML = encode$2.encodeXML = void 0;
	var xml_json_1 = __importDefault$2(require$$0$1);
	var inverseXML = getInverseObj(xml_json_1.default);
	var xmlReplacer = getInverseReplacer(inverseXML);
	encode$2.encodeXML = getInverse(inverseXML, xmlReplacer);
	var entities_json_1 = __importDefault$2(require$$1$1);
	var inverseHTML = getInverseObj(entities_json_1.default);
	var htmlReplacer = getInverseReplacer(inverseHTML);
	encode$2.encodeHTML = getInverse(inverseHTML, htmlReplacer);
	function getInverseObj(obj) {
	    return Object.keys(obj)
	        .sort()
	        .reduce(function (inverse, name) {
	        inverse[obj[name]] = "&" + name + ";";
	        return inverse;
	    }, {});
	}
	function getInverseReplacer(inverse) {
	    var single = [];
	    var multiple = [];
	    for (var _i = 0, _a = Object.keys(inverse); _i < _a.length; _i++) {
	        var k = _a[_i];
	        if (k.length === 1) {
	            // Add value to single array
	            single.push("\\" + k);
	        }
	        else {
	            // Add value to multiple array
	            multiple.push(k);
	        }
	    }
	    // Add ranges to single characters.
	    single.sort();
	    for (var start = 0; start < single.length - 1; start++) {
	        // Find the end of a run of characters
	        var end = start;
	        while (end < single.length - 1 &&
	            single[end].charCodeAt(1) + 1 === single[end + 1].charCodeAt(1)) {
	            end += 1;
	        }
	        var count = 1 + end - start;
	        // We want to replace at least three characters
	        if (count < 3)
	            continue;
	        single.splice(start, count, single[start] + "-" + single[end]);
	    }
	    multiple.unshift("[" + single.join("") + "]");
	    return new RegExp(multiple.join("|"), "g");
	}
	var reNonASCII = /(?:[\x80-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/g;
	function singleCharReplacer(c) {
	    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
	    return "&#x" + c.codePointAt(0).toString(16).toUpperCase() + ";";
	}
	function getInverse(inverse, re) {
	    return function (data) {
	        return data
	            .replace(re, function (name) { return inverse[name]; })
	            .replace(reNonASCII, singleCharReplacer);
	    };
	}
	var reXmlChars = getInverseReplacer(inverseXML);
	function escape(data) {
	    return data
	        .replace(reXmlChars, singleCharReplacer)
	        .replace(reNonASCII, singleCharReplacer);
	}
	encode$2.escape = escape;

	(function (exports) {
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.encode = exports.decodeStrict = exports.decode = void 0;
		var decode_1 = decode$1;
		var encode_1 = encode$2;
		/**
		 * Decodes a string with entities.
		 *
		 * @param data String to decode.
		 * @param level Optional level to decode at. 0 = XML, 1 = HTML. Default is 0.
		 */
		function decode(data, level) {
		    return (!level || level <= 0 ? decode_1.decodeXML : decode_1.decodeHTML)(data);
		}
		exports.decode = decode;
		/**
		 * Decodes a string with entities. Does not allow missing trailing semicolons for entities.
		 *
		 * @param data String to decode.
		 * @param level Optional level to decode at. 0 = XML, 1 = HTML. Default is 0.
		 */
		function decodeStrict(data, level) {
		    return (!level || level <= 0 ? decode_1.decodeXML : decode_1.decodeHTMLStrict)(data);
		}
		exports.decodeStrict = decodeStrict;
		/**
		 * Encodes a string with entities.
		 *
		 * @param data String to encode.
		 * @param level Optional level to encode at. 0 = XML, 1 = HTML. Default is 0.
		 */
		function encode(data, level) {
		    return (!level || level <= 0 ? encode_1.encodeXML : encode_1.encodeHTML)(data);
		}
		exports.encode = encode;
		var encode_2 = encode$2;
		Object.defineProperty(exports, "encodeXML", { enumerable: true, get: function () { return encode_2.encodeXML; } });
		Object.defineProperty(exports, "encodeHTML", { enumerable: true, get: function () { return encode_2.encodeHTML; } });
		Object.defineProperty(exports, "escape", { enumerable: true, get: function () { return encode_2.escape; } });
		// Legacy aliases
		Object.defineProperty(exports, "encodeHTML4", { enumerable: true, get: function () { return encode_2.encodeHTML; } });
		Object.defineProperty(exports, "encodeHTML5", { enumerable: true, get: function () { return encode_2.encodeHTML; } });
		var decode_2 = decode$1;
		Object.defineProperty(exports, "decodeXML", { enumerable: true, get: function () { return decode_2.decodeXML; } });
		Object.defineProperty(exports, "decodeHTML", { enumerable: true, get: function () { return decode_2.decodeHTML; } });
		Object.defineProperty(exports, "decodeHTMLStrict", { enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } });
		// Legacy aliases
		Object.defineProperty(exports, "decodeHTML4", { enumerable: true, get: function () { return decode_2.decodeHTML; } });
		Object.defineProperty(exports, "decodeHTML5", { enumerable: true, get: function () { return decode_2.decodeHTML; } });
		Object.defineProperty(exports, "decodeHTML4Strict", { enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } });
		Object.defineProperty(exports, "decodeHTML5Strict", { enumerable: true, get: function () { return decode_2.decodeHTMLStrict; } });
		Object.defineProperty(exports, "decodeXMLStrict", { enumerable: true, get: function () { return decode_2.decodeXML; } }); 
	} (lib));

	var foreignNames = {};

	Object.defineProperty(foreignNames, "__esModule", { value: true });
	foreignNames.attributeNames = foreignNames.elementNames = void 0;
	foreignNames.elementNames = new Map([
	    ["altglyph", "altGlyph"],
	    ["altglyphdef", "altGlyphDef"],
	    ["altglyphitem", "altGlyphItem"],
	    ["animatecolor", "animateColor"],
	    ["animatemotion", "animateMotion"],
	    ["animatetransform", "animateTransform"],
	    ["clippath", "clipPath"],
	    ["feblend", "feBlend"],
	    ["fecolormatrix", "feColorMatrix"],
	    ["fecomponenttransfer", "feComponentTransfer"],
	    ["fecomposite", "feComposite"],
	    ["feconvolvematrix", "feConvolveMatrix"],
	    ["fediffuselighting", "feDiffuseLighting"],
	    ["fedisplacementmap", "feDisplacementMap"],
	    ["fedistantlight", "feDistantLight"],
	    ["fedropshadow", "feDropShadow"],
	    ["feflood", "feFlood"],
	    ["fefunca", "feFuncA"],
	    ["fefuncb", "feFuncB"],
	    ["fefuncg", "feFuncG"],
	    ["fefuncr", "feFuncR"],
	    ["fegaussianblur", "feGaussianBlur"],
	    ["feimage", "feImage"],
	    ["femerge", "feMerge"],
	    ["femergenode", "feMergeNode"],
	    ["femorphology", "feMorphology"],
	    ["feoffset", "feOffset"],
	    ["fepointlight", "fePointLight"],
	    ["fespecularlighting", "feSpecularLighting"],
	    ["fespotlight", "feSpotLight"],
	    ["fetile", "feTile"],
	    ["feturbulence", "feTurbulence"],
	    ["foreignobject", "foreignObject"],
	    ["glyphref", "glyphRef"],
	    ["lineargradient", "linearGradient"],
	    ["radialgradient", "radialGradient"],
	    ["textpath", "textPath"],
	]);
	foreignNames.attributeNames = new Map([
	    ["definitionurl", "definitionURL"],
	    ["attributename", "attributeName"],
	    ["attributetype", "attributeType"],
	    ["basefrequency", "baseFrequency"],
	    ["baseprofile", "baseProfile"],
	    ["calcmode", "calcMode"],
	    ["clippathunits", "clipPathUnits"],
	    ["diffuseconstant", "diffuseConstant"],
	    ["edgemode", "edgeMode"],
	    ["filterunits", "filterUnits"],
	    ["glyphref", "glyphRef"],
	    ["gradienttransform", "gradientTransform"],
	    ["gradientunits", "gradientUnits"],
	    ["kernelmatrix", "kernelMatrix"],
	    ["kernelunitlength", "kernelUnitLength"],
	    ["keypoints", "keyPoints"],
	    ["keysplines", "keySplines"],
	    ["keytimes", "keyTimes"],
	    ["lengthadjust", "lengthAdjust"],
	    ["limitingconeangle", "limitingConeAngle"],
	    ["markerheight", "markerHeight"],
	    ["markerunits", "markerUnits"],
	    ["markerwidth", "markerWidth"],
	    ["maskcontentunits", "maskContentUnits"],
	    ["maskunits", "maskUnits"],
	    ["numoctaves", "numOctaves"],
	    ["pathlength", "pathLength"],
	    ["patterncontentunits", "patternContentUnits"],
	    ["patterntransform", "patternTransform"],
	    ["patternunits", "patternUnits"],
	    ["pointsatx", "pointsAtX"],
	    ["pointsaty", "pointsAtY"],
	    ["pointsatz", "pointsAtZ"],
	    ["preservealpha", "preserveAlpha"],
	    ["preserveaspectratio", "preserveAspectRatio"],
	    ["primitiveunits", "primitiveUnits"],
	    ["refx", "refX"],
	    ["refy", "refY"],
	    ["repeatcount", "repeatCount"],
	    ["repeatdur", "repeatDur"],
	    ["requiredextensions", "requiredExtensions"],
	    ["requiredfeatures", "requiredFeatures"],
	    ["specularconstant", "specularConstant"],
	    ["specularexponent", "specularExponent"],
	    ["spreadmethod", "spreadMethod"],
	    ["startoffset", "startOffset"],
	    ["stddeviation", "stdDeviation"],
	    ["stitchtiles", "stitchTiles"],
	    ["surfacescale", "surfaceScale"],
	    ["systemlanguage", "systemLanguage"],
	    ["tablevalues", "tableValues"],
	    ["targetx", "targetX"],
	    ["targety", "targetY"],
	    ["textlength", "textLength"],
	    ["viewbox", "viewBox"],
	    ["viewtarget", "viewTarget"],
	    ["xchannelselector", "xChannelSelector"],
	    ["ychannelselector", "yChannelSelector"],
	    ["zoomandpan", "zoomAndPan"],
	]);

	var __assign$1 = (commonjsGlobal && commonjsGlobal.__assign) || function () {
	    __assign$1 = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign$1.apply(this, arguments);
	};
	var __createBinding$1 = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
	    if (k2 === undefined) k2 = k;
	    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
	}) : (function(o, m, k, k2) {
	    if (k2 === undefined) k2 = k;
	    o[k2] = m[k];
	}));
	var __setModuleDefault$1 = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
	    Object.defineProperty(o, "default", { enumerable: true, value: v });
	}) : function(o, v) {
	    o["default"] = v;
	});
	var __importStar$1 = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
	    if (mod && mod.__esModule) return mod;
	    var result = {};
	    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding$1(result, mod, k);
	    __setModuleDefault$1(result, mod);
	    return result;
	};
	Object.defineProperty(lib$1, "__esModule", { value: true });
	/*
	 * Module dependencies
	 */
	var ElementType = __importStar$1(lib$4);
	var entities_1 = lib;
	/**
	 * Mixed-case SVG and MathML tags & attributes
	 * recognized by the HTML parser.
	 *
	 * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign
	 */
	var foreignNames_1 = foreignNames;
	var unencodedElements = new Set([
	    "style",
	    "script",
	    "xmp",
	    "iframe",
	    "noembed",
	    "noframes",
	    "plaintext",
	    "noscript",
	]);
	/**
	 * Format attributes
	 */
	function formatAttributes(attributes, opts) {
	    if (!attributes)
	        return;
	    return Object.keys(attributes)
	        .map(function (key) {
	        var _a, _b;
	        var value = (_a = attributes[key]) !== null && _a !== void 0 ? _a : "";
	        if (opts.xmlMode === "foreign") {
	            /* Fix up mixed-case attribute names */
	            key = (_b = foreignNames_1.attributeNames.get(key)) !== null && _b !== void 0 ? _b : key;
	        }
	        if (!opts.emptyAttrs && !opts.xmlMode && value === "") {
	            return key;
	        }
	        return key + "=\"" + (opts.decodeEntities !== false
	            ? entities_1.encodeXML(value)
	            : value.replace(/"/g, "&quot;")) + "\"";
	    })
	        .join(" ");
	}
	/**
	 * Self-enclosing tags
	 */
	var singleTag = new Set([
	    "area",
	    "base",
	    "basefont",
	    "br",
	    "col",
	    "command",
	    "embed",
	    "frame",
	    "hr",
	    "img",
	    "input",
	    "isindex",
	    "keygen",
	    "link",
	    "meta",
	    "param",
	    "source",
	    "track",
	    "wbr",
	]);
	/**
	 * Renders a DOM node or an array of DOM nodes to a string.
	 *
	 * Can be thought of as the equivalent of the `outerHTML` of the passed node(s).
	 *
	 * @param node Node to be rendered.
	 * @param options Changes serialization behavior
	 */
	function render(node, options) {
	    if (options === void 0) { options = {}; }
	    var nodes = "length" in node ? node : [node];
	    var output = "";
	    for (var i = 0; i < nodes.length; i++) {
	        output += renderNode(nodes[i], options);
	    }
	    return output;
	}
	lib$1.default = render;
	function renderNode(node, options) {
	    switch (node.type) {
	        case ElementType.Root:
	            return render(node.children, options);
	        case ElementType.Directive:
	        case ElementType.Doctype:
	            return renderDirective(node);
	        case ElementType.Comment:
	            return renderComment(node);
	        case ElementType.CDATA:
	            return renderCdata(node);
	        case ElementType.Script:
	        case ElementType.Style:
	        case ElementType.Tag:
	            return renderTag(node, options);
	        case ElementType.Text:
	            return renderText(node, options);
	    }
	}
	var foreignModeIntegrationPoints = new Set([
	    "mi",
	    "mo",
	    "mn",
	    "ms",
	    "mtext",
	    "annotation-xml",
	    "foreignObject",
	    "desc",
	    "title",
	]);
	var foreignElements = new Set(["svg", "math"]);
	function renderTag(elem, opts) {
	    var _a;
	    // Handle SVG / MathML in HTML
	    if (opts.xmlMode === "foreign") {
	        /* Fix up mixed-case element names */
	        elem.name = (_a = foreignNames_1.elementNames.get(elem.name)) !== null && _a !== void 0 ? _a : elem.name;
	        /* Exit foreign mode at integration points */
	        if (elem.parent &&
	            foreignModeIntegrationPoints.has(elem.parent.name)) {
	            opts = __assign$1(__assign$1({}, opts), { xmlMode: false });
	        }
	    }
	    if (!opts.xmlMode && foreignElements.has(elem.name)) {
	        opts = __assign$1(__assign$1({}, opts), { xmlMode: "foreign" });
	    }
	    var tag = "<" + elem.name;
	    var attribs = formatAttributes(elem.attribs, opts);
	    if (attribs) {
	        tag += " " + attribs;
	    }
	    if (elem.children.length === 0 &&
	        (opts.xmlMode
	            ? // In XML mode or foreign mode, and user hasn't explicitly turned off self-closing tags
	                opts.selfClosingTags !== false
	            : // User explicitly asked for self-closing tags, even in HTML mode
	                opts.selfClosingTags && singleTag.has(elem.name))) {
	        if (!opts.xmlMode)
	            tag += " ";
	        tag += "/>";
	    }
	    else {
	        tag += ">";
	        if (elem.children.length > 0) {
	            tag += render(elem.children, opts);
	        }
	        if (opts.xmlMode || !singleTag.has(elem.name)) {
	            tag += "</" + elem.name + ">";
	        }
	    }
	    return tag;
	}
	function renderDirective(elem) {
	    return "<" + elem.data + ">";
	}
	function renderText(elem, opts) {
	    var data = elem.data || "";
	    // If entities weren't decoded, no need to encode them back
	    if (opts.decodeEntities !== false &&
	        !(!opts.xmlMode &&
	            elem.parent &&
	            unencodedElements.has(elem.parent.name))) {
	        data = entities_1.encodeXML(data);
	    }
	    return data;
	}
	function renderCdata(elem) {
	    return "<![CDATA[" + elem.children[0].data + "]]>";
	}
	function renderComment(elem) {
	    return "<!--" + elem.data + "-->";
	}

	var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(stringify$2, "__esModule", { value: true });
	stringify$2.innerText = stringify$2.textContent = stringify$2.getText = stringify$2.getInnerHTML = stringify$2.getOuterHTML = void 0;
	var domhandler_1$5 = lib$5;
	var dom_serializer_1 = __importDefault$1(lib$1);
	var domelementtype_1 = lib$4;
	/**
	 * @param node Node to get the outer HTML of.
	 * @param options Options for serialization.
	 * @deprecated Use the `dom-serializer` module directly.
	 * @returns `node`'s outer HTML.
	 */
	function getOuterHTML(node, options) {
	    return (0, dom_serializer_1.default)(node, options);
	}
	stringify$2.getOuterHTML = getOuterHTML;
	/**
	 * @param node Node to get the inner HTML of.
	 * @param options Options for serialization.
	 * @deprecated Use the `dom-serializer` module directly.
	 * @returns `node`'s inner HTML.
	 */
	function getInnerHTML(node, options) {
	    return (0, domhandler_1$5.hasChildren)(node)
	        ? node.children.map(function (node) { return getOuterHTML(node, options); }).join("")
	        : "";
	}
	stringify$2.getInnerHTML = getInnerHTML;
	/**
	 * Get a node's inner text. Same as `textContent`, but inserts newlines for `<br>` tags.
	 *
	 * @deprecated Use `textContent` instead.
	 * @param node Node to get the inner text of.
	 * @returns `node`'s inner text.
	 */
	function getText$1(node) {
	    if (Array.isArray(node))
	        return node.map(getText$1).join("");
	    if ((0, domhandler_1$5.isTag)(node))
	        return node.name === "br" ? "\n" : getText$1(node.children);
	    if ((0, domhandler_1$5.isCDATA)(node))
	        return getText$1(node.children);
	    if ((0, domhandler_1$5.isText)(node))
	        return node.data;
	    return "";
	}
	stringify$2.getText = getText$1;
	/**
	 * Get a node's text content.
	 *
	 * @param node Node to get the text content of.
	 * @returns `node`'s text content.
	 * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Node/textContent}
	 */
	function textContent(node) {
	    if (Array.isArray(node))
	        return node.map(textContent).join("");
	    if ((0, domhandler_1$5.hasChildren)(node) && !(0, domhandler_1$5.isComment)(node)) {
	        return textContent(node.children);
	    }
	    if ((0, domhandler_1$5.isText)(node))
	        return node.data;
	    return "";
	}
	stringify$2.textContent = textContent;
	/**
	 * Get a node's inner text.
	 *
	 * @param node Node to get the inner text of.
	 * @returns `node`'s inner text.
	 * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Node/innerText}
	 */
	function innerText(node) {
	    if (Array.isArray(node))
	        return node.map(innerText).join("");
	    if ((0, domhandler_1$5.hasChildren)(node) && (node.type === domelementtype_1.ElementType.Tag || (0, domhandler_1$5.isCDATA)(node))) {
	        return innerText(node.children);
	    }
	    if ((0, domhandler_1$5.isText)(node))
	        return node.data;
	    return "";
	}
	stringify$2.innerText = innerText;

	var traversal = {};

	Object.defineProperty(traversal, "__esModule", { value: true });
	traversal.prevElementSibling = traversal.nextElementSibling = traversal.getName = traversal.hasAttrib = traversal.getAttributeValue = traversal.getSiblings = traversal.getParent = traversal.getChildren = void 0;
	var domhandler_1$4 = lib$5;
	var emptyArray = [];
	/**
	 * Get a node's children.
	 *
	 * @param elem Node to get the children of.
	 * @returns `elem`'s children, or an empty array.
	 */
	function getChildren(elem) {
	    var _a;
	    return (_a = elem.children) !== null && _a !== void 0 ? _a : emptyArray;
	}
	traversal.getChildren = getChildren;
	/**
	 * Get a node's parent.
	 *
	 * @param elem Node to get the parent of.
	 * @returns `elem`'s parent node.
	 */
	function getParent(elem) {
	    return elem.parent || null;
	}
	traversal.getParent = getParent;
	/**
	 * Gets an elements siblings, including the element itself.
	 *
	 * Attempts to get the children through the element's parent first.
	 * If we don't have a parent (the element is a root node),
	 * we walk the element's `prev` & `next` to get all remaining nodes.
	 *
	 * @param elem Element to get the siblings of.
	 * @returns `elem`'s siblings.
	 */
	function getSiblings(elem) {
	    var _a, _b;
	    var parent = getParent(elem);
	    if (parent != null)
	        return getChildren(parent);
	    var siblings = [elem];
	    var prev = elem.prev, next = elem.next;
	    while (prev != null) {
	        siblings.unshift(prev);
	        (_a = prev, prev = _a.prev);
	    }
	    while (next != null) {
	        siblings.push(next);
	        (_b = next, next = _b.next);
	    }
	    return siblings;
	}
	traversal.getSiblings = getSiblings;
	/**
	 * Gets an attribute from an element.
	 *
	 * @param elem Element to check.
	 * @param name Attribute name to retrieve.
	 * @returns The element's attribute value, or `undefined`.
	 */
	function getAttributeValue(elem, name) {
	    var _a;
	    return (_a = elem.attribs) === null || _a === void 0 ? void 0 : _a[name];
	}
	traversal.getAttributeValue = getAttributeValue;
	/**
	 * Checks whether an element has an attribute.
	 *
	 * @param elem Element to check.
	 * @param name Attribute name to look for.
	 * @returns Returns whether `elem` has the attribute `name`.
	 */
	function hasAttrib(elem, name) {
	    return (elem.attribs != null &&
	        Object.prototype.hasOwnProperty.call(elem.attribs, name) &&
	        elem.attribs[name] != null);
	}
	traversal.hasAttrib = hasAttrib;
	/**
	 * Get the tag name of an element.
	 *
	 * @param elem The element to get the name for.
	 * @returns The tag name of `elem`.
	 */
	function getName(elem) {
	    return elem.name;
	}
	traversal.getName = getName;
	/**
	 * Returns the next element sibling of a node.
	 *
	 * @param elem The element to get the next sibling of.
	 * @returns `elem`'s next sibling that is a tag.
	 */
	function nextElementSibling(elem) {
	    var _a;
	    var next = elem.next;
	    while (next !== null && !(0, domhandler_1$4.isTag)(next))
	        (_a = next, next = _a.next);
	    return next;
	}
	traversal.nextElementSibling = nextElementSibling;
	/**
	 * Returns the previous element sibling of a node.
	 *
	 * @param elem The element to get the previous sibling of.
	 * @returns `elem`'s previous sibling that is a tag.
	 */
	function prevElementSibling(elem) {
	    var _a;
	    var prev = elem.prev;
	    while (prev !== null && !(0, domhandler_1$4.isTag)(prev))
	        (_a = prev, prev = _a.prev);
	    return prev;
	}
	traversal.prevElementSibling = prevElementSibling;

	var manipulation = {};

	Object.defineProperty(manipulation, "__esModule", { value: true });
	manipulation.prepend = manipulation.prependChild = manipulation.append = manipulation.appendChild = manipulation.replaceElement = manipulation.removeElement = void 0;
	/**
	 * Remove an element from the dom
	 *
	 * @param elem The element to be removed
	 */
	function removeElement(elem) {
	    if (elem.prev)
	        elem.prev.next = elem.next;
	    if (elem.next)
	        elem.next.prev = elem.prev;
	    if (elem.parent) {
	        var childs = elem.parent.children;
	        childs.splice(childs.lastIndexOf(elem), 1);
	    }
	}
	manipulation.removeElement = removeElement;
	/**
	 * Replace an element in the dom
	 *
	 * @param elem The element to be replaced
	 * @param replacement The element to be added
	 */
	function replaceElement(elem, replacement) {
	    var prev = (replacement.prev = elem.prev);
	    if (prev) {
	        prev.next = replacement;
	    }
	    var next = (replacement.next = elem.next);
	    if (next) {
	        next.prev = replacement;
	    }
	    var parent = (replacement.parent = elem.parent);
	    if (parent) {
	        var childs = parent.children;
	        childs[childs.lastIndexOf(elem)] = replacement;
	    }
	}
	manipulation.replaceElement = replaceElement;
	/**
	 * Append a child to an element.
	 *
	 * @param elem The element to append to.
	 * @param child The element to be added as a child.
	 */
	function appendChild$1(elem, child) {
	    removeElement(child);
	    child.next = null;
	    child.parent = elem;
	    if (elem.children.push(child) > 1) {
	        var sibling = elem.children[elem.children.length - 2];
	        sibling.next = child;
	        child.prev = sibling;
	    }
	    else {
	        child.prev = null;
	    }
	}
	manipulation.appendChild = appendChild$1;
	/**
	 * Append an element after another.
	 *
	 * @param elem The element to append after.
	 * @param next The element be added.
	 */
	function append(elem, next) {
	    removeElement(next);
	    var parent = elem.parent;
	    var currNext = elem.next;
	    next.next = currNext;
	    next.prev = elem;
	    elem.next = next;
	    next.parent = parent;
	    if (currNext) {
	        currNext.prev = next;
	        if (parent) {
	            var childs = parent.children;
	            childs.splice(childs.lastIndexOf(currNext), 0, next);
	        }
	    }
	    else if (parent) {
	        parent.children.push(next);
	    }
	}
	manipulation.append = append;
	/**
	 * Prepend a child to an element.
	 *
	 * @param elem The element to prepend before.
	 * @param child The element to be added as a child.
	 */
	function prependChild(elem, child) {
	    removeElement(child);
	    child.parent = elem;
	    child.prev = null;
	    if (elem.children.unshift(child) !== 1) {
	        var sibling = elem.children[1];
	        sibling.prev = child;
	        child.next = sibling;
	    }
	    else {
	        child.next = null;
	    }
	}
	manipulation.prependChild = prependChild;
	/**
	 * Prepend an element before another.
	 *
	 * @param elem The element to prepend before.
	 * @param prev The element be added.
	 */
	function prepend(elem, prev) {
	    removeElement(prev);
	    var parent = elem.parent;
	    if (parent) {
	        var childs = parent.children;
	        childs.splice(childs.indexOf(elem), 0, prev);
	    }
	    if (elem.prev) {
	        elem.prev.next = prev;
	    }
	    prev.parent = parent;
	    prev.prev = elem.prev;
	    prev.next = elem;
	    elem.prev = prev;
	}
	manipulation.prepend = prepend;

	var querying = {};

	Object.defineProperty(querying, "__esModule", { value: true });
	querying.findAll = querying.existsOne = querying.findOne = querying.findOneChild = querying.find = querying.filter = void 0;
	var domhandler_1$3 = lib$5;
	/**
	 * Search a node and its children for nodes passing a test function.
	 *
	 * @param test Function to test nodes on.
	 * @param node Node to search. Will be included in the result set if it matches.
	 * @param recurse Also consider child nodes.
	 * @param limit Maximum number of nodes to return.
	 * @returns All nodes passing `test`.
	 */
	function filter(test, node, recurse, limit) {
	    if (recurse === void 0) { recurse = true; }
	    if (limit === void 0) { limit = Infinity; }
	    if (!Array.isArray(node))
	        node = [node];
	    return find$2(test, node, recurse, limit);
	}
	querying.filter = filter;
	/**
	 * Search an array of node and its children for nodes passing a test function.
	 *
	 * @param test Function to test nodes on.
	 * @param nodes Array of nodes to search.
	 * @param recurse Also consider child nodes.
	 * @param limit Maximum number of nodes to return.
	 * @returns All nodes passing `test`.
	 */
	function find$2(test, nodes, recurse, limit) {
	    var result = [];
	    for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
	        var elem = nodes_1[_i];
	        if (test(elem)) {
	            result.push(elem);
	            if (--limit <= 0)
	                break;
	        }
	        if (recurse && (0, domhandler_1$3.hasChildren)(elem) && elem.children.length > 0) {
	            var children = find$2(test, elem.children, recurse, limit);
	            result.push.apply(result, children);
	            limit -= children.length;
	            if (limit <= 0)
	                break;
	        }
	    }
	    return result;
	}
	querying.find = find$2;
	/**
	 * Finds the first element inside of an array that matches a test function.
	 *
	 * @param test Function to test nodes on.
	 * @param nodes Array of nodes to search.
	 * @returns The first node in the array that passes `test`.
	 */
	function findOneChild(test, nodes) {
	    return nodes.find(test);
	}
	querying.findOneChild = findOneChild;
	/**
	 * Finds one element in a tree that passes a test.
	 *
	 * @param test Function to test nodes on.
	 * @param nodes Array of nodes to search.
	 * @param recurse Also consider child nodes.
	 * @returns The first child node that passes `test`.
	 */
	function findOne(test, nodes, recurse) {
	    if (recurse === void 0) { recurse = true; }
	    var elem = null;
	    for (var i = 0; i < nodes.length && !elem; i++) {
	        var checked = nodes[i];
	        if (!(0, domhandler_1$3.isTag)(checked)) {
	            continue;
	        }
	        else if (test(checked)) {
	            elem = checked;
	        }
	        else if (recurse && checked.children.length > 0) {
	            elem = findOne(test, checked.children);
	        }
	    }
	    return elem;
	}
	querying.findOne = findOne;
	/**
	 * @param test Function to test nodes on.
	 * @param nodes Array of nodes to search.
	 * @returns Whether a tree of nodes contains at least one node passing a test.
	 */
	function existsOne(test, nodes) {
	    return nodes.some(function (checked) {
	        return (0, domhandler_1$3.isTag)(checked) &&
	            (test(checked) ||
	                (checked.children.length > 0 &&
	                    existsOne(test, checked.children)));
	    });
	}
	querying.existsOne = existsOne;
	/**
	 * Search and array of nodes and its children for nodes passing a test function.
	 *
	 * Same as `find`, only with less options, leading to reduced complexity.
	 *
	 * @param test Function to test nodes on.
	 * @param nodes Array of nodes to search.
	 * @returns All nodes passing `test`.
	 */
	function findAll(test, nodes) {
	    var _a;
	    var result = [];
	    var stack = nodes.filter(domhandler_1$3.isTag);
	    var elem;
	    while ((elem = stack.shift())) {
	        var children = (_a = elem.children) === null || _a === void 0 ? void 0 : _a.filter(domhandler_1$3.isTag);
	        if (children && children.length > 0) {
	            stack.unshift.apply(stack, children);
	        }
	        if (test(elem))
	            result.push(elem);
	    }
	    return result;
	}
	querying.findAll = findAll;

	var legacy = {};

	Object.defineProperty(legacy, "__esModule", { value: true });
	legacy.getElementsByTagType = legacy.getElementsByTagName = legacy.getElementById = legacy.getElements = legacy.testElement = void 0;
	var domhandler_1$2 = lib$5;
	var querying_1 = querying;
	var Checks = {
	    tag_name: function (name) {
	        if (typeof name === "function") {
	            return function (elem) { return (0, domhandler_1$2.isTag)(elem) && name(elem.name); };
	        }
	        else if (name === "*") {
	            return domhandler_1$2.isTag;
	        }
	        return function (elem) { return (0, domhandler_1$2.isTag)(elem) && elem.name === name; };
	    },
	    tag_type: function (type) {
	        if (typeof type === "function") {
	            return function (elem) { return type(elem.type); };
	        }
	        return function (elem) { return elem.type === type; };
	    },
	    tag_contains: function (data) {
	        if (typeof data === "function") {
	            return function (elem) { return (0, domhandler_1$2.isText)(elem) && data(elem.data); };
	        }
	        return function (elem) { return (0, domhandler_1$2.isText)(elem) && elem.data === data; };
	    },
	};
	/**
	 * @param attrib Attribute to check.
	 * @param value Attribute value to look for.
	 * @returns A function to check whether the a node has an attribute with a particular value.
	 */
	function getAttribCheck(attrib, value) {
	    if (typeof value === "function") {
	        return function (elem) { return (0, domhandler_1$2.isTag)(elem) && value(elem.attribs[attrib]); };
	    }
	    return function (elem) { return (0, domhandler_1$2.isTag)(elem) && elem.attribs[attrib] === value; };
	}
	/**
	 * @param a First function to combine.
	 * @param b Second function to combine.
	 * @returns A function taking a node and returning `true` if either
	 * of the input functions returns `true` for the node.
	 */
	function combineFuncs(a, b) {
	    return function (elem) { return a(elem) || b(elem); };
	}
	/**
	 * @param options An object describing nodes to look for.
	 * @returns A function executing all checks in `options` and returning `true`
	 * if any of them match a node.
	 */
	function compileTest(options) {
	    var funcs = Object.keys(options).map(function (key) {
	        var value = options[key];
	        return Object.prototype.hasOwnProperty.call(Checks, key)
	            ? Checks[key](value)
	            : getAttribCheck(key, value);
	    });
	    return funcs.length === 0 ? null : funcs.reduce(combineFuncs);
	}
	/**
	 * @param options An object describing nodes to look for.
	 * @param node The element to test.
	 * @returns Whether the element matches the description in `options`.
	 */
	function testElement(options, node) {
	    var test = compileTest(options);
	    return test ? test(node) : true;
	}
	legacy.testElement = testElement;
	/**
	 * @param options An object describing nodes to look for.
	 * @param nodes Nodes to search through.
	 * @param recurse Also consider child nodes.
	 * @param limit Maximum number of nodes to return.
	 * @returns All nodes that match `options`.
	 */
	function getElements$1(options, nodes, recurse, limit) {
	    if (limit === void 0) { limit = Infinity; }
	    var test = compileTest(options);
	    return test ? (0, querying_1.filter)(test, nodes, recurse, limit) : [];
	}
	legacy.getElements = getElements$1;
	/**
	 * @param id The unique ID attribute value to look for.
	 * @param nodes Nodes to search through.
	 * @param recurse Also consider child nodes.
	 * @returns The node with the supplied ID.
	 */
	function getElementById(id, nodes, recurse) {
	    if (recurse === void 0) { recurse = true; }
	    if (!Array.isArray(nodes))
	        nodes = [nodes];
	    return (0, querying_1.findOne)(getAttribCheck("id", id), nodes, recurse);
	}
	legacy.getElementById = getElementById;
	/**
	 * @param tagName Tag name to search for.
	 * @param nodes Nodes to search through.
	 * @param recurse Also consider child nodes.
	 * @param limit Maximum number of nodes to return.
	 * @returns All nodes with the supplied `tagName`.
	 */
	function getElementsByTagName(tagName, nodes, recurse, limit) {
	    if (recurse === void 0) { recurse = true; }
	    if (limit === void 0) { limit = Infinity; }
	    return (0, querying_1.filter)(Checks.tag_name(tagName), nodes, recurse, limit);
	}
	legacy.getElementsByTagName = getElementsByTagName;
	/**
	 * @param type Element type to look for.
	 * @param nodes Nodes to search through.
	 * @param recurse Also consider child nodes.
	 * @param limit Maximum number of nodes to return.
	 * @returns All nodes with the supplied `type`.
	 */
	function getElementsByTagType(type, nodes, recurse, limit) {
	    if (recurse === void 0) { recurse = true; }
	    if (limit === void 0) { limit = Infinity; }
	    return (0, querying_1.filter)(Checks.tag_type(type), nodes, recurse, limit);
	}
	legacy.getElementsByTagType = getElementsByTagType;

	var helpers = {};

	Object.defineProperty(helpers, "__esModule", { value: true });
	helpers.uniqueSort = helpers.compareDocumentPosition = helpers.removeSubsets = void 0;
	var domhandler_1$1 = lib$5;
	/**
	 * Given an array of nodes, remove any member that is contained by another.
	 *
	 * @param nodes Nodes to filter.
	 * @returns Remaining nodes that aren't subtrees of each other.
	 */
	function removeSubsets(nodes) {
	    var idx = nodes.length;
	    /*
	     * Check if each node (or one of its ancestors) is already contained in the
	     * array.
	     */
	    while (--idx >= 0) {
	        var node = nodes[idx];
	        /*
	         * Remove the node if it is not unique.
	         * We are going through the array from the end, so we only
	         * have to check nodes that preceed the node under consideration in the array.
	         */
	        if (idx > 0 && nodes.lastIndexOf(node, idx - 1) >= 0) {
	            nodes.splice(idx, 1);
	            continue;
	        }
	        for (var ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
	            if (nodes.includes(ancestor)) {
	                nodes.splice(idx, 1);
	                break;
	            }
	        }
	    }
	    return nodes;
	}
	helpers.removeSubsets = removeSubsets;
	/**
	 * Compare the position of one node against another node in any other document.
	 * The return value is a bitmask with the following values:
	 *
	 * Document order:
	 * > There is an ordering, document order, defined on all the nodes in the
	 * > document corresponding to the order in which the first character of the
	 * > XML representation of each node occurs in the XML representation of the
	 * > document after expansion of general entities. Thus, the document element
	 * > node will be the first node. Element nodes occur before their children.
	 * > Thus, document order orders element nodes in order of the occurrence of
	 * > their start-tag in the XML (after expansion of entities). The attribute
	 * > nodes of an element occur after the element and before its children. The
	 * > relative order of attribute nodes is implementation-dependent./
	 *
	 * Source:
	 * http://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-document-order
	 *
	 * @param nodeA The first node to use in the comparison
	 * @param nodeB The second node to use in the comparison
	 * @returns A bitmask describing the input nodes' relative position.
	 *
	 * See http://dom.spec.whatwg.org/#dom-node-comparedocumentposition for
	 * a description of these values.
	 */
	function compareDocumentPosition(nodeA, nodeB) {
	    var aParents = [];
	    var bParents = [];
	    if (nodeA === nodeB) {
	        return 0;
	    }
	    var current = (0, domhandler_1$1.hasChildren)(nodeA) ? nodeA : nodeA.parent;
	    while (current) {
	        aParents.unshift(current);
	        current = current.parent;
	    }
	    current = (0, domhandler_1$1.hasChildren)(nodeB) ? nodeB : nodeB.parent;
	    while (current) {
	        bParents.unshift(current);
	        current = current.parent;
	    }
	    var maxIdx = Math.min(aParents.length, bParents.length);
	    var idx = 0;
	    while (idx < maxIdx && aParents[idx] === bParents[idx]) {
	        idx++;
	    }
	    if (idx === 0) {
	        return 1 /* DISCONNECTED */;
	    }
	    var sharedParent = aParents[idx - 1];
	    var siblings = sharedParent.children;
	    var aSibling = aParents[idx];
	    var bSibling = bParents[idx];
	    if (siblings.indexOf(aSibling) > siblings.indexOf(bSibling)) {
	        if (sharedParent === nodeB) {
	            return 4 /* FOLLOWING */ | 16 /* CONTAINED_BY */;
	        }
	        return 4 /* FOLLOWING */;
	    }
	    if (sharedParent === nodeA) {
	        return 2 /* PRECEDING */ | 8 /* CONTAINS */;
	    }
	    return 2 /* PRECEDING */;
	}
	helpers.compareDocumentPosition = compareDocumentPosition;
	/**
	 * Sort an array of nodes based on their relative position in the document and
	 * remove any duplicate nodes. If the array contains nodes that do not belong
	 * to the same document, sort order is unspecified.
	 *
	 * @param nodes Array of DOM nodes.
	 * @returns Collection of unique nodes, sorted in document order.
	 */
	function uniqueSort(nodes) {
	    nodes = nodes.filter(function (node, i, arr) { return !arr.includes(node, i + 1); });
	    nodes.sort(function (a, b) {
	        var relative = compareDocumentPosition(a, b);
	        if (relative & 2 /* PRECEDING */) {
	            return -1;
	        }
	        else if (relative & 4 /* FOLLOWING */) {
	            return 1;
	        }
	        return 0;
	    });
	    return nodes;
	}
	helpers.uniqueSort = uniqueSort;

	var feeds = {};

	Object.defineProperty(feeds, "__esModule", { value: true });
	feeds.getFeed = void 0;
	var stringify_1 = stringify$2;
	var legacy_1 = legacy;
	/**
	 * Get the feed object from the root of a DOM tree.
	 *
	 * @param doc - The DOM to to extract the feed from.
	 * @returns The feed.
	 */
	function getFeed(doc) {
	    var feedRoot = getOneElement$1(isValidFeed$1, doc);
	    return !feedRoot
	        ? null
	        : feedRoot.name === "feed"
	            ? getAtomFeed(feedRoot)
	            : getRssFeed(feedRoot);
	}
	feeds.getFeed = getFeed;
	/**
	 * Parse an Atom feed.
	 *
	 * @param feedRoot The root of the feed.
	 * @returns The parsed feed.
	 */
	function getAtomFeed(feedRoot) {
	    var _a;
	    var childs = feedRoot.children;
	    var feed = {
	        type: "atom",
	        items: (0, legacy_1.getElementsByTagName)("entry", childs).map(function (item) {
	            var _a;
	            var children = item.children;
	            var entry = { media: getMediaElements$1(children) };
	            addConditionally$1(entry, "id", "id", children);
	            addConditionally$1(entry, "title", "title", children);
	            var href = (_a = getOneElement$1("link", children)) === null || _a === void 0 ? void 0 : _a.attribs.href;
	            if (href) {
	                entry.link = href;
	            }
	            var description = fetch$2("summary", children) || fetch$2("content", children);
	            if (description) {
	                entry.description = description;
	            }
	            var pubDate = fetch$2("updated", children);
	            if (pubDate) {
	                entry.pubDate = new Date(pubDate);
	            }
	            return entry;
	        }),
	    };
	    addConditionally$1(feed, "id", "id", childs);
	    addConditionally$1(feed, "title", "title", childs);
	    var href = (_a = getOneElement$1("link", childs)) === null || _a === void 0 ? void 0 : _a.attribs.href;
	    if (href) {
	        feed.link = href;
	    }
	    addConditionally$1(feed, "description", "subtitle", childs);
	    var updated = fetch$2("updated", childs);
	    if (updated) {
	        feed.updated = new Date(updated);
	    }
	    addConditionally$1(feed, "author", "email", childs, true);
	    return feed;
	}
	/**
	 * Parse a RSS feed.
	 *
	 * @param feedRoot The root of the feed.
	 * @returns The parsed feed.
	 */
	function getRssFeed(feedRoot) {
	    var _a, _b;
	    var childs = (_b = (_a = getOneElement$1("channel", feedRoot.children)) === null || _a === void 0 ? void 0 : _a.children) !== null && _b !== void 0 ? _b : [];
	    var feed = {
	        type: feedRoot.name.substr(0, 3),
	        id: "",
	        items: (0, legacy_1.getElementsByTagName)("item", feedRoot.children).map(function (item) {
	            var children = item.children;
	            var entry = { media: getMediaElements$1(children) };
	            addConditionally$1(entry, "id", "guid", children);
	            addConditionally$1(entry, "title", "title", children);
	            addConditionally$1(entry, "link", "link", children);
	            addConditionally$1(entry, "description", "description", children);
	            var pubDate = fetch$2("pubDate", children);
	            if (pubDate)
	                entry.pubDate = new Date(pubDate);
	            return entry;
	        }),
	    };
	    addConditionally$1(feed, "title", "title", childs);
	    addConditionally$1(feed, "link", "link", childs);
	    addConditionally$1(feed, "description", "description", childs);
	    var updated = fetch$2("lastBuildDate", childs);
	    if (updated) {
	        feed.updated = new Date(updated);
	    }
	    addConditionally$1(feed, "author", "managingEditor", childs, true);
	    return feed;
	}
	var MEDIA_KEYS_STRING = ["url", "type", "lang"];
	var MEDIA_KEYS_INT = [
	    "fileSize",
	    "bitrate",
	    "framerate",
	    "samplingrate",
	    "channels",
	    "duration",
	    "height",
	    "width",
	];
	/**
	 * Get all media elements of a feed item.
	 *
	 * @param where Nodes to search in.
	 * @returns Media elements.
	 */
	function getMediaElements$1(where) {
	    return (0, legacy_1.getElementsByTagName)("media:content", where).map(function (elem) {
	        var attribs = elem.attribs;
	        var media = {
	            medium: attribs.medium,
	            isDefault: !!attribs.isDefault,
	        };
	        for (var _i = 0, MEDIA_KEYS_STRING_1 = MEDIA_KEYS_STRING; _i < MEDIA_KEYS_STRING_1.length; _i++) {
	            var attrib = MEDIA_KEYS_STRING_1[_i];
	            if (attribs[attrib]) {
	                media[attrib] = attribs[attrib];
	            }
	        }
	        for (var _a = 0, MEDIA_KEYS_INT_1 = MEDIA_KEYS_INT; _a < MEDIA_KEYS_INT_1.length; _a++) {
	            var attrib = MEDIA_KEYS_INT_1[_a];
	            if (attribs[attrib]) {
	                media[attrib] = parseInt(attribs[attrib], 10);
	            }
	        }
	        if (attribs.expression) {
	            media.expression =
	                attribs.expression;
	        }
	        return media;
	    });
	}
	/**
	 * Get one element by tag name.
	 *
	 * @param tagName Tag name to look for
	 * @param node Node to search in
	 * @returns The element or null
	 */
	function getOneElement$1(tagName, node) {
	    return (0, legacy_1.getElementsByTagName)(tagName, node, true, 1)[0];
	}
	/**
	 * Get the text content of an element with a certain tag name.
	 *
	 * @param tagName Tag name to look for.
	 * @param where  Node to search in.
	 * @param recurse Whether to recurse into child nodes.
	 * @returns The text content of the element.
	 */
	function fetch$2(tagName, where, recurse) {
	    if (recurse === void 0) { recurse = false; }
	    return (0, stringify_1.textContent)((0, legacy_1.getElementsByTagName)(tagName, where, recurse, 1)).trim();
	}
	/**
	 * Adds a property to an object if it has a value.
	 *
	 * @param obj Object to be extended
	 * @param prop Property name
	 * @param tagName Tag name that contains the conditionally added property
	 * @param where Element to search for the property
	 * @param recurse Whether to recurse into child nodes.
	 */
	function addConditionally$1(obj, prop, tagName, where, recurse) {
	    if (recurse === void 0) { recurse = false; }
	    var val = fetch$2(tagName, where, recurse);
	    if (val)
	        obj[prop] = val;
	}
	/**
	 * Checks if an element is a feed root node.
	 *
	 * @param value The name of the element to check.
	 * @returns Whether an element is a feed root node.
	 */
	function isValidFeed$1(value) {
	    return value === "rss" || value === "feed" || value === "rdf:RDF";
	}

	(function (exports) {
		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
		    if (k2 === undefined) k2 = k;
		    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
		}) : (function(o, m, k, k2) {
		    if (k2 === undefined) k2 = k;
		    o[k2] = m[k];
		}));
		var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.hasChildren = exports.isDocument = exports.isComment = exports.isText = exports.isCDATA = exports.isTag = void 0;
		__exportStar(stringify$2, exports);
		__exportStar(traversal, exports);
		__exportStar(manipulation, exports);
		__exportStar(querying, exports);
		__exportStar(legacy, exports);
		__exportStar(helpers, exports);
		__exportStar(feeds, exports);
		/** @deprecated Use these methods from `domhandler` directly. */
		var domhandler_1 = lib$5;
		Object.defineProperty(exports, "isTag", { enumerable: true, get: function () { return domhandler_1.isTag; } });
		Object.defineProperty(exports, "isCDATA", { enumerable: true, get: function () { return domhandler_1.isCDATA; } });
		Object.defineProperty(exports, "isText", { enumerable: true, get: function () { return domhandler_1.isText; } });
		Object.defineProperty(exports, "isComment", { enumerable: true, get: function () { return domhandler_1.isComment; } });
		Object.defineProperty(exports, "isDocument", { enumerable: true, get: function () { return domhandler_1.isDocument; } });
		Object.defineProperty(exports, "hasChildren", { enumerable: true, get: function () { return domhandler_1.hasChildren; } }); 
	} (lib$2));

	var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
	    var extendStatics = function (d, b) {
	        extendStatics = Object.setPrototypeOf ||
	            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
	            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
	        return extendStatics(d, b);
	    };
	    return function (d, b) {
	        if (typeof b !== "function" && b !== null)
	            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
	        extendStatics(d, b);
	        function __() { this.constructor = d; }
	        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	    };
	})();
	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
	    if (k2 === undefined) k2 = k;
	    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
	}) : (function(o, m, k, k2) {
	    if (k2 === undefined) k2 = k;
	    o[k2] = m[k];
	}));
	var __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
	    Object.defineProperty(o, "default", { enumerable: true, value: v });
	}) : function(o, v) {
	    o["default"] = v;
	});
	var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
	    if (mod && mod.__esModule) return mod;
	    var result = {};
	    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
	    __setModuleDefault(result, mod);
	    return result;
	};
	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
	    return (mod && mod.__esModule) ? mod : { "default": mod };
	};
	Object.defineProperty(FeedHandler$1, "__esModule", { value: true });
	FeedHandler$1.parseFeed = FeedHandler$1.FeedHandler = void 0;
	var domhandler_1 = __importDefault(lib$5);
	var DomUtils = __importStar(lib$2);
	var Parser_1 = Parser$3;
	var FeedItemMediaMedium;
	(function (FeedItemMediaMedium) {
	    FeedItemMediaMedium[FeedItemMediaMedium["image"] = 0] = "image";
	    FeedItemMediaMedium[FeedItemMediaMedium["audio"] = 1] = "audio";
	    FeedItemMediaMedium[FeedItemMediaMedium["video"] = 2] = "video";
	    FeedItemMediaMedium[FeedItemMediaMedium["document"] = 3] = "document";
	    FeedItemMediaMedium[FeedItemMediaMedium["executable"] = 4] = "executable";
	})(FeedItemMediaMedium || (FeedItemMediaMedium = {}));
	var FeedItemMediaExpression;
	(function (FeedItemMediaExpression) {
	    FeedItemMediaExpression[FeedItemMediaExpression["sample"] = 0] = "sample";
	    FeedItemMediaExpression[FeedItemMediaExpression["full"] = 1] = "full";
	    FeedItemMediaExpression[FeedItemMediaExpression["nonstop"] = 2] = "nonstop";
	})(FeedItemMediaExpression || (FeedItemMediaExpression = {}));
	// TODO: Consume data as it is coming in
	var FeedHandler = /** @class */ (function (_super) {
	    __extends(FeedHandler, _super);
	    /**
	     *
	     * @param callback
	     * @param options
	     */
	    function FeedHandler(callback, options) {
	        var _this = this;
	        if (typeof callback === "object") {
	            callback = undefined;
	            options = callback;
	        }
	        _this = _super.call(this, callback, options) || this;
	        return _this;
	    }
	    FeedHandler.prototype.onend = function () {
	        var _a, _b;
	        var feedRoot = getOneElement(isValidFeed, this.dom);
	        if (!feedRoot) {
	            this.handleCallback(new Error("couldn't find root of feed"));
	            return;
	        }
	        var feed = {};
	        if (feedRoot.name === "feed") {
	            var childs = feedRoot.children;
	            feed.type = "atom";
	            addConditionally(feed, "id", "id", childs);
	            addConditionally(feed, "title", "title", childs);
	            var href = getAttribute("href", getOneElement("link", childs));
	            if (href) {
	                feed.link = href;
	            }
	            addConditionally(feed, "description", "subtitle", childs);
	            var updated = fetch$1("updated", childs);
	            if (updated) {
	                feed.updated = new Date(updated);
	            }
	            addConditionally(feed, "author", "email", childs, true);
	            feed.items = getElements("entry", childs).map(function (item) {
	                var entry = {};
	                var children = item.children;
	                addConditionally(entry, "id", "id", children);
	                addConditionally(entry, "title", "title", children);
	                var href = getAttribute("href", getOneElement("link", children));
	                if (href) {
	                    entry.link = href;
	                }
	                var description = fetch$1("summary", children) || fetch$1("content", children);
	                if (description) {
	                    entry.description = description;
	                }
	                var pubDate = fetch$1("updated", children);
	                if (pubDate) {
	                    entry.pubDate = new Date(pubDate);
	                }
	                entry.media = getMediaElements(children);
	                return entry;
	            });
	        }
	        else {
	            var childs = (_b = (_a = getOneElement("channel", feedRoot.children)) === null || _a === void 0 ? void 0 : _a.children) !== null && _b !== void 0 ? _b : [];
	            feed.type = feedRoot.name.substr(0, 3);
	            feed.id = "";
	            addConditionally(feed, "title", "title", childs);
	            addConditionally(feed, "link", "link", childs);
	            addConditionally(feed, "description", "description", childs);
	            var updated = fetch$1("lastBuildDate", childs);
	            if (updated) {
	                feed.updated = new Date(updated);
	            }
	            addConditionally(feed, "author", "managingEditor", childs, true);
	            feed.items = getElements("item", feedRoot.children).map(function (item) {
	                var entry = {};
	                var children = item.children;
	                addConditionally(entry, "id", "guid", children);
	                addConditionally(entry, "title", "title", children);
	                addConditionally(entry, "link", "link", children);
	                addConditionally(entry, "description", "description", children);
	                var pubDate = fetch$1("pubDate", children);
	                if (pubDate)
	                    entry.pubDate = new Date(pubDate);
	                entry.media = getMediaElements(children);
	                return entry;
	            });
	        }
	        this.feed = feed;
	        this.handleCallback(null);
	    };
	    return FeedHandler;
	}(domhandler_1.default));
	FeedHandler$1.FeedHandler = FeedHandler;
	function getMediaElements(where) {
	    return getElements("media:content", where).map(function (elem) {
	        var media = {
	            medium: elem.attribs.medium,
	            isDefault: !!elem.attribs.isDefault,
	        };
	        if (elem.attribs.url) {
	            media.url = elem.attribs.url;
	        }
	        if (elem.attribs.fileSize) {
	            media.fileSize = parseInt(elem.attribs.fileSize, 10);
	        }
	        if (elem.attribs.type) {
	            media.type = elem.attribs.type;
	        }
	        if (elem.attribs.expression) {
	            media.expression = elem.attribs
	                .expression;
	        }
	        if (elem.attribs.bitrate) {
	            media.bitrate = parseInt(elem.attribs.bitrate, 10);
	        }
	        if (elem.attribs.framerate) {
	            media.framerate = parseInt(elem.attribs.framerate, 10);
	        }
	        if (elem.attribs.samplingrate) {
	            media.samplingrate = parseInt(elem.attribs.samplingrate, 10);
	        }
	        if (elem.attribs.channels) {
	            media.channels = parseInt(elem.attribs.channels, 10);
	        }
	        if (elem.attribs.duration) {
	            media.duration = parseInt(elem.attribs.duration, 10);
	        }
	        if (elem.attribs.height) {
	            media.height = parseInt(elem.attribs.height, 10);
	        }
	        if (elem.attribs.width) {
	            media.width = parseInt(elem.attribs.width, 10);
	        }
	        if (elem.attribs.lang) {
	            media.lang = elem.attribs.lang;
	        }
	        return media;
	    });
	}
	function getElements(tagName, where) {
	    return DomUtils.getElementsByTagName(tagName, where, true);
	}
	function getOneElement(tagName, node) {
	    return DomUtils.getElementsByTagName(tagName, node, true, 1)[0];
	}
	function fetch$1(tagName, where, recurse) {
	    if (recurse === void 0) { recurse = false; }
	    return DomUtils.getText(DomUtils.getElementsByTagName(tagName, where, recurse, 1)).trim();
	}
	function getAttribute(name, elem) {
	    if (!elem) {
	        return null;
	    }
	    var attribs = elem.attribs;
	    return attribs[name];
	}
	function addConditionally(obj, prop, what, where, recurse) {
	    if (recurse === void 0) { recurse = false; }
	    var tmp = fetch$1(what, where, recurse);
	    if (tmp)
	        obj[prop] = tmp;
	}
	function isValidFeed(value) {
	    return value === "rss" || value === "feed" || value === "rdf:RDF";
	}
	/**
	 * Parse a feed.
	 *
	 * @param feed The feed that should be parsed, as a string.
	 * @param options Optionally, options for parsing. When using this option, you should set `xmlMode` to `true`.
	 */
	function parseFeed(feed, options) {
	    if (options === void 0) { options = { xmlMode: true }; }
	    var handler = new FeedHandler(options);
	    new Parser_1.Parser(handler, options).end(feed);
	    return handler.feed;
	}
	FeedHandler$1.parseFeed = parseFeed;

	(function (exports) {
		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
		    if (k2 === undefined) k2 = k;
		    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
		}) : (function(o, m, k, k2) {
		    if (k2 === undefined) k2 = k;
		    o[k2] = m[k];
		}));
		var __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
		    Object.defineProperty(o, "default", { enumerable: true, value: v });
		}) : function(o, v) {
		    o["default"] = v;
		});
		var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
		    if (mod && mod.__esModule) return mod;
		    var result = {};
		    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
		    __setModuleDefault(result, mod);
		    return result;
		};
		var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
		};
		var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
		    return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.RssHandler = exports.DefaultHandler = exports.DomUtils = exports.ElementType = exports.Tokenizer = exports.createDomStream = exports.parseDOM = exports.parseDocument = exports.DomHandler = exports.Parser = void 0;
		var Parser_1 = Parser$3;
		Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return Parser_1.Parser; } });
		var domhandler_1 = lib$5;
		Object.defineProperty(exports, "DomHandler", { enumerable: true, get: function () { return domhandler_1.DomHandler; } });
		Object.defineProperty(exports, "DefaultHandler", { enumerable: true, get: function () { return domhandler_1.DomHandler; } });
		// Helper methods
		/**
		 * Parses the data, returns the resulting document.
		 *
		 * @param data The data that should be parsed.
		 * @param options Optional options for the parser and DOM builder.
		 */
		function parseDocument(data, options) {
		    var handler = new domhandler_1.DomHandler(undefined, options);
		    new Parser_1.Parser(handler, options).end(data);
		    return handler.root;
		}
		exports.parseDocument = parseDocument;
		/**
		 * Parses data, returns an array of the root nodes.
		 *
		 * Note that the root nodes still have a `Document` node as their parent.
		 * Use `parseDocument` to get the `Document` node instead.
		 *
		 * @param data The data that should be parsed.
		 * @param options Optional options for the parser and DOM builder.
		 * @deprecated Use `parseDocument` instead.
		 */
		function parseDOM(data, options) {
		    return parseDocument(data, options).children;
		}
		exports.parseDOM = parseDOM;
		/**
		 * Creates a parser instance, with an attached DOM handler.
		 *
		 * @param cb A callback that will be called once parsing has been completed.
		 * @param options Optional options for the parser and DOM builder.
		 * @param elementCb An optional callback that will be called every time a tag has been completed inside of the DOM.
		 */
		function createDomStream(cb, options, elementCb) {
		    var handler = new domhandler_1.DomHandler(cb, options, elementCb);
		    return new Parser_1.Parser(handler, options);
		}
		exports.createDomStream = createDomStream;
		var Tokenizer_1 = Tokenizer$6;
		Object.defineProperty(exports, "Tokenizer", { enumerable: true, get: function () { return __importDefault(Tokenizer_1).default; } });
		var ElementType = __importStar(lib$4);
		exports.ElementType = ElementType;
		/*
		 * All of the following exports exist for backwards-compatibility.
		 * They should probably be removed eventually.
		 */
		__exportStar(FeedHandler$1, exports);
		exports.DomUtils = __importStar(lib$2);
		var FeedHandler_1 = FeedHandler$1;
		Object.defineProperty(exports, "RssHandler", { enumerable: true, get: function () { return FeedHandler_1.FeedHandler; } }); 
	} (lib$3));

	const merge$2 = cjs;

	/**
	 * Given a list of class and ID selectors (prefixed with '.' and '#'),
	 * return them as separate lists of names without prefixes.
	 *
	 * @param { string[] } selectors Class and ID selectors (`[".class", "#id"]` etc).
	 * @returns { { classes: string[], ids: string[] } }
	 */
	function splitClassesAndIds$1 (selectors) {
	  const classes = [];
	  const ids = [];
	  for (const selector of selectors) {
	    if (selector.startsWith('.')) {
	      classes.push(selector.substring(1));
	    } else if (selector.startsWith('#')) {
	      ids.push(selector.substring(1));
	    }
	  }
	  return { classes: classes, ids: ids };
	}

	/**
	 * Make a recursive function that will only run to a given depth
	 * and switches to an alternative function at that depth. \
	 * No limitation if `n` is `undefined` (Just wraps `f` in that case).
	 *
	 * @param   { number | undefined } n   Allowed depth of recursion. `undefined` for no limitation.
	 * @param   { Function }           f   Function that accepts recursive callback as the first argument.
	 * @param   { Function }           [g] Function to run instead, when maximum depth was reached. Do nothing by default.
	 * @returns { Function }
	 */
	function limitedDepthRecursive$1 (n, f, g = () => undefined) {
	  if (n === undefined) {
	    const f1 = function (...args) { return f(f1, ...args); };
	    return f1;
	  }
	  if (n >= 0) {
	    return function (...args) { return f(limitedDepthRecursive$1(n - 1, f, g), ...args); };
	  }
	  return g;
	}

	/**
	 * Convert a number into alphabetic sequence representation (Sequence without zeroes).
	 *
	 * For example: `a, ..., z, aa, ..., zz, aaa, ...`.
	 *
	 * @param   { number } num              Number to convert. Must be >= 1.
	 * @param   { string } [baseChar = 'a'] Character for 1 in the sequence.
	 * @param   { number } [base = 26]      Number of characters in the sequence.
	 * @returns { string }
	 */
	function numberToLetterSequence$1 (num, baseChar = 'a', base = 26) {
	  const digits = [];
	  do {
	    num -= 1;
	    digits.push(num % base);
	    num = (num / base) >> 0; // quick `floor`
	  } while (num > 0);
	  const baseCode = baseChar.charCodeAt(0);
	  return digits
	    .reverse()
	    .map(n => String.fromCharCode(baseCode + n))
	    .join('');
	}

	const I$3 = ['I', 'X', 'C', 'M'];
	const V$2 = ['V', 'L', 'D'];

	/**
	 * Convert a number to it's Roman representation. No large numbers extension.
	 *
	 * @param   { number } num Number to convert. `0 < num <= 3999`.
	 * @returns { string }
	 */
	function numberToRoman$1 (num) {
	  return [...(num) + '']
	    .map(n => +n)
	    .reverse()
	    .map((v, i) => ((v % 5 < 4)
	      ? (v < 5 ? '' : V$2[i]) + I$3[i].repeat(v % 5)
	      : I$3[i] + (v < 5 ? V$2[i] : I$3[i + 1])))
	    .reverse()
	    .join('');
	}

	/**
	 * Return the same string or a substring with the given character occurences removed from each end if any.
	 *
	 * @param   { string } str  A string to trim.
	 * @param   { string } char A character to be trimmed.
	 * @returns { string }
	 */
	function trimCharacter$2 (str, char) {
	  let start = 0;
	  let end = str.length;
	  while (start < end && str[start] === char) { ++start; }
	  while (end > start && str[end - 1] === char) { --end; }
	  return (start > 0 || end < str.length)
	    ? str.substring(start, end)
	    : str;
	}

	/**
	 * Get a nested property from an object.
	 *
	 * @param   { object }   obj  The object to query for the value.
	 * @param   { string[] } path The path to the property.
	 * @returns { any }
	 */
	function get$2 (obj, path) {
	  for (const key of path) {
	    if (!obj) { return undefined; }
	    obj = obj[key];
	  }
	  return obj;
	}

	/**
	 * Deduplicate an array by a given key callback.
	 * Item properties are merged recursively and with the preference for last defined values.
	 * Of items with the same key, merged item takes the place of the last item,
	 * others are omitted.
	 *
	 * @param { any[] } items An array to deduplicate.
	 * @param { (x: any) => string } getKey Callback to get a value that distinguishes unique items.
	 * @returns { any[] }
	 */
	function mergeDuplicatesPreferLast$1 (items, getKey) {
	  const map = new Map();
	  for (let i = items.length; i-- > 0;) {
	    const item = items[i];
	    const key = getKey(item);
	    map.set(
	      key,
	      (map.has(key))
	        ? merge$2(item, map.get(key), { arrayMerge: overwriteMerge$1 })
	        : item
	    );
	  }
	  return [...map.values()].reverse();
	}

	const overwriteMerge$1 = (acc, src, options) => [...src];

	var helper = {
	  get: get$2,
	  limitedDepthRecursive: limitedDepthRecursive$1,
	  mergeDuplicatesPreferLast: mergeDuplicatesPreferLast$1,
	  numberToLetterSequence: numberToLetterSequence$1,
	  numberToRoman: numberToRoman$1,
	  splitClassesAndIds: splitClassesAndIds$1,
	  trimCharacter: trimCharacter$2
	};

	// eslint-disable-next-line import/no-unassigned-import


	/**
	 * Helps to build text from words.
	 */
	let InlineTextBuilder$1 = class InlineTextBuilder {
	  /**
	   * Creates an instance of InlineTextBuilder.
	   *
	   * If `maxLineLength` is not provided then it is either `options.wordwrap` or unlimited.
	   *
	   * @param { Options } options           HtmlToText options.
	   * @param { number }  [ maxLineLength ] This builder will try to wrap text to fit this line length.
	   */
	  constructor (options, maxLineLength = undefined) {
	    /** @type { string[][] } */
	    this.lines = [];
	    /** @type { string[] }   */
	    this.nextLineWords = [];
	    this.maxLineLength = maxLineLength || options.wordwrap || Number.MAX_VALUE;
	    this.nextLineAvailableChars = this.maxLineLength;
	    this.wrapCharacters = options.longWordSplit.wrapCharacters || [];
	    this.forceWrapOnLimit = options.longWordSplit.forceWrapOnLimit || false;

	    this.stashedSpace = false;
	    this.wordBreakOpportunity = false;
	  }

	  /**
	   * Add a new word.
	   *
	   * @param { string } word A word to add.
	   */
	  pushWord (word) {
	    if (this.nextLineAvailableChars <= 0) {
	      this.startNewLine();
	    }
	    const isLineStart = this.nextLineWords.length === 0;
	    const cost = word.length + (isLineStart ? 0 : 1);
	    if (cost <= this.nextLineAvailableChars) { // Fits into available budget

	      this.nextLineWords.push(word);
	      this.nextLineAvailableChars -= cost;

	    } else { // Does not fit - try to split the word

	      // The word is moved to a new line - prefer to wrap between words.
	      const [first, ...rest] = this.splitLongWord(word);
	      if (!isLineStart) { this.startNewLine(); }
	      this.nextLineWords.push(first);
	      this.nextLineAvailableChars -= first.length;
	      for (const part of rest) {
	        this.startNewLine();
	        this.nextLineWords.push(part);
	        this.nextLineAvailableChars -= part.length;
	      }

	    }
	  }

	  /**
	   * Pop a word from the currently built line.
	   * This doesn't affect completed lines.
	   *
	   * @returns { string }
	   */
	  popWord () {
	    const lastWord = this.nextLineWords.pop();
	    if (lastWord !== undefined) {
	      const isLineStart = this.nextLineWords.length === 0;
	      const cost = lastWord.length + (isLineStart ? 0 : 1);
	      this.nextLineAvailableChars += cost;
	    }
	    return lastWord;
	  }

	  /**
	   * Concat a word to the last word already in the builder.
	   * Adds a new word in case there are no words yet in the last line.
	   *
	   * @param { string } word A word to be concatenated.
	   */
	  concatWord (word) {
	    if (this.wordBreakOpportunity && word.length > this.nextLineAvailableChars) {
	      this.pushWord(word);
	      this.wordBreakOpportunity = false;
	    } else {
	      const lastWord = this.popWord();
	      this.pushWord((lastWord) ? lastWord.concat(word) : word);
	    }
	  }

	  /**
	   * Add current line (and more empty lines if provided argument > 1) to the list of complete lines and start a new one.
	   *
	   * @param { number } n Number of line breaks that will be added to the resulting string.
	   */
	  startNewLine (n = 1) {
	    this.lines.push(this.nextLineWords);
	    if (n > 1) {
	      this.lines.push(...Array.from({ length: n - 1 }, () => []));
	    }
	    this.nextLineWords = [];
	    this.nextLineAvailableChars = this.maxLineLength;
	  }

	  /**
	   * No words in this builder.
	   *
	   * @returns { boolean }
	   */
	  isEmpty () {
	    return this.lines.length === 0
	        && this.nextLineWords.length === 0;
	  }

	  clear () {
	    this.lines.length = 0;
	    this.nextLineWords.length = 0;
	    this.nextLineAvailableChars = this.maxLineLength;
	  }

	  /**
	   * Join all lines of words inside the InlineTextBuilder into a complete string.
	   *
	   * @returns { string }
	   */
	  toString () {
	    return [...this.lines, this.nextLineWords]
	      .map(words => words.join(' '))
	      .join('\n');
	  }

	  /**
	   * Split a long word up to fit within the word wrap limit.
	   * Use either a character to split looking back from the word wrap limit,
	   * or truncate to the word wrap limit.
	   *
	   * @param   { string }   word Input word.
	   * @returns { string[] }      Parts of the word.
	   */
	  splitLongWord (word) {
	    const parts = [];
	    let idx = 0;
	    while (word.length > this.maxLineLength) {

	      const firstLine = word.substring(0, this.maxLineLength);
	      const remainingChars = word.substring(this.maxLineLength);

	      const splitIndex = firstLine.lastIndexOf(this.wrapCharacters[idx]);

	      if (splitIndex > -1) { // Found a character to split on

	        word = firstLine.substring(splitIndex + 1) + remainingChars;
	        parts.push(firstLine.substring(0, splitIndex + 1));

	      } else { // Not found a character to split on

	        idx++;
	        if (idx < this.wrapCharacters.length) { // There is next character to try

	          word = firstLine + remainingChars;

	        } else { // No more characters to try

	          if (this.forceWrapOnLimit) {
	            parts.push(firstLine);
	            word = remainingChars;
	            if (word.length > this.maxLineLength) {
	              continue;
	            }
	          } else {
	            word = firstLine + remainingChars;
	          }
	          break;

	        }

	      }

	    }
	    parts.push(word); // Add remaining part to array
	    return parts;
	  }
	};

	var inlineTextBuilder = { InlineTextBuilder: InlineTextBuilder$1 };

	/* eslint-disable max-classes-per-file */

	const { InlineTextBuilder } = inlineTextBuilder;


	let StackItem$1 = class StackItem {
	  constructor (next = null) { this.next = next; }

	  getRoot () { return (this.next) ? this.next : this; }
	};

	let BlockStackItem$1 = class BlockStackItem extends StackItem$1 {
	  constructor (options, next = null, leadingLineBreaks = 1, maxLineLength = undefined) {
	    super(next);
	    this.leadingLineBreaks = leadingLineBreaks;
	    this.inlineTextBuilder = new InlineTextBuilder(options, maxLineLength);
	    this.rawText = '';
	    this.stashedLineBreaks = 0;
	    this.isPre = next && next.isPre;
	  }
	};

	let TableStackItem$1 = class TableStackItem extends StackItem$1 {
	  constructor (next = null) {
	    super(next);
	    this.rows = [];
	    this.isPre = next && next.isPre;
	  }
	};

	let TableRowStackItem$1 = class TableRowStackItem extends StackItem$1 {
	  constructor (next = null) {
	    super(next);
	    this.cells = [];
	    this.isPre = next && next.isPre;
	  }
	};

	let TableCellStackItem$1 = class TableCellStackItem extends StackItem$1 {
	  constructor (options, next = null, maxColumnWidth = undefined) {
	    super(next);
	    this.inlineTextBuilder = new InlineTextBuilder(options, maxColumnWidth);
	    this.rawText = '';
	    this.stashedLineBreaks = 0;
	    this.isPre = next && next.isPre;
	  }
	};

	let TransformerStackItem$1 = class TransformerStackItem extends StackItem$1 {
	  constructor (next = null, transform) {
	    super(next);
	    this.transform = transform;
	  }
	};

	var stackItem = {
	  BlockStackItem: BlockStackItem$1,
	  StackItem: StackItem$1,
	  TableCellStackItem: TableCellStackItem$1,
	  TableRowStackItem: TableRowStackItem$1,
	  TableStackItem: TableStackItem$1,
	  TransformerStackItem: TransformerStackItem$1,
	};

	function getRow (matrix, j) {
	  if (!matrix[j]) { matrix[j] = []; }
	  return matrix[j];
	}

	function findFirstVacantIndex (row, x = 0) {
	  while (row[x]) { x++; }
	  return x;
	}

	function transposeInPlace (matrix, maxSize) {
	  for (let i = 0; i < maxSize; i++) {
	    const rowI = getRow(matrix, i);
	    for (let j = 0; j < i; j++) {
	      const rowJ = getRow(matrix, j);
	      const temp = rowI[j];
	      rowI[j] = rowJ[i];
	      rowJ[i] = temp;
	    }
	  }
	}

	function putCellIntoLayout (cell, layout, baseRow, baseCol) {
	  for (let r = 0; r < cell.rowspan; r++) {
	    const layoutRow = getRow(layout, baseRow + r);
	    for (let c = 0; c < cell.colspan; c++) {
	      layoutRow[baseCol + c] = cell;
	    }
	  }
	}

	function updateOffset (offsets, base, span, value) {
	  offsets[base + span] = Math.max(
	    offsets[base + span] || 0,
	    offsets[base] + value
	  );
	}

	/**
	 * @typedef { object } TablePrinterCell
	 * Cell definition for the table printer.
	 *
	 * @property { number } colspan Number of columns this cell occupies.
	 * @property { number } rowspan Number of rows this cell occupies.
	 * @property { string } text Cell contents (pre-wrapped).
	 */

	/**
	 * Render a table into string.
	 * Cells can contain multiline text and span across multiple rows and columns.
	 *
	 * Modifies cells to add lines array.
	 *
	 * @param { TablePrinterCell[][] } tableRows Table to render.
	 * @param { number } rowSpacing Number of spaces between columns.
	 * @param { number } colSpacing Number of empty lines between rows.
	 * @returns { string }
	 */
	function tableToString$1 (tableRows, rowSpacing, colSpacing) {
	  const layout = [];
	  let colNumber = 0;
	  const rowNumber = tableRows.length;
	  const rowOffsets = [0];
	  // Fill the layout table and row offsets row-by-row.
	  for (let j = 0; j < rowNumber; j++) {
	    const layoutRow = getRow(layout, j);
	    const cells = tableRows[j];
	    let x = 0;
	    for (let i = 0; i < cells.length; i++) {
	      const cell = cells[i];
	      x = findFirstVacantIndex(layoutRow, x);
	      putCellIntoLayout(cell, layout, j, x);
	      x += cell.colspan;
	      cell.lines = cell.text.split('\n');
	      const cellHeight = cell.lines.length;
	      updateOffset(rowOffsets, j, cell.rowspan, cellHeight + rowSpacing);
	    }
	    colNumber = (layoutRow.length > colNumber) ? layoutRow.length : colNumber;
	  }

	  transposeInPlace(layout, (rowNumber > colNumber) ? rowNumber : colNumber);

	  const outputLines = [];
	  const colOffsets = [0];
	  // Fill column offsets and output lines column-by-column.
	  for (let x = 0; x < colNumber; x++) {
	    let y = 0;
	    let cell;
	    while (y < rowNumber && (cell = layout[x][y])) {
	      if (!cell.rendered) {
	        let cellWidth = 0;
	        for (let j = 0; j < cell.lines.length; j++) {
	          const line = cell.lines[j];
	          const lineOffset = rowOffsets[y] + j;
	          outputLines[lineOffset] = (outputLines[lineOffset] || '').padEnd(colOffsets[x]) + line;
	          cellWidth = (line.length > cellWidth) ? line.length : cellWidth;
	        }
	        updateOffset(colOffsets, x, cell.colspan, cellWidth + colSpacing);
	        cell.rendered = true;
	      }
	      y += cell.rowspan;
	    }
	  }

	  return outputLines.join('\n');
	}

	var tablePrinter = { tableToString: tableToString$1 };

	// eslint-disable-next-line import/no-unassigned-import



	function charactersToCodes (str) {
	  return [...str]
	    .map(c => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0'))
	    .join('');
	}

	/**
	 * Helps to handle HTML whitespaces.
	 *
	 * @class WhitespaceProcessor
	 */
	let WhitespaceProcessor$1 = class WhitespaceProcessor {

	  /**
	   * Creates an instance of WhitespaceProcessor.
	   *
	   * @param { Options } options    HtmlToText options.
	   * @memberof WhitespaceProcessor
	   */
	  constructor (options) {
	    this.whitespaceChars = (options.preserveNewlines)
	      ? options.whitespaceCharacters.replace(/\n/g, '')
	      : options.whitespaceCharacters;
	    const whitespaceCodes = charactersToCodes(this.whitespaceChars);
	    this.leadingWhitespaceRe = new RegExp(`^[${whitespaceCodes}]`);
	    this.trailingWhitespaceRe = new RegExp(`[${whitespaceCodes}]$`);
	    this.allWhitespaceOrEmptyRe = new RegExp(`^[${whitespaceCodes}]*$`);
	    this.newlineOrNonWhitespaceRe = new RegExp(`(\\n|[^\\n${whitespaceCodes}])`, 'g');

	    if (options.preserveNewlines) {

	      const wordOrNewlineRe = new RegExp(`\\n|[^\\n${whitespaceCodes}]+`, 'gm');

	      /**
	       * Shrink whitespaces and wrap text, add to the builder.
	       *
	       * @param { string }                  text              Input text.
	       * @param { InlineTextBuilder }       inlineTextBuilder A builder to receive processed text.
	       * @param { (str: string) => string } [ transform ]     A transform to be applied to words.
	       */
	      this.shrinkWrapAdd = function (text, inlineTextBuilder, transform = (str => str)) {
	        if (!text) { return; }
	        const previouslyStashedSpace = inlineTextBuilder.stashedSpace;
	        let anyMatch = false;
	        let m = wordOrNewlineRe.exec(text);
	        if (m) {
	          anyMatch = true;
	          if (m[0] === '\n') {
	            inlineTextBuilder.startNewLine();
	          } else if (previouslyStashedSpace || this.testLeadingWhitespace(text)) {
	            inlineTextBuilder.pushWord(transform(m[0]));
	          } else {
	            inlineTextBuilder.concatWord(transform(m[0]));
	          }
	          while ((m = wordOrNewlineRe.exec(text)) !== null) {
	            if (m[0] === '\n') {
	              inlineTextBuilder.startNewLine();
	            } else {
	              inlineTextBuilder.pushWord(transform(m[0]));
	            }
	          }
	        }
	        inlineTextBuilder.stashedSpace = (previouslyStashedSpace && !anyMatch) || (this.testTrailingWhitespace(text));
	        // No need to stash a space in case last added item was a new line,
	        // but that won't affect anything later anyway.
	      };

	    } else {

	      const wordRe = new RegExp(`[^${whitespaceCodes}]+`, 'g');

	      this.shrinkWrapAdd = function (text, inlineTextBuilder, transform = (str => str)) {
	        if (!text) { return; }
	        const previouslyStashedSpace = inlineTextBuilder.stashedSpace;
	        let anyMatch = false;
	        let m = wordRe.exec(text);
	        if (m) {
	          anyMatch = true;
	          if (previouslyStashedSpace || this.testLeadingWhitespace(text)) {
	            inlineTextBuilder.pushWord(transform(m[0]));
	          } else {
	            inlineTextBuilder.concatWord(transform(m[0]));
	          }
	          while ((m = wordRe.exec(text)) !== null) {
	            inlineTextBuilder.pushWord(transform(m[0]));
	          }
	        }
	        inlineTextBuilder.stashedSpace = (previouslyStashedSpace && !anyMatch) || this.testTrailingWhitespace(text);
	      };

	    }
	  }

	  /**
	   * Test whether the given text starts with HTML whitespace character.
	   *
	   * @param   { string }  text  The string to test.
	   * @returns { boolean }
	   */
	  testLeadingWhitespace (text) {
	    return this.leadingWhitespaceRe.test(text);
	  }

	  /**
	   * Test whether the given text ends with HTML whitespace character.
	   *
	   * @param   { string }  text  The string to test.
	   * @returns { boolean }
	   */
	  testTrailingWhitespace (text) {
	    return this.trailingWhitespaceRe.test(text);
	  }

	  /**
	   * Test whether the given text contains any non-whitespace characters.
	   *
	   * @param   { string }  text  The string to test.
	   * @returns { boolean }
	   */
	  testContainsWords (text) {
	    return !this.allWhitespaceOrEmptyRe.test(text);
	  }

	  /**
	   * Return the number of newlines if there are no words.
	   *
	   * If any word is found then return zero regardless of the actual number of newlines.
	   *
	   * @param   { string }  text  Input string.
	   * @returns { number }
	   */
	  countNewlinesNoWords (text) {
	    this.newlineOrNonWhitespaceRe.lastIndex = 0;
	    let counter = 0;
	    let match;
	    while ((match = this.newlineOrNonWhitespaceRe.exec(text)) !== null) {
	      if (match[0] === '\n') {
	        counter++;
	      } else {
	        return 0;
	      }
	    }
	    return counter;
	  }

	};

	var whitespaceProcessor = { WhitespaceProcessor: WhitespaceProcessor$1 };

	const { trimCharacter: trimCharacter$1 } = helper;
	// eslint-disable-next-line no-unused-vars
	const { StackItem, BlockStackItem, TableCellStackItem, TableRowStackItem, TableStackItem, TransformerStackItem }
	  = stackItem;
	const { tableToString } = tablePrinter;
	const { WhitespaceProcessor } = whitespaceProcessor;

	// eslint-disable-next-line import/no-unassigned-import



	/**
	 * Helps to build text from inline and block elements.
	 *
	 * @class BlockTextBuilder
	 */
	let BlockTextBuilder$1 = class BlockTextBuilder {

	  /**
	   * Creates an instance of BlockTextBuilder.
	   *
	   * @param { Options } options HtmlToText options.
	   * @param { Picker<DomNode, TagDefinition> } picker Selectors decision tree picker.
	   */
	  constructor (options, picker) {
	    this.options = options;
	    this.picker = picker;
	    this.whitespaceProcessor = new WhitespaceProcessor(options);
	    /** @type { StackItem } */
	    this._stackItem = new BlockStackItem(options);
	    /** @type { TransformerStackItem } */
	    this._wordTransformer = undefined;
	  }

	  /**
	   * Put a word-by-word transform function onto the transformations stack.
	   *
	   * Mainly used for uppercasing. Can be bypassed to add unformatted text such as URLs.
	   *
	   * Word transformations applied before wrapping.
	   *
	   * @param { (str: string) => string } wordTransform Word transformation function.
	   */
	  pushWordTransform (wordTransform) {
	    this._wordTransformer = new TransformerStackItem(this._wordTransformer, wordTransform);
	  }

	  /**
	   * Remove a function from the word transformations stack.
	   *
	   * @returns { (str: string) => string } A function that was removed.
	   */
	  popWordTransform () {
	    if (!this._wordTransformer) { return undefined; }
	    const transform = this._wordTransformer.transform;
	    this._wordTransformer = this._wordTransformer.next;
	    return transform;
	  }

	  /** @returns { (str: string) => string } */
	  _getCombinedWordTransformer () {
	    const applyTransformer = (str, transformer) =>
	      ((transformer) ? applyTransformer(transformer.transform(str), transformer.next) : str);
	    return (str) => applyTransformer(str, this._wordTransformer);
	  }

	  _popStackItem () {
	    const item = this._stackItem;
	    this._stackItem = item.next;
	    return item;
	  }

	  /**
	   * Add a line break into currently built block.
	   */
	  addLineBreak () {
	    if (!(
	      this._stackItem instanceof BlockStackItem
	      || this._stackItem instanceof TableCellStackItem
	    )) { return; }
	    if (this._stackItem.isPre) {
	      this._stackItem.rawText += '\n';
	    } else {
	      this._stackItem.inlineTextBuilder.startNewLine();
	    }
	  }

	  /**
	   * Allow to break line in case directly following text will not fit.
	   */
	  addWordBreakOpportunity () {
	    if (
	      this._stackItem instanceof BlockStackItem
	      || this._stackItem instanceof TableCellStackItem
	    ) {
	      this._stackItem.inlineTextBuilder.wordBreakOpportunity = true;
	    }
	  }

	  /**
	   * Add a node inline into the currently built block.
	   *
	   * @param { string } str
	   * Text content of a node to add.
	   *
	   * @param { object | boolean } [ optionsObjectOrNoWordTransform ]
	   * Object holding the parameters of the operation.
	   *
	   * Boolean value is deprecated.
	   *
	   * @param { boolean } [ optionsObjectOrNoWordTransform.noWordTransform = false ]
	   * Ignore word transformers if there are any.
	   */
	  addInline (str, optionsObjectOrNoWordTransform = {}) {
	    if (typeof optionsObjectOrNoWordTransform === 'object') {
	      this._addInline(str, optionsObjectOrNoWordTransform);
	    } else {
	      this._addInline(str, { noWordTransform: optionsObjectOrNoWordTransform });
	    }
	  }

	  _addInline (str, { noWordTransform = false } = {}) {
	    if (!(
	      this._stackItem instanceof BlockStackItem
	      || this._stackItem instanceof TableCellStackItem
	    )) { return; }

	    if (this._stackItem.isPre) {
	      this._stackItem.rawText += str;
	      return;
	    }

	    if (
	      str.length === 0 || // empty string
	      (
	        this._stackItem.stashedLineBreaks && // stashed linebreaks make whitespace irrelevant
	        !this.whitespaceProcessor.testContainsWords(str) // no words to add
	      )
	    ) { return; }

	    if (this.options.preserveNewlines) {
	      const newlinesNumber = this.whitespaceProcessor.countNewlinesNoWords(str);
	      if (newlinesNumber > 0) {
	        this._stackItem.inlineTextBuilder.startNewLine(newlinesNumber);
	        // keep stashedLineBreaks unchanged
	        return;
	      }
	    }

	    if (this._stackItem.stashedLineBreaks) {
	      this._stackItem.inlineTextBuilder.startNewLine(this._stackItem.stashedLineBreaks);
	    }
	    this.whitespaceProcessor.shrinkWrapAdd(
	      str,
	      this._stackItem.inlineTextBuilder,
	      (this._wordTransformer && !noWordTransform) ? this._getCombinedWordTransformer() : undefined
	    );
	    this._stackItem.stashedLineBreaks = 0; // inline text doesn't introduce line breaks
	  }

	  /**
	   * Start building a new block.
	   *
	   * @param { object | number } [optionsObjectOrLeadingLineBreaks]
	   * Object holding the parameters of the block.
	   *
	   * Number value is deprecated.
	   *
	   * @param { number }  [optionsObjectOrLeadingLineBreaks.leadingLineBreaks = 1]
	   * This block should have at least this number of line breaks to separate if from any preceding block.
	   *
	   * @param { number }  [optionsObjectOrLeadingLineBreaks.reservedLineLength = 0]
	   * Reserve this number of characters on each line for block markup.
	   *
	   * @param { boolean } [optionsObjectOrLeadingLineBreaks.isPre = false]
	   * Should HTML whitespace be preserved inside this block.
	   *
	   * @param { number }  [reservedLineLength]
	   * Deprecated.
	   *
	   * @param { boolean } [isPre]
	   * Deprecated.
	   */
	  openBlock (optionsObjectOrLeadingLineBreaks = {}, reservedLineLength = undefined, isPre = undefined) {
	    if (typeof optionsObjectOrLeadingLineBreaks === 'object') {
	      this._openBlock(optionsObjectOrLeadingLineBreaks);
	    } else {
	      this._openBlock({
	        isPre: isPre,
	        leadingLineBreaks: optionsObjectOrLeadingLineBreaks,
	        reservedLineLength: reservedLineLength,
	      });
	    }
	  }

	  _openBlock ({ leadingLineBreaks = 1, reservedLineLength = 0, isPre = false } = {}) {
	    const maxLineLength = Math.max(20, this._stackItem.inlineTextBuilder.maxLineLength - reservedLineLength);
	    this._stackItem = new BlockStackItem(
	      this.options,
	      this._stackItem,
	      leadingLineBreaks,
	      maxLineLength
	    );
	    if (isPre) { this._stackItem.isPre = true; }
	  }

	  /**
	   * Finalize currently built block, add it's content to the parent block.
	   *
	   * @param { object | number }         [optionsObjectOrTrailingLineBreaks]
	   * Object holding the parameters of the block.
	   *
	   * Number value is deprecated.
	   *
	   * @param { number }                  [optionsObjectOrTrailingLineBreaks.trailingLineBreaks = 1]
	   * This block should have at least this number of line breaks to separate it from any following block.
	   *
	   * @param { (str: string) => string } [optionsObjectOrTrailingLineBreaks.blockTransform = undefined]
	   * A function to transform the block text before adding to the parent block.
	   * This happens after word wrap and should be used in combination with reserved line length
	   * in order to keep line lengths correct.
	   * Used for whole block markup.
	   *
	   * @param { (str: string) => string } [blockTransform]
	   * Deprecated.
	   */
	  closeBlock (optionsObjectOrTrailingLineBreaks = {}, blockTransform = undefined) {
	    if (typeof optionsObjectOrTrailingLineBreaks === 'object') {
	      this._closeBlock(optionsObjectOrTrailingLineBreaks);
	    } else {
	      this._closeBlock({
	        trailingLineBreaks: optionsObjectOrTrailingLineBreaks,
	        blockTransform: blockTransform,
	      });
	    }
	  }

	  _closeBlock ({ trailingLineBreaks = 1, blockTransform = undefined } = {}) {
	    const block = this._popStackItem();
	    const blockText = (blockTransform) ? blockTransform(getText(block)) : getText(block);
	    addText(this._stackItem, blockText, block.leadingLineBreaks, Math.max(block.stashedLineBreaks, trailingLineBreaks));
	  }

	  /**
	   * Start building a table.
	   */
	  openTable () {
	    this._stackItem = new TableStackItem(this._stackItem);
	  }

	  /**
	   * Start building a table row.
	   */
	  openTableRow () {
	    if (!(this._stackItem instanceof TableStackItem)) {
	      throw new Error('Can\'t add table row to something that is not a table! Check the formatter.');
	    }
	    this._stackItem = new TableRowStackItem(this._stackItem);
	  }

	  /**
	   * Start building a table cell.
	   *
	   * @param { object | number } [optionsObjectOrMaxColumnWidth = undefined]
	   * Object holding the parameters of the cell.
	   *
	   * Number value is deprecated.
	   *
	   * @param { number } [optionsObjectOrMaxColumnWidth.maxColumnWidth = undefined]
	   * Wrap cell content to this width. Fall back to global wordwrap value if undefined.
	   */
	  openTableCell (optionsObjectOrMaxColumnWidth = {}) {
	    if (typeof optionsObjectOrMaxColumnWidth === 'object') {
	      this._openTableCell(optionsObjectOrMaxColumnWidth);
	    } else {
	      this._openTableCell({ maxColumnWidth: optionsObjectOrMaxColumnWidth });
	    }
	  }

	  _openTableCell ({ maxColumnWidth = undefined } = {}) {
	    if (!(this._stackItem instanceof TableRowStackItem)) {
	      throw new Error('Can\'t add table cell to something that is not a table row! Check the formatter.');
	    }
	    this._stackItem = new TableCellStackItem(this.options, this._stackItem, maxColumnWidth);
	  }

	  /**
	   * Finalize currently built table cell and add it to parent table row's cells.
	   *
	   * @param { object | number } [optionsObjectOrColspan]
	   * Object holding the parameters of the cell.
	   *
	   * Number value is deprecated.
	   *
	   * @param { number } [optionsObjectOrColspan.colspan = 1] How many columns this cell should occupy.
	   * @param { number } [optionsObjectOrColspan.rowspan = 1] How many rows this cell should occupy.
	   *
	   * @param { number } [rowspan] Deprecated.
	   */
	  closeTableCell (optionsObjectOrColspan = {}, rowspan = undefined) {
	    if (typeof optionsObjectOrColspan === 'object') {
	      this._closeTableCell(optionsObjectOrColspan);
	    } else {
	      this._closeTableCell({
	        colspan: optionsObjectOrColspan,
	        rowspan: rowspan,
	      });
	    }
	  }

	  _closeTableCell ({ colspan = 1, rowspan = 1 } = {}) {
	    const cell = this._popStackItem();
	    const text = trimCharacter$1(getText(cell), '\n');
	    cell.next.cells.push({ colspan: colspan, rowspan: rowspan, text: text });
	  }

	  /**
	   * Finalize currently built table row and add it to parent table's rows.
	   */
	  closeTableRow () {
	    const row = this._popStackItem();
	    row.next.rows.push(row.cells);
	  }

	  /**
	   * Finalize currently built table and add the rendered text to the parent block.
	   *
	   * @param { object | number } [optionsObjectOrColSpacing]
	   * Object holding the parameters of the table.
	   *
	   * Number value is deprecated.
	   *
	   * @param { number } [optionsObjectOrColSpacing.colSpacing = 3]
	   * Number of spaces between table columns.
	   *
	   * @param { number } [optionsObjectOrColSpacing.rowSpacing = 0]
	   * Number of empty lines between table rows.
	   *
	   * @param { number } [optionsObjectOrColSpacing.leadingLineBreaks = 2]
	   * This table should have at least this number of line breaks to separate if from any preceding block.
	   *
	   * @param { number } [optionsObjectOrColSpacing.trailingLineBreaks = 2]
	   * This table should have at least this number of line breaks to separate it from any following block.
	   *
	   * @param { number } [rowSpacing]
	   * Deprecated.
	   *
	   * @param { number } [leadingLineBreaks]
	   * Deprecated.
	   *
	   * @param { number } [trailingLineBreaks]
	   * Deprecated.
	   */
	  closeTable (
	    optionsObjectOrColSpacing = {},
	    rowSpacing = undefined,
	    leadingLineBreaks = undefined,
	    trailingLineBreaks = undefined
	  ) {
	    if (typeof optionsObjectOrColSpacing === 'object') {
	      this._closeTable(optionsObjectOrColSpacing);
	    } else {
	      this._closeTable({
	        colSpacing: optionsObjectOrColSpacing,
	        leadingLineBreaks: leadingLineBreaks,
	        rowSpacing: rowSpacing,
	        trailingLineBreaks: trailingLineBreaks
	      });
	    }
	  }

	  _closeTable ({ colSpacing = 3, rowSpacing = 0, leadingLineBreaks = 2, trailingLineBreaks = 2 } = {}) {
	    const table = this._popStackItem();
	    const output = tableToString(table.rows, rowSpacing, colSpacing);
	    if (output) {
	      addText(this._stackItem, output, leadingLineBreaks, trailingLineBreaks);
	    }
	  }

	  /**
	   * Return the rendered text content of this builder.
	   *
	   * @returns { string }
	   */
	  toString () {
	    return getText(this._stackItem.getRoot());
	    // There should only be the root item if everything is closed properly.
	  }

	};

	function getText (stackItem) {
	  if (!(
	    stackItem instanceof BlockStackItem
	    || stackItem instanceof TableCellStackItem
	  )) {
	    throw new Error('Only blocks and table cells can be requested for text contents.');
	  }
	  return (stackItem.inlineTextBuilder.isEmpty())
	    ? stackItem.rawText
	    : stackItem.rawText + stackItem.inlineTextBuilder.toString();
	}

	function addText (stackItem, text, leadingLineBreaks, trailingLineBreaks) {
	  if (!(
	    stackItem instanceof BlockStackItem
	    || stackItem instanceof TableCellStackItem
	  )) {
	    throw new Error('Only blocks and table cells can contain text.');
	  }
	  const parentText = getText(stackItem);
	  const lineBreaks = Math.max(stackItem.stashedLineBreaks, leadingLineBreaks);
	  stackItem.inlineTextBuilder.clear();
	  if (parentText) {
	    stackItem.rawText = parentText + '\n'.repeat(lineBreaks) + text;
	  } else {
	    stackItem.rawText = text;
	    stackItem.leadingLineBreaks = lineBreaks;
	  }
	  stackItem.stashedLineBreaks = trailingLineBreaks;
	}

	var blockTextBuilder = { BlockTextBuilder: BlockTextBuilder$1 };

	const he$2 = heExports;

	const { get: get$1, numberToLetterSequence, numberToRoman, splitClassesAndIds, trimCharacter } = helper;

	// eslint-disable-next-line import/no-unassigned-import



	/**
	 * Dummy formatter that discards the input and does nothing.
	 *
	 * @type { FormatCallback }
	 */
	function formatSkip (elem, walk, builder, formatOptions) {
	  /* do nothing */
	}

	/**
	 * Process an inline-level element.
	 *
	 * @type { FormatCallback }
	 */
	function formatInline (elem, walk, builder, formatOptions) {
	  walk(elem.children, builder);
	}

	/**
	 * Process a block-level container.
	 *
	 * @type { FormatCallback }
	 */
	function formatBlock (elem, walk, builder, formatOptions) {
	  builder.openBlock({ leadingLineBreaks: formatOptions.leadingLineBreaks });
	  walk(elem.children, builder);
	  builder.closeBlock({ trailingLineBreaks: formatOptions.trailingLineBreaks });
	}

	/**
	 * Process a line-break.
	 *
	 * @type { FormatCallback }
	 */
	function formatLineBreak (elem, walk, builder, formatOptions) {
	  builder.addLineBreak();
	}

	/**
	 * Process a `wbk` tag (word break opportunity).
	 *
	 * @type { FormatCallback }
	 */
	function formatWbr (elem, walk, builder, formatOptions) {
	  builder.addWordBreakOpportunity();
	}

	/**
	 * Process a horizontal line.
	 *
	 * @type { FormatCallback }
	 */
	function formatHorizontalLine (elem, walk, builder, formatOptions) {
	  builder.openBlock({ leadingLineBreaks: formatOptions.leadingLineBreaks || 2 });
	  builder.addInline('-'.repeat(formatOptions.length || builder.options.wordwrap || 40));
	  builder.closeBlock({ trailingLineBreaks: formatOptions.trailingLineBreaks || 2 });
	}

	/**
	 * Process a paragraph.
	 *
	 * @type { FormatCallback }
	 */
	function formatParagraph (elem, walk, builder, formatOptions) {
	  builder.openBlock({ leadingLineBreaks: formatOptions.leadingLineBreaks || 2 });
	  walk(elem.children, builder);
	  builder.closeBlock({ trailingLineBreaks: formatOptions.trailingLineBreaks || 2 });
	}

	/**
	 * Process a preformatted content.
	 *
	 * @type { FormatCallback }
	 */
	function formatPre (elem, walk, builder, formatOptions) {
	  builder.openBlock({
	    isPre: true,
	    leadingLineBreaks: formatOptions.leadingLineBreaks || 2
	  });
	  walk(elem.children, builder);
	  builder.closeBlock({ trailingLineBreaks: formatOptions.trailingLineBreaks || 2 });
	}

	/**
	 * Process a heading.
	 *
	 * @type { FormatCallback }
	 */
	function formatHeading (elem, walk, builder, formatOptions) {
	  builder.openBlock({ leadingLineBreaks: formatOptions.leadingLineBreaks || 2 });
	  if (formatOptions.uppercase !== false) {
	    builder.pushWordTransform(str => str.toUpperCase());
	    walk(elem.children, builder);
	    builder.popWordTransform();
	  } else {
	    walk(elem.children, builder);
	  }
	  builder.closeBlock({ trailingLineBreaks: formatOptions.trailingLineBreaks || 2 });
	}

	/**
	 * Process a blockquote.
	 *
	 * @type { FormatCallback }
	 */
	function formatBlockquote (elem, walk, builder, formatOptions) {
	  builder.openBlock({
	    leadingLineBreaks: formatOptions.leadingLineBreaks || 2,
	    reservedLineLength: 2
	  });
	  walk(elem.children, builder);
	  builder.closeBlock({
	    trailingLineBreaks: formatOptions.trailingLineBreaks || 2,
	    blockTransform: str => ((formatOptions.trimEmptyLines !== false) ? trimCharacter(str, '\n') : str)
	      .split('\n')
	      .map(line => '> ' + line)
	      .join('\n')
	  });
	}

	function withBrackets (str, brackets) {
	  if (!brackets) { return str; }

	  const lbr = (typeof brackets[0] === 'string')
	    ? brackets[0]
	    : '[';
	  const rbr = (typeof brackets[1] === 'string')
	    ? brackets[1]
	    : ']';
	  return lbr + str + rbr;
	}

	/**
	 * Process an image.
	 *
	 * @type { FormatCallback }
	 */
	function formatImage (elem, walk, builder, formatOptions) {
	  const attribs = elem.attribs || {};
	  const alt = (attribs.alt)
	    ? he$2.decode(attribs.alt, builder.options.decodeOptions)
	    : '';
	  const src = (!attribs.src)
	    ? ''
	    : (formatOptions.baseUrl && attribs.src.indexOf('/') === 0)
	      ? formatOptions.baseUrl + attribs.src
	      : attribs.src;
	  const text = (!src)
	    ? alt
	    : (!alt)
	      ? withBrackets(src, formatOptions.linkBrackets)
	      : alt + ' ' + withBrackets(src, formatOptions.linkBrackets);

	  builder.addInline(text);
	}

	/**
	 * Process an anchor.
	 *
	 * @type { FormatCallback }
	 */
	function formatAnchor (elem, walk, builder, formatOptions) {
	  function getHref () {
	    if (formatOptions.ignoreHref) { return ''; }
	    if (!elem.attribs || !elem.attribs.href) { return ''; }
	    let href = elem.attribs.href.replace(/^mailto:/, '');
	    if (formatOptions.noAnchorUrl && href[0] === '#') { return ''; }
	    href = (formatOptions.baseUrl && href[0] === '/')
	      ? formatOptions.baseUrl + href
	      : href;
	    return he$2.decode(href, builder.options.decodeOptions);
	  }
	  const href = getHref();
	  if (!href) {
	    walk(elem.children, builder);
	  } else {
	    let text = '';
	    builder.pushWordTransform(
	      str => {
	        if (str) { text += str; }
	        return str;
	      }
	    );
	    walk(elem.children, builder);
	    builder.popWordTransform();

	    const hideSameLink = formatOptions.hideLinkHrefIfSameAsText && href === text;
	    if (!hideSameLink) {
	      builder.addInline(
	        (!text)
	          ? href
	          : ' ' + withBrackets(href, formatOptions.linkBrackets),
	        { noWordTransform: true }
	      );
	    }
	  }
	}

	/**
	 * @param { DomNode }           elem               List items with their prefixes.
	 * @param { RecursiveCallback } walk               Recursive callback to process child nodes.
	 * @param { BlockTextBuilder }  builder            Passed around to accumulate output text.
	 * @param { FormatOptions }     formatOptions      Options specific to a formatter.
	 * @param { () => string }      nextPrefixCallback Function that returns increasing index each time it is called.
	 */
	function formatList (elem, walk, builder, formatOptions, nextPrefixCallback) {
	  const isNestedList = get$1(elem, ['parent', 'name']) === 'li';

	  // With Roman numbers, index length is not as straightforward as with Arabic numbers or letters,
	  // so the dumb length comparison is the most robust way to get the correct value.
	  let maxPrefixLength = 0;
	  const listItems = (elem.children || [])
	    // it might be more accurate to check only for html spaces here, but no significant benefit
	    .filter(child => child.type !== 'text' || !/^\s*$/.test(child.data))
	    .map(function (child) {
	      if (child.name !== 'li') {
	        return { node: child, prefix: '' };
	      }
	      const prefix = (isNestedList)
	        ? nextPrefixCallback().trimStart()
	        : nextPrefixCallback();
	      if (prefix.length > maxPrefixLength) { maxPrefixLength = prefix.length; }
	      return { node: child, prefix: prefix };
	    });
	  if (!listItems.length) { return; }

	  const reservedLineLength = maxPrefixLength;
	  const spacing = '\n' + ' '.repeat(reservedLineLength);
	  builder.openBlock({ leadingLineBreaks: isNestedList ? 1 : (formatOptions.leadingLineBreaks || 2) });
	  for (const { node, prefix } of listItems) {
	    builder.openBlock({
	      leadingLineBreaks: 1,
	      reservedLineLength: reservedLineLength
	    });
	    walk([node], builder);
	    builder.closeBlock({
	      trailingLineBreaks: 1,
	      blockTransform: str => prefix + ' '.repeat(reservedLineLength - prefix.length) + str.replace(/\n/g, spacing)
	    });
	  }
	  builder.closeBlock({ trailingLineBreaks: isNestedList ? 1 : (formatOptions.trailingLineBreaks || 2) });
	}

	/**
	 * Process an unordered list.
	 *
	 * @type { FormatCallback }
	 */
	function formatUnorderedList (elem, walk, builder, formatOptions) {
	  const prefix = formatOptions.itemPrefix || ' * ';
	  return formatList(elem, walk, builder, formatOptions, () => prefix);
	}

	/**
	 * Process an ordered list.
	 *
	 * @type { FormatCallback }
	 */
	function formatOrderedList (elem, walk, builder, formatOptions) {
	  let nextIndex = Number(elem.attribs.start || '1');
	  const indexFunction = getOrderedListIndexFunction(elem.attribs.type);
	  const nextPrefixCallback = () => ' ' + indexFunction(nextIndex++) + '. ';
	  return formatList(elem, walk, builder, formatOptions, nextPrefixCallback);
	}

	/**
	 * Return a function that can be used to generate index markers of a specified format.
	 *
	 * @param   { string } [olType='1'] Marker type.
	 * @returns { (i: number) => string }
	 */
	function getOrderedListIndexFunction (olType = '1') {
	  switch (olType) {
	    case 'a': return (i) => numberToLetterSequence(i, 'a');
	    case 'A': return (i) => numberToLetterSequence(i, 'A');
	    case 'i': return (i) => numberToRoman(i).toLowerCase();
	    case 'I': return (i) => numberToRoman(i);
	    case '1':
	    default: return (i) => (i).toString();
	  }
	}

	function isDataTable (attr, tables) {
	  if (tables === true) { return true; }
	  if (!attr) { return false; }

	  const { classes, ids } = splitClassesAndIds(tables);
	  const attrClasses = (attr['class'] || '').split(' ');
	  const attrIds = (attr['id'] || '').split(' ');

	  return attrClasses.some(x => classes.includes(x)) || attrIds.some(x => ids.includes(x));
	}

	/**
	 * Process a table (either as a container or as a data table, depending on options).
	 *
	 * @type { FormatCallback }
	 */
	function formatTable (elem, walk, builder, formatOptions) {
	  return isDataTable(elem.attribs, builder.options.tables)
	    ? formatDataTable(elem, walk, builder, formatOptions)
	    : formatBlock(elem, walk, builder, formatOptions);
	}

	/**
	 * Process a data table.
	 *
	 * @type { FormatCallback }
	 */
	function formatDataTable (elem, walk, builder, formatOptions) {
	  builder.openTable();
	  elem.children.forEach(walkTable);
	  builder.closeTable({
	    colSpacing: formatOptions.colSpacing,
	    leadingLineBreaks: formatOptions.leadingLineBreaks,
	    rowSpacing: formatOptions.rowSpacing,
	    trailingLineBreaks: formatOptions.trailingLineBreaks
	  });

	  function formatCell (cellNode) {
	    const colspan = +get$1(cellNode, ['attribs', 'colspan']) || 1;
	    const rowspan = +get$1(cellNode, ['attribs', 'rowspan']) || 1;
	    builder.openTableCell({ maxColumnWidth: formatOptions.maxColumnWidth });
	    walk(cellNode.children, builder);
	    builder.closeTableCell({ colspan: colspan, rowspan: rowspan });
	  }

	  function walkTable (elem) {
	    if (elem.type !== 'tag') { return; }

	    const formatHeaderCell = (formatOptions.uppercaseHeaderCells !== false)
	      ? (cellNode) => {
	        builder.pushWordTransform(str => str.toUpperCase());
	        formatCell(cellNode);
	        builder.popWordTransform();
	      }
	      : formatCell;

	    switch (elem.name) {
	      case 'thead':
	      case 'tbody':
	      case 'tfoot':
	      case 'center':
	        elem.children.forEach(walkTable);
	        return;

	      case 'tr': {
	        builder.openTableRow();
	        for (const childOfTr of elem.children) {
	          if (childOfTr.type !== 'tag') { continue; }
	          switch (childOfTr.name) {
	            case 'th': {
	              formatHeaderCell(childOfTr);
	              break;
	            }
	            case 'td': {
	              formatCell(childOfTr);
	              break;
	            }
	              // do nothing
	          }
	        }
	        builder.closeTableRow();
	        break;
	      }
	        // do nothing
	    }
	  }
	}

	var formatter = {
	  anchor: formatAnchor,
	  block: formatBlock,
	  blockquote: formatBlockquote,
	  dataTable: formatDataTable,
	  heading: formatHeading,
	  horizontalLine: formatHorizontalLine,
	  image: formatImage,
	  inline: formatInline,
	  lineBreak: formatLineBreak,
	  orderedList: formatOrderedList,
	  paragraph: formatParagraph,
	  pre: formatPre,
	  skip: formatSkip,
	  table: formatTable,
	  unorderedList: formatUnorderedList,
	  wbr: formatWbr
	};

	const { hp2Builder } = hp2Builder$2;
	const merge$1 = cjs;
	const he$1 = heExports;
	const htmlparser = lib$3;
	const selderee = selderee$2;

	const { BlockTextBuilder } = blockTextBuilder;
	const defaultFormatters = formatter;
	const { limitedDepthRecursive, mergeDuplicatesPreferLast, get } = helper;

	// eslint-disable-next-line import/no-unassigned-import



	/**
	 * Default options.
	 *
	 * @constant
	 * @type { Options }
	 * @default
	 * @private
	 */
	const DEFAULT_OPTIONS$1 = {
	  baseElements: {
	    selectors: [ 'body' ],
	    orderBy: 'selectors', // 'selectors' | 'occurrence'
	    returnDomByDefault: true
	  },
	  decodeOptions: {
	    isAttributeValue: false,
	    strict: false
	  },
	  formatters: {},
	  limits: {
	    ellipsis: '...',
	    maxBaseElements: undefined,
	    maxChildNodes: undefined,
	    maxDepth: undefined,
	    maxInputLength: (1 << 24) // 16_777_216
	  },
	  longWordSplit: {
	    forceWrapOnLimit: false,
	    wrapCharacters: []
	  },
	  preserveNewlines: false,
	  selectors: [
	    { selector: '*', format: 'inline' },
	    {
	      selector: 'a',
	      format: 'anchor',
	      options: {
	        baseUrl: null,
	        hideLinkHrefIfSameAsText: false,
	        ignoreHref: false,
	        linkBrackets: ['[', ']'],
	        noAnchorUrl: true
	      }
	    },
	    { selector: 'article', format: 'block' },
	    { selector: 'aside', format: 'block' },
	    {
	      selector: 'blockquote',
	      format: 'blockquote',
	      options: { leadingLineBreaks: 2, trailingLineBreaks: 2, trimEmptyLines: true }
	    },
	    { selector: 'br', format: 'lineBreak' },
	    { selector: 'div', format: 'block' },
	    { selector: 'footer', format: 'block' },
	    { selector: 'form', format: 'block' },
	    { selector: 'h1', format: 'heading', options: { leadingLineBreaks: 3, trailingLineBreaks: 2, uppercase: true } },
	    { selector: 'h2', format: 'heading', options: { leadingLineBreaks: 3, trailingLineBreaks: 2, uppercase: true } },
	    { selector: 'h3', format: 'heading', options: { leadingLineBreaks: 3, trailingLineBreaks: 2, uppercase: true } },
	    { selector: 'h4', format: 'heading', options: { leadingLineBreaks: 2, trailingLineBreaks: 2, uppercase: true } },
	    { selector: 'h5', format: 'heading', options: { leadingLineBreaks: 2, trailingLineBreaks: 2, uppercase: true } },
	    { selector: 'h6', format: 'heading', options: { leadingLineBreaks: 2, trailingLineBreaks: 2, uppercase: true } },
	    { selector: 'header', format: 'block' },
	    {
	      selector: 'hr',
	      format: 'horizontalLine',
	      options: { leadingLineBreaks: 2, length: undefined, trailingLineBreaks: 2 }
	    },
	    {
	      selector: 'img',
	      format: 'image',
	      options: { baseUrl: null, linkBrackets: ['[', ']'] }
	    },
	    { selector: 'main', format: 'block' },
	    { selector: 'nav', format: 'block' },
	    {
	      selector: 'ol',
	      format: 'orderedList',
	      options: { leadingLineBreaks: 2, trailingLineBreaks: 2 }
	    },
	    { selector: 'p', format: 'paragraph', options: { leadingLineBreaks: 2, trailingLineBreaks: 2 } },
	    { selector: 'pre', format: 'pre', options: { leadingLineBreaks: 2, trailingLineBreaks: 2 } },
	    { selector: 'section', format: 'block' },
	    {
	      selector: 'table',
	      format: 'table',
	      options: {
	        colSpacing: 3,
	        leadingLineBreaks: 2,
	        maxColumnWidth: 60,
	        rowSpacing: 0,
	        trailingLineBreaks: 2,
	        uppercaseHeaderCells: true
	      }
	    },
	    {
	      selector: 'ul',
	      format: 'unorderedList',
	      options: { itemPrefix: ' * ', leadingLineBreaks: 2, trailingLineBreaks: 2 }
	    },
	    { selector: 'wbr', format: 'wbr' },
	  ],
	  tables: [], // deprecated
	  whitespaceCharacters: ' \t\r\n\f\u200b',
	  wordwrap: 80
	};

	const concatMerge = (acc, src, options) => [...acc, ...src];
	const overwriteMerge = (acc, src, options) => [...src];
	const selectorsMerge = (acc, src, options) => (
	  (acc.some(s => typeof s === 'object'))
	    ? concatMerge(acc, src) // selectors
	    : overwriteMerge(acc, src) // baseElements.selectors
	);

	/**
	 * Preprocess options, compile selectors into a decision tree,
	 * return a function intended for batch processing.
	 *
	 * @param   { Options } [options = {}]   HtmlToText options.
	 * @returns { (html: string) => string } Pre-configured converter function.
	 * @static
	 */
	function compile (options = {}) {
	  options = merge$1(
	    DEFAULT_OPTIONS$1,
	    options,
	    {
	      arrayMerge: overwriteMerge,
	      customMerge: (key) => ((key === 'selectors') ? selectorsMerge : undefined)
	    }
	  );
	  options.formatters = Object.assign({}, defaultFormatters, options.formatters);

	  handleDeprecatedOptions(options);

	  const uniqueSelectors = mergeDuplicatesPreferLast(options.selectors, (s => s.selector));
	  const selectorsWithoutFormat = uniqueSelectors.filter(s => !s.format);
	  if (selectorsWithoutFormat.length) {
	    throw new Error(
	      'Following selectors have no specified format: ' +
	      selectorsWithoutFormat.map(s => `\`${s.selector}\``).join(', ')
	    );
	  }
	  const picker = new selderee.DecisionTree(
	    uniqueSelectors.map(s => [s.selector, s])
	  ).build(hp2Builder);

	  const baseSelectorsPicker = new selderee.DecisionTree(
	    options.baseElements.selectors.map((s, i) => [s, i + 1])
	  ).build(hp2Builder);
	  function findBaseElements (dom) {
	    return findBases(dom, options, baseSelectorsPicker);
	  }

	  const limitedWalk = limitedDepthRecursive(
	    options.limits.maxDepth,
	    recursiveWalk,
	    function (dom, builder) {
	      builder.addInline(options.limits.ellipsis || '');
	    }
	  );

	  return function (html) {
	    return process$1(html, options, picker, findBaseElements, limitedWalk);
	  };
	}

	/**
	 * Convert given HTML according to preprocessed options.
	 *
	 * @param { string } html HTML content to convert.
	 * @param { Options } options HtmlToText options (preprocessed).
	 * @param { Picker<DomNode, TagDefinition> } picker
	 * Tag definition picker for DOM nodes processing.
	 * @param { (dom: DomNode[]) => DomNode[] } findBaseElements
	 * Function to extract elements from HTML DOM
	 * that will only be present in the output text.
	 * @param { RecursiveCallback } walk Recursive callback.
	 * @returns { string }
	 */
	function process$1 (html, options, picker, findBaseElements, walk) {
	  const maxInputLength = options.limits.maxInputLength;
	  if (maxInputLength && html && html.length > maxInputLength) {
	    console.warn(
	      `Input length ${html.length} is above allowed limit of ${maxInputLength}. Truncating without ellipsis.`
	    );
	    html = html.substring(0, maxInputLength);
	  }

	  const handler = new htmlparser.DomHandler();
	  new htmlparser.Parser(handler, { decodeEntities: false }).parseComplete(html);

	  const bases = findBaseElements(handler.dom);
	  const builder = new BlockTextBuilder(options, picker);
	  walk(bases, builder);
	  return builder.toString();
	}

	/**
	 * Convert given HTML content to plain text string.
	 *
	 * @param   { string }  html           HTML content to convert.
	 * @param   { Options } [options = {}] HtmlToText options.
	 * @returns { string }                 Plain text string.
	 * @static
	 *
	 * @example
	 * const { convert } = require('html-to-text');
	 * const text = convert('<h1>Hello World</h1>', {
	 *   wordwrap: 130
	 * });
	 * console.log(text); // HELLO WORLD
	 */
	function convert$4 (html, options = {}) {
	  return compile(options)(html);
	}

	/**
	 * Map previously existing and now deprecated options to the new options layout.
	 * This is a subject for cleanup in major releases.
	 *
	 * @param { Options } options HtmlToText options.
	 */
	function handleDeprecatedOptions (options) {
	  const selectorDefinitions = options.selectors;

	  if (options.tags) {
	    const tagDefinitions = Object.entries(options.tags).map(
	      ([selector, definition]) => ({ ...definition, selector: selector || '*' })
	    );
	    selectorDefinitions.push(...tagDefinitions);
	  }

	  function set (obj, path, value) {
	    const valueKey = path.pop();
	    for (const key of path) {
	      let nested = obj[key];
	      if (!nested) {
	        nested = {};
	        obj[key] = nested;
	      }
	      obj = nested;
	    }
	    obj[valueKey] = value;
	  }

	  function copyFormatterOption (source, format, target) {
	    if (options[source] === undefined) { return; }
	    for (const definition of selectorDefinitions) {
	      if (definition.format === format) {
	        set(definition, ['options', target], options[source]);
	      }
	    }
	  }

	  copyFormatterOption('hideLinkHrefIfSameAsText', 'anchor', 'hideLinkHrefIfSameAsText');
	  copyFormatterOption('ignoreHref', 'anchor', 'ignoreHref');
	  copyFormatterOption('linkHrefBaseUrl', 'anchor', 'baseUrl');
	  copyFormatterOption('noAnchorUrl', 'anchor', 'noAnchorUrl');
	  copyFormatterOption('noLinkBrackets', 'anchor', 'noLinkBrackets');

	  copyFormatterOption('linkHrefBaseUrl', 'image', 'baseUrl');

	  copyFormatterOption('unorderedListItemPrefix', 'unorderedList', 'itemPrefix');

	  copyFormatterOption('uppercaseHeadings', 'heading', 'uppercase');
	  copyFormatterOption('uppercaseHeadings', 'table', 'uppercaseHeadings');
	  copyFormatterOption('uppercaseHeadings', 'dataTable', 'uppercaseHeadings');

	  if (options['ignoreImage']) {
	    for (const definition of selectorDefinitions) {
	      if (definition.format === 'image') {
	        definition.format = 'skip';
	      }
	    }
	  }

	  if (options['singleNewLineParagraphs']) {
	    for (const definition of selectorDefinitions) {
	      if (definition.format === 'paragraph' || definition.format === 'pre') {
	        set(definition, ['options', 'leadingLineBreaks'], 1);
	        set(definition, ['options', 'trailingLineBreaks'], 1);
	      }
	    }
	  }

	  if (options['baseElement']) {
	    const baseElement = options['baseElement'];
	    set(
	      options,
	      ['baseElements', 'selectors'],
	      (Array.isArray(baseElement) ? baseElement : [baseElement])
	    );
	  }
	  if (options['returnDomByDefault'] !== undefined) {
	    set(options, ['baseElements', 'returnDomByDefault'], options['returnDomByDefault']);
	  }

	  for (const definition of selectorDefinitions) {
	    if (definition.format === 'anchor' && get(definition, ['options', 'noLinkBrackets'])) {
	      set(definition, ['options', 'linkBrackets'], false);
	    }
	  }
	}

	function findBases (dom, options, baseSelectorsPicker) {
	  const results = [];

	  function recursiveWalk (walk, /** @type { DomNode[] } */ dom) {
	    dom = dom.slice(0, options.limits.maxChildNodes);
	    for (const elem of dom) {
	      if (elem.type !== 'tag') {
	        continue;
	      }
	      const pickedSelectorIndex = baseSelectorsPicker.pick1(elem);
	      if (pickedSelectorIndex > 0) {
	        results.push({ selectorIndex: pickedSelectorIndex, element: elem });
	      } else if (elem.children) {
	        walk(elem.children);
	      }
	      if (results.length >= options.limits.maxBaseElements) {
	        return;
	      }
	    }
	  }

	  const limitedWalk = limitedDepthRecursive(
	    options.limits.maxDepth,
	    recursiveWalk
	  );
	  limitedWalk(dom);

	  if (options.baseElements.orderBy !== 'occurrence') { // 'selectors'
	    results.sort((a, b) => a.selectorIndex - b.selectorIndex);
	  }
	  return (options.baseElements.returnDomByDefault && results.length === 0)
	    ? dom
	    : results.map(x => x.element);
	}

	/**
	 * Function to walk through DOM nodes and accumulate their string representations.
	 *
	 * @param   { RecursiveCallback } walk    Recursive callback.
	 * @param   { DomNode[] }         [dom]   Nodes array to process.
	 * @param   { BlockTextBuilder }  builder Passed around to accumulate output text.
	 * @private
	 */
	function recursiveWalk (walk, dom, builder) {
	  if (!dom) { return; }

	  const options = builder.options;

	  const tooManyChildNodes = dom.length > options.limits.maxChildNodes;
	  if (tooManyChildNodes) {
	    dom = dom.slice(0, options.limits.maxChildNodes);
	    dom.push({
	      data: options.limits.ellipsis,
	      type: 'text'
	    });
	  }

	  for (const elem of dom) {
	    switch (elem.type) {
	      case 'text': {
	        builder.addInline(he$1.decode(elem.data, options.decodeOptions));
	        break;
	      }
	      case 'tag': {
	        const tagDefinition = builder.picker.pick1(elem);
	        const format = options.formatters[tagDefinition.format];
	        format(elem, walk, builder, tagDefinition.options || {});
	        break;
	      }
	    }
	  }

	  return;
	}

	/**
	 * @deprecated Use `{ convert }` function instead!
	 * @see convert
	 *
	 * @param   { string }  html           HTML content to convert.
	 * @param   { Options } [options = {}] HtmlToText options.
	 * @returns { string }                 Plain text string.
	 * @static
	 */
	const fromString = (html, options = {}) => convert$4(html, options);

	var htmlToText$1 = {
	  compile: compile,
	  convert: convert$4,
	  fromString: fromString,
	  htmlToText: convert$4
	};

	var htmlToText = htmlToText$1;

	var reactDomServerLegacy_browser_production_min = {};

	var aa$2=reactExports;function k$2(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return "Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}var ba$2=!1;function m(a,b){ba$2&&(ba$2=!1,"<"!==b[0]&&a.push("\x3c!-- --\x3e"));return "\x3c!-- --\x3e"===b?ba$2=!0:a.push(b)}
	var q$1=Object.prototype.hasOwnProperty,ca$2=/^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,da$2={},ea$2={};
	function fa$2(a){if(q$1.call(ea$2,a))return !0;if(q$1.call(da$2,a))return !1;if(ca$2.test(a))return ea$2[a]=!0;da$2[a]=!0;return !1}function r(a,b,c,d,f,e,g){this.acceptsBooleans=2===b||3===b||4===b;this.attributeName=d;this.attributeNamespace=f;this.mustUseProperty=c;this.propertyName=a;this.type=b;this.sanitizeURL=e;this.removeEmptyString=g;}var t$1={};
	"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(a){t$1[a]=new r(a,0,!1,a,null,!1,!1);});[["acceptCharset","accept-charset"],["className","class"],["htmlFor","for"],["httpEquiv","http-equiv"]].forEach(function(a){var b=a[0];t$1[b]=new r(b,1,!1,a[1],null,!1,!1);});["contentEditable","draggable","spellCheck","value"].forEach(function(a){t$1[a]=new r(a,2,!1,a.toLowerCase(),null,!1,!1);});
	["autoReverse","externalResourcesRequired","focusable","preserveAlpha"].forEach(function(a){t$1[a]=new r(a,2,!1,a,null,!1,!1);});"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(a){t$1[a]=new r(a,3,!1,a.toLowerCase(),null,!1,!1);});
	["checked","multiple","muted","selected"].forEach(function(a){t$1[a]=new r(a,3,!0,a,null,!1,!1);});["capture","download"].forEach(function(a){t$1[a]=new r(a,4,!1,a,null,!1,!1);});["cols","rows","size","span"].forEach(function(a){t$1[a]=new r(a,6,!1,a,null,!1,!1);});["rowSpan","start"].forEach(function(a){t$1[a]=new r(a,5,!1,a.toLowerCase(),null,!1,!1);});var ha$2=/[\-:]([a-z])/g;function ia$2(a){return a[1].toUpperCase()}
	"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(a){var b=a.replace(ha$2,
	ia$2);t$1[b]=new r(b,1,!1,a,null,!1,!1);});"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a){var b=a.replace(ha$2,ia$2);t$1[b]=new r(b,1,!1,a,"http://www.w3.org/1999/xlink",!1,!1);});["xml:base","xml:lang","xml:space"].forEach(function(a){var b=a.replace(ha$2,ia$2);t$1[b]=new r(b,1,!1,a,"http://www.w3.org/XML/1998/namespace",!1,!1);});["tabIndex","crossOrigin"].forEach(function(a){t$1[a]=new r(a,1,!1,a.toLowerCase(),null,!1,!1);});
	t$1.xlinkHref=new r("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!1);["src","href","action","formAction"].forEach(function(a){t$1[a]=new r(a,1,!1,a.toLowerCase(),null,!0,!0);});
	var u$2={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,
	fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},ja$2=["Webkit","ms","Moz","O"];Object.keys(u$2).forEach(function(a){ja$2.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);u$2[b]=u$2[a];});});var ka$2=/["'&<>]/;
	function v$2(a){if("boolean"===typeof a||"number"===typeof a)return ""+a;a=""+a;var b=ka$2.exec(a);if(b){var c="",d,f=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}f!==d&&(c+=a.substring(f,d));f=d+1;c+=b;}a=f!==d?c+a.substring(f,d):c;}return a}var la$2=/([A-Z])/g,ma$2=/^ms-/,na$2=Array.isArray;function w$2(a,b){return {insertionMode:a,selectedValue:b}}
	function oa$2(a,b,c){switch(b){case "select":return w$2(1,null!=c.value?c.value:c.defaultValue);case "svg":return w$2(2,null);case "math":return w$2(3,null);case "foreignObject":return w$2(1,null);case "table":return w$2(4,null);case "thead":case "tbody":case "tfoot":return w$2(5,null);case "colgroup":return w$2(7,null);case "tr":return w$2(6,null)}return 4<=a.insertionMode||0===a.insertionMode?w$2(1,null):a}function pa$2(a,b){""!==b&&a.push(v$2(b),"\x3c!-- --\x3e");}var qa$2=new Map;
	function ra$2(a,b,c){if("object"!==typeof c)throw Error(k$2(62));b=!0;for(var d in c)if(q$1.call(c,d)){var f=c[d];if(null!=f&&"boolean"!==typeof f&&""!==f){if(0===d.indexOf("--")){var e=v$2(d);f=v$2((""+f).trim());}else {e=d;var g=qa$2.get(e);void 0!==g?e=g:(g=v$2(e.replace(la$2,"-$1").toLowerCase().replace(ma$2,"-ms-")),qa$2.set(e,g),e=g);f="number"===typeof f?0===f||q$1.call(u$2,d)?""+f:f+"px":v$2((""+f).trim());}b?(b=!1,a.push(' style="',e,":",f)):a.push(";",e,":",f);}}b||a.push('"');}
	function y$2(a,b,c,d){switch(c){case "style":ra$2(a,b,d);return;case "defaultValue":case "defaultChecked":case "innerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":return}if(!(2<c.length)||"o"!==c[0]&&"O"!==c[0]||"n"!==c[1]&&"N"!==c[1])if(b=t$1.hasOwnProperty(c)?t$1[c]:null,null!==b){switch(typeof d){case "function":case "symbol":return;case "boolean":if(!b.acceptsBooleans)return}c=b.attributeName;switch(b.type){case 3:d&&a.push(" ",c,'=""');break;case 4:!0===d?a.push(" ",c,'=""'):
	!1!==d&&a.push(" ",c,'="',v$2(d),'"');break;case 5:isNaN(d)||a.push(" ",c,'="',v$2(d),'"');break;case 6:!isNaN(d)&&1<=d&&a.push(" ",c,'="',v$2(d),'"');break;default:b.sanitizeURL&&(d=""+d),a.push(" ",c,'="',v$2(d),'"');}}else if(fa$2(c)){switch(typeof d){case "function":case "symbol":return;case "boolean":if(b=c.toLowerCase().slice(0,5),"data-"!==b&&"aria-"!==b)return}a.push(" ",c,'="',v$2(d),'"');}}
	function A$2(a,b,c){if(null!=b){if(null!=c)throw Error(k$2(60));if("object"!==typeof b||!("__html"in b))throw Error(k$2(61));b=b.__html;null!==b&&void 0!==b&&a.push(""+b);}}function sa$2(a){var b="";aa$2.Children.forEach(a,function(a){null!=a&&(b+=a);});return b}
	function ta$2(a,b,c,d){a.push(B$2(c));var f=c=null,e;for(e in b)if(q$1.call(b,e)){var g=b[e];if(null!=g)switch(e){case "children":c=g;break;case "dangerouslySetInnerHTML":f=g;break;default:y$2(a,d,e,g);}}a.push(">");A$2(a,f,c);return "string"===typeof c?(a.push(v$2(c)),null):c}var ua$2=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,va$2=new Map;function B$2(a){var b=va$2.get(a);if(void 0===b){if(!ua$2.test(a))throw Error(k$2(65,a));b="<"+a;va$2.set(a,b);}return b}
	function wa$2(a,b,c,d,f){switch(b){case "select":a.push(B$2("select"));var e=null,g=null;for(n in c)if(q$1.call(c,n)){var h=c[n];if(null!=h)switch(n){case "children":e=h;break;case "dangerouslySetInnerHTML":g=h;break;case "defaultValue":case "value":break;default:y$2(a,d,n,h);}}a.push(">");A$2(a,g,e);return e;case "option":g=f.selectedValue;a.push(B$2("option"));var l=h=null,p=null;var n=null;for(e in c)if(q$1.call(c,e)&&(b=c[e],null!=b))switch(e){case "children":h=b;break;case "selected":p=b;break;case "dangerouslySetInnerHTML":n=
	b;break;case "value":l=b;default:y$2(a,d,e,b);}if(null!=g)if(c=null!==l?""+l:sa$2(h),na$2(g))for(d=0;d<g.length;d++){if(""+g[d]===c){a.push(' selected=""');break}}else ""+g===c&&a.push(' selected=""');else p&&a.push(' selected=""');a.push(">");A$2(a,n,h);return h;case "textarea":a.push(B$2("textarea"));n=g=e=null;for(h in c)if(q$1.call(c,h)&&(l=c[h],null!=l))switch(h){case "children":n=l;break;case "value":e=l;break;case "defaultValue":g=l;break;case "dangerouslySetInnerHTML":throw Error(k$2(91));default:y$2(a,d,h,
	l);}null===e&&null!==g&&(e=g);a.push(">");if(null!=n){if(null!=e)throw Error(k$2(92));if(na$2(n)&&1<n.length)throw Error(k$2(93));e=""+n;}"string"===typeof e&&"\n"===e[0]&&a.push("\n");null!==e&&a.push(v$2(""+e));return null;case "input":a.push(B$2("input"));l=n=h=e=null;for(g in c)if(q$1.call(c,g)&&(p=c[g],null!=p))switch(g){case "children":case "dangerouslySetInnerHTML":throw Error(k$2(399,"input"));case "defaultChecked":l=p;break;case "defaultValue":h=p;break;case "checked":n=p;break;case "value":e=p;break;default:y$2(a,
	d,g,p);}null!==n?y$2(a,d,"checked",n):null!==l&&y$2(a,d,"checked",l);null!==e?y$2(a,d,"value",e):null!==h&&y$2(a,d,"value",h);a.push("/>");return null;case "menuitem":a.push(B$2("menuitem"));for(var z in c)if(q$1.call(c,z)&&(e=c[z],null!=e))switch(z){case "children":case "dangerouslySetInnerHTML":throw Error(k$2(400));default:y$2(a,d,z,e);}a.push(">");return null;case "listing":case "pre":a.push(B$2(b));g=e=null;for(l in c)if(q$1.call(c,l)&&(h=c[l],null!=h))switch(l){case "children":e=h;break;case "dangerouslySetInnerHTML":g=
	h;break;default:y$2(a,d,l,h);}a.push(">");if(null!=g){if(null!=e)throw Error(k$2(60));if("object"!==typeof g||!("__html"in g))throw Error(k$2(61));c=g.__html;null!==c&&void 0!==c&&("string"===typeof c&&0<c.length&&"\n"===c[0]?a.push("\n",c):a.push(""+c));}"string"===typeof e&&"\n"===e[0]&&a.push("\n");return e;case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":a.push(B$2(b));for(var C in c)if(q$1.call(c,
	C)&&(e=c[C],null!=e))switch(C){case "children":case "dangerouslySetInnerHTML":throw Error(k$2(399,b));default:y$2(a,d,C,e);}a.push("/>");return null;case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":return ta$2(a,c,b,d);case "html":return 0===f.insertionMode&&a.push("<!DOCTYPE html>"),ta$2(a,c,b,d);default:if(-1===b.indexOf("-")&&"string"!==typeof c.is)return ta$2(a,c,b,d);a.push(B$2(b));g=e=
	null;for(p in c)if(q$1.call(c,p)&&(h=c[p],null!=h))switch(p){case "children":e=h;break;case "dangerouslySetInnerHTML":g=h;break;case "style":ra$2(a,d,h);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;default:fa$2(p)&&"function"!==typeof h&&"symbol"!==typeof h&&a.push(" ",p,'="',v$2(h),'"');}a.push(">");A$2(a,g,e);return e}}function xa$2(a,b,c){m(a,'\x3c!--$?--\x3e<template id="');if(null===c)throw Error(k$2(395));m(a,c);return m(a,'"></template>')}
	function ya$2(a,b,c,d){switch(c.insertionMode){case 0:case 1:return m(a,'<div hidden id="'),m(a,b.segmentPrefix),b=d.toString(16),m(a,b),m(a,'">');case 2:return m(a,'<svg aria-hidden="true" style="display:none" id="'),m(a,b.segmentPrefix),b=d.toString(16),m(a,b),m(a,'">');case 3:return m(a,'<math aria-hidden="true" style="display:none" id="'),m(a,b.segmentPrefix),b=d.toString(16),m(a,b),m(a,'">');case 4:return m(a,'<table hidden id="'),m(a,b.segmentPrefix),b=d.toString(16),m(a,b),m(a,'">');case 5:return m(a,
	'<table hidden><tbody id="'),m(a,b.segmentPrefix),b=d.toString(16),m(a,b),m(a,'">');case 6:return m(a,'<table hidden><tr id="'),m(a,b.segmentPrefix),b=d.toString(16),m(a,b),m(a,'">');case 7:return m(a,'<table hidden><colgroup id="'),m(a,b.segmentPrefix),b=d.toString(16),m(a,b),m(a,'">');default:throw Error(k$2(397));}}
	function za$2(a,b){switch(b.insertionMode){case 0:case 1:return m(a,"</div>");case 2:return m(a,"</svg>");case 3:return m(a,"</math>");case 4:return m(a,"</table>");case 5:return m(a,"</tbody></table>");case 6:return m(a,"</tr></table>");case 7:return m(a,"</colgroup></table>");default:throw Error(k$2(397));}}
	function Aa$2(a,b){b=void 0===b?"":b;return {bootstrapChunks:[],startInlineScript:"<script>",placeholderPrefix:b+"P:",segmentPrefix:b+"S:",boundaryPrefix:b+"B:",idPrefix:b,nextSuspenseID:0,sentCompleteSegmentFunction:!1,sentCompleteBoundaryFunction:!1,sentClientRenderFunction:!1,generateStaticMarkup:a}}
	var D$2=Object.assign,Ba$2=Symbol.for("react.element"),Ca$2=Symbol.for("react.portal"),Da$2=Symbol.for("react.fragment"),Ea$2=Symbol.for("react.strict_mode"),Fa$2=Symbol.for("react.profiler"),Ga$2=Symbol.for("react.provider"),Ha$2=Symbol.for("react.context"),Ia$2=Symbol.for("react.forward_ref"),Ja$2=Symbol.for("react.suspense"),Ka$2=Symbol.for("react.suspense_list"),La$2=Symbol.for("react.memo"),Ma$2=Symbol.for("react.lazy"),Na$2=Symbol.for("react.scope"),Oa$2=Symbol.for("react.debug_trace_mode"),Pa$2=Symbol.for("react.legacy_hidden"),
	Qa$2=Symbol.for("react.default_value"),Ra$2=Symbol.iterator;
	function Sa$2(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case Da$2:return "Fragment";case Ca$2:return "Portal";case Fa$2:return "Profiler";case Ea$2:return "StrictMode";case Ja$2:return "Suspense";case Ka$2:return "SuspenseList"}if("object"===typeof a)switch(a.$$typeof){case Ha$2:return (a.displayName||"Context")+".Consumer";case Ga$2:return (a._context.displayName||"Context")+".Provider";case Ia$2:var b=a.render;a=a.displayName;a||(a=b.displayName||
	b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case La$2:return b=a.displayName||null,null!==b?b:Sa$2(a.type)||"Memo";case Ma$2:b=a._payload;a=a._init;try{return Sa$2(a(b))}catch(c){}}return null}var Ta$2={};function Ua$2(a,b){a=a.contextTypes;if(!a)return Ta$2;var c={},d;for(d in a)c[d]=b[d];return c}var E$1=null;
	function F$1(a,b){if(a!==b){a.context._currentValue2=a.parentValue;a=a.parent;var c=b.parent;if(null===a){if(null!==c)throw Error(k$2(401));}else {if(null===c)throw Error(k$2(401));F$1(a,c);}b.context._currentValue2=b.value;}}function Va$2(a){a.context._currentValue2=a.parentValue;a=a.parent;null!==a&&Va$2(a);}function Wa$2(a){var b=a.parent;null!==b&&Wa$2(b);a.context._currentValue2=a.value;}
	function Xa$2(a,b){a.context._currentValue2=a.parentValue;a=a.parent;if(null===a)throw Error(k$2(402));a.depth===b.depth?F$1(a,b):Xa$2(a,b);}function Ya$2(a,b){var c=b.parent;if(null===c)throw Error(k$2(402));a.depth===c.depth?F$1(a,c):Ya$2(a,c);b.context._currentValue2=b.value;}function G$2(a){var b=E$1;b!==a&&(null===b?Wa$2(a):null===a?Va$2(b):b.depth===a.depth?F$1(b,a):b.depth>a.depth?Xa$2(b,a):Ya$2(b,a),E$1=a);}
	var Za$2={isMounted:function(){return !1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b);},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b];},enqueueForceUpdate:function(){}};
	function $a$2(a,b,c,d){var f=void 0!==a.state?a.state:null;a.updater=Za$2;a.props=c;a.state=f;var e={queue:[],replace:!1};a._reactInternals=e;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue2:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,f),f=null===g||void 0===g?f:D$2({},f,g),a.state=f);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
	a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&Za$2.enqueueReplaceState(a,a.state,null),null!==e.queue&&0<e.queue.length)if(b=e.queue,g=e.replace,e.queue=null,e.replace=!1,g&&1===b.length)a.state=b[0];else {e=g?b[0]:a.state;f=!0;for(g=g?1:0;g<b.length;g++){var h=b[g];h="function"===typeof h?h.call(a,e,c,d):h;null!=h&&(f?(f=!1,e=D$2({},e,h)):D$2(e,h));}a.state=e;}else e.queue=null;}
	var ab$1={id:1,overflow:""};function bb$2(a,b,c){var d=a.id;a=a.overflow;var f=32-H$2(d)-1;d&=~(1<<f);c+=1;var e=32-H$2(b)+f;if(30<e){var g=f-f%5;e=(d&(1<<g)-1).toString(32);d>>=g;f-=g;return {id:1<<32-H$2(b)+f|c<<f|d,overflow:e+a}}return {id:1<<e|c<<f|d,overflow:a}}var H$2=Math.clz32?Math.clz32:cb$1,db$2=Math.log,eb$1=Math.LN2;function cb$1(a){a>>>=0;return 0===a?32:31-(db$2(a)/eb$1|0)|0}function fb$2(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}
	var gb$2="function"===typeof Object.is?Object.is:fb$2,I$2=null,hb$1=null,J$1=null,K$1=null,L$2=!1,M$1=!1,N$1=0,O$2=null,P$1=0;function Q$1(){if(null===I$2)throw Error(k$2(321));return I$2}function ib$1(){if(0<P$1)throw Error(k$2(312));return {memoizedState:null,queue:null,next:null}}function jb$1(){null===K$1?null===J$1?(L$2=!1,J$1=K$1=ib$1()):(L$2=!0,K$1=J$1):null===K$1.next?(L$2=!1,K$1=K$1.next=ib$1()):(L$2=!0,K$1=K$1.next);return K$1}function kb$2(){hb$1=I$2=null;M$1=!1;J$1=null;P$1=0;K$1=O$2=null;}function lb$1(a,b){return "function"===typeof b?b(a):b}
	function mb$1(a,b,c){I$2=Q$1();K$1=jb$1();if(L$2){var d=K$1.queue;b=d.dispatch;if(null!==O$2&&(c=O$2.get(d),void 0!==c)){O$2.delete(d);d=K$1.memoizedState;do d=a(d,c.action),c=c.next;while(null!==c);K$1.memoizedState=d;return [d,b]}return [K$1.memoizedState,b]}a=a===lb$1?"function"===typeof b?b():b:void 0!==c?c(b):b;K$1.memoizedState=a;a=K$1.queue={last:null,dispatch:null};a=a.dispatch=nb$1.bind(null,I$2,a);return [K$1.memoizedState,a]}
	function ob$1(a,b){I$2=Q$1();K$1=jb$1();b=void 0===b?null:b;if(null!==K$1){var c=K$1.memoizedState;if(null!==c&&null!==b){var d=c[1];a:if(null===d)d=!1;else {for(var f=0;f<d.length&&f<b.length;f++)if(!gb$2(b[f],d[f])){d=!1;break a}d=!0;}if(d)return c[0]}}a=a();K$1.memoizedState=[a,b];return a}function nb$1(a,b,c){if(25<=P$1)throw Error(k$2(301));if(a===I$2)if(M$1=!0,a={action:c,next:null},null===O$2&&(O$2=new Map),c=O$2.get(b),void 0===c)O$2.set(b,a);else {for(b=c;null!==b.next;)b=b.next;b.next=a;}}function pb$1(){throw Error(k$2(394));}
	function R$2(){}
	var qb$1={readContext:function(a){return a._currentValue2},useContext:function(a){Q$1();return a._currentValue2},useMemo:ob$1,useReducer:mb$1,useRef:function(a){I$2=Q$1();K$1=jb$1();var b=K$1.memoizedState;return null===b?(a={current:a},K$1.memoizedState=a):b},useState:function(a){return mb$1(lb$1,a)},useInsertionEffect:R$2,useLayoutEffect:function(){},useCallback:function(a,b){return ob$1(function(){return a},b)},useImperativeHandle:R$2,useEffect:R$2,useDebugValue:R$2,useDeferredValue:function(a){Q$1();return a},useTransition:function(){Q$1();return [!1,
	pb$1]},useId:function(){var a=hb$1.treeContext;var b=a.overflow;a=a.id;a=(a&~(1<<32-H$2(a)-1)).toString(32)+b;var c=S$1;if(null===c)throw Error(k$2(404));b=N$1++;a=":"+c.idPrefix+"R"+a;0<b&&(a+="H"+b.toString(32));return a+":"},useMutableSource:function(a,b){Q$1();return b(a._source)},useSyncExternalStore:function(a,b,c){if(void 0===c)throw Error(k$2(407));return c()}},S$1=null,rb$1=aa$2.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentDispatcher;function sb$1(a){console.error(a);}function T$2(){}
	function tb$1(a,b,c,d,f,e,g,h,l){var p=[],n=new Set;b={destination:null,responseState:b,progressiveChunkSize:void 0===d?12800:d,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:n,pingedTasks:p,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],onError:void 0===f?sb$1:f,onAllReady:T$2,onShellReady:void 0===g?T$2:g,onShellError:T$2,onFatalError:T$2};c=U$1(b,0,null,c);c.parentFlushed=!0;
	a=ub$1(b,a,null,c,n,Ta$2,null,ab$1);p.push(a);return b}function ub$1(a,b,c,d,f,e,g,h){a.allPendingTasks++;null===c?a.pendingRootTasks++:c.pendingTasks++;var l={node:b,ping:function(){var b=a.pingedTasks;b.push(l);1===b.length&&vb$2(a);},blockedBoundary:c,blockedSegment:d,abortSet:f,legacyContext:e,context:g,treeContext:h};f.add(l);return l}function U$1(a,b,c,d){return {status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],formatContext:d,boundary:c}}function V$1(a,b){a=a.onError;a(b);}
	function W$2(a,b){var c=a.onShellError;c(b);c=a.onFatalError;c(b);null!==a.destination?(a.status=2,a.destination.destroy(b)):(a.status=1,a.fatalError=b);}function wb$2(a,b,c,d,f){I$2={};hb$1=b;N$1=0;for(a=c(d,f);M$1;)M$1=!1,N$1=0,P$1+=1,K$1=null,a=c(d,f);kb$2();return a}
	function xb$2(a,b,c,d){var f=c.render(),e=d.childContextTypes;if(null!==e&&void 0!==e){var g=b.legacyContext;if("function"!==typeof c.getChildContext)d=g;else {c=c.getChildContext();for(var h in c)if(!(h in e))throw Error(k$2(108,Sa$2(d)||"Unknown",h));d=D$2({},g,c);}b.legacyContext=d;X$2(a,b,f);b.legacyContext=g;}else X$2(a,b,f);}function yb$2(a,b){if(a&&a.defaultProps){b=D$2({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
	function zb$1(a,b,c,d,f){if("function"===typeof c)if(c.prototype&&c.prototype.isReactComponent){f=Ua$2(c,b.legacyContext);var e=c.contextType;e=new c(d,"object"===typeof e&&null!==e?e._currentValue2:f);$a$2(e,c,d,f);xb$2(a,b,e,c);}else {e=Ua$2(c,b.legacyContext);f=wb$2(a,b,c,d,e);var g=0!==N$1;if("object"===typeof f&&null!==f&&"function"===typeof f.render&&void 0===f.$$typeof)$a$2(f,c,d,e),xb$2(a,b,f,c);else if(g){d=b.treeContext;b.treeContext=bb$2(d,1,0);try{X$2(a,b,f);}finally{b.treeContext=d;}}else X$2(a,b,f);}else if("string"===
	typeof c)switch(f=b.blockedSegment,e=wa$2(f.chunks,c,d,a.responseState,f.formatContext),g=f.formatContext,f.formatContext=oa$2(g,c,d),Ab$2(a,b,e),f.formatContext=g,c){case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "input":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":break;default:f.chunks.push("</",c,">");}else {switch(c){case Pa$2:case Oa$2:case Ea$2:case Fa$2:case Da$2:X$2(a,b,d.children);return;case Ka$2:X$2(a,b,d.children);return;case Na$2:throw Error(k$2(343));
	case Ja$2:a:{c=b.blockedBoundary;f=b.blockedSegment;e=d.fallback;d=d.children;g=new Set;var h={id:null,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,forceClientRender:!1,completedSegments:[],byteSize:0,fallbackAbortableTasks:g},l=U$1(a,f.chunks.length,h,f.formatContext);f.children.push(l);var p=U$1(a,0,null,f.formatContext);p.parentFlushed=!0;b.blockedBoundary=h;b.blockedSegment=p;try{if(Ab$2(a,b,d),p.status=1,Y$2(h,p),0===h.pendingTasks)break a}catch(n){p.status=4,V$1(a,n),h.forceClientRender=!0;}finally{b.blockedBoundary=
	c,b.blockedSegment=f;}b=ub$1(a,e,c,l,g,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b);}return}if("object"===typeof c&&null!==c)switch(c.$$typeof){case Ia$2:d=wb$2(a,b,c.render,d,f);if(0!==N$1){c=b.treeContext;b.treeContext=bb$2(c,1,0);try{X$2(a,b,d);}finally{b.treeContext=c;}}else X$2(a,b,d);return;case La$2:c=c.type;d=yb$2(c,d);zb$1(a,b,c,d,f);return;case Ga$2:f=d.children;c=c._context;d=d.value;e=c._currentValue2;c._currentValue2=d;g=E$1;E$1=d={parent:g,depth:null===g?0:g.depth+1,context:c,parentValue:e,value:d};
	b.context=d;X$2(a,b,f);a=E$1;if(null===a)throw Error(k$2(403));d=a.parentValue;a.context._currentValue2=d===Qa$2?a.context._defaultValue:d;a=E$1=a.parent;b.context=a;return;case Ha$2:d=d.children;d=d(c._currentValue2);X$2(a,b,d);return;case Ma$2:f=c._init;c=f(c._payload);d=yb$2(c,d);zb$1(a,b,c,d,void 0);return}throw Error(k$2(130,null==c?c:typeof c,""));}}
	function X$2(a,b,c){b.node=c;if("object"===typeof c&&null!==c){switch(c.$$typeof){case Ba$2:zb$1(a,b,c.type,c.props,c.ref);return;case Ca$2:throw Error(k$2(257));case Ma$2:var d=c._init;c=d(c._payload);X$2(a,b,c);return}if(na$2(c)){Bb$1(a,b,c);return}null===c||"object"!==typeof c?d=null:(d=Ra$2&&c[Ra$2]||c["@@iterator"],d="function"===typeof d?d:null);if(d&&(d=d.call(c))){c=d.next();if(!c.done){var f=[];do f.push(c.value),c=d.next();while(!c.done);Bb$1(a,b,f);}return}a=Object.prototype.toString.call(c);throw Error(k$2(31,"[object Object]"===
	a?"object with keys {"+Object.keys(c).join(", ")+"}":a));}"string"===typeof c?(b=b.blockedSegment.chunks,a.responseState.generateStaticMarkup?b.push(v$2(c)):pa$2(b,c)):"number"===typeof c&&(b=b.blockedSegment.chunks,c=""+c,a.responseState.generateStaticMarkup?b.push(v$2(c)):pa$2(b,c));}function Bb$1(a,b,c){for(var d=c.length,f=0;f<d;f++){var e=b.treeContext;b.treeContext=bb$2(e,d,f);try{Ab$2(a,b,c[f]);}finally{b.treeContext=e;}}}
	function Ab$2(a,b,c){var d=b.blockedSegment.formatContext,f=b.legacyContext,e=b.context;try{return X$2(a,b,c)}catch(l){if(kb$2(),"object"===typeof l&&null!==l&&"function"===typeof l.then){c=l;var g=b.blockedSegment,h=U$1(a,g.chunks.length,null,g.formatContext);g.children.push(h);a=ub$1(a,b.node,b.blockedBoundary,h,b.abortSet,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.blockedSegment.formatContext=d;b.legacyContext=f;b.context=e;G$2(e);}else throw b.blockedSegment.formatContext=d,b.legacyContext=
	f,b.context=e,G$2(e),l;}}function Cb$2(a){var b=a.blockedBoundary;a=a.blockedSegment;a.status=3;Db$1(this,b,a);}
	function Eb$1(a){var b=a.blockedBoundary;a.blockedSegment.status=3;null===b?(this.allPendingTasks--,2!==this.status&&(this.status=2,null!==this.destination&&this.destination.push(null))):(b.pendingTasks--,b.forceClientRender||(b.forceClientRender=!0,b.parentFlushed&&this.clientRenderedBoundaries.push(b)),b.fallbackAbortableTasks.forEach(Eb$1,this),b.fallbackAbortableTasks.clear(),this.allPendingTasks--,0===this.allPendingTasks&&(a=this.onAllReady,a()));}
	function Y$2(a,b){if(0===b.chunks.length&&1===b.children.length&&null===b.children[0].boundary){var c=b.children[0];c.id=b.id;c.parentFlushed=!0;1===c.status&&Y$2(a,c);}else a.completedSegments.push(b);}
	function Db$1(a,b,c){if(null===b){if(c.parentFlushed){if(null!==a.completedRootSegment)throw Error(k$2(389));a.completedRootSegment=c;}a.pendingRootTasks--;0===a.pendingRootTasks&&(a.onShellError=T$2,b=a.onShellReady,b());}else b.pendingTasks--,b.forceClientRender||(0===b.pendingTasks?(c.parentFlushed&&1===c.status&&Y$2(b,c),b.parentFlushed&&a.completedBoundaries.push(b),b.fallbackAbortableTasks.forEach(Cb$2,a),b.fallbackAbortableTasks.clear()):c.parentFlushed&&1===c.status&&(Y$2(b,c),1===b.completedSegments.length&&
	b.parentFlushed&&a.partialBoundaries.push(b)));a.allPendingTasks--;0===a.allPendingTasks&&(a=a.onAllReady,a());}
	function vb$2(a){if(2!==a.status){var b=E$1,c=rb$1.current;rb$1.current=qb$1;var d=S$1;S$1=a.responseState;try{var f=a.pingedTasks,e;for(e=0;e<f.length;e++){var g=f[e];var h=a,l=g.blockedSegment;if(0===l.status){G$2(g.context);try{X$2(h,g,g.node),g.abortSet.delete(g),l.status=1,Db$1(h,g.blockedBoundary,l);}catch(x){if(kb$2(),"object"===typeof x&&null!==x&&"function"===typeof x.then){var p=g.ping;x.then(p,p);}else {g.abortSet.delete(g);l.status=4;var n=g.blockedBoundary,z=x;V$1(h,z);null===n?W$2(h,z):(n.pendingTasks--,n.forceClientRender||
	(n.forceClientRender=!0,n.parentFlushed&&h.clientRenderedBoundaries.push(n)));h.allPendingTasks--;if(0===h.allPendingTasks){var C=h.onAllReady;C();}}}finally{}}}f.splice(0,e);null!==a.destination&&Fb$1(a,a.destination);}catch(x){V$1(a,x),W$2(a,x);}finally{S$1=d,rb$1.current=c,c===qb$1&&G$2(b);}}}
	function Z$2(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:var d=c.id=a.nextSegmentId++;a=a.responseState;m(b,'<template id="');m(b,a.placeholderPrefix);a=d.toString(16);m(b,a);return m(b,'"></template>');case 1:c.status=2;var f=!0;d=c.chunks;var e=0;c=c.children;for(var g=0;g<c.length;g++){for(f=c[g];e<f.index;e++)m(b,d[e]);f=Gb$1(a,b,f);}for(;e<d.length-1;e++)m(b,d[e]);e<d.length&&(f=m(b,d[e]));return f;default:throw Error(k$2(390));}}
	function Gb$1(a,b,c){var d=c.boundary;if(null===d)return Z$2(a,b,c);d.parentFlushed=!0;if(d.forceClientRender)return a.responseState.generateStaticMarkup||m(b,"\x3c!--$!--\x3e"),Z$2(a,b,c),a=a.responseState.generateStaticMarkup?!0:m(b,"\x3c!--/$--\x3e"),a;if(0<d.pendingTasks){d.rootSegmentID=a.nextSegmentId++;0<d.completedSegments.length&&a.partialBoundaries.push(d);var f=a.responseState;var e=f.nextSuspenseID++;f=f.boundaryPrefix+e.toString(16);d=d.id=f;xa$2(b,a.responseState,d);Z$2(a,b,c);return m(b,"\x3c!--/$--\x3e")}if(d.byteSize>
	a.progressiveChunkSize)return d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),xa$2(b,a.responseState,d.id),Z$2(a,b,c),m(b,"\x3c!--/$--\x3e");a.responseState.generateStaticMarkup||m(b,"\x3c!--$--\x3e");c=d.completedSegments;if(1!==c.length)throw Error(k$2(391));Gb$1(a,b,c[0]);a=a.responseState.generateStaticMarkup?!0:m(b,"\x3c!--/$--\x3e");return a}function Hb$1(a,b,c){ya$2(b,a.responseState,c.formatContext,c.id);Gb$1(a,b,c);return za$2(b,c.formatContext)}
	function Ib$1(a,b,c){for(var d=c.completedSegments,f=0;f<d.length;f++)Jb$1(a,b,c,d[f]);d.length=0;a=a.responseState;d=c.id;c=c.rootSegmentID;m(b,a.startInlineScript);a.sentCompleteBoundaryFunction?m(b,'$RC("'):(a.sentCompleteBoundaryFunction=!0,m(b,'function $RC(a,b){a=document.getElementById(a);b=document.getElementById(b);b.parentNode.removeChild(b);if(a){a=a.previousSibling;var f=a.parentNode,c=a.nextSibling,e=0;do{if(c&&8===c.nodeType){var d=c.data;if("/$"===d)if(0===e)break;else e--;else"$"!==d&&"$?"!==d&&"$!"!==d||e++}d=c.nextSibling;f.removeChild(c);c=d}while(c);for(;b.firstChild;)f.insertBefore(b.firstChild,c);a.data="$";a._reactRetry&&a._reactRetry()}};$RC("'));
	if(null===d)throw Error(k$2(395));c=c.toString(16);m(b,d);m(b,'","');m(b,a.segmentPrefix);m(b,c);return m(b,'")\x3c/script>')}
	function Jb$1(a,b,c,d){if(2===d.status)return !0;var f=d.id;if(-1===f){if(-1===(d.id=c.rootSegmentID))throw Error(k$2(392));return Hb$1(a,b,d)}Hb$1(a,b,d);a=a.responseState;m(b,a.startInlineScript);a.sentCompleteSegmentFunction?m(b,'$RS("'):(a.sentCompleteSegmentFunction=!0,m(b,'function $RS(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("'));m(b,a.segmentPrefix);f=f.toString(16);
	m(b,f);m(b,'","');m(b,a.placeholderPrefix);m(b,f);return m(b,'")\x3c/script>')}
	function Fb$1(a,b){try{var c=a.completedRootSegment;if(null!==c&&0===a.pendingRootTasks){Gb$1(a,b,c);a.completedRootSegment=null;var d=a.responseState.bootstrapChunks;for(c=0;c<d.length-1;c++)m(b,d[c]);c<d.length&&m(b,d[c]);}var f=a.clientRenderedBoundaries,e;for(e=0;e<f.length;e++){d=b;var g=a.responseState,h=f[e].id;m(d,g.startInlineScript);g.sentClientRenderFunction?m(d,'$RX("'):(g.sentClientRenderFunction=!0,m(d,'function $RX(a){if(a=document.getElementById(a))a=a.previousSibling,a.data="$!",a._reactRetry&&a._reactRetry()};$RX("'));if(null===
	h)throw Error(k$2(395));m(d,h);if(!m(d,'")\x3c/script>')){a.destination=null;e++;f.splice(0,e);return}}f.splice(0,e);var l=a.completedBoundaries;for(e=0;e<l.length;e++)if(!Ib$1(a,b,l[e])){a.destination=null;e++;l.splice(0,e);return}l.splice(0,e);var p=a.partialBoundaries;for(e=0;e<p.length;e++){var n=p[e];a:{f=a;g=b;var z=n.completedSegments;for(h=0;h<z.length;h++)if(!Jb$1(f,g,n,z[h])){h++;z.splice(0,h);var C=!1;break a}z.splice(0,h);C=!0;}if(!C){a.destination=null;e++;p.splice(0,e);return}}p.splice(0,e);
	var x=a.completedBoundaries;for(e=0;e<x.length;e++)if(!Ib$1(a,b,x[e])){a.destination=null;e++;x.splice(0,e);return}x.splice(0,e);}finally{0===a.allPendingTasks&&0===a.pingedTasks.length&&0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length&&b.push(null);}}function Kb$1(a){try{var b=a.abortableTasks;b.forEach(Eb$1,a);b.clear();null!==a.destination&&Fb$1(a,a.destination);}catch(c){V$1(a,c),W$2(a,c);}}function Lb$1(){}
	function Mb$1(a,b,c){var d=!1,f=null,e="",g={push:function(a){null!==a&&(e+=a);return !0},destroy:function(a){d=!0;f=a;}},h=!1;a=tb$1(a,Aa$2(c,b?b.identifierPrefix:void 0),{insertionMode:1,selectedValue:null},Infinity,Lb$1,void 0,function(){h=!0;});vb$2(a);Kb$1(a);if(1===a.status)a.status=2,g.destroy(a.fatalError);else if(2!==a.status&&null===a.destination){a.destination=g;try{Fb$1(a,g);}catch(l){V$1(a,l),W$2(a,l);}}if(d)throw f;if(!h)throw Error(k$2(426));return e}
	reactDomServerLegacy_browser_production_min.renderToNodeStream=function(){throw Error(k$2(207));};reactDomServerLegacy_browser_production_min.renderToStaticMarkup=function(a,b){return Mb$1(a,b,!0)};reactDomServerLegacy_browser_production_min.renderToStaticNodeStream=function(){throw Error(k$2(208));};reactDomServerLegacy_browser_production_min.renderToString=function(a,b){return Mb$1(a,b,!1)};reactDomServerLegacy_browser_production_min.version="18.0.0-fc46dba67-20220329";

	var reactDomServer_browser_production_min = {};

	var aa$1=reactExports;function k$1(a){for(var b="https://reactjs.org/docs/error-decoder.html?invariant="+a,c=1;c<arguments.length;c++)b+="&args[]="+encodeURIComponent(arguments[c]);return "Minified React error #"+a+"; visit "+b+" for the full message or use the non-minified dev environment for full errors and additional helpful warnings."}var l$1=null,n=0;
	function p$1(a,b){if(0!==b.length)if(512<b.length)0<n&&(a.enqueue(new Uint8Array(l$1.buffer,0,n)),l$1=new Uint8Array(512),n=0),a.enqueue(b);else {var c=l$1.length-n;c<b.length&&(0===c?a.enqueue(l$1):(l$1.set(b.subarray(0,c),n),a.enqueue(l$1),b=b.subarray(c)),l$1=new Uint8Array(512),n=0);l$1.set(b,n);n+=b.length;}}function t(a,b){p$1(a,b);return !0}function ba$1(a){l$1&&0<n&&(a.enqueue(new Uint8Array(l$1.buffer,0,n)),l$1=null,n=0);}var ca$1=new TextEncoder;function u$1(a){return ca$1.encode(a)}function v$1(a){return ca$1.encode(a)}
	function da$1(a,b){"function"===typeof a.error?a.error(b):a.close();}var w$1=Object.prototype.hasOwnProperty,ea$1=/^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,fa$1={},ha$1={};
	function ia$1(a){if(w$1.call(ha$1,a))return !0;if(w$1.call(fa$1,a))return !1;if(ea$1.test(a))return ha$1[a]=!0;fa$1[a]=!0;return !1}function x$1(a,b,c,d,f,e,g){this.acceptsBooleans=2===b||3===b||4===b;this.attributeName=d;this.attributeNamespace=f;this.mustUseProperty=c;this.propertyName=a;this.type=b;this.sanitizeURL=e;this.removeEmptyString=g;}var y$1={};
	"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(" ").forEach(function(a){y$1[a]=new x$1(a,0,!1,a,null,!1,!1);});[["acceptCharset","accept-charset"],["className","class"],["htmlFor","for"],["httpEquiv","http-equiv"]].forEach(function(a){var b=a[0];y$1[b]=new x$1(b,1,!1,a[1],null,!1,!1);});["contentEditable","draggable","spellCheck","value"].forEach(function(a){y$1[a]=new x$1(a,2,!1,a.toLowerCase(),null,!1,!1);});
	["autoReverse","externalResourcesRequired","focusable","preserveAlpha"].forEach(function(a){y$1[a]=new x$1(a,2,!1,a,null,!1,!1);});"allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope".split(" ").forEach(function(a){y$1[a]=new x$1(a,3,!1,a.toLowerCase(),null,!1,!1);});
	["checked","multiple","muted","selected"].forEach(function(a){y$1[a]=new x$1(a,3,!0,a,null,!1,!1);});["capture","download"].forEach(function(a){y$1[a]=new x$1(a,4,!1,a,null,!1,!1);});["cols","rows","size","span"].forEach(function(a){y$1[a]=new x$1(a,6,!1,a,null,!1,!1);});["rowSpan","start"].forEach(function(a){y$1[a]=new x$1(a,5,!1,a.toLowerCase(),null,!1,!1);});var ja$1=/[\-:]([a-z])/g;function ka$1(a){return a[1].toUpperCase()}
	"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height".split(" ").forEach(function(a){var b=a.replace(ja$1,
	ka$1);y$1[b]=new x$1(b,1,!1,a,null,!1,!1);});"xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type".split(" ").forEach(function(a){var b=a.replace(ja$1,ka$1);y$1[b]=new x$1(b,1,!1,a,"http://www.w3.org/1999/xlink",!1,!1);});["xml:base","xml:lang","xml:space"].forEach(function(a){var b=a.replace(ja$1,ka$1);y$1[b]=new x$1(b,1,!1,a,"http://www.w3.org/XML/1998/namespace",!1,!1);});["tabIndex","crossOrigin"].forEach(function(a){y$1[a]=new x$1(a,1,!1,a.toLowerCase(),null,!1,!1);});
	y$1.xlinkHref=new x$1("xlinkHref",1,!1,"xlink:href","http://www.w3.org/1999/xlink",!0,!1);["src","href","action","formAction"].forEach(function(a){y$1[a]=new x$1(a,1,!1,a.toLowerCase(),null,!0,!0);});
	var z$1={animationIterationCount:!0,aspectRatio:!0,borderImageOutset:!0,borderImageSlice:!0,borderImageWidth:!0,boxFlex:!0,boxFlexGroup:!0,boxOrdinalGroup:!0,columnCount:!0,columns:!0,flex:!0,flexGrow:!0,flexPositive:!0,flexShrink:!0,flexNegative:!0,flexOrder:!0,gridArea:!0,gridRow:!0,gridRowEnd:!0,gridRowSpan:!0,gridRowStart:!0,gridColumn:!0,gridColumnEnd:!0,gridColumnSpan:!0,gridColumnStart:!0,fontWeight:!0,lineClamp:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,tabSize:!0,widows:!0,zIndex:!0,zoom:!0,
	fillOpacity:!0,floodOpacity:!0,stopOpacity:!0,strokeDasharray:!0,strokeDashoffset:!0,strokeMiterlimit:!0,strokeOpacity:!0,strokeWidth:!0},la$1=["Webkit","ms","Moz","O"];Object.keys(z$1).forEach(function(a){la$1.forEach(function(b){b=b+a.charAt(0).toUpperCase()+a.substring(1);z$1[b]=z$1[a];});});var ma$1=/["'&<>]/;
	function A$1(a){if("boolean"===typeof a||"number"===typeof a)return ""+a;a=""+a;var b=ma$1.exec(a);if(b){var c="",d,f=0;for(d=b.index;d<a.length;d++){switch(a.charCodeAt(d)){case 34:b="&quot;";break;case 38:b="&amp;";break;case 39:b="&#x27;";break;case 60:b="&lt;";break;case 62:b="&gt;";break;default:continue}f!==d&&(c+=a.substring(f,d));f=d+1;c+=b;}a=f!==d?c+a.substring(f,d):c;}return a}
	var na$1=/([A-Z])/g,oa$1=/^ms-/,pa$1=Array.isArray,qa$1=v$1("<script>"),ra$1=v$1("\x3c/script>"),sa$1=v$1('<script src="'),ta$1=v$1('<script type="module" src="'),ua$1=v$1('" async="">\x3c/script>');
	function va$1(a,b,c,d,f){a=void 0===a?"":a;b=void 0===b?qa$1:v$1('<script nonce="'+A$1(b)+'">');var e=[];void 0!==c&&e.push(b,u$1(A$1(c)),ra$1);if(void 0!==d)for(c=0;c<d.length;c++)e.push(sa$1,u$1(A$1(d[c])),ua$1);if(void 0!==f)for(d=0;d<f.length;d++)e.push(ta$1,u$1(A$1(f[d])),ua$1);return {bootstrapChunks:e,startInlineScript:b,placeholderPrefix:v$1(a+"P:"),segmentPrefix:v$1(a+"S:"),boundaryPrefix:a+"B:",idPrefix:a,nextSuspenseID:0,sentCompleteSegmentFunction:!1,sentCompleteBoundaryFunction:!1,sentClientRenderFunction:!1}}
	function B$1(a,b){return {insertionMode:a,selectedValue:b}}function wa$1(a){return B$1("http://www.w3.org/2000/svg"===a?2:"http://www.w3.org/1998/Math/MathML"===a?3:0,null)}
	function xa$1(a,b,c){switch(b){case "select":return B$1(1,null!=c.value?c.value:c.defaultValue);case "svg":return B$1(2,null);case "math":return B$1(3,null);case "foreignObject":return B$1(1,null);case "table":return B$1(4,null);case "thead":case "tbody":case "tfoot":return B$1(5,null);case "colgroup":return B$1(7,null);case "tr":return B$1(6,null)}return 4<=a.insertionMode||0===a.insertionMode?B$1(1,null):a}var ya$1=v$1("\x3c!-- --\x3e"),za$1=new Map,Aa$1=v$1(' style="'),Ba$1=v$1(":"),Ca$1=v$1(";");
	function Da$1(a,b,c){if("object"!==typeof c)throw Error(k$1(62));b=!0;for(var d in c)if(w$1.call(c,d)){var f=c[d];if(null!=f&&"boolean"!==typeof f&&""!==f){if(0===d.indexOf("--")){var e=u$1(A$1(d));f=u$1(A$1((""+f).trim()));}else {e=d;var g=za$1.get(e);void 0!==g?e=g:(g=v$1(A$1(e.replace(na$1,"-$1").toLowerCase().replace(oa$1,"-ms-"))),za$1.set(e,g),e=g);f="number"===typeof f?0===f||w$1.call(z$1,d)?u$1(""+f):u$1(f+"px"):u$1(A$1((""+f).trim()));}b?(b=!1,a.push(Aa$1,e,Ba$1,f)):a.push(Ca$1,e,Ba$1,f);}}b||a.push(D$1);}
	var G$1=v$1(" "),H$1=v$1('="'),D$1=v$1('"'),Ea$1=v$1('=""');
	function I$1(a,b,c,d){switch(c){case "style":Da$1(a,b,d);return;case "defaultValue":case "defaultChecked":case "innerHTML":case "suppressContentEditableWarning":case "suppressHydrationWarning":return}if(!(2<c.length)||"o"!==c[0]&&"O"!==c[0]||"n"!==c[1]&&"N"!==c[1])if(b=y$1.hasOwnProperty(c)?y$1[c]:null,null!==b){switch(typeof d){case "function":case "symbol":return;case "boolean":if(!b.acceptsBooleans)return}c=u$1(b.attributeName);switch(b.type){case 3:d&&a.push(G$1,c,Ea$1);break;case 4:!0===d?a.push(G$1,c,Ea$1):!1!==
	d&&a.push(G$1,c,H$1,u$1(A$1(d)),D$1);break;case 5:isNaN(d)||a.push(G$1,c,H$1,u$1(A$1(d)),D$1);break;case 6:!isNaN(d)&&1<=d&&a.push(G$1,c,H$1,u$1(A$1(d)),D$1);break;default:b.sanitizeURL&&(d=""+d),a.push(G$1,c,H$1,u$1(A$1(d)),D$1);}}else if(ia$1(c)){switch(typeof d){case "function":case "symbol":return;case "boolean":if(b=c.toLowerCase().slice(0,5),"data-"!==b&&"aria-"!==b)return}a.push(G$1,u$1(c),H$1,u$1(A$1(d)),D$1);}}var J=v$1(">"),Fa$1=v$1("/>");
	function K(a,b,c){if(null!=b){if(null!=c)throw Error(k$1(60));if("object"!==typeof b||!("__html"in b))throw Error(k$1(61));b=b.__html;null!==b&&void 0!==b&&a.push(u$1(""+b));}}function Ga$1(a){var b="";aa$1.Children.forEach(a,function(a){null!=a&&(b+=a);});return b}var Ha$1=v$1(' selected=""');
	function Ia$1(a,b,c,d){a.push(L$1(c));var f=c=null,e;for(e in b)if(w$1.call(b,e)){var g=b[e];if(null!=g)switch(e){case "children":c=g;break;case "dangerouslySetInnerHTML":f=g;break;default:I$1(a,d,e,g);}}a.push(J);K(a,f,c);return "string"===typeof c?(a.push(u$1(A$1(c))),null):c}var Ja$1=v$1("\n"),Ka$1=/^[a-zA-Z][a-zA-Z:_\.\-\d]*$/,La$1=new Map;function L$1(a){var b=La$1.get(a);if(void 0===b){if(!Ka$1.test(a))throw Error(k$1(65,a));b=v$1("<"+a);La$1.set(a,b);}return b}var Ma$1=v$1("<!DOCTYPE html>");
	function Na$1(a,b,c,d,f){switch(b){case "select":a.push(L$1("select"));var e=null,g=null;for(r in c)if(w$1.call(c,r)){var h=c[r];if(null!=h)switch(r){case "children":e=h;break;case "dangerouslySetInnerHTML":g=h;break;case "defaultValue":case "value":break;default:I$1(a,d,r,h);}}a.push(J);K(a,g,e);return e;case "option":g=f.selectedValue;a.push(L$1("option"));var m=h=null,q=null;var r=null;for(e in c)if(w$1.call(c,e)&&(b=c[e],null!=b))switch(e){case "children":h=b;break;case "selected":q=b;break;case "dangerouslySetInnerHTML":r=
	b;break;case "value":m=b;default:I$1(a,d,e,b);}if(null!=g)if(c=null!==m?""+m:Ga$1(h),pa$1(g))for(d=0;d<g.length;d++){if(""+g[d]===c){a.push(Ha$1);break}}else ""+g===c&&a.push(Ha$1);else q&&a.push(Ha$1);a.push(J);K(a,r,h);return h;case "textarea":a.push(L$1("textarea"));r=g=e=null;for(h in c)if(w$1.call(c,h)&&(m=c[h],null!=m))switch(h){case "children":r=m;break;case "value":e=m;break;case "defaultValue":g=m;break;case "dangerouslySetInnerHTML":throw Error(k$1(91));default:I$1(a,d,h,m);}null===e&&null!==g&&(e=g);a.push(J);
	if(null!=r){if(null!=e)throw Error(k$1(92));if(pa$1(r)&&1<r.length)throw Error(k$1(93));e=""+r;}"string"===typeof e&&"\n"===e[0]&&a.push(Ja$1);null!==e&&a.push(u$1(A$1(""+e)));return null;case "input":a.push(L$1("input"));m=r=h=e=null;for(g in c)if(w$1.call(c,g)&&(q=c[g],null!=q))switch(g){case "children":case "dangerouslySetInnerHTML":throw Error(k$1(399,"input"));case "defaultChecked":m=q;break;case "defaultValue":h=q;break;case "checked":r=q;break;case "value":e=q;break;default:I$1(a,d,g,q);}null!==r?I$1(a,d,"checked",
	r):null!==m&&I$1(a,d,"checked",m);null!==e?I$1(a,d,"value",e):null!==h&&I$1(a,d,"value",h);a.push(Fa$1);return null;case "menuitem":a.push(L$1("menuitem"));for(var E in c)if(w$1.call(c,E)&&(e=c[E],null!=e))switch(E){case "children":case "dangerouslySetInnerHTML":throw Error(k$1(400));default:I$1(a,d,E,e);}a.push(J);return null;case "listing":case "pre":a.push(L$1(b));g=e=null;for(m in c)if(w$1.call(c,m)&&(h=c[m],null!=h))switch(m){case "children":e=h;break;case "dangerouslySetInnerHTML":g=h;break;default:I$1(a,d,m,h);}a.push(J);
	if(null!=g){if(null!=e)throw Error(k$1(60));if("object"!==typeof g||!("__html"in g))throw Error(k$1(61));c=g.__html;null!==c&&void 0!==c&&("string"===typeof c&&0<c.length&&"\n"===c[0]?a.push(Ja$1,u$1(c)):a.push(u$1(""+c)));}"string"===typeof e&&"\n"===e[0]&&a.push(Ja$1);return e;case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":a.push(L$1(b));for(var F in c)if(w$1.call(c,F)&&(e=c[F],null!=e))switch(F){case "children":case "dangerouslySetInnerHTML":throw Error(k$1(399,
	b));default:I$1(a,d,F,e);}a.push(Fa$1);return null;case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph":return Ia$1(a,c,b,d);case "html":return 0===f.insertionMode&&a.push(Ma$1),Ia$1(a,c,b,d);default:if(-1===b.indexOf("-")&&"string"!==typeof c.is)return Ia$1(a,c,b,d);a.push(L$1(b));g=e=null;for(q in c)if(w$1.call(c,q)&&(h=c[q],null!=h))switch(q){case "children":e=h;break;case "dangerouslySetInnerHTML":g=
	h;break;case "style":Da$1(a,d,h);break;case "suppressContentEditableWarning":case "suppressHydrationWarning":break;default:ia$1(q)&&"function"!==typeof h&&"symbol"!==typeof h&&a.push(G$1,u$1(q),H$1,u$1(A$1(h)),D$1);}a.push(J);K(a,g,e);return e}}var Oa$1=v$1("</"),Pa$1=v$1(">"),Qa$1=v$1('<template id="'),Ra$1=v$1('"></template>'),Sa$1=v$1("\x3c!--$--\x3e"),Ta$1=v$1('\x3c!--$?--\x3e<template id="'),Ua$1=v$1('"></template>'),Va$1=v$1("\x3c!--$!--\x3e"),Wa$1=v$1("\x3c!--/$--\x3e");
	function Xa$1(a,b,c){p$1(a,Ta$1);if(null===c)throw Error(k$1(395));p$1(a,c);return t(a,Ua$1)}
	var Ya$1=v$1('<div hidden id="'),Za$1=v$1('">'),$a$1=v$1("</div>"),ab=v$1('<svg aria-hidden="true" style="display:none" id="'),bb$1=v$1('">'),cb=v$1("</svg>"),db$1=v$1('<math aria-hidden="true" style="display:none" id="'),eb=v$1('">'),fb$1=v$1("</math>"),gb$1=v$1('<table hidden id="'),hb=v$1('">'),ib=v$1("</table>"),jb=v$1('<table hidden><tbody id="'),kb$1=v$1('">'),lb=v$1("</tbody></table>"),mb=v$1('<table hidden><tr id="'),nb=v$1('">'),ob=v$1("</tr></table>"),pb=v$1('<table hidden><colgroup id="'),qb=v$1('">'),rb=v$1("</colgroup></table>");
	function sb(a,b,c,d){switch(c.insertionMode){case 0:case 1:return p$1(a,Ya$1),p$1(a,b.segmentPrefix),p$1(a,u$1(d.toString(16))),t(a,Za$1);case 2:return p$1(a,ab),p$1(a,b.segmentPrefix),p$1(a,u$1(d.toString(16))),t(a,bb$1);case 3:return p$1(a,db$1),p$1(a,b.segmentPrefix),p$1(a,u$1(d.toString(16))),t(a,eb);case 4:return p$1(a,gb$1),p$1(a,b.segmentPrefix),p$1(a,u$1(d.toString(16))),t(a,hb);case 5:return p$1(a,jb),p$1(a,b.segmentPrefix),p$1(a,u$1(d.toString(16))),t(a,kb$1);case 6:return p$1(a,mb),p$1(a,b.segmentPrefix),p$1(a,u$1(d.toString(16))),t(a,nb);case 7:return p$1(a,
	pb),p$1(a,b.segmentPrefix),p$1(a,u$1(d.toString(16))),t(a,qb);default:throw Error(k$1(397));}}function tb(a,b){switch(b.insertionMode){case 0:case 1:return t(a,$a$1);case 2:return t(a,cb);case 3:return t(a,fb$1);case 4:return t(a,ib);case 5:return t(a,lb);case 6:return t(a,ob);case 7:return t(a,rb);default:throw Error(k$1(397));}}
	var ub=v$1('function $RS(a,b){a=document.getElementById(a);b=document.getElementById(b);for(a.parentNode.removeChild(a);a.firstChild;)b.parentNode.insertBefore(a.firstChild,b);b.parentNode.removeChild(b)};$RS("'),vb$1=v$1('$RS("'),wb$1=v$1('","'),xb$1=v$1('")\x3c/script>'),yb$1=v$1('function $RC(a,b){a=document.getElementById(a);b=document.getElementById(b);b.parentNode.removeChild(b);if(a){a=a.previousSibling;var f=a.parentNode,c=a.nextSibling,e=0;do{if(c&&8===c.nodeType){var d=c.data;if("/$"===d)if(0===e)break;else e--;else"$"!==d&&"$?"!==d&&"$!"!==d||e++}d=c.nextSibling;f.removeChild(c);c=d}while(c);for(;b.firstChild;)f.insertBefore(b.firstChild,c);a.data="$";a._reactRetry&&a._reactRetry()}};$RC("'),
	zb=v$1('$RC("'),Ab$1=v$1('","'),Bb=v$1('")\x3c/script>'),Cb$1=v$1('function $RX(a){if(a=document.getElementById(a))a=a.previousSibling,a.data="$!",a._reactRetry&&a._reactRetry()};$RX("'),Db=v$1('$RX("'),Eb=v$1('")\x3c/script>'),M=Object.assign,Fb=Symbol.for("react.element"),Gb=Symbol.for("react.portal"),Hb=Symbol.for("react.fragment"),Ib=Symbol.for("react.strict_mode"),Jb=Symbol.for("react.profiler"),Kb=Symbol.for("react.provider"),Lb=Symbol.for("react.context"),Mb=Symbol.for("react.forward_ref"),Nb=Symbol.for("react.suspense"),
	Ob=Symbol.for("react.suspense_list"),Pb=Symbol.for("react.memo"),Qb=Symbol.for("react.lazy"),Rb=Symbol.for("react.scope"),Sb$1=Symbol.for("react.debug_trace_mode"),Tb=Symbol.for("react.legacy_hidden"),Ub=Symbol.for("react.default_value"),Vb=Symbol.iterator;
	function Wb(a){if(null==a)return null;if("function"===typeof a)return a.displayName||a.name||null;if("string"===typeof a)return a;switch(a){case Hb:return "Fragment";case Gb:return "Portal";case Jb:return "Profiler";case Ib:return "StrictMode";case Nb:return "Suspense";case Ob:return "SuspenseList"}if("object"===typeof a)switch(a.$$typeof){case Lb:return (a.displayName||"Context")+".Consumer";case Kb:return (a._context.displayName||"Context")+".Provider";case Mb:var b=a.render;a=a.displayName;a||(a=b.displayName||
	b.name||"",a=""!==a?"ForwardRef("+a+")":"ForwardRef");return a;case Pb:return b=a.displayName||null,null!==b?b:Wb(a.type)||"Memo";case Qb:b=a._payload;a=a._init;try{return Wb(a(b))}catch(c){}}return null}var Xb={};function Yb(a,b){a=a.contextTypes;if(!a)return Xb;var c={},d;for(d in a)c[d]=b[d];return c}var N=null;
	function O$1(a,b){if(a!==b){a.context._currentValue=a.parentValue;a=a.parent;var c=b.parent;if(null===a){if(null!==c)throw Error(k$1(401));}else {if(null===c)throw Error(k$1(401));O$1(a,c);}b.context._currentValue=b.value;}}function Zb(a){a.context._currentValue=a.parentValue;a=a.parent;null!==a&&Zb(a);}function $b(a){var b=a.parent;null!==b&&$b(b);a.context._currentValue=a.value;}
	function ac$1(a,b){a.context._currentValue=a.parentValue;a=a.parent;if(null===a)throw Error(k$1(402));a.depth===b.depth?O$1(a,b):ac$1(a,b);}function bc$1(a,b){var c=b.parent;if(null===c)throw Error(k$1(402));a.depth===c.depth?O$1(a,c):bc$1(a,c);b.context._currentValue=b.value;}function P(a){var b=N;b!==a&&(null===b?$b(a):null===a?Zb(b):b.depth===a.depth?O$1(b,a):b.depth>a.depth?ac$1(b,a):bc$1(b,a),N=a);}
	var cc$1={isMounted:function(){return !1},enqueueSetState:function(a,b){a=a._reactInternals;null!==a.queue&&a.queue.push(b);},enqueueReplaceState:function(a,b){a=a._reactInternals;a.replace=!0;a.queue=[b];},enqueueForceUpdate:function(){}};
	function dc$1(a,b,c,d){var f=void 0!==a.state?a.state:null;a.updater=cc$1;a.props=c;a.state=f;var e={queue:[],replace:!1};a._reactInternals=e;var g=b.contextType;a.context="object"===typeof g&&null!==g?g._currentValue:d;g=b.getDerivedStateFromProps;"function"===typeof g&&(g=g(c,f),f=null===g||void 0===g?f:M({},f,g),a.state=f);if("function"!==typeof b.getDerivedStateFromProps&&"function"!==typeof a.getSnapshotBeforeUpdate&&("function"===typeof a.UNSAFE_componentWillMount||"function"===typeof a.componentWillMount))if(b=
	a.state,"function"===typeof a.componentWillMount&&a.componentWillMount(),"function"===typeof a.UNSAFE_componentWillMount&&a.UNSAFE_componentWillMount(),b!==a.state&&cc$1.enqueueReplaceState(a,a.state,null),null!==e.queue&&0<e.queue.length)if(b=e.queue,g=e.replace,e.queue=null,e.replace=!1,g&&1===b.length)a.state=b[0];else {e=g?b[0]:a.state;f=!0;for(g=g?1:0;g<b.length;g++){var h=b[g];h="function"===typeof h?h.call(a,e,c,d):h;null!=h&&(f?(f=!1,e=M({},e,h)):M(e,h));}a.state=e;}else e.queue=null;}
	var ec$1={id:1,overflow:""};function fc$1(a,b,c){var d=a.id;a=a.overflow;var f=32-Q(d)-1;d&=~(1<<f);c+=1;var e=32-Q(b)+f;if(30<e){var g=f-f%5;e=(d&(1<<g)-1).toString(32);d>>=g;f-=g;return {id:1<<32-Q(b)+f|c<<f|d,overflow:e+a}}return {id:1<<e|c<<f|d,overflow:a}}var Q=Math.clz32?Math.clz32:gc$1,hc$1=Math.log,ic$1=Math.LN2;function gc$1(a){a>>>=0;return 0===a?32:31-(hc$1(a)/ic$1|0)|0}function jc$1(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}
	var kc$1="function"===typeof Object.is?Object.is:jc$1,R$1=null,lc$1=null,mc$1=null,S=null,T$1=!1,nc=!1,U=0,V=null,oc$1=0;function W$1(){if(null===R$1)throw Error(k$1(321));return R$1}function pc$1(){if(0<oc$1)throw Error(k$1(312));return {memoizedState:null,queue:null,next:null}}function qc$1(){null===S?null===mc$1?(T$1=!1,mc$1=S=pc$1()):(T$1=!0,S=mc$1):null===S.next?(T$1=!1,S=S.next=pc$1()):(T$1=!0,S=S.next);return S}function rc$1(){lc$1=R$1=null;nc=!1;mc$1=null;oc$1=0;S=V=null;}function sc$1(a,b){return "function"===typeof b?b(a):b}
	function tc$1(a,b,c){R$1=W$1();S=qc$1();if(T$1){var d=S.queue;b=d.dispatch;if(null!==V&&(c=V.get(d),void 0!==c)){V.delete(d);d=S.memoizedState;do d=a(d,c.action),c=c.next;while(null!==c);S.memoizedState=d;return [d,b]}return [S.memoizedState,b]}a=a===sc$1?"function"===typeof b?b():b:void 0!==c?c(b):b;S.memoizedState=a;a=S.queue={last:null,dispatch:null};a=a.dispatch=uc$1.bind(null,R$1,a);return [S.memoizedState,a]}
	function vc$1(a,b){R$1=W$1();S=qc$1();b=void 0===b?null:b;if(null!==S){var c=S.memoizedState;if(null!==c&&null!==b){var d=c[1];a:if(null===d)d=!1;else {for(var f=0;f<d.length&&f<b.length;f++)if(!kc$1(b[f],d[f])){d=!1;break a}d=!0;}if(d)return c[0]}}a=a();S.memoizedState=[a,b];return a}function uc$1(a,b,c){if(25<=oc$1)throw Error(k$1(301));if(a===R$1)if(nc=!0,a={action:c,next:null},null===V&&(V=new Map),c=V.get(b),void 0===c)V.set(b,a);else {for(b=c;null!==b.next;)b=b.next;b.next=a;}}
	function wc$1(){throw Error(k$1(394));}function xc$1(){}
	var zc$1={readContext:function(a){return a._currentValue},useContext:function(a){W$1();return a._currentValue},useMemo:vc$1,useReducer:tc$1,useRef:function(a){R$1=W$1();S=qc$1();var b=S.memoizedState;return null===b?(a={current:a},S.memoizedState=a):b},useState:function(a){return tc$1(sc$1,a)},useInsertionEffect:xc$1,useLayoutEffect:function(){},useCallback:function(a,b){return vc$1(function(){return a},b)},useImperativeHandle:xc$1,useEffect:xc$1,useDebugValue:xc$1,useDeferredValue:function(a){W$1();return a},useTransition:function(){W$1();
	return [!1,wc$1]},useId:function(){var a=lc$1.treeContext;var b=a.overflow;a=a.id;a=(a&~(1<<32-Q(a)-1)).toString(32)+b;var c=yc$1;if(null===c)throw Error(k$1(404));b=U++;a=":"+c.idPrefix+"R"+a;0<b&&(a+="H"+b.toString(32));return a+":"},useMutableSource:function(a,b){W$1();return b(a._source)},useSyncExternalStore:function(a,b,c){if(void 0===c)throw Error(k$1(407));return c()}},yc$1=null,Ac$1=aa$1.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentDispatcher;function Bc$1(a){console.error(a);}
	function X$1(){}
	function Cc$1(a,b,c,d,f,e,g,h,m){var q=[],r=new Set;b={destination:null,responseState:b,progressiveChunkSize:void 0===d?12800:d,status:0,fatalError:null,nextSegmentId:0,allPendingTasks:0,pendingRootTasks:0,completedRootSegment:null,abortableTasks:r,pingedTasks:q,clientRenderedBoundaries:[],completedBoundaries:[],partialBoundaries:[],onError:void 0===f?Bc$1:f,onAllReady:void 0===e?X$1:e,onShellReady:void 0===g?X$1:g,onShellError:void 0===h?X$1:h,onFatalError:void 0===m?X$1:m};c=Dc$1(b,0,null,c);c.parentFlushed=!0;
	a=Ec$1(b,a,null,c,r,Xb,null,ec$1);q.push(a);return b}function Ec$1(a,b,c,d,f,e,g,h){a.allPendingTasks++;null===c?a.pendingRootTasks++:c.pendingTasks++;var m={node:b,ping:function(){var b=a.pingedTasks;b.push(m);1===b.length&&Fc$1(a);},blockedBoundary:c,blockedSegment:d,abortSet:f,legacyContext:e,context:g,treeContext:h};f.add(m);return m}function Dc$1(a,b,c,d){return {status:0,id:-1,index:b,parentFlushed:!1,chunks:[],children:[],formatContext:d,boundary:c}}function Y$1(a,b){a=a.onError;a(b);}
	function Gc$1(a,b){var c=a.onShellError;c(b);c=a.onFatalError;c(b);null!==a.destination?(a.status=2,da$1(a.destination,b)):(a.status=1,a.fatalError=b);}function Hc$1(a,b,c,d,f){R$1={};lc$1=b;U=0;for(a=c(d,f);nc;)nc=!1,U=0,oc$1+=1,S=null,a=c(d,f);rc$1();return a}
	function Ic$1(a,b,c,d){var f=c.render(),e=d.childContextTypes;if(null!==e&&void 0!==e){var g=b.legacyContext;if("function"!==typeof c.getChildContext)d=g;else {c=c.getChildContext();for(var h in c)if(!(h in e))throw Error(k$1(108,Wb(d)||"Unknown",h));d=M({},g,c);}b.legacyContext=d;Z$1(a,b,f);b.legacyContext=g;}else Z$1(a,b,f);}function Jc$1(a,b){if(a&&a.defaultProps){b=M({},b);a=a.defaultProps;for(var c in a)void 0===b[c]&&(b[c]=a[c]);return b}return b}
	function Kc$1(a,b,c,d,f){if("function"===typeof c)if(c.prototype&&c.prototype.isReactComponent){f=Yb(c,b.legacyContext);var e=c.contextType;e=new c(d,"object"===typeof e&&null!==e?e._currentValue:f);dc$1(e,c,d,f);Ic$1(a,b,e,c);}else {e=Yb(c,b.legacyContext);f=Hc$1(a,b,c,d,e);var g=0!==U;if("object"===typeof f&&null!==f&&"function"===typeof f.render&&void 0===f.$$typeof)dc$1(f,c,d,e),Ic$1(a,b,f,c);else if(g){d=b.treeContext;b.treeContext=fc$1(d,1,0);try{Z$1(a,b,f);}finally{b.treeContext=d;}}else Z$1(a,b,f);}else if("string"===
	typeof c)switch(f=b.blockedSegment,e=Na$1(f.chunks,c,d,a.responseState,f.formatContext),g=f.formatContext,f.formatContext=xa$1(g,c,d),Lc$1(a,b,e),f.formatContext=g,c){case "area":case "base":case "br":case "col":case "embed":case "hr":case "img":case "input":case "keygen":case "link":case "meta":case "param":case "source":case "track":case "wbr":break;default:f.chunks.push(Oa$1,u$1(c),Pa$1);}else {switch(c){case Tb:case Sb$1:case Ib:case Jb:case Hb:Z$1(a,b,d.children);return;case Ob:Z$1(a,b,d.children);return;case Rb:throw Error(k$1(343));
	case Nb:a:{c=b.blockedBoundary;f=b.blockedSegment;e=d.fallback;d=d.children;g=new Set;var h={id:null,rootSegmentID:-1,parentFlushed:!1,pendingTasks:0,forceClientRender:!1,completedSegments:[],byteSize:0,fallbackAbortableTasks:g},m=Dc$1(a,f.chunks.length,h,f.formatContext);f.children.push(m);var q=Dc$1(a,0,null,f.formatContext);q.parentFlushed=!0;b.blockedBoundary=h;b.blockedSegment=q;try{if(Lc$1(a,b,d),q.status=1,Mc$1(h,q),0===h.pendingTasks)break a}catch(r){q.status=4,Y$1(a,r),h.forceClientRender=!0;}finally{b.blockedBoundary=
	c,b.blockedSegment=f;}b=Ec$1(a,e,c,m,g,b.legacyContext,b.context,b.treeContext);a.pingedTasks.push(b);}return}if("object"===typeof c&&null!==c)switch(c.$$typeof){case Mb:d=Hc$1(a,b,c.render,d,f);if(0!==U){c=b.treeContext;b.treeContext=fc$1(c,1,0);try{Z$1(a,b,d);}finally{b.treeContext=c;}}else Z$1(a,b,d);return;case Pb:c=c.type;d=Jc$1(c,d);Kc$1(a,b,c,d,f);return;case Kb:f=d.children;c=c._context;d=d.value;e=c._currentValue;c._currentValue=d;g=N;N=d={parent:g,depth:null===g?0:g.depth+1,context:c,parentValue:e,value:d};
	b.context=d;Z$1(a,b,f);a=N;if(null===a)throw Error(k$1(403));d=a.parentValue;a.context._currentValue=d===Ub?a.context._defaultValue:d;a=N=a.parent;b.context=a;return;case Lb:d=d.children;d=d(c._currentValue);Z$1(a,b,d);return;case Qb:f=c._init;c=f(c._payload);d=Jc$1(c,d);Kc$1(a,b,c,d,void 0);return}throw Error(k$1(130,null==c?c:typeof c,""));}}
	function Z$1(a,b,c){b.node=c;if("object"===typeof c&&null!==c){switch(c.$$typeof){case Fb:Kc$1(a,b,c.type,c.props,c.ref);return;case Gb:throw Error(k$1(257));case Qb:var d=c._init;c=d(c._payload);Z$1(a,b,c);return}if(pa$1(c)){Nc$1(a,b,c);return}null===c||"object"!==typeof c?d=null:(d=Vb&&c[Vb]||c["@@iterator"],d="function"===typeof d?d:null);if(d&&(d=d.call(c))){c=d.next();if(!c.done){var f=[];do f.push(c.value),c=d.next();while(!c.done);Nc$1(a,b,f);}return}b=Object.prototype.toString.call(c);throw Error(k$1(31,"[object Object]"===
	b?"object with keys {"+Object.keys(c).join(", ")+"}":b));}"string"===typeof c?""!==c&&b.blockedSegment.chunks.push(u$1(A$1(c)),ya$1):"number"===typeof c&&(a=""+c,""!==a&&b.blockedSegment.chunks.push(u$1(A$1(a)),ya$1));}function Nc$1(a,b,c){for(var d=c.length,f=0;f<d;f++){var e=b.treeContext;b.treeContext=fc$1(e,d,f);try{Lc$1(a,b,c[f]);}finally{b.treeContext=e;}}}
	function Lc$1(a,b,c){var d=b.blockedSegment.formatContext,f=b.legacyContext,e=b.context;try{return Z$1(a,b,c)}catch(m){if(rc$1(),"object"===typeof m&&null!==m&&"function"===typeof m.then){c=m;var g=b.blockedSegment,h=Dc$1(a,g.chunks.length,null,g.formatContext);g.children.push(h);a=Ec$1(a,b.node,b.blockedBoundary,h,b.abortSet,b.legacyContext,b.context,b.treeContext).ping;c.then(a,a);b.blockedSegment.formatContext=d;b.legacyContext=f;b.context=e;P(e);}else throw b.blockedSegment.formatContext=d,b.legacyContext=
	f,b.context=e,P(e),m;}}function Oc$1(a){var b=a.blockedBoundary;a=a.blockedSegment;a.status=3;Pc$1(this,b,a);}
	function Qc$1(a){var b=a.blockedBoundary;a.blockedSegment.status=3;null===b?(this.allPendingTasks--,2!==this.status&&(this.status=2,null!==this.destination&&this.destination.close())):(b.pendingTasks--,b.forceClientRender||(b.forceClientRender=!0,b.parentFlushed&&this.clientRenderedBoundaries.push(b)),b.fallbackAbortableTasks.forEach(Qc$1,this),b.fallbackAbortableTasks.clear(),this.allPendingTasks--,0===this.allPendingTasks&&(a=this.onAllReady,a()));}
	function Mc$1(a,b){if(0===b.chunks.length&&1===b.children.length&&null===b.children[0].boundary){var c=b.children[0];c.id=b.id;c.parentFlushed=!0;1===c.status&&Mc$1(a,c);}else a.completedSegments.push(b);}
	function Pc$1(a,b,c){if(null===b){if(c.parentFlushed){if(null!==a.completedRootSegment)throw Error(k$1(389));a.completedRootSegment=c;}a.pendingRootTasks--;0===a.pendingRootTasks&&(a.onShellError=X$1,b=a.onShellReady,b());}else b.pendingTasks--,b.forceClientRender||(0===b.pendingTasks?(c.parentFlushed&&1===c.status&&Mc$1(b,c),b.parentFlushed&&a.completedBoundaries.push(b),b.fallbackAbortableTasks.forEach(Oc$1,a),b.fallbackAbortableTasks.clear()):c.parentFlushed&&1===c.status&&(Mc$1(b,c),1===b.completedSegments.length&&
	b.parentFlushed&&a.partialBoundaries.push(b)));a.allPendingTasks--;0===a.allPendingTasks&&(a=a.onAllReady,a());}
	function Fc$1(a){if(2!==a.status){var b=N,c=Ac$1.current;Ac$1.current=zc$1;var d=yc$1;yc$1=a.responseState;try{var f=a.pingedTasks,e;for(e=0;e<f.length;e++){var g=f[e];var h=a,m=g.blockedSegment;if(0===m.status){P(g.context);try{Z$1(h,g,g.node),g.abortSet.delete(g),m.status=1,Pc$1(h,g.blockedBoundary,m);}catch(C){if(rc$1(),"object"===typeof C&&null!==C&&"function"===typeof C.then){var q=g.ping;C.then(q,q);}else {g.abortSet.delete(g);m.status=4;var r=g.blockedBoundary,E=C;Y$1(h,E);null===r?Gc$1(h,E):(r.pendingTasks--,r.forceClientRender||
	(r.forceClientRender=!0,r.parentFlushed&&h.clientRenderedBoundaries.push(r)));h.allPendingTasks--;if(0===h.allPendingTasks){var F=h.onAllReady;F();}}}finally{}}}f.splice(0,e);null!==a.destination&&Rc$1(a,a.destination);}catch(C){Y$1(a,C),Gc$1(a,C);}finally{yc$1=d,Ac$1.current=c,c===zc$1&&P(b);}}}
	function Sc$1(a,b,c){c.parentFlushed=!0;switch(c.status){case 0:var d=c.id=a.nextSegmentId++;a=a.responseState;p$1(b,Qa$1);p$1(b,a.placeholderPrefix);a=u$1(d.toString(16));p$1(b,a);return t(b,Ra$1);case 1:c.status=2;var f=!0;d=c.chunks;var e=0;c=c.children;for(var g=0;g<c.length;g++){for(f=c[g];e<f.index;e++)p$1(b,d[e]);f=Tc$1(a,b,f);}for(;e<d.length-1;e++)p$1(b,d[e]);e<d.length&&(f=t(b,d[e]));return f;default:throw Error(k$1(390));}}
	function Tc$1(a,b,c){var d=c.boundary;if(null===d)return Sc$1(a,b,c);d.parentFlushed=!0;if(d.forceClientRender)t(b,Va$1),Sc$1(a,b,c);else if(0<d.pendingTasks){d.rootSegmentID=a.nextSegmentId++;0<d.completedSegments.length&&a.partialBoundaries.push(d);var f=a.responseState;var e=f.nextSuspenseID++;f=v$1(f.boundaryPrefix+e.toString(16));d=d.id=f;Xa$1(b,a.responseState,d);Sc$1(a,b,c);}else if(d.byteSize>a.progressiveChunkSize)d.rootSegmentID=a.nextSegmentId++,a.completedBoundaries.push(d),Xa$1(b,a.responseState,d.id),
	Sc$1(a,b,c);else {t(b,Sa$1);c=d.completedSegments;if(1!==c.length)throw Error(k$1(391));Tc$1(a,b,c[0]);}return t(b,Wa$1)}function Uc$1(a,b,c){sb(b,a.responseState,c.formatContext,c.id);Tc$1(a,b,c);return tb(b,c.formatContext)}
	function Vc$1(a,b,c){for(var d=c.completedSegments,f=0;f<d.length;f++)Wc$1(a,b,c,d[f]);d.length=0;a=a.responseState;d=c.id;c=c.rootSegmentID;p$1(b,a.startInlineScript);a.sentCompleteBoundaryFunction?p$1(b,zb):(a.sentCompleteBoundaryFunction=!0,p$1(b,yb$1));if(null===d)throw Error(k$1(395));c=u$1(c.toString(16));p$1(b,d);p$1(b,Ab$1);p$1(b,a.segmentPrefix);p$1(b,c);return t(b,Bb)}
	function Wc$1(a,b,c,d){if(2===d.status)return !0;var f=d.id;if(-1===f){if(-1===(d.id=c.rootSegmentID))throw Error(k$1(392));return Uc$1(a,b,d)}Uc$1(a,b,d);a=a.responseState;p$1(b,a.startInlineScript);a.sentCompleteSegmentFunction?p$1(b,vb$1):(a.sentCompleteSegmentFunction=!0,p$1(b,ub));p$1(b,a.segmentPrefix);f=u$1(f.toString(16));p$1(b,f);p$1(b,wb$1);p$1(b,a.placeholderPrefix);p$1(b,f);return t(b,xb$1)}
	function Rc$1(a,b){l$1=new Uint8Array(512);n=0;try{var c=a.completedRootSegment;if(null!==c&&0===a.pendingRootTasks){Tc$1(a,b,c);a.completedRootSegment=null;var d=a.responseState.bootstrapChunks;for(c=0;c<d.length-1;c++)p$1(b,d[c]);c<d.length&&t(b,d[c]);}var f=a.clientRenderedBoundaries,e;for(e=0;e<f.length;e++){d=b;var g=a.responseState,h=f[e].id;p$1(d,g.startInlineScript);g.sentClientRenderFunction?p$1(d,Db):(g.sentClientRenderFunction=!0,p$1(d,Cb$1));if(null===h)throw Error(k$1(395));p$1(d,h);if(!t(d,Eb));}f.splice(0,e);var m=a.completedBoundaries;for(e=0;e<m.length;e++)if(!Vc$1(a,b,m[e]));m.splice(0,e);ba$1(b);l$1=new Uint8Array(512);n=0;var q=a.partialBoundaries;for(e=0;e<q.length;e++){var r=q[e];a:{f=a;g=b;var E=r.completedSegments;for(h=0;h<E.length;h++)if(!Wc$1(f,g,r,E[h])){h++;E.splice(0,h);var F=!1;break a}E.splice(0,h);F=!0;}if(!F){a.destination=null;e++;q.splice(0,e);return}}q.splice(0,e);var C=a.completedBoundaries;for(e=0;e<
	C.length;e++)if(!Vc$1(a,b,C[e]));C.splice(0,e);}finally{ba$1(b),0===a.allPendingTasks&&0===a.pingedTasks.length&&0===a.clientRenderedBoundaries.length&&0===a.completedBoundaries.length&&b.close();}}function Xc$1(a){try{var b=a.abortableTasks;b.forEach(Qc$1,a);b.clear();null!==a.destination&&Rc$1(a,a.destination);}catch(c){Y$1(a,c),Gc$1(a,c);}}
	reactDomServer_browser_production_min.renderToReadableStream=function(a,b){return new Promise(function(c,d){var f,e,g=new Promise(function(a,b){e=a;f=b;}),h=Cc$1(a,va$1(b?b.identifierPrefix:void 0,b?b.nonce:void 0,b?b.bootstrapScriptContent:void 0,b?b.bootstrapScripts:void 0,b?b.bootstrapModules:void 0),wa$1(b?b.namespaceURI:void 0),b?b.progressiveChunkSize:void 0,b?b.onError:void 0,e,function(){var a=new ReadableStream({type:"bytes",pull:function(a){if(1===h.status)h.status=2,da$1(a,h.fatalError);else if(2!==h.status&&null===h.destination){h.destination=
	a;try{Rc$1(h,a);}catch(F){Y$1(h,F),Gc$1(h,F);}}},cancel:function(){Xc$1(h);}});a.allReady=g;c(a);},function(a){g.catch(function(){});d(a);},f);if(b&&b.signal){var m=b.signal,q=function(){Xc$1(h);m.removeEventListener("abort",q);};m.addEventListener("abort",q);}Fc$1(h);})};reactDomServer_browser_production_min.version="18.0.0-fc46dba67-20220329";

	var l, s$1;
	{
	  l = reactDomServerLegacy_browser_production_min;
	  s$1 = reactDomServer_browser_production_min;
	}

	l.version;
	l.renderToString;
	var renderToStaticMarkup = l.renderToStaticMarkup;
	l.renderToNodeStream;
	l.renderToStaticNodeStream;
	s$1.renderToReadableStream;

	/**
	 * Parse space-separated tokens to an array of strings.
	 *
	 * @param {string} value
	 *   Space-separated tokens.
	 * @returns {Array<string>}
	 *   List of tokens.
	 */
	function parse$2(value) {
	  const input = String(value || '').trim();
	  return input ? input.split(/[ \t\n\r\f]+/g) : []
	}

	/**
	 * Serialize an array of strings as space separated-tokens.
	 *
	 * @param {Array<string|number>} values
	 *   List of tokens.
	 * @returns {string}
	 *   Space-separated tokens.
	 */
	function stringify$1(values) {
	  return values.join(' ').trim()
	}

	// Scheme: https://tools.ietf.org/html/rfc3986#section-3.1
	// Absolute URL: https://tools.ietf.org/html/rfc3986#section-4.3
	const ABSOLUTE_URL_REGEX = /^[a-zA-Z][a-zA-Z\d+\-.]*?:/;

	// Windows paths like `c:\`
	const WINDOWS_PATH_REGEX = /^[a-zA-Z]:\\/;

	function isAbsoluteUrl(url) {
		if (typeof url !== 'string') {
			throw new TypeError(`Expected a \`string\`, got \`${typeof url}\``);
		}

		if (WINDOWS_PATH_REGEX.test(url)) {
			return false;
		}

		return ABSOLUTE_URL_REGEX.test(url);
	}

	var hasOwn = Object.prototype.hasOwnProperty;
	var toStr = Object.prototype.toString;
	var defineProperty = Object.defineProperty;
	var gOPD = Object.getOwnPropertyDescriptor;

	var isArray = function isArray(arr) {
		if (typeof Array.isArray === 'function') {
			return Array.isArray(arr);
		}

		return toStr.call(arr) === '[object Array]';
	};

	var isPlainObject$2 = function isPlainObject(obj) {
		if (!obj || toStr.call(obj) !== '[object Object]') {
			return false;
		}

		var hasOwnConstructor = hasOwn.call(obj, 'constructor');
		var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
		// Not own constructor property must be Object
		if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
			return false;
		}

		// Own properties are enumerated firstly, so to speed up,
		// if last one is own, then all properties are own.
		var key;
		for (key in obj) { /**/ }

		return typeof key === 'undefined' || hasOwn.call(obj, key);
	};

	// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target
	var setProperty = function setProperty(target, options) {
		if (defineProperty && options.name === '__proto__') {
			defineProperty(target, options.name, {
				enumerable: true,
				configurable: true,
				value: options.newValue,
				writable: true
			});
		} else {
			target[options.name] = options.newValue;
		}
	};

	// Return undefined instead of __proto__ if '__proto__' is not an own property
	var getProperty = function getProperty(obj, name) {
		if (name === '__proto__') {
			if (!hasOwn.call(obj, name)) {
				return void 0;
			} else if (gOPD) {
				// In early versions of node, obj['__proto__'] is buggy when obj has
				// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.
				return gOPD(obj, name).value;
			}
		}

		return obj[name];
	};

	var extend = function extend() {
		var options, name, src, copy, copyIsArray, clone;
		var target = arguments[0];
		var i = 1;
		var length = arguments.length;
		var deep = false;

		// Handle a deep copy situation
		if (typeof target === 'boolean') {
			deep = target;
			target = arguments[1] || {};
			// skip the boolean and the target
			i = 2;
		}
		if (target == null || (typeof target !== 'object' && typeof target !== 'function')) {
			target = {};
		}

		for (; i < length; ++i) {
			options = arguments[i];
			// Only deal with non-null/undefined values
			if (options != null) {
				// Extend the base object
				for (name in options) {
					src = getProperty(target, name);
					copy = getProperty(options, name);

					// Prevent never-ending loop
					if (target !== copy) {
						// Recurse if we're merging plain objects or arrays
						if (deep && copy && (isPlainObject$2(copy) || (copyIsArray = isArray(copy)))) {
							if (copyIsArray) {
								copyIsArray = false;
								clone = src && isArray(src) ? src : [];
							} else {
								clone = src && isPlainObject$2(src) ? src : {};
							}

							// Never move original objects, clone them
							setProperty(target, { name: name, newValue: extend(deep, clone, copy) });

						// Don't bring in undefined values
						} else if (typeof copy !== 'undefined') {
							setProperty(target, { name: name, newValue: copy });
						}
					}
				}
			}
		}

		// Return the modified object
		return target;
	};

	var extend$1 = /*@__PURE__*/getDefaultExportFromCjs(extend);

	/**
	 * @typedef {import('hast').Root} Root
	 * @typedef {import('hast').Properties} Properties
	 * @typedef {import('hast').Element} Element
	 *
	 * @typedef {Element['children'][number]} ElementChild
	 *
	 * @typedef {'_self'|'_blank'|'_parent'|'_top'} Target
	 * @typedef {Array<string>|string} Rel
	 * @typedef {Array<string>} Protocols
	 * @typedef {ElementChild|Array<ElementChild>} Content
	 * @typedef {Properties} ContentProperties
	 *
	 * @callback TargetCallback
	 * @param {Element} node
	 * @returns {Target|null|undefined}
	 *
	 * @callback RelCallback
	 * @param {Element} node
	 * @returns {Rel|null|undefined}
	 *
	 * @callback ProtocolsCallback
	 * @param {Element} node
	 * @returns {Protocols|null|undefined}
	 *
	 * @callback ContentCallback
	 * @param {Element} node
	 * @returns {Content|null|undefined}
	 *
	 * @callback ContentPropertiesCallback
	 * @param {Element} node
	 * @returns {Properties|null|undefined}
	 *
	 * @typedef Options
	 *   Configuration.
	 * @property {Target|TargetCallback} [target]
	 *   How to display referenced documents (`string?`: `_self`, `_blank`,
	 *   `_parent`, or `_top`, default: `_blank`).
	 *   The default (nothing) is to not set `target`s on links.
	 * @property {Rel|RelCallback} [rel=['nofollow', 'noopener', 'noreferrer']]
	 *   Link types to hint about the referenced documents.
	 *   Pass an empty array (`[]`) to not set `rel`s on links.
	 *
	 *   **Note**: when using a `target`, add `noopener` and `noreferrer` to avoid
	 *   exploitation of the `window.opener` API.
	 * @property {Protocols|ProtocolsCallback} [protocols=['http', 'https']]
	 *   Protocols to check, such as `mailto` or `tel`.
	 * @property {Content|ContentCallback} [content]
	 *   hast content to insert at the end of external links.
	 *   Will be inserted in a `<span>` element.
	 *
	 *   Useful for improving accessibility by giving users advanced warning when
	 *   opening a new window.
	 * @property {ContentProperties|ContentPropertiesCallback} [contentProperties]
	 *   hast properties to add to the `span` wrapping `content`, when given.
	 */


	const defaultRel = ['nofollow'];
	const defaultProtocols = ['http', 'https'];

	/**
	 * If this is a value, return that.
	 * If this is a function instead, call it to get the result.
	 *
	 * @template T
	 * @param {T} value
	 * @param {Element} node
	 * @returns {T extends Function ? ReturnType<T> : T}
	 */
	function callIfNeeded(value, node) {
	  return typeof value === 'function' ? value(node) : value
	}

	/**
	 * Plugin to automatically add `target` and `rel` attributes to external links.
	 *
	 * @type {import('unified').Plugin<[Options?] | Array<void>, Root>}
	 */
	function rehypeExternalLinks(options = {}) {
	  return (tree) => {
	    visit$2(tree, 'element', (node) => {
	      if (
	        node.tagName === 'a' &&
	        node.properties &&
	        typeof node.properties.href === 'string'
	      ) {
	        const url = node.properties.href;
	        const protocol = url.slice(0, url.indexOf(':'));

	        const target = callIfNeeded(options.target, node);

	        const relRaw = callIfNeeded(options.rel, node) || defaultRel;
	        const rel = typeof relRaw === 'string' ? parse$2(relRaw) : relRaw;

	        const protocols =
	          callIfNeeded(options.protocols, node) || defaultProtocols;

	        const contentRaw = callIfNeeded(options.content, node);
	        const content =
	          contentRaw && !Array.isArray(contentRaw) ? [contentRaw] : contentRaw;

	        const contentProperties =
	          callIfNeeded(options.contentProperties, node) || {};

	        if (isAbsoluteUrl(url) && protocols.includes(protocol)) {
	          if (target) {
	            node.properties.target = target;
	          }

	          if (rel.length > 0) {
	            node.properties.rel = rel.concat();
	          }

	          if (content) {
	            node.children.push({
	              type: 'element',
	              tagName: 'span',
	              properties: extend$1(true, contentProperties),
	              children: extend$1(true, content)
	            });
	          }
	        }
	      }
	    });
	  }
	}

	var unicode$3 = {};

	const UNDEFINED_CODE_POINTS = [
	    0xfffe,
	    0xffff,
	    0x1fffe,
	    0x1ffff,
	    0x2fffe,
	    0x2ffff,
	    0x3fffe,
	    0x3ffff,
	    0x4fffe,
	    0x4ffff,
	    0x5fffe,
	    0x5ffff,
	    0x6fffe,
	    0x6ffff,
	    0x7fffe,
	    0x7ffff,
	    0x8fffe,
	    0x8ffff,
	    0x9fffe,
	    0x9ffff,
	    0xafffe,
	    0xaffff,
	    0xbfffe,
	    0xbffff,
	    0xcfffe,
	    0xcffff,
	    0xdfffe,
	    0xdffff,
	    0xefffe,
	    0xeffff,
	    0xffffe,
	    0xfffff,
	    0x10fffe,
	    0x10ffff
	];

	unicode$3.REPLACEMENT_CHARACTER = '\uFFFD';

	unicode$3.CODE_POINTS = {
	    EOF: -1,
	    NULL: 0x00,
	    TABULATION: 0x09,
	    CARRIAGE_RETURN: 0x0d,
	    LINE_FEED: 0x0a,
	    FORM_FEED: 0x0c,
	    SPACE: 0x20,
	    EXCLAMATION_MARK: 0x21,
	    QUOTATION_MARK: 0x22,
	    NUMBER_SIGN: 0x23,
	    AMPERSAND: 0x26,
	    APOSTROPHE: 0x27,
	    HYPHEN_MINUS: 0x2d,
	    SOLIDUS: 0x2f,
	    DIGIT_0: 0x30,
	    DIGIT_9: 0x39,
	    SEMICOLON: 0x3b,
	    LESS_THAN_SIGN: 0x3c,
	    EQUALS_SIGN: 0x3d,
	    GREATER_THAN_SIGN: 0x3e,
	    QUESTION_MARK: 0x3f,
	    LATIN_CAPITAL_A: 0x41,
	    LATIN_CAPITAL_F: 0x46,
	    LATIN_CAPITAL_X: 0x58,
	    LATIN_CAPITAL_Z: 0x5a,
	    RIGHT_SQUARE_BRACKET: 0x5d,
	    GRAVE_ACCENT: 0x60,
	    LATIN_SMALL_A: 0x61,
	    LATIN_SMALL_F: 0x66,
	    LATIN_SMALL_X: 0x78,
	    LATIN_SMALL_Z: 0x7a,
	    REPLACEMENT_CHARACTER: 0xfffd
	};

	unicode$3.CODE_POINT_SEQUENCES = {
	    DASH_DASH_STRING: [0x2d, 0x2d], //--
	    DOCTYPE_STRING: [0x44, 0x4f, 0x43, 0x54, 0x59, 0x50, 0x45], //DOCTYPE
	    CDATA_START_STRING: [0x5b, 0x43, 0x44, 0x41, 0x54, 0x41, 0x5b], //[CDATA[
	    SCRIPT_STRING: [0x73, 0x63, 0x72, 0x69, 0x70, 0x74], //script
	    PUBLIC_STRING: [0x50, 0x55, 0x42, 0x4c, 0x49, 0x43], //PUBLIC
	    SYSTEM_STRING: [0x53, 0x59, 0x53, 0x54, 0x45, 0x4d] //SYSTEM
	};

	//Surrogates
	unicode$3.isSurrogate = function(cp) {
	    return cp >= 0xd800 && cp <= 0xdfff;
	};

	unicode$3.isSurrogatePair = function(cp) {
	    return cp >= 0xdc00 && cp <= 0xdfff;
	};

	unicode$3.getSurrogatePairCodePoint = function(cp1, cp2) {
	    return (cp1 - 0xd800) * 0x400 + 0x2400 + cp2;
	};

	//NOTE: excluding NULL and ASCII whitespace
	unicode$3.isControlCodePoint = function(cp) {
	    return (
	        (cp !== 0x20 && cp !== 0x0a && cp !== 0x0d && cp !== 0x09 && cp !== 0x0c && cp >= 0x01 && cp <= 0x1f) ||
	        (cp >= 0x7f && cp <= 0x9f)
	    );
	};

	unicode$3.isUndefinedCodePoint = function(cp) {
	    return (cp >= 0xfdd0 && cp <= 0xfdef) || UNDEFINED_CODE_POINTS.indexOf(cp) > -1;
	};

	var errorCodes = {
	    controlCharacterInInputStream: 'control-character-in-input-stream',
	    noncharacterInInputStream: 'noncharacter-in-input-stream',
	    surrogateInInputStream: 'surrogate-in-input-stream',
	    nonVoidHtmlElementStartTagWithTrailingSolidus: 'non-void-html-element-start-tag-with-trailing-solidus',
	    endTagWithAttributes: 'end-tag-with-attributes',
	    endTagWithTrailingSolidus: 'end-tag-with-trailing-solidus',
	    unexpectedSolidusInTag: 'unexpected-solidus-in-tag',
	    unexpectedNullCharacter: 'unexpected-null-character',
	    unexpectedQuestionMarkInsteadOfTagName: 'unexpected-question-mark-instead-of-tag-name',
	    invalidFirstCharacterOfTagName: 'invalid-first-character-of-tag-name',
	    unexpectedEqualsSignBeforeAttributeName: 'unexpected-equals-sign-before-attribute-name',
	    missingEndTagName: 'missing-end-tag-name',
	    unexpectedCharacterInAttributeName: 'unexpected-character-in-attribute-name',
	    unknownNamedCharacterReference: 'unknown-named-character-reference',
	    missingSemicolonAfterCharacterReference: 'missing-semicolon-after-character-reference',
	    unexpectedCharacterAfterDoctypeSystemIdentifier: 'unexpected-character-after-doctype-system-identifier',
	    unexpectedCharacterInUnquotedAttributeValue: 'unexpected-character-in-unquoted-attribute-value',
	    eofBeforeTagName: 'eof-before-tag-name',
	    eofInTag: 'eof-in-tag',
	    missingAttributeValue: 'missing-attribute-value',
	    missingWhitespaceBetweenAttributes: 'missing-whitespace-between-attributes',
	    missingWhitespaceAfterDoctypePublicKeyword: 'missing-whitespace-after-doctype-public-keyword',
	    missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers:
	        'missing-whitespace-between-doctype-public-and-system-identifiers',
	    missingWhitespaceAfterDoctypeSystemKeyword: 'missing-whitespace-after-doctype-system-keyword',
	    missingQuoteBeforeDoctypePublicIdentifier: 'missing-quote-before-doctype-public-identifier',
	    missingQuoteBeforeDoctypeSystemIdentifier: 'missing-quote-before-doctype-system-identifier',
	    missingDoctypePublicIdentifier: 'missing-doctype-public-identifier',
	    missingDoctypeSystemIdentifier: 'missing-doctype-system-identifier',
	    abruptDoctypePublicIdentifier: 'abrupt-doctype-public-identifier',
	    abruptDoctypeSystemIdentifier: 'abrupt-doctype-system-identifier',
	    cdataInHtmlContent: 'cdata-in-html-content',
	    incorrectlyOpenedComment: 'incorrectly-opened-comment',
	    eofInScriptHtmlCommentLikeText: 'eof-in-script-html-comment-like-text',
	    eofInDoctype: 'eof-in-doctype',
	    nestedComment: 'nested-comment',
	    abruptClosingOfEmptyComment: 'abrupt-closing-of-empty-comment',
	    eofInComment: 'eof-in-comment',
	    incorrectlyClosedComment: 'incorrectly-closed-comment',
	    eofInCdata: 'eof-in-cdata',
	    absenceOfDigitsInNumericCharacterReference: 'absence-of-digits-in-numeric-character-reference',
	    nullCharacterReference: 'null-character-reference',
	    surrogateCharacterReference: 'surrogate-character-reference',
	    characterReferenceOutsideUnicodeRange: 'character-reference-outside-unicode-range',
	    controlCharacterReference: 'control-character-reference',
	    noncharacterCharacterReference: 'noncharacter-character-reference',
	    missingWhitespaceBeforeDoctypeName: 'missing-whitespace-before-doctype-name',
	    missingDoctypeName: 'missing-doctype-name',
	    invalidCharacterSequenceAfterDoctypeName: 'invalid-character-sequence-after-doctype-name',
	    duplicateAttribute: 'duplicate-attribute',
	    nonConformingDoctype: 'non-conforming-doctype',
	    missingDoctype: 'missing-doctype',
	    misplacedDoctype: 'misplaced-doctype',
	    endTagWithoutMatchingOpenElement: 'end-tag-without-matching-open-element',
	    closingOfElementWithOpenChildElements: 'closing-of-element-with-open-child-elements',
	    disallowedContentInNoscriptInHead: 'disallowed-content-in-noscript-in-head',
	    openElementsLeftAfterEof: 'open-elements-left-after-eof',
	    abandonedHeadElementChild: 'abandoned-head-element-child',
	    misplacedStartTagForHeadElement: 'misplaced-start-tag-for-head-element',
	    nestedNoscriptInHead: 'nested-noscript-in-head',
	    eofInElementThatCanContainOnlyText: 'eof-in-element-that-can-contain-only-text'
	};

	const unicode$2 = unicode$3;
	const ERR$2 = errorCodes;

	//Aliases
	const $$7 = unicode$2.CODE_POINTS;

	//Const
	const DEFAULT_BUFFER_WATERLINE = 1 << 16;

	//Preprocessor
	//NOTE: HTML input preprocessing
	//(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#preprocessing-the-input-stream)
	let Preprocessor$1 = class Preprocessor {
	    constructor() {
	        this.html = null;

	        this.pos = -1;
	        this.lastGapPos = -1;
	        this.lastCharPos = -1;

	        this.gapStack = [];

	        this.skipNextNewLine = false;

	        this.lastChunkWritten = false;
	        this.endOfChunkHit = false;
	        this.bufferWaterline = DEFAULT_BUFFER_WATERLINE;
	    }

	    _err() {
	        // NOTE: err reporting is noop by default. Enabled by mixin.
	    }

	    _addGap() {
	        this.gapStack.push(this.lastGapPos);
	        this.lastGapPos = this.pos;
	    }

	    _processSurrogate(cp) {
	        //NOTE: try to peek a surrogate pair
	        if (this.pos !== this.lastCharPos) {
	            const nextCp = this.html.charCodeAt(this.pos + 1);

	            if (unicode$2.isSurrogatePair(nextCp)) {
	                //NOTE: we have a surrogate pair. Peek pair character and recalculate code point.
	                this.pos++;

	                //NOTE: add gap that should be avoided during retreat
	                this._addGap();

	                return unicode$2.getSurrogatePairCodePoint(cp, nextCp);
	            }
	        }

	        //NOTE: we are at the end of a chunk, therefore we can't infer surrogate pair yet.
	        else if (!this.lastChunkWritten) {
	            this.endOfChunkHit = true;
	            return $$7.EOF;
	        }

	        //NOTE: isolated surrogate
	        this._err(ERR$2.surrogateInInputStream);

	        return cp;
	    }

	    dropParsedChunk() {
	        if (this.pos > this.bufferWaterline) {
	            this.lastCharPos -= this.pos;
	            this.html = this.html.substring(this.pos);
	            this.pos = 0;
	            this.lastGapPos = -1;
	            this.gapStack = [];
	        }
	    }

	    write(chunk, isLastChunk) {
	        if (this.html) {
	            this.html += chunk;
	        } else {
	            this.html = chunk;
	        }

	        this.lastCharPos = this.html.length - 1;
	        this.endOfChunkHit = false;
	        this.lastChunkWritten = isLastChunk;
	    }

	    insertHtmlAtCurrentPos(chunk) {
	        this.html = this.html.substring(0, this.pos + 1) + chunk + this.html.substring(this.pos + 1, this.html.length);

	        this.lastCharPos = this.html.length - 1;
	        this.endOfChunkHit = false;
	    }

	    advance() {
	        this.pos++;

	        if (this.pos > this.lastCharPos) {
	            this.endOfChunkHit = !this.lastChunkWritten;
	            return $$7.EOF;
	        }

	        let cp = this.html.charCodeAt(this.pos);

	        //NOTE: any U+000A LINE FEED (LF) characters that immediately follow a U+000D CARRIAGE RETURN (CR) character
	        //must be ignored.
	        if (this.skipNextNewLine && cp === $$7.LINE_FEED) {
	            this.skipNextNewLine = false;
	            this._addGap();
	            return this.advance();
	        }

	        //NOTE: all U+000D CARRIAGE RETURN (CR) characters must be converted to U+000A LINE FEED (LF) characters
	        if (cp === $$7.CARRIAGE_RETURN) {
	            this.skipNextNewLine = true;
	            return $$7.LINE_FEED;
	        }

	        this.skipNextNewLine = false;

	        if (unicode$2.isSurrogate(cp)) {
	            cp = this._processSurrogate(cp);
	        }

	        //OPTIMIZATION: first check if code point is in the common allowed
	        //range (ASCII alphanumeric, whitespaces, big chunk of BMP)
	        //before going into detailed performance cost validation.
	        const isCommonValidRange =
	            (cp > 0x1f && cp < 0x7f) || cp === $$7.LINE_FEED || cp === $$7.CARRIAGE_RETURN || (cp > 0x9f && cp < 0xfdd0);

	        if (!isCommonValidRange) {
	            this._checkForProblematicCharacters(cp);
	        }

	        return cp;
	    }

	    _checkForProblematicCharacters(cp) {
	        if (unicode$2.isControlCodePoint(cp)) {
	            this._err(ERR$2.controlCharacterInInputStream);
	        } else if (unicode$2.isUndefinedCodePoint(cp)) {
	            this._err(ERR$2.noncharacterInInputStream);
	        }
	    }

	    retreat() {
	        if (this.pos === this.lastGapPos) {
	            this.lastGapPos = this.gapStack.pop();
	            this.pos--;
	        }

	        this.pos--;
	    }
	};

	var preprocessor = Preprocessor$1;

	//NOTE: this file contains auto-generated array mapped radix tree that is used for the named entity references consumption
	//(details: https://github.com/inikulin/parse5/tree/master/scripts/generate-named-entity-data/README.md)
	var namedEntityData = new Uint16Array([4,52,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,106,303,412,810,1432,1701,1796,1987,2114,2360,2420,2484,3170,3251,4140,4393,4575,4610,5106,5512,5728,6117,6274,6315,6345,6427,6516,7002,7910,8733,9323,9870,10170,10631,10893,11318,11386,11467,12773,13092,14474,14922,15448,15542,16419,17666,18166,18611,19004,19095,19298,19397,4,16,69,77,97,98,99,102,103,108,109,110,111,112,114,115,116,117,140,150,158,169,176,194,199,210,216,222,226,242,256,266,283,294,108,105,103,5,198,1,59,148,1,198,80,5,38,1,59,156,1,38,99,117,116,101,5,193,1,59,167,1,193,114,101,118,101,59,1,258,4,2,105,121,182,191,114,99,5,194,1,59,189,1,194,59,1,1040,114,59,3,55349,56580,114,97,118,101,5,192,1,59,208,1,192,112,104,97,59,1,913,97,99,114,59,1,256,100,59,1,10835,4,2,103,112,232,237,111,110,59,1,260,102,59,3,55349,56632,112,108,121,70,117,110,99,116,105,111,110,59,1,8289,105,110,103,5,197,1,59,264,1,197,4,2,99,115,272,277,114,59,3,55349,56476,105,103,110,59,1,8788,105,108,100,101,5,195,1,59,292,1,195,109,108,5,196,1,59,301,1,196,4,8,97,99,101,102,111,114,115,117,321,350,354,383,388,394,400,405,4,2,99,114,327,336,107,115,108,97,115,104,59,1,8726,4,2,118,119,342,345,59,1,10983,101,100,59,1,8966,121,59,1,1041,4,3,99,114,116,362,369,379,97,117,115,101,59,1,8757,110,111,117,108,108,105,115,59,1,8492,97,59,1,914,114,59,3,55349,56581,112,102,59,3,55349,56633,101,118,101,59,1,728,99,114,59,1,8492,109,112,101,113,59,1,8782,4,14,72,79,97,99,100,101,102,104,105,108,111,114,115,117,442,447,456,504,542,547,569,573,577,616,678,784,790,796,99,121,59,1,1063,80,89,5,169,1,59,454,1,169,4,3,99,112,121,464,470,497,117,116,101,59,1,262,4,2,59,105,476,478,1,8914,116,97,108,68,105,102,102,101,114,101,110,116,105,97,108,68,59,1,8517,108,101,121,115,59,1,8493,4,4,97,101,105,111,514,520,530,535,114,111,110,59,1,268,100,105,108,5,199,1,59,528,1,199,114,99,59,1,264,110,105,110,116,59,1,8752,111,116,59,1,266,4,2,100,110,553,560,105,108,108,97,59,1,184,116,101,114,68,111,116,59,1,183,114,59,1,8493,105,59,1,935,114,99,108,101,4,4,68,77,80,84,591,596,603,609,111,116,59,1,8857,105,110,117,115,59,1,8854,108,117,115,59,1,8853,105,109,101,115,59,1,8855,111,4,2,99,115,623,646,107,119,105,115,101,67,111,110,116,111,117,114,73,110,116,101,103,114,97,108,59,1,8754,101,67,117,114,108,121,4,2,68,81,658,671,111,117,98,108,101,81,117,111,116,101,59,1,8221,117,111,116,101,59,1,8217,4,4,108,110,112,117,688,701,736,753,111,110,4,2,59,101,696,698,1,8759,59,1,10868,4,3,103,105,116,709,717,722,114,117,101,110,116,59,1,8801,110,116,59,1,8751,111,117,114,73,110,116,101,103,114,97,108,59,1,8750,4,2,102,114,742,745,59,1,8450,111,100,117,99,116,59,1,8720,110,116,101,114,67,108,111,99,107,119,105,115,101,67,111,110,116,111,117,114,73,110,116,101,103,114,97,108,59,1,8755,111,115,115,59,1,10799,99,114,59,3,55349,56478,112,4,2,59,67,803,805,1,8915,97,112,59,1,8781,4,11,68,74,83,90,97,99,101,102,105,111,115,834,850,855,860,865,888,903,916,921,1011,1415,4,2,59,111,840,842,1,8517,116,114,97,104,100,59,1,10513,99,121,59,1,1026,99,121,59,1,1029,99,121,59,1,1039,4,3,103,114,115,873,879,883,103,101,114,59,1,8225,114,59,1,8609,104,118,59,1,10980,4,2,97,121,894,900,114,111,110,59,1,270,59,1,1044,108,4,2,59,116,910,912,1,8711,97,59,1,916,114,59,3,55349,56583,4,2,97,102,927,998,4,2,99,109,933,992,114,105,116,105,99,97,108,4,4,65,68,71,84,950,957,978,985,99,117,116,101,59,1,180,111,4,2,116,117,964,967,59,1,729,98,108,101,65,99,117,116,101,59,1,733,114,97,118,101,59,1,96,105,108,100,101,59,1,732,111,110,100,59,1,8900,102,101,114,101,110,116,105,97,108,68,59,1,8518,4,4,112,116,117,119,1021,1026,1048,1249,102,59,3,55349,56635,4,3,59,68,69,1034,1036,1041,1,168,111,116,59,1,8412,113,117,97,108,59,1,8784,98,108,101,4,6,67,68,76,82,85,86,1065,1082,1101,1189,1211,1236,111,110,116,111,117,114,73,110,116,101,103,114,97,108,59,1,8751,111,4,2,116,119,1089,1092,59,1,168,110,65,114,114,111,119,59,1,8659,4,2,101,111,1107,1141,102,116,4,3,65,82,84,1117,1124,1136,114,114,111,119,59,1,8656,105,103,104,116,65,114,114,111,119,59,1,8660,101,101,59,1,10980,110,103,4,2,76,82,1149,1177,101,102,116,4,2,65,82,1158,1165,114,114,111,119,59,1,10232,105,103,104,116,65,114,114,111,119,59,1,10234,105,103,104,116,65,114,114,111,119,59,1,10233,105,103,104,116,4,2,65,84,1199,1206,114,114,111,119,59,1,8658,101,101,59,1,8872,112,4,2,65,68,1218,1225,114,114,111,119,59,1,8657,111,119,110,65,114,114,111,119,59,1,8661,101,114,116,105,99,97,108,66,97,114,59,1,8741,110,4,6,65,66,76,82,84,97,1264,1292,1299,1352,1391,1408,114,114,111,119,4,3,59,66,85,1276,1278,1283,1,8595,97,114,59,1,10515,112,65,114,114,111,119,59,1,8693,114,101,118,101,59,1,785,101,102,116,4,3,82,84,86,1310,1323,1334,105,103,104,116,86,101,99,116,111,114,59,1,10576,101,101,86,101,99,116,111,114,59,1,10590,101,99,116,111,114,4,2,59,66,1345,1347,1,8637,97,114,59,1,10582,105,103,104,116,4,2,84,86,1362,1373,101,101,86,101,99,116,111,114,59,1,10591,101,99,116,111,114,4,2,59,66,1384,1386,1,8641,97,114,59,1,10583,101,101,4,2,59,65,1399,1401,1,8868,114,114,111,119,59,1,8615,114,114,111,119,59,1,8659,4,2,99,116,1421,1426,114,59,3,55349,56479,114,111,107,59,1,272,4,16,78,84,97,99,100,102,103,108,109,111,112,113,115,116,117,120,1466,1470,1478,1489,1515,1520,1525,1536,1544,1593,1609,1617,1650,1664,1668,1677,71,59,1,330,72,5,208,1,59,1476,1,208,99,117,116,101,5,201,1,59,1487,1,201,4,3,97,105,121,1497,1503,1512,114,111,110,59,1,282,114,99,5,202,1,59,1510,1,202,59,1,1069,111,116,59,1,278,114,59,3,55349,56584,114,97,118,101,5,200,1,59,1534,1,200,101,109,101,110,116,59,1,8712,4,2,97,112,1550,1555,99,114,59,1,274,116,121,4,2,83,86,1563,1576,109,97,108,108,83,113,117,97,114,101,59,1,9723,101,114,121,83,109,97,108,108,83,113,117,97,114,101,59,1,9643,4,2,103,112,1599,1604,111,110,59,1,280,102,59,3,55349,56636,115,105,108,111,110,59,1,917,117,4,2,97,105,1624,1640,108,4,2,59,84,1631,1633,1,10869,105,108,100,101,59,1,8770,108,105,98,114,105,117,109,59,1,8652,4,2,99,105,1656,1660,114,59,1,8496,109,59,1,10867,97,59,1,919,109,108,5,203,1,59,1675,1,203,4,2,105,112,1683,1689,115,116,115,59,1,8707,111,110,101,110,116,105,97,108,69,59,1,8519,4,5,99,102,105,111,115,1713,1717,1722,1762,1791,121,59,1,1060,114,59,3,55349,56585,108,108,101,100,4,2,83,86,1732,1745,109,97,108,108,83,113,117,97,114,101,59,1,9724,101,114,121,83,109,97,108,108,83,113,117,97,114,101,59,1,9642,4,3,112,114,117,1770,1775,1781,102,59,3,55349,56637,65,108,108,59,1,8704,114,105,101,114,116,114,102,59,1,8497,99,114,59,1,8497,4,12,74,84,97,98,99,100,102,103,111,114,115,116,1822,1827,1834,1848,1855,1877,1882,1887,1890,1896,1978,1984,99,121,59,1,1027,5,62,1,59,1832,1,62,109,109,97,4,2,59,100,1843,1845,1,915,59,1,988,114,101,118,101,59,1,286,4,3,101,105,121,1863,1869,1874,100,105,108,59,1,290,114,99,59,1,284,59,1,1043,111,116,59,1,288,114,59,3,55349,56586,59,1,8921,112,102,59,3,55349,56638,101,97,116,101,114,4,6,69,70,71,76,83,84,1915,1933,1944,1953,1959,1971,113,117,97,108,4,2,59,76,1925,1927,1,8805,101,115,115,59,1,8923,117,108,108,69,113,117,97,108,59,1,8807,114,101,97,116,101,114,59,1,10914,101,115,115,59,1,8823,108,97,110,116,69,113,117,97,108,59,1,10878,105,108,100,101,59,1,8819,99,114,59,3,55349,56482,59,1,8811,4,8,65,97,99,102,105,111,115,117,2005,2012,2026,2032,2036,2049,2073,2089,82,68,99,121,59,1,1066,4,2,99,116,2018,2023,101,107,59,1,711,59,1,94,105,114,99,59,1,292,114,59,1,8460,108,98,101,114,116,83,112,97,99,101,59,1,8459,4,2,112,114,2055,2059,102,59,1,8461,105,122,111,110,116,97,108,76,105,110,101,59,1,9472,4,2,99,116,2079,2083,114,59,1,8459,114,111,107,59,1,294,109,112,4,2,68,69,2097,2107,111,119,110,72,117,109,112,59,1,8782,113,117,97,108,59,1,8783,4,14,69,74,79,97,99,100,102,103,109,110,111,115,116,117,2144,2149,2155,2160,2171,2189,2194,2198,2209,2245,2307,2329,2334,2341,99,121,59,1,1045,108,105,103,59,1,306,99,121,59,1,1025,99,117,116,101,5,205,1,59,2169,1,205,4,2,105,121,2177,2186,114,99,5,206,1,59,2184,1,206,59,1,1048,111,116,59,1,304,114,59,1,8465,114,97,118,101,5,204,1,59,2207,1,204,4,3,59,97,112,2217,2219,2238,1,8465,4,2,99,103,2225,2229,114,59,1,298,105,110,97,114,121,73,59,1,8520,108,105,101,115,59,1,8658,4,2,116,118,2251,2281,4,2,59,101,2257,2259,1,8748,4,2,103,114,2265,2271,114,97,108,59,1,8747,115,101,99,116,105,111,110,59,1,8898,105,115,105,98,108,101,4,2,67,84,2293,2300,111,109,109,97,59,1,8291,105,109,101,115,59,1,8290,4,3,103,112,116,2315,2320,2325,111,110,59,1,302,102,59,3,55349,56640,97,59,1,921,99,114,59,1,8464,105,108,100,101,59,1,296,4,2,107,109,2347,2352,99,121,59,1,1030,108,5,207,1,59,2358,1,207,4,5,99,102,111,115,117,2372,2386,2391,2397,2414,4,2,105,121,2378,2383,114,99,59,1,308,59,1,1049,114,59,3,55349,56589,112,102,59,3,55349,56641,4,2,99,101,2403,2408,114,59,3,55349,56485,114,99,121,59,1,1032,107,99,121,59,1,1028,4,7,72,74,97,99,102,111,115,2436,2441,2446,2452,2467,2472,2478,99,121,59,1,1061,99,121,59,1,1036,112,112,97,59,1,922,4,2,101,121,2458,2464,100,105,108,59,1,310,59,1,1050,114,59,3,55349,56590,112,102,59,3,55349,56642,99,114,59,3,55349,56486,4,11,74,84,97,99,101,102,108,109,111,115,116,2508,2513,2520,2562,2585,2981,2986,3004,3011,3146,3167,99,121,59,1,1033,5,60,1,59,2518,1,60,4,5,99,109,110,112,114,2532,2538,2544,2548,2558,117,116,101,59,1,313,98,100,97,59,1,923,103,59,1,10218,108,97,99,101,116,114,102,59,1,8466,114,59,1,8606,4,3,97,101,121,2570,2576,2582,114,111,110,59,1,317,100,105,108,59,1,315,59,1,1051,4,2,102,115,2591,2907,116,4,10,65,67,68,70,82,84,85,86,97,114,2614,2663,2672,2728,2735,2760,2820,2870,2888,2895,4,2,110,114,2620,2633,103,108,101,66,114,97,99,107,101,116,59,1,10216,114,111,119,4,3,59,66,82,2644,2646,2651,1,8592,97,114,59,1,8676,105,103,104,116,65,114,114,111,119,59,1,8646,101,105,108,105,110,103,59,1,8968,111,4,2,117,119,2679,2692,98,108,101,66,114,97,99,107,101,116,59,1,10214,110,4,2,84,86,2699,2710,101,101,86,101,99,116,111,114,59,1,10593,101,99,116,111,114,4,2,59,66,2721,2723,1,8643,97,114,59,1,10585,108,111,111,114,59,1,8970,105,103,104,116,4,2,65,86,2745,2752,114,114,111,119,59,1,8596,101,99,116,111,114,59,1,10574,4,2,101,114,2766,2792,101,4,3,59,65,86,2775,2777,2784,1,8867,114,114,111,119,59,1,8612,101,99,116,111,114,59,1,10586,105,97,110,103,108,101,4,3,59,66,69,2806,2808,2813,1,8882,97,114,59,1,10703,113,117,97,108,59,1,8884,112,4,3,68,84,86,2829,2841,2852,111,119,110,86,101,99,116,111,114,59,1,10577,101,101,86,101,99,116,111,114,59,1,10592,101,99,116,111,114,4,2,59,66,2863,2865,1,8639,97,114,59,1,10584,101,99,116,111,114,4,2,59,66,2881,2883,1,8636,97,114,59,1,10578,114,114,111,119,59,1,8656,105,103,104,116,97,114,114,111,119,59,1,8660,115,4,6,69,70,71,76,83,84,2922,2936,2947,2956,2962,2974,113,117,97,108,71,114,101,97,116,101,114,59,1,8922,117,108,108,69,113,117,97,108,59,1,8806,114,101,97,116,101,114,59,1,8822,101,115,115,59,1,10913,108,97,110,116,69,113,117,97,108,59,1,10877,105,108,100,101,59,1,8818,114,59,3,55349,56591,4,2,59,101,2992,2994,1,8920,102,116,97,114,114,111,119,59,1,8666,105,100,111,116,59,1,319,4,3,110,112,119,3019,3110,3115,103,4,4,76,82,108,114,3030,3058,3070,3098,101,102,116,4,2,65,82,3039,3046,114,114,111,119,59,1,10229,105,103,104,116,65,114,114,111,119,59,1,10231,105,103,104,116,65,114,114,111,119,59,1,10230,101,102,116,4,2,97,114,3079,3086,114,114,111,119,59,1,10232,105,103,104,116,97,114,114,111,119,59,1,10234,105,103,104,116,97,114,114,111,119,59,1,10233,102,59,3,55349,56643,101,114,4,2,76,82,3123,3134,101,102,116,65,114,114,111,119,59,1,8601,105,103,104,116,65,114,114,111,119,59,1,8600,4,3,99,104,116,3154,3158,3161,114,59,1,8466,59,1,8624,114,111,107,59,1,321,59,1,8810,4,8,97,99,101,102,105,111,115,117,3188,3192,3196,3222,3227,3237,3243,3248,112,59,1,10501,121,59,1,1052,4,2,100,108,3202,3213,105,117,109,83,112,97,99,101,59,1,8287,108,105,110,116,114,102,59,1,8499,114,59,3,55349,56592,110,117,115,80,108,117,115,59,1,8723,112,102,59,3,55349,56644,99,114,59,1,8499,59,1,924,4,9,74,97,99,101,102,111,115,116,117,3271,3276,3283,3306,3422,3427,4120,4126,4137,99,121,59,1,1034,99,117,116,101,59,1,323,4,3,97,101,121,3291,3297,3303,114,111,110,59,1,327,100,105,108,59,1,325,59,1,1053,4,3,103,115,119,3314,3380,3415,97,116,105,118,101,4,3,77,84,86,3327,3340,3365,101,100,105,117,109,83,112,97,99,101,59,1,8203,104,105,4,2,99,110,3348,3357,107,83,112,97,99,101,59,1,8203,83,112,97,99,101,59,1,8203,101,114,121,84,104,105,110,83,112,97,99,101,59,1,8203,116,101,100,4,2,71,76,3389,3405,114,101,97,116,101,114,71,114,101,97,116,101,114,59,1,8811,101,115,115,76,101,115,115,59,1,8810,76,105,110,101,59,1,10,114,59,3,55349,56593,4,4,66,110,112,116,3437,3444,3460,3464,114,101,97,107,59,1,8288,66,114,101,97,107,105,110,103,83,112,97,99,101,59,1,160,102,59,1,8469,4,13,59,67,68,69,71,72,76,78,80,82,83,84,86,3492,3494,3517,3536,3578,3657,3685,3784,3823,3860,3915,4066,4107,1,10988,4,2,111,117,3500,3510,110,103,114,117,101,110,116,59,1,8802,112,67,97,112,59,1,8813,111,117,98,108,101,86,101,114,116,105,99,97,108,66,97,114,59,1,8742,4,3,108,113,120,3544,3552,3571,101,109,101,110,116,59,1,8713,117,97,108,4,2,59,84,3561,3563,1,8800,105,108,100,101,59,3,8770,824,105,115,116,115,59,1,8708,114,101,97,116,101,114,4,7,59,69,70,71,76,83,84,3600,3602,3609,3621,3631,3637,3650,1,8815,113,117,97,108,59,1,8817,117,108,108,69,113,117,97,108,59,3,8807,824,114,101,97,116,101,114,59,3,8811,824,101,115,115,59,1,8825,108,97,110,116,69,113,117,97,108,59,3,10878,824,105,108,100,101,59,1,8821,117,109,112,4,2,68,69,3666,3677,111,119,110,72,117,109,112,59,3,8782,824,113,117,97,108,59,3,8783,824,101,4,2,102,115,3692,3724,116,84,114,105,97,110,103,108,101,4,3,59,66,69,3709,3711,3717,1,8938,97,114,59,3,10703,824,113,117,97,108,59,1,8940,115,4,6,59,69,71,76,83,84,3739,3741,3748,3757,3764,3777,1,8814,113,117,97,108,59,1,8816,114,101,97,116,101,114,59,1,8824,101,115,115,59,3,8810,824,108,97,110,116,69,113,117,97,108,59,3,10877,824,105,108,100,101,59,1,8820,101,115,116,101,100,4,2,71,76,3795,3812,114,101,97,116,101,114,71,114,101,97,116,101,114,59,3,10914,824,101,115,115,76,101,115,115,59,3,10913,824,114,101,99,101,100,101,115,4,3,59,69,83,3838,3840,3848,1,8832,113,117,97,108,59,3,10927,824,108,97,110,116,69,113,117,97,108,59,1,8928,4,2,101,105,3866,3881,118,101,114,115,101,69,108,101,109,101,110,116,59,1,8716,103,104,116,84,114,105,97,110,103,108,101,4,3,59,66,69,3900,3902,3908,1,8939,97,114,59,3,10704,824,113,117,97,108,59,1,8941,4,2,113,117,3921,3973,117,97,114,101,83,117,4,2,98,112,3933,3952,115,101,116,4,2,59,69,3942,3945,3,8847,824,113,117,97,108,59,1,8930,101,114,115,101,116,4,2,59,69,3963,3966,3,8848,824,113,117,97,108,59,1,8931,4,3,98,99,112,3981,4000,4045,115,101,116,4,2,59,69,3990,3993,3,8834,8402,113,117,97,108,59,1,8840,99,101,101,100,115,4,4,59,69,83,84,4015,4017,4025,4037,1,8833,113,117,97,108,59,3,10928,824,108,97,110,116,69,113,117,97,108,59,1,8929,105,108,100,101,59,3,8831,824,101,114,115,101,116,4,2,59,69,4056,4059,3,8835,8402,113,117,97,108,59,1,8841,105,108,100,101,4,4,59,69,70,84,4080,4082,4089,4100,1,8769,113,117,97,108,59,1,8772,117,108,108,69,113,117,97,108,59,1,8775,105,108,100,101,59,1,8777,101,114,116,105,99,97,108,66,97,114,59,1,8740,99,114,59,3,55349,56489,105,108,100,101,5,209,1,59,4135,1,209,59,1,925,4,14,69,97,99,100,102,103,109,111,112,114,115,116,117,118,4170,4176,4187,4205,4212,4217,4228,4253,4259,4292,4295,4316,4337,4346,108,105,103,59,1,338,99,117,116,101,5,211,1,59,4185,1,211,4,2,105,121,4193,4202,114,99,5,212,1,59,4200,1,212,59,1,1054,98,108,97,99,59,1,336,114,59,3,55349,56594,114,97,118,101,5,210,1,59,4226,1,210,4,3,97,101,105,4236,4241,4246,99,114,59,1,332,103,97,59,1,937,99,114,111,110,59,1,927,112,102,59,3,55349,56646,101,110,67,117,114,108,121,4,2,68,81,4272,4285,111,117,98,108,101,81,117,111,116,101,59,1,8220,117,111,116,101,59,1,8216,59,1,10836,4,2,99,108,4301,4306,114,59,3,55349,56490,97,115,104,5,216,1,59,4314,1,216,105,4,2,108,109,4323,4332,100,101,5,213,1,59,4330,1,213,101,115,59,1,10807,109,108,5,214,1,59,4344,1,214,101,114,4,2,66,80,4354,4380,4,2,97,114,4360,4364,114,59,1,8254,97,99,4,2,101,107,4372,4375,59,1,9182,101,116,59,1,9140,97,114,101,110,116,104,101,115,105,115,59,1,9180,4,9,97,99,102,104,105,108,111,114,115,4413,4422,4426,4431,4435,4438,4448,4471,4561,114,116,105,97,108,68,59,1,8706,121,59,1,1055,114,59,3,55349,56595,105,59,1,934,59,1,928,117,115,77,105,110,117,115,59,1,177,4,2,105,112,4454,4467,110,99,97,114,101,112,108,97,110,101,59,1,8460,102,59,1,8473,4,4,59,101,105,111,4481,4483,4526,4531,1,10939,99,101,100,101,115,4,4,59,69,83,84,4498,4500,4507,4519,1,8826,113,117,97,108,59,1,10927,108,97,110,116,69,113,117,97,108,59,1,8828,105,108,100,101,59,1,8830,109,101,59,1,8243,4,2,100,112,4537,4543,117,99,116,59,1,8719,111,114,116,105,111,110,4,2,59,97,4555,4557,1,8759,108,59,1,8733,4,2,99,105,4567,4572,114,59,3,55349,56491,59,1,936,4,4,85,102,111,115,4585,4594,4599,4604,79,84,5,34,1,59,4592,1,34,114,59,3,55349,56596,112,102,59,1,8474,99,114,59,3,55349,56492,4,12,66,69,97,99,101,102,104,105,111,114,115,117,4636,4642,4650,4681,4704,4763,4767,4771,5047,5069,5081,5094,97,114,114,59,1,10512,71,5,174,1,59,4648,1,174,4,3,99,110,114,4658,4664,4668,117,116,101,59,1,340,103,59,1,10219,114,4,2,59,116,4675,4677,1,8608,108,59,1,10518,4,3,97,101,121,4689,4695,4701,114,111,110,59,1,344,100,105,108,59,1,342,59,1,1056,4,2,59,118,4710,4712,1,8476,101,114,115,101,4,2,69,85,4722,4748,4,2,108,113,4728,4736,101,109,101,110,116,59,1,8715,117,105,108,105,98,114,105,117,109,59,1,8651,112,69,113,117,105,108,105,98,114,105,117,109,59,1,10607,114,59,1,8476,111,59,1,929,103,104,116,4,8,65,67,68,70,84,85,86,97,4792,4840,4849,4905,4912,4972,5022,5040,4,2,110,114,4798,4811,103,108,101,66,114,97,99,107,101,116,59,1,10217,114,111,119,4,3,59,66,76,4822,4824,4829,1,8594,97,114,59,1,8677,101,102,116,65,114,114,111,119,59,1,8644,101,105,108,105,110,103,59,1,8969,111,4,2,117,119,4856,4869,98,108,101,66,114,97,99,107,101,116,59,1,10215,110,4,2,84,86,4876,4887,101,101,86,101,99,116,111,114,59,1,10589,101,99,116,111,114,4,2,59,66,4898,4900,1,8642,97,114,59,1,10581,108,111,111,114,59,1,8971,4,2,101,114,4918,4944,101,4,3,59,65,86,4927,4929,4936,1,8866,114,114,111,119,59,1,8614,101,99,116,111,114,59,1,10587,105,97,110,103,108,101,4,3,59,66,69,4958,4960,4965,1,8883,97,114,59,1,10704,113,117,97,108,59,1,8885,112,4,3,68,84,86,4981,4993,5004,111,119,110,86,101,99,116,111,114,59,1,10575,101,101,86,101,99,116,111,114,59,1,10588,101,99,116,111,114,4,2,59,66,5015,5017,1,8638,97,114,59,1,10580,101,99,116,111,114,4,2,59,66,5033,5035,1,8640,97,114,59,1,10579,114,114,111,119,59,1,8658,4,2,112,117,5053,5057,102,59,1,8477,110,100,73,109,112,108,105,101,115,59,1,10608,105,103,104,116,97,114,114,111,119,59,1,8667,4,2,99,104,5087,5091,114,59,1,8475,59,1,8625,108,101,68,101,108,97,121,101,100,59,1,10740,4,13,72,79,97,99,102,104,105,109,111,113,115,116,117,5134,5150,5157,5164,5198,5203,5259,5265,5277,5283,5374,5380,5385,4,2,67,99,5140,5146,72,99,121,59,1,1065,121,59,1,1064,70,84,99,121,59,1,1068,99,117,116,101,59,1,346,4,5,59,97,101,105,121,5176,5178,5184,5190,5195,1,10940,114,111,110,59,1,352,100,105,108,59,1,350,114,99,59,1,348,59,1,1057,114,59,3,55349,56598,111,114,116,4,4,68,76,82,85,5216,5227,5238,5250,111,119,110,65,114,114,111,119,59,1,8595,101,102,116,65,114,114,111,119,59,1,8592,105,103,104,116,65,114,114,111,119,59,1,8594,112,65,114,114,111,119,59,1,8593,103,109,97,59,1,931,97,108,108,67,105,114,99,108,101,59,1,8728,112,102,59,3,55349,56650,4,2,114,117,5289,5293,116,59,1,8730,97,114,101,4,4,59,73,83,85,5306,5308,5322,5367,1,9633,110,116,101,114,115,101,99,116,105,111,110,59,1,8851,117,4,2,98,112,5329,5347,115,101,116,4,2,59,69,5338,5340,1,8847,113,117,97,108,59,1,8849,101,114,115,101,116,4,2,59,69,5358,5360,1,8848,113,117,97,108,59,1,8850,110,105,111,110,59,1,8852,99,114,59,3,55349,56494,97,114,59,1,8902,4,4,98,99,109,112,5395,5420,5475,5478,4,2,59,115,5401,5403,1,8912,101,116,4,2,59,69,5411,5413,1,8912,113,117,97,108,59,1,8838,4,2,99,104,5426,5468,101,101,100,115,4,4,59,69,83,84,5440,5442,5449,5461,1,8827,113,117,97,108,59,1,10928,108,97,110,116,69,113,117,97,108,59,1,8829,105,108,100,101,59,1,8831,84,104,97,116,59,1,8715,59,1,8721,4,3,59,101,115,5486,5488,5507,1,8913,114,115,101,116,4,2,59,69,5498,5500,1,8835,113,117,97,108,59,1,8839,101,116,59,1,8913,4,11,72,82,83,97,99,102,104,105,111,114,115,5536,5546,5552,5567,5579,5602,5607,5655,5695,5701,5711,79,82,78,5,222,1,59,5544,1,222,65,68,69,59,1,8482,4,2,72,99,5558,5563,99,121,59,1,1035,121,59,1,1062,4,2,98,117,5573,5576,59,1,9,59,1,932,4,3,97,101,121,5587,5593,5599,114,111,110,59,1,356,100,105,108,59,1,354,59,1,1058,114,59,3,55349,56599,4,2,101,105,5613,5631,4,2,114,116,5619,5627,101,102,111,114,101,59,1,8756,97,59,1,920,4,2,99,110,5637,5647,107,83,112,97,99,101,59,3,8287,8202,83,112,97,99,101,59,1,8201,108,100,101,4,4,59,69,70,84,5668,5670,5677,5688,1,8764,113,117,97,108,59,1,8771,117,108,108,69,113,117,97,108,59,1,8773,105,108,100,101,59,1,8776,112,102,59,3,55349,56651,105,112,108,101,68,111,116,59,1,8411,4,2,99,116,5717,5722,114,59,3,55349,56495,114,111,107,59,1,358,4,14,97,98,99,100,102,103,109,110,111,112,114,115,116,117,5758,5789,5805,5823,5830,5835,5846,5852,5921,5937,6089,6095,6101,6108,4,2,99,114,5764,5774,117,116,101,5,218,1,59,5772,1,218,114,4,2,59,111,5781,5783,1,8607,99,105,114,59,1,10569,114,4,2,99,101,5796,5800,121,59,1,1038,118,101,59,1,364,4,2,105,121,5811,5820,114,99,5,219,1,59,5818,1,219,59,1,1059,98,108,97,99,59,1,368,114,59,3,55349,56600,114,97,118,101,5,217,1,59,5844,1,217,97,99,114,59,1,362,4,2,100,105,5858,5905,101,114,4,2,66,80,5866,5892,4,2,97,114,5872,5876,114,59,1,95,97,99,4,2,101,107,5884,5887,59,1,9183,101,116,59,1,9141,97,114,101,110,116,104,101,115,105,115,59,1,9181,111,110,4,2,59,80,5913,5915,1,8899,108,117,115,59,1,8846,4,2,103,112,5927,5932,111,110,59,1,370,102,59,3,55349,56652,4,8,65,68,69,84,97,100,112,115,5955,5985,5996,6009,6026,6033,6044,6075,114,114,111,119,4,3,59,66,68,5967,5969,5974,1,8593,97,114,59,1,10514,111,119,110,65,114,114,111,119,59,1,8645,111,119,110,65,114,114,111,119,59,1,8597,113,117,105,108,105,98,114,105,117,109,59,1,10606,101,101,4,2,59,65,6017,6019,1,8869,114,114,111,119,59,1,8613,114,114,111,119,59,1,8657,111,119,110,97,114,114,111,119,59,1,8661,101,114,4,2,76,82,6052,6063,101,102,116,65,114,114,111,119,59,1,8598,105,103,104,116,65,114,114,111,119,59,1,8599,105,4,2,59,108,6082,6084,1,978,111,110,59,1,933,105,110,103,59,1,366,99,114,59,3,55349,56496,105,108,100,101,59,1,360,109,108,5,220,1,59,6115,1,220,4,9,68,98,99,100,101,102,111,115,118,6137,6143,6148,6152,6166,6250,6255,6261,6267,97,115,104,59,1,8875,97,114,59,1,10987,121,59,1,1042,97,115,104,4,2,59,108,6161,6163,1,8873,59,1,10982,4,2,101,114,6172,6175,59,1,8897,4,3,98,116,121,6183,6188,6238,97,114,59,1,8214,4,2,59,105,6194,6196,1,8214,99,97,108,4,4,66,76,83,84,6209,6214,6220,6231,97,114,59,1,8739,105,110,101,59,1,124,101,112,97,114,97,116,111,114,59,1,10072,105,108,100,101,59,1,8768,84,104,105,110,83,112,97,99,101,59,1,8202,114,59,3,55349,56601,112,102,59,3,55349,56653,99,114,59,3,55349,56497,100,97,115,104,59,1,8874,4,5,99,101,102,111,115,6286,6292,6298,6303,6309,105,114,99,59,1,372,100,103,101,59,1,8896,114,59,3,55349,56602,112,102,59,3,55349,56654,99,114,59,3,55349,56498,4,4,102,105,111,115,6325,6330,6333,6339,114,59,3,55349,56603,59,1,926,112,102,59,3,55349,56655,99,114,59,3,55349,56499,4,9,65,73,85,97,99,102,111,115,117,6365,6370,6375,6380,6391,6405,6410,6416,6422,99,121,59,1,1071,99,121,59,1,1031,99,121,59,1,1070,99,117,116,101,5,221,1,59,6389,1,221,4,2,105,121,6397,6402,114,99,59,1,374,59,1,1067,114,59,3,55349,56604,112,102,59,3,55349,56656,99,114,59,3,55349,56500,109,108,59,1,376,4,8,72,97,99,100,101,102,111,115,6445,6450,6457,6472,6477,6501,6505,6510,99,121,59,1,1046,99,117,116,101,59,1,377,4,2,97,121,6463,6469,114,111,110,59,1,381,59,1,1047,111,116,59,1,379,4,2,114,116,6483,6497,111,87,105,100,116,104,83,112,97,99,101,59,1,8203,97,59,1,918,114,59,1,8488,112,102,59,1,8484,99,114,59,3,55349,56501,4,16,97,98,99,101,102,103,108,109,110,111,112,114,115,116,117,119,6550,6561,6568,6612,6622,6634,6645,6672,6699,6854,6870,6923,6933,6963,6974,6983,99,117,116,101,5,225,1,59,6559,1,225,114,101,118,101,59,1,259,4,6,59,69,100,105,117,121,6582,6584,6588,6591,6600,6609,1,8766,59,3,8766,819,59,1,8767,114,99,5,226,1,59,6598,1,226,116,101,5,180,1,59,6607,1,180,59,1,1072,108,105,103,5,230,1,59,6620,1,230,4,2,59,114,6628,6630,1,8289,59,3,55349,56606,114,97,118,101,5,224,1,59,6643,1,224,4,2,101,112,6651,6667,4,2,102,112,6657,6663,115,121,109,59,1,8501,104,59,1,8501,104,97,59,1,945,4,2,97,112,6678,6692,4,2,99,108,6684,6688,114,59,1,257,103,59,1,10815,5,38,1,59,6697,1,38,4,2,100,103,6705,6737,4,5,59,97,100,115,118,6717,6719,6724,6727,6734,1,8743,110,100,59,1,10837,59,1,10844,108,111,112,101,59,1,10840,59,1,10842,4,7,59,101,108,109,114,115,122,6753,6755,6758,6762,6814,6835,6848,1,8736,59,1,10660,101,59,1,8736,115,100,4,2,59,97,6770,6772,1,8737,4,8,97,98,99,100,101,102,103,104,6790,6793,6796,6799,6802,6805,6808,6811,59,1,10664,59,1,10665,59,1,10666,59,1,10667,59,1,10668,59,1,10669,59,1,10670,59,1,10671,116,4,2,59,118,6821,6823,1,8735,98,4,2,59,100,6830,6832,1,8894,59,1,10653,4,2,112,116,6841,6845,104,59,1,8738,59,1,197,97,114,114,59,1,9084,4,2,103,112,6860,6865,111,110,59,1,261,102,59,3,55349,56658,4,7,59,69,97,101,105,111,112,6886,6888,6891,6897,6900,6904,6908,1,8776,59,1,10864,99,105,114,59,1,10863,59,1,8778,100,59,1,8779,115,59,1,39,114,111,120,4,2,59,101,6917,6919,1,8776,113,59,1,8778,105,110,103,5,229,1,59,6931,1,229,4,3,99,116,121,6941,6946,6949,114,59,3,55349,56502,59,1,42,109,112,4,2,59,101,6957,6959,1,8776,113,59,1,8781,105,108,100,101,5,227,1,59,6972,1,227,109,108,5,228,1,59,6981,1,228,4,2,99,105,6989,6997,111,110,105,110,116,59,1,8755,110,116,59,1,10769,4,16,78,97,98,99,100,101,102,105,107,108,110,111,112,114,115,117,7036,7041,7119,7135,7149,7155,7219,7224,7347,7354,7463,7489,7786,7793,7814,7866,111,116,59,1,10989,4,2,99,114,7047,7094,107,4,4,99,101,112,115,7058,7064,7073,7080,111,110,103,59,1,8780,112,115,105,108,111,110,59,1,1014,114,105,109,101,59,1,8245,105,109,4,2,59,101,7088,7090,1,8765,113,59,1,8909,4,2,118,119,7100,7105,101,101,59,1,8893,101,100,4,2,59,103,7113,7115,1,8965,101,59,1,8965,114,107,4,2,59,116,7127,7129,1,9141,98,114,107,59,1,9142,4,2,111,121,7141,7146,110,103,59,1,8780,59,1,1073,113,117,111,59,1,8222,4,5,99,109,112,114,116,7167,7181,7188,7193,7199,97,117,115,4,2,59,101,7176,7178,1,8757,59,1,8757,112,116,121,118,59,1,10672,115,105,59,1,1014,110,111,117,59,1,8492,4,3,97,104,119,7207,7210,7213,59,1,946,59,1,8502,101,101,110,59,1,8812,114,59,3,55349,56607,103,4,7,99,111,115,116,117,118,119,7241,7262,7288,7305,7328,7335,7340,4,3,97,105,117,7249,7253,7258,112,59,1,8898,114,99,59,1,9711,112,59,1,8899,4,3,100,112,116,7270,7275,7281,111,116,59,1,10752,108,117,115,59,1,10753,105,109,101,115,59,1,10754,4,2,113,116,7294,7300,99,117,112,59,1,10758,97,114,59,1,9733,114,105,97,110,103,108,101,4,2,100,117,7318,7324,111,119,110,59,1,9661,112,59,1,9651,112,108,117,115,59,1,10756,101,101,59,1,8897,101,100,103,101,59,1,8896,97,114,111,119,59,1,10509,4,3,97,107,111,7362,7436,7458,4,2,99,110,7368,7432,107,4,3,108,115,116,7377,7386,7394,111,122,101,110,103,101,59,1,10731,113,117,97,114,101,59,1,9642,114,105,97,110,103,108,101,4,4,59,100,108,114,7411,7413,7419,7425,1,9652,111,119,110,59,1,9662,101,102,116,59,1,9666,105,103,104,116,59,1,9656,107,59,1,9251,4,2,49,51,7442,7454,4,2,50,52,7448,7451,59,1,9618,59,1,9617,52,59,1,9619,99,107,59,1,9608,4,2,101,111,7469,7485,4,2,59,113,7475,7478,3,61,8421,117,105,118,59,3,8801,8421,116,59,1,8976,4,4,112,116,119,120,7499,7504,7517,7523,102,59,3,55349,56659,4,2,59,116,7510,7512,1,8869,111,109,59,1,8869,116,105,101,59,1,8904,4,12,68,72,85,86,98,100,104,109,112,116,117,118,7549,7571,7597,7619,7655,7660,7682,7708,7715,7721,7728,7750,4,4,76,82,108,114,7559,7562,7565,7568,59,1,9559,59,1,9556,59,1,9558,59,1,9555,4,5,59,68,85,100,117,7583,7585,7588,7591,7594,1,9552,59,1,9574,59,1,9577,59,1,9572,59,1,9575,4,4,76,82,108,114,7607,7610,7613,7616,59,1,9565,59,1,9562,59,1,9564,59,1,9561,4,7,59,72,76,82,104,108,114,7635,7637,7640,7643,7646,7649,7652,1,9553,59,1,9580,59,1,9571,59,1,9568,59,1,9579,59,1,9570,59,1,9567,111,120,59,1,10697,4,4,76,82,108,114,7670,7673,7676,7679,59,1,9557,59,1,9554,59,1,9488,59,1,9484,4,5,59,68,85,100,117,7694,7696,7699,7702,7705,1,9472,59,1,9573,59,1,9576,59,1,9516,59,1,9524,105,110,117,115,59,1,8863,108,117,115,59,1,8862,105,109,101,115,59,1,8864,4,4,76,82,108,114,7738,7741,7744,7747,59,1,9563,59,1,9560,59,1,9496,59,1,9492,4,7,59,72,76,82,104,108,114,7766,7768,7771,7774,7777,7780,7783,1,9474,59,1,9578,59,1,9569,59,1,9566,59,1,9532,59,1,9508,59,1,9500,114,105,109,101,59,1,8245,4,2,101,118,7799,7804,118,101,59,1,728,98,97,114,5,166,1,59,7812,1,166,4,4,99,101,105,111,7824,7829,7834,7846,114,59,3,55349,56503,109,105,59,1,8271,109,4,2,59,101,7841,7843,1,8765,59,1,8909,108,4,3,59,98,104,7855,7857,7860,1,92,59,1,10693,115,117,98,59,1,10184,4,2,108,109,7872,7885,108,4,2,59,101,7879,7881,1,8226,116,59,1,8226,112,4,3,59,69,101,7894,7896,7899,1,8782,59,1,10926,4,2,59,113,7905,7907,1,8783,59,1,8783,4,15,97,99,100,101,102,104,105,108,111,114,115,116,117,119,121,7942,8021,8075,8080,8121,8126,8157,8279,8295,8430,8446,8485,8491,8707,8726,4,3,99,112,114,7950,7956,8007,117,116,101,59,1,263,4,6,59,97,98,99,100,115,7970,7972,7977,7984,7998,8003,1,8745,110,100,59,1,10820,114,99,117,112,59,1,10825,4,2,97,117,7990,7994,112,59,1,10827,112,59,1,10823,111,116,59,1,10816,59,3,8745,65024,4,2,101,111,8013,8017,116,59,1,8257,110,59,1,711,4,4,97,101,105,117,8031,8046,8056,8061,4,2,112,114,8037,8041,115,59,1,10829,111,110,59,1,269,100,105,108,5,231,1,59,8054,1,231,114,99,59,1,265,112,115,4,2,59,115,8069,8071,1,10828,109,59,1,10832,111,116,59,1,267,4,3,100,109,110,8088,8097,8104,105,108,5,184,1,59,8095,1,184,112,116,121,118,59,1,10674,116,5,162,2,59,101,8112,8114,1,162,114,100,111,116,59,1,183,114,59,3,55349,56608,4,3,99,101,105,8134,8138,8154,121,59,1,1095,99,107,4,2,59,109,8146,8148,1,10003,97,114,107,59,1,10003,59,1,967,114,4,7,59,69,99,101,102,109,115,8174,8176,8179,8258,8261,8268,8273,1,9675,59,1,10691,4,3,59,101,108,8187,8189,8193,1,710,113,59,1,8791,101,4,2,97,100,8200,8223,114,114,111,119,4,2,108,114,8210,8216,101,102,116,59,1,8634,105,103,104,116,59,1,8635,4,5,82,83,97,99,100,8235,8238,8241,8246,8252,59,1,174,59,1,9416,115,116,59,1,8859,105,114,99,59,1,8858,97,115,104,59,1,8861,59,1,8791,110,105,110,116,59,1,10768,105,100,59,1,10991,99,105,114,59,1,10690,117,98,115,4,2,59,117,8288,8290,1,9827,105,116,59,1,9827,4,4,108,109,110,112,8305,8326,8376,8400,111,110,4,2,59,101,8313,8315,1,58,4,2,59,113,8321,8323,1,8788,59,1,8788,4,2,109,112,8332,8344,97,4,2,59,116,8339,8341,1,44,59,1,64,4,3,59,102,108,8352,8354,8358,1,8705,110,59,1,8728,101,4,2,109,120,8365,8371,101,110,116,59,1,8705,101,115,59,1,8450,4,2,103,105,8382,8395,4,2,59,100,8388,8390,1,8773,111,116,59,1,10861,110,116,59,1,8750,4,3,102,114,121,8408,8412,8417,59,3,55349,56660,111,100,59,1,8720,5,169,2,59,115,8424,8426,1,169,114,59,1,8471,4,2,97,111,8436,8441,114,114,59,1,8629,115,115,59,1,10007,4,2,99,117,8452,8457,114,59,3,55349,56504,4,2,98,112,8463,8474,4,2,59,101,8469,8471,1,10959,59,1,10961,4,2,59,101,8480,8482,1,10960,59,1,10962,100,111,116,59,1,8943,4,7,100,101,108,112,114,118,119,8507,8522,8536,8550,8600,8697,8702,97,114,114,4,2,108,114,8516,8519,59,1,10552,59,1,10549,4,2,112,115,8528,8532,114,59,1,8926,99,59,1,8927,97,114,114,4,2,59,112,8545,8547,1,8630,59,1,10557,4,6,59,98,99,100,111,115,8564,8566,8573,8587,8592,8596,1,8746,114,99,97,112,59,1,10824,4,2,97,117,8579,8583,112,59,1,10822,112,59,1,10826,111,116,59,1,8845,114,59,1,10821,59,3,8746,65024,4,4,97,108,114,118,8610,8623,8663,8672,114,114,4,2,59,109,8618,8620,1,8631,59,1,10556,121,4,3,101,118,119,8632,8651,8656,113,4,2,112,115,8639,8645,114,101,99,59,1,8926,117,99,99,59,1,8927,101,101,59,1,8910,101,100,103,101,59,1,8911,101,110,5,164,1,59,8670,1,164,101,97,114,114,111,119,4,2,108,114,8684,8690,101,102,116,59,1,8630,105,103,104,116,59,1,8631,101,101,59,1,8910,101,100,59,1,8911,4,2,99,105,8713,8721,111,110,105,110,116,59,1,8754,110,116,59,1,8753,108,99,116,121,59,1,9005,4,19,65,72,97,98,99,100,101,102,104,105,106,108,111,114,115,116,117,119,122,8773,8778,8783,8821,8839,8854,8887,8914,8930,8944,9036,9041,9058,9197,9227,9258,9281,9297,9305,114,114,59,1,8659,97,114,59,1,10597,4,4,103,108,114,115,8793,8799,8805,8809,103,101,114,59,1,8224,101,116,104,59,1,8504,114,59,1,8595,104,4,2,59,118,8816,8818,1,8208,59,1,8867,4,2,107,108,8827,8834,97,114,111,119,59,1,10511,97,99,59,1,733,4,2,97,121,8845,8851,114,111,110,59,1,271,59,1,1076,4,3,59,97,111,8862,8864,8880,1,8518,4,2,103,114,8870,8876,103,101,114,59,1,8225,114,59,1,8650,116,115,101,113,59,1,10871,4,3,103,108,109,8895,8902,8907,5,176,1,59,8900,1,176,116,97,59,1,948,112,116,121,118,59,1,10673,4,2,105,114,8920,8926,115,104,116,59,1,10623,59,3,55349,56609,97,114,4,2,108,114,8938,8941,59,1,8643,59,1,8642,4,5,97,101,103,115,118,8956,8986,8989,8996,9001,109,4,3,59,111,115,8965,8967,8983,1,8900,110,100,4,2,59,115,8975,8977,1,8900,117,105,116,59,1,9830,59,1,9830,59,1,168,97,109,109,97,59,1,989,105,110,59,1,8946,4,3,59,105,111,9009,9011,9031,1,247,100,101,5,247,2,59,111,9020,9022,1,247,110,116,105,109,101,115,59,1,8903,110,120,59,1,8903,99,121,59,1,1106,99,4,2,111,114,9048,9053,114,110,59,1,8990,111,112,59,1,8973,4,5,108,112,116,117,119,9070,9076,9081,9130,9144,108,97,114,59,1,36,102,59,3,55349,56661,4,5,59,101,109,112,115,9093,9095,9109,9116,9122,1,729,113,4,2,59,100,9102,9104,1,8784,111,116,59,1,8785,105,110,117,115,59,1,8760,108,117,115,59,1,8724,113,117,97,114,101,59,1,8865,98,108,101,98,97,114,119,101,100,103,101,59,1,8966,110,4,3,97,100,104,9153,9160,9172,114,114,111,119,59,1,8595,111,119,110,97,114,114,111,119,115,59,1,8650,97,114,112,111,111,110,4,2,108,114,9184,9190,101,102,116,59,1,8643,105,103,104,116,59,1,8642,4,2,98,99,9203,9211,107,97,114,111,119,59,1,10512,4,2,111,114,9217,9222,114,110,59,1,8991,111,112,59,1,8972,4,3,99,111,116,9235,9248,9252,4,2,114,121,9241,9245,59,3,55349,56505,59,1,1109,108,59,1,10742,114,111,107,59,1,273,4,2,100,114,9264,9269,111,116,59,1,8945,105,4,2,59,102,9276,9278,1,9663,59,1,9662,4,2,97,104,9287,9292,114,114,59,1,8693,97,114,59,1,10607,97,110,103,108,101,59,1,10662,4,2,99,105,9311,9315,121,59,1,1119,103,114,97,114,114,59,1,10239,4,18,68,97,99,100,101,102,103,108,109,110,111,112,113,114,115,116,117,120,9361,9376,9398,9439,9444,9447,9462,9495,9531,9585,9598,9614,9659,9755,9771,9792,9808,9826,4,2,68,111,9367,9372,111,116,59,1,10871,116,59,1,8785,4,2,99,115,9382,9392,117,116,101,5,233,1,59,9390,1,233,116,101,114,59,1,10862,4,4,97,105,111,121,9408,9414,9430,9436,114,111,110,59,1,283,114,4,2,59,99,9421,9423,1,8790,5,234,1,59,9428,1,234,108,111,110,59,1,8789,59,1,1101,111,116,59,1,279,59,1,8519,4,2,68,114,9453,9458,111,116,59,1,8786,59,3,55349,56610,4,3,59,114,115,9470,9472,9482,1,10906,97,118,101,5,232,1,59,9480,1,232,4,2,59,100,9488,9490,1,10902,111,116,59,1,10904,4,4,59,105,108,115,9505,9507,9515,9518,1,10905,110,116,101,114,115,59,1,9191,59,1,8467,4,2,59,100,9524,9526,1,10901,111,116,59,1,10903,4,3,97,112,115,9539,9544,9564,99,114,59,1,275,116,121,4,3,59,115,118,9554,9556,9561,1,8709,101,116,59,1,8709,59,1,8709,112,4,2,49,59,9571,9583,4,2,51,52,9577,9580,59,1,8196,59,1,8197,1,8195,4,2,103,115,9591,9594,59,1,331,112,59,1,8194,4,2,103,112,9604,9609,111,110,59,1,281,102,59,3,55349,56662,4,3,97,108,115,9622,9635,9640,114,4,2,59,115,9629,9631,1,8917,108,59,1,10723,117,115,59,1,10865,105,4,3,59,108,118,9649,9651,9656,1,949,111,110,59,1,949,59,1,1013,4,4,99,115,117,118,9669,9686,9716,9747,4,2,105,111,9675,9680,114,99,59,1,8790,108,111,110,59,1,8789,4,2,105,108,9692,9696,109,59,1,8770,97,110,116,4,2,103,108,9705,9710,116,114,59,1,10902,101,115,115,59,1,10901,4,3,97,101,105,9724,9729,9734,108,115,59,1,61,115,116,59,1,8799,118,4,2,59,68,9741,9743,1,8801,68,59,1,10872,112,97,114,115,108,59,1,10725,4,2,68,97,9761,9766,111,116,59,1,8787,114,114,59,1,10609,4,3,99,100,105,9779,9783,9788,114,59,1,8495,111,116,59,1,8784,109,59,1,8770,4,2,97,104,9798,9801,59,1,951,5,240,1,59,9806,1,240,4,2,109,114,9814,9822,108,5,235,1,59,9820,1,235,111,59,1,8364,4,3,99,105,112,9834,9838,9843,108,59,1,33,115,116,59,1,8707,4,2,101,111,9849,9859,99,116,97,116,105,111,110,59,1,8496,110,101,110,116,105,97,108,101,59,1,8519,4,12,97,99,101,102,105,106,108,110,111,112,114,115,9896,9910,9914,9921,9954,9960,9967,9989,9994,10027,10036,10164,108,108,105,110,103,100,111,116,115,101,113,59,1,8786,121,59,1,1092,109,97,108,101,59,1,9792,4,3,105,108,114,9929,9935,9950,108,105,103,59,1,64259,4,2,105,108,9941,9945,103,59,1,64256,105,103,59,1,64260,59,3,55349,56611,108,105,103,59,1,64257,108,105,103,59,3,102,106,4,3,97,108,116,9975,9979,9984,116,59,1,9837,105,103,59,1,64258,110,115,59,1,9649,111,102,59,1,402,4,2,112,114,10000,10005,102,59,3,55349,56663,4,2,97,107,10011,10016,108,108,59,1,8704,4,2,59,118,10022,10024,1,8916,59,1,10969,97,114,116,105,110,116,59,1,10765,4,2,97,111,10042,10159,4,2,99,115,10048,10155,4,6,49,50,51,52,53,55,10062,10102,10114,10135,10139,10151,4,6,50,51,52,53,54,56,10076,10083,10086,10093,10096,10099,5,189,1,59,10081,1,189,59,1,8531,5,188,1,59,10091,1,188,59,1,8533,59,1,8537,59,1,8539,4,2,51,53,10108,10111,59,1,8532,59,1,8534,4,3,52,53,56,10122,10129,10132,5,190,1,59,10127,1,190,59,1,8535,59,1,8540,53,59,1,8536,4,2,54,56,10145,10148,59,1,8538,59,1,8541,56,59,1,8542,108,59,1,8260,119,110,59,1,8994,99,114,59,3,55349,56507,4,17,69,97,98,99,100,101,102,103,105,106,108,110,111,114,115,116,118,10206,10217,10247,10254,10268,10273,10358,10363,10374,10380,10385,10406,10458,10464,10470,10497,10610,4,2,59,108,10212,10214,1,8807,59,1,10892,4,3,99,109,112,10225,10231,10244,117,116,101,59,1,501,109,97,4,2,59,100,10239,10241,1,947,59,1,989,59,1,10886,114,101,118,101,59,1,287,4,2,105,121,10260,10265,114,99,59,1,285,59,1,1075,111,116,59,1,289,4,4,59,108,113,115,10283,10285,10288,10308,1,8805,59,1,8923,4,3,59,113,115,10296,10298,10301,1,8805,59,1,8807,108,97,110,116,59,1,10878,4,4,59,99,100,108,10318,10320,10324,10345,1,10878,99,59,1,10921,111,116,4,2,59,111,10332,10334,1,10880,4,2,59,108,10340,10342,1,10882,59,1,10884,4,2,59,101,10351,10354,3,8923,65024,115,59,1,10900,114,59,3,55349,56612,4,2,59,103,10369,10371,1,8811,59,1,8921,109,101,108,59,1,8503,99,121,59,1,1107,4,4,59,69,97,106,10395,10397,10400,10403,1,8823,59,1,10898,59,1,10917,59,1,10916,4,4,69,97,101,115,10416,10419,10434,10453,59,1,8809,112,4,2,59,112,10426,10428,1,10890,114,111,120,59,1,10890,4,2,59,113,10440,10442,1,10888,4,2,59,113,10448,10450,1,10888,59,1,8809,105,109,59,1,8935,112,102,59,3,55349,56664,97,118,101,59,1,96,4,2,99,105,10476,10480,114,59,1,8458,109,4,3,59,101,108,10489,10491,10494,1,8819,59,1,10894,59,1,10896,5,62,6,59,99,100,108,113,114,10512,10514,10527,10532,10538,10545,1,62,4,2,99,105,10520,10523,59,1,10919,114,59,1,10874,111,116,59,1,8919,80,97,114,59,1,10645,117,101,115,116,59,1,10876,4,5,97,100,101,108,115,10557,10574,10579,10599,10605,4,2,112,114,10563,10570,112,114,111,120,59,1,10886,114,59,1,10616,111,116,59,1,8919,113,4,2,108,113,10586,10592,101,115,115,59,1,8923,108,101,115,115,59,1,10892,101,115,115,59,1,8823,105,109,59,1,8819,4,2,101,110,10616,10626,114,116,110,101,113,113,59,3,8809,65024,69,59,3,8809,65024,4,10,65,97,98,99,101,102,107,111,115,121,10653,10658,10713,10718,10724,10760,10765,10786,10850,10875,114,114,59,1,8660,4,4,105,108,109,114,10668,10674,10678,10684,114,115,112,59,1,8202,102,59,1,189,105,108,116,59,1,8459,4,2,100,114,10690,10695,99,121,59,1,1098,4,3,59,99,119,10703,10705,10710,1,8596,105,114,59,1,10568,59,1,8621,97,114,59,1,8463,105,114,99,59,1,293,4,3,97,108,114,10732,10748,10754,114,116,115,4,2,59,117,10741,10743,1,9829,105,116,59,1,9829,108,105,112,59,1,8230,99,111,110,59,1,8889,114,59,3,55349,56613,115,4,2,101,119,10772,10779,97,114,111,119,59,1,10533,97,114,111,119,59,1,10534,4,5,97,109,111,112,114,10798,10803,10809,10839,10844,114,114,59,1,8703,116,104,116,59,1,8763,107,4,2,108,114,10816,10827,101,102,116,97,114,114,111,119,59,1,8617,105,103,104,116,97,114,114,111,119,59,1,8618,102,59,3,55349,56665,98,97,114,59,1,8213,4,3,99,108,116,10858,10863,10869,114,59,3,55349,56509,97,115,104,59,1,8463,114,111,107,59,1,295,4,2,98,112,10881,10887,117,108,108,59,1,8259,104,101,110,59,1,8208,4,15,97,99,101,102,103,105,106,109,110,111,112,113,115,116,117,10925,10936,10958,10977,10990,11001,11039,11045,11101,11192,11220,11226,11237,11285,11299,99,117,116,101,5,237,1,59,10934,1,237,4,3,59,105,121,10944,10946,10955,1,8291,114,99,5,238,1,59,10953,1,238,59,1,1080,4,2,99,120,10964,10968,121,59,1,1077,99,108,5,161,1,59,10975,1,161,4,2,102,114,10983,10986,59,1,8660,59,3,55349,56614,114,97,118,101,5,236,1,59,10999,1,236,4,4,59,105,110,111,11011,11013,11028,11034,1,8520,4,2,105,110,11019,11024,110,116,59,1,10764,116,59,1,8749,102,105,110,59,1,10716,116,97,59,1,8489,108,105,103,59,1,307,4,3,97,111,112,11053,11092,11096,4,3,99,103,116,11061,11065,11088,114,59,1,299,4,3,101,108,112,11073,11076,11082,59,1,8465,105,110,101,59,1,8464,97,114,116,59,1,8465,104,59,1,305,102,59,1,8887,101,100,59,1,437,4,5,59,99,102,111,116,11113,11115,11121,11136,11142,1,8712,97,114,101,59,1,8453,105,110,4,2,59,116,11129,11131,1,8734,105,101,59,1,10717,100,111,116,59,1,305,4,5,59,99,101,108,112,11154,11156,11161,11179,11186,1,8747,97,108,59,1,8890,4,2,103,114,11167,11173,101,114,115,59,1,8484,99,97,108,59,1,8890,97,114,104,107,59,1,10775,114,111,100,59,1,10812,4,4,99,103,112,116,11202,11206,11211,11216,121,59,1,1105,111,110,59,1,303,102,59,3,55349,56666,97,59,1,953,114,111,100,59,1,10812,117,101,115,116,5,191,1,59,11235,1,191,4,2,99,105,11243,11248,114,59,3,55349,56510,110,4,5,59,69,100,115,118,11261,11263,11266,11271,11282,1,8712,59,1,8953,111,116,59,1,8949,4,2,59,118,11277,11279,1,8948,59,1,8947,59,1,8712,4,2,59,105,11291,11293,1,8290,108,100,101,59,1,297,4,2,107,109,11305,11310,99,121,59,1,1110,108,5,239,1,59,11316,1,239,4,6,99,102,109,111,115,117,11332,11346,11351,11357,11363,11380,4,2,105,121,11338,11343,114,99,59,1,309,59,1,1081,114,59,3,55349,56615,97,116,104,59,1,567,112,102,59,3,55349,56667,4,2,99,101,11369,11374,114,59,3,55349,56511,114,99,121,59,1,1112,107,99,121,59,1,1108,4,8,97,99,102,103,104,106,111,115,11404,11418,11433,11438,11445,11450,11455,11461,112,112,97,4,2,59,118,11413,11415,1,954,59,1,1008,4,2,101,121,11424,11430,100,105,108,59,1,311,59,1,1082,114,59,3,55349,56616,114,101,101,110,59,1,312,99,121,59,1,1093,99,121,59,1,1116,112,102,59,3,55349,56668,99,114,59,3,55349,56512,4,23,65,66,69,72,97,98,99,100,101,102,103,104,106,108,109,110,111,112,114,115,116,117,118,11515,11538,11544,11555,11560,11721,11780,11818,11868,12136,12160,12171,12203,12208,12246,12275,12327,12509,12523,12569,12641,12732,12752,4,3,97,114,116,11523,11528,11532,114,114,59,1,8666,114,59,1,8656,97,105,108,59,1,10523,97,114,114,59,1,10510,4,2,59,103,11550,11552,1,8806,59,1,10891,97,114,59,1,10594,4,9,99,101,103,109,110,112,113,114,116,11580,11586,11594,11600,11606,11624,11627,11636,11694,117,116,101,59,1,314,109,112,116,121,118,59,1,10676,114,97,110,59,1,8466,98,100,97,59,1,955,103,4,3,59,100,108,11615,11617,11620,1,10216,59,1,10641,101,59,1,10216,59,1,10885,117,111,5,171,1,59,11634,1,171,114,4,8,59,98,102,104,108,112,115,116,11655,11657,11669,11673,11677,11681,11685,11690,1,8592,4,2,59,102,11663,11665,1,8676,115,59,1,10527,115,59,1,10525,107,59,1,8617,112,59,1,8619,108,59,1,10553,105,109,59,1,10611,108,59,1,8610,4,3,59,97,101,11702,11704,11709,1,10923,105,108,59,1,10521,4,2,59,115,11715,11717,1,10925,59,3,10925,65024,4,3,97,98,114,11729,11734,11739,114,114,59,1,10508,114,107,59,1,10098,4,2,97,107,11745,11758,99,4,2,101,107,11752,11755,59,1,123,59,1,91,4,2,101,115,11764,11767,59,1,10635,108,4,2,100,117,11774,11777,59,1,10639,59,1,10637,4,4,97,101,117,121,11790,11796,11811,11815,114,111,110,59,1,318,4,2,100,105,11802,11807,105,108,59,1,316,108,59,1,8968,98,59,1,123,59,1,1083,4,4,99,113,114,115,11828,11832,11845,11864,97,59,1,10550,117,111,4,2,59,114,11840,11842,1,8220,59,1,8222,4,2,100,117,11851,11857,104,97,114,59,1,10599,115,104,97,114,59,1,10571,104,59,1,8626,4,5,59,102,103,113,115,11880,11882,12008,12011,12031,1,8804,116,4,5,97,104,108,114,116,11895,11913,11935,11947,11996,114,114,111,119,4,2,59,116,11905,11907,1,8592,97,105,108,59,1,8610,97,114,112,111,111,110,4,2,100,117,11925,11931,111,119,110,59,1,8637,112,59,1,8636,101,102,116,97,114,114,111,119,115,59,1,8647,105,103,104,116,4,3,97,104,115,11959,11974,11984,114,114,111,119,4,2,59,115,11969,11971,1,8596,59,1,8646,97,114,112,111,111,110,115,59,1,8651,113,117,105,103,97,114,114,111,119,59,1,8621,104,114,101,101,116,105,109,101,115,59,1,8907,59,1,8922,4,3,59,113,115,12019,12021,12024,1,8804,59,1,8806,108,97,110,116,59,1,10877,4,5,59,99,100,103,115,12043,12045,12049,12070,12083,1,10877,99,59,1,10920,111,116,4,2,59,111,12057,12059,1,10879,4,2,59,114,12065,12067,1,10881,59,1,10883,4,2,59,101,12076,12079,3,8922,65024,115,59,1,10899,4,5,97,100,101,103,115,12095,12103,12108,12126,12131,112,112,114,111,120,59,1,10885,111,116,59,1,8918,113,4,2,103,113,12115,12120,116,114,59,1,8922,103,116,114,59,1,10891,116,114,59,1,8822,105,109,59,1,8818,4,3,105,108,114,12144,12150,12156,115,104,116,59,1,10620,111,111,114,59,1,8970,59,3,55349,56617,4,2,59,69,12166,12168,1,8822,59,1,10897,4,2,97,98,12177,12198,114,4,2,100,117,12184,12187,59,1,8637,4,2,59,108,12193,12195,1,8636,59,1,10602,108,107,59,1,9604,99,121,59,1,1113,4,5,59,97,99,104,116,12220,12222,12227,12235,12241,1,8810,114,114,59,1,8647,111,114,110,101,114,59,1,8990,97,114,100,59,1,10603,114,105,59,1,9722,4,2,105,111,12252,12258,100,111,116,59,1,320,117,115,116,4,2,59,97,12267,12269,1,9136,99,104,101,59,1,9136,4,4,69,97,101,115,12285,12288,12303,12322,59,1,8808,112,4,2,59,112,12295,12297,1,10889,114,111,120,59,1,10889,4,2,59,113,12309,12311,1,10887,4,2,59,113,12317,12319,1,10887,59,1,8808,105,109,59,1,8934,4,8,97,98,110,111,112,116,119,122,12345,12359,12364,12421,12446,12467,12474,12490,4,2,110,114,12351,12355,103,59,1,10220,114,59,1,8701,114,107,59,1,10214,103,4,3,108,109,114,12373,12401,12409,101,102,116,4,2,97,114,12382,12389,114,114,111,119,59,1,10229,105,103,104,116,97,114,114,111,119,59,1,10231,97,112,115,116,111,59,1,10236,105,103,104,116,97,114,114,111,119,59,1,10230,112,97,114,114,111,119,4,2,108,114,12433,12439,101,102,116,59,1,8619,105,103,104,116,59,1,8620,4,3,97,102,108,12454,12458,12462,114,59,1,10629,59,3,55349,56669,117,115,59,1,10797,105,109,101,115,59,1,10804,4,2,97,98,12480,12485,115,116,59,1,8727,97,114,59,1,95,4,3,59,101,102,12498,12500,12506,1,9674,110,103,101,59,1,9674,59,1,10731,97,114,4,2,59,108,12517,12519,1,40,116,59,1,10643,4,5,97,99,104,109,116,12535,12540,12548,12561,12564,114,114,59,1,8646,111,114,110,101,114,59,1,8991,97,114,4,2,59,100,12556,12558,1,8651,59,1,10605,59,1,8206,114,105,59,1,8895,4,6,97,99,104,105,113,116,12583,12589,12594,12597,12614,12635,113,117,111,59,1,8249,114,59,3,55349,56513,59,1,8624,109,4,3,59,101,103,12606,12608,12611,1,8818,59,1,10893,59,1,10895,4,2,98,117,12620,12623,59,1,91,111,4,2,59,114,12630,12632,1,8216,59,1,8218,114,111,107,59,1,322,5,60,8,59,99,100,104,105,108,113,114,12660,12662,12675,12680,12686,12692,12698,12705,1,60,4,2,99,105,12668,12671,59,1,10918,114,59,1,10873,111,116,59,1,8918,114,101,101,59,1,8907,109,101,115,59,1,8905,97,114,114,59,1,10614,117,101,115,116,59,1,10875,4,2,80,105,12711,12716,97,114,59,1,10646,4,3,59,101,102,12724,12726,12729,1,9667,59,1,8884,59,1,9666,114,4,2,100,117,12739,12746,115,104,97,114,59,1,10570,104,97,114,59,1,10598,4,2,101,110,12758,12768,114,116,110,101,113,113,59,3,8808,65024,69,59,3,8808,65024,4,14,68,97,99,100,101,102,104,105,108,110,111,112,115,117,12803,12809,12893,12908,12914,12928,12933,12937,13011,13025,13032,13049,13052,13069,68,111,116,59,1,8762,4,4,99,108,112,114,12819,12827,12849,12887,114,5,175,1,59,12825,1,175,4,2,101,116,12833,12836,59,1,9794,4,2,59,101,12842,12844,1,10016,115,101,59,1,10016,4,2,59,115,12855,12857,1,8614,116,111,4,4,59,100,108,117,12869,12871,12877,12883,1,8614,111,119,110,59,1,8615,101,102,116,59,1,8612,112,59,1,8613,107,101,114,59,1,9646,4,2,111,121,12899,12905,109,109,97,59,1,10793,59,1,1084,97,115,104,59,1,8212,97,115,117,114,101,100,97,110,103,108,101,59,1,8737,114,59,3,55349,56618,111,59,1,8487,4,3,99,100,110,12945,12954,12985,114,111,5,181,1,59,12952,1,181,4,4,59,97,99,100,12964,12966,12971,12976,1,8739,115,116,59,1,42,105,114,59,1,10992,111,116,5,183,1,59,12983,1,183,117,115,4,3,59,98,100,12995,12997,13000,1,8722,59,1,8863,4,2,59,117,13006,13008,1,8760,59,1,10794,4,2,99,100,13017,13021,112,59,1,10971,114,59,1,8230,112,108,117,115,59,1,8723,4,2,100,112,13038,13044,101,108,115,59,1,8871,102,59,3,55349,56670,59,1,8723,4,2,99,116,13058,13063,114,59,3,55349,56514,112,111,115,59,1,8766,4,3,59,108,109,13077,13079,13087,1,956,116,105,109,97,112,59,1,8888,97,112,59,1,8888,4,24,71,76,82,86,97,98,99,100,101,102,103,104,105,106,108,109,111,112,114,115,116,117,118,119,13142,13165,13217,13229,13247,13330,13359,13414,13420,13508,13513,13579,13602,13626,13631,13762,13767,13855,13936,13995,14214,14285,14312,14432,4,2,103,116,13148,13152,59,3,8921,824,4,2,59,118,13158,13161,3,8811,8402,59,3,8811,824,4,3,101,108,116,13173,13200,13204,102,116,4,2,97,114,13181,13188,114,114,111,119,59,1,8653,105,103,104,116,97,114,114,111,119,59,1,8654,59,3,8920,824,4,2,59,118,13210,13213,3,8810,8402,59,3,8810,824,105,103,104,116,97,114,114,111,119,59,1,8655,4,2,68,100,13235,13241,97,115,104,59,1,8879,97,115,104,59,1,8878,4,5,98,99,110,112,116,13259,13264,13270,13275,13308,108,97,59,1,8711,117,116,101,59,1,324,103,59,3,8736,8402,4,5,59,69,105,111,112,13287,13289,13293,13298,13302,1,8777,59,3,10864,824,100,59,3,8779,824,115,59,1,329,114,111,120,59,1,8777,117,114,4,2,59,97,13316,13318,1,9838,108,4,2,59,115,13325,13327,1,9838,59,1,8469,4,2,115,117,13336,13344,112,5,160,1,59,13342,1,160,109,112,4,2,59,101,13352,13355,3,8782,824,59,3,8783,824,4,5,97,101,111,117,121,13371,13385,13391,13407,13411,4,2,112,114,13377,13380,59,1,10819,111,110,59,1,328,100,105,108,59,1,326,110,103,4,2,59,100,13399,13401,1,8775,111,116,59,3,10861,824,112,59,1,10818,59,1,1085,97,115,104,59,1,8211,4,7,59,65,97,100,113,115,120,13436,13438,13443,13466,13472,13478,13494,1,8800,114,114,59,1,8663,114,4,2,104,114,13450,13454,107,59,1,10532,4,2,59,111,13460,13462,1,8599,119,59,1,8599,111,116,59,3,8784,824,117,105,118,59,1,8802,4,2,101,105,13484,13489,97,114,59,1,10536,109,59,3,8770,824,105,115,116,4,2,59,115,13503,13505,1,8708,59,1,8708,114,59,3,55349,56619,4,4,69,101,115,116,13523,13527,13563,13568,59,3,8807,824,4,3,59,113,115,13535,13537,13559,1,8817,4,3,59,113,115,13545,13547,13551,1,8817,59,3,8807,824,108,97,110,116,59,3,10878,824,59,3,10878,824,105,109,59,1,8821,4,2,59,114,13574,13576,1,8815,59,1,8815,4,3,65,97,112,13587,13592,13597,114,114,59,1,8654,114,114,59,1,8622,97,114,59,1,10994,4,3,59,115,118,13610,13612,13623,1,8715,4,2,59,100,13618,13620,1,8956,59,1,8954,59,1,8715,99,121,59,1,1114,4,7,65,69,97,100,101,115,116,13647,13652,13656,13661,13665,13737,13742,114,114,59,1,8653,59,3,8806,824,114,114,59,1,8602,114,59,1,8229,4,4,59,102,113,115,13675,13677,13703,13725,1,8816,116,4,2,97,114,13684,13691,114,114,111,119,59,1,8602,105,103,104,116,97,114,114,111,119,59,1,8622,4,3,59,113,115,13711,13713,13717,1,8816,59,3,8806,824,108,97,110,116,59,3,10877,824,4,2,59,115,13731,13734,3,10877,824,59,1,8814,105,109,59,1,8820,4,2,59,114,13748,13750,1,8814,105,4,2,59,101,13757,13759,1,8938,59,1,8940,105,100,59,1,8740,4,2,112,116,13773,13778,102,59,3,55349,56671,5,172,3,59,105,110,13787,13789,13829,1,172,110,4,4,59,69,100,118,13800,13802,13806,13812,1,8713,59,3,8953,824,111,116,59,3,8949,824,4,3,97,98,99,13820,13823,13826,59,1,8713,59,1,8951,59,1,8950,105,4,2,59,118,13836,13838,1,8716,4,3,97,98,99,13846,13849,13852,59,1,8716,59,1,8958,59,1,8957,4,3,97,111,114,13863,13892,13899,114,4,4,59,97,115,116,13874,13876,13883,13888,1,8742,108,108,101,108,59,1,8742,108,59,3,11005,8421,59,3,8706,824,108,105,110,116,59,1,10772,4,3,59,99,101,13907,13909,13914,1,8832,117,101,59,1,8928,4,2,59,99,13920,13923,3,10927,824,4,2,59,101,13929,13931,1,8832,113,59,3,10927,824,4,4,65,97,105,116,13946,13951,13971,13982,114,114,59,1,8655,114,114,4,3,59,99,119,13961,13963,13967,1,8603,59,3,10547,824,59,3,8605,824,103,104,116,97,114,114,111,119,59,1,8603,114,105,4,2,59,101,13990,13992,1,8939,59,1,8941,4,7,99,104,105,109,112,113,117,14011,14036,14060,14080,14085,14090,14106,4,4,59,99,101,114,14021,14023,14028,14032,1,8833,117,101,59,1,8929,59,3,10928,824,59,3,55349,56515,111,114,116,4,2,109,112,14045,14050,105,100,59,1,8740,97,114,97,108,108,101,108,59,1,8742,109,4,2,59,101,14067,14069,1,8769,4,2,59,113,14075,14077,1,8772,59,1,8772,105,100,59,1,8740,97,114,59,1,8742,115,117,4,2,98,112,14098,14102,101,59,1,8930,101,59,1,8931,4,3,98,99,112,14114,14157,14171,4,4,59,69,101,115,14124,14126,14130,14133,1,8836,59,3,10949,824,59,1,8840,101,116,4,2,59,101,14141,14144,3,8834,8402,113,4,2,59,113,14151,14153,1,8840,59,3,10949,824,99,4,2,59,101,14164,14166,1,8833,113,59,3,10928,824,4,4,59,69,101,115,14181,14183,14187,14190,1,8837,59,3,10950,824,59,1,8841,101,116,4,2,59,101,14198,14201,3,8835,8402,113,4,2,59,113,14208,14210,1,8841,59,3,10950,824,4,4,103,105,108,114,14224,14228,14238,14242,108,59,1,8825,108,100,101,5,241,1,59,14236,1,241,103,59,1,8824,105,97,110,103,108,101,4,2,108,114,14254,14269,101,102,116,4,2,59,101,14263,14265,1,8938,113,59,1,8940,105,103,104,116,4,2,59,101,14279,14281,1,8939,113,59,1,8941,4,2,59,109,14291,14293,1,957,4,3,59,101,115,14301,14303,14308,1,35,114,111,59,1,8470,112,59,1,8199,4,9,68,72,97,100,103,105,108,114,115,14332,14338,14344,14349,14355,14369,14376,14408,14426,97,115,104,59,1,8877,97,114,114,59,1,10500,112,59,3,8781,8402,97,115,104,59,1,8876,4,2,101,116,14361,14365,59,3,8805,8402,59,3,62,8402,110,102,105,110,59,1,10718,4,3,65,101,116,14384,14389,14393,114,114,59,1,10498,59,3,8804,8402,4,2,59,114,14399,14402,3,60,8402,105,101,59,3,8884,8402,4,2,65,116,14414,14419,114,114,59,1,10499,114,105,101,59,3,8885,8402,105,109,59,3,8764,8402,4,3,65,97,110,14440,14445,14468,114,114,59,1,8662,114,4,2,104,114,14452,14456,107,59,1,10531,4,2,59,111,14462,14464,1,8598,119,59,1,8598,101,97,114,59,1,10535,4,18,83,97,99,100,101,102,103,104,105,108,109,111,112,114,115,116,117,118,14512,14515,14535,14560,14597,14603,14618,14643,14657,14662,14701,14741,14747,14769,14851,14877,14907,14916,59,1,9416,4,2,99,115,14521,14531,117,116,101,5,243,1,59,14529,1,243,116,59,1,8859,4,2,105,121,14541,14557,114,4,2,59,99,14548,14550,1,8858,5,244,1,59,14555,1,244,59,1,1086,4,5,97,98,105,111,115,14572,14577,14583,14587,14591,115,104,59,1,8861,108,97,99,59,1,337,118,59,1,10808,116,59,1,8857,111,108,100,59,1,10684,108,105,103,59,1,339,4,2,99,114,14609,14614,105,114,59,1,10687,59,3,55349,56620,4,3,111,114,116,14626,14630,14640,110,59,1,731,97,118,101,5,242,1,59,14638,1,242,59,1,10689,4,2,98,109,14649,14654,97,114,59,1,10677,59,1,937,110,116,59,1,8750,4,4,97,99,105,116,14672,14677,14693,14698,114,114,59,1,8634,4,2,105,114,14683,14687,114,59,1,10686,111,115,115,59,1,10683,110,101,59,1,8254,59,1,10688,4,3,97,101,105,14709,14714,14719,99,114,59,1,333,103,97,59,1,969,4,3,99,100,110,14727,14733,14736,114,111,110,59,1,959,59,1,10678,117,115,59,1,8854,112,102,59,3,55349,56672,4,3,97,101,108,14755,14759,14764,114,59,1,10679,114,112,59,1,10681,117,115,59,1,8853,4,7,59,97,100,105,111,115,118,14785,14787,14792,14831,14837,14841,14848,1,8744,114,114,59,1,8635,4,4,59,101,102,109,14802,14804,14817,14824,1,10845,114,4,2,59,111,14811,14813,1,8500,102,59,1,8500,5,170,1,59,14822,1,170,5,186,1,59,14829,1,186,103,111,102,59,1,8886,114,59,1,10838,108,111,112,101,59,1,10839,59,1,10843,4,3,99,108,111,14859,14863,14873,114,59,1,8500,97,115,104,5,248,1,59,14871,1,248,108,59,1,8856,105,4,2,108,109,14884,14893,100,101,5,245,1,59,14891,1,245,101,115,4,2,59,97,14901,14903,1,8855,115,59,1,10806,109,108,5,246,1,59,14914,1,246,98,97,114,59,1,9021,4,12,97,99,101,102,104,105,108,109,111,114,115,117,14948,14992,14996,15033,15038,15068,15090,15189,15192,15222,15427,15441,114,4,4,59,97,115,116,14959,14961,14976,14989,1,8741,5,182,2,59,108,14968,14970,1,182,108,101,108,59,1,8741,4,2,105,108,14982,14986,109,59,1,10995,59,1,11005,59,1,8706,121,59,1,1087,114,4,5,99,105,109,112,116,15009,15014,15019,15024,15027,110,116,59,1,37,111,100,59,1,46,105,108,59,1,8240,59,1,8869,101,110,107,59,1,8241,114,59,3,55349,56621,4,3,105,109,111,15046,15057,15063,4,2,59,118,15052,15054,1,966,59,1,981,109,97,116,59,1,8499,110,101,59,1,9742,4,3,59,116,118,15076,15078,15087,1,960,99,104,102,111,114,107,59,1,8916,59,1,982,4,2,97,117,15096,15119,110,4,2,99,107,15103,15115,107,4,2,59,104,15110,15112,1,8463,59,1,8462,118,59,1,8463,115,4,9,59,97,98,99,100,101,109,115,116,15140,15142,15148,15151,15156,15168,15171,15179,15184,1,43,99,105,114,59,1,10787,59,1,8862,105,114,59,1,10786,4,2,111,117,15162,15165,59,1,8724,59,1,10789,59,1,10866,110,5,177,1,59,15177,1,177,105,109,59,1,10790,119,111,59,1,10791,59,1,177,4,3,105,112,117,15200,15208,15213,110,116,105,110,116,59,1,10773,102,59,3,55349,56673,110,100,5,163,1,59,15220,1,163,4,10,59,69,97,99,101,105,110,111,115,117,15244,15246,15249,15253,15258,15334,15347,15367,15416,15421,1,8826,59,1,10931,112,59,1,10935,117,101,59,1,8828,4,2,59,99,15264,15266,1,10927,4,6,59,97,99,101,110,115,15280,15282,15290,15299,15303,15329,1,8826,112,112,114,111,120,59,1,10935,117,114,108,121,101,113,59,1,8828,113,59,1,10927,4,3,97,101,115,15311,15319,15324,112,112,114,111,120,59,1,10937,113,113,59,1,10933,105,109,59,1,8936,105,109,59,1,8830,109,101,4,2,59,115,15342,15344,1,8242,59,1,8473,4,3,69,97,115,15355,15358,15362,59,1,10933,112,59,1,10937,105,109,59,1,8936,4,3,100,102,112,15375,15378,15404,59,1,8719,4,3,97,108,115,15386,15392,15398,108,97,114,59,1,9006,105,110,101,59,1,8978,117,114,102,59,1,8979,4,2,59,116,15410,15412,1,8733,111,59,1,8733,105,109,59,1,8830,114,101,108,59,1,8880,4,2,99,105,15433,15438,114,59,3,55349,56517,59,1,968,110,99,115,112,59,1,8200,4,6,102,105,111,112,115,117,15462,15467,15472,15478,15485,15491,114,59,3,55349,56622,110,116,59,1,10764,112,102,59,3,55349,56674,114,105,109,101,59,1,8279,99,114,59,3,55349,56518,4,3,97,101,111,15499,15520,15534,116,4,2,101,105,15506,15515,114,110,105,111,110,115,59,1,8461,110,116,59,1,10774,115,116,4,2,59,101,15528,15530,1,63,113,59,1,8799,116,5,34,1,59,15540,1,34,4,21,65,66,72,97,98,99,100,101,102,104,105,108,109,110,111,112,114,115,116,117,120,15586,15609,15615,15620,15796,15855,15893,15931,15977,16001,16039,16183,16204,16222,16228,16285,16312,16318,16363,16408,16416,4,3,97,114,116,15594,15599,15603,114,114,59,1,8667,114,59,1,8658,97,105,108,59,1,10524,97,114,114,59,1,10511,97,114,59,1,10596,4,7,99,100,101,110,113,114,116,15636,15651,15656,15664,15687,15696,15770,4,2,101,117,15642,15646,59,3,8765,817,116,101,59,1,341,105,99,59,1,8730,109,112,116,121,118,59,1,10675,103,4,4,59,100,101,108,15675,15677,15680,15683,1,10217,59,1,10642,59,1,10661,101,59,1,10217,117,111,5,187,1,59,15694,1,187,114,4,11,59,97,98,99,102,104,108,112,115,116,119,15721,15723,15727,15739,15742,15746,15750,15754,15758,15763,15767,1,8594,112,59,1,10613,4,2,59,102,15733,15735,1,8677,115,59,1,10528,59,1,10547,115,59,1,10526,107,59,1,8618,112,59,1,8620,108,59,1,10565,105,109,59,1,10612,108,59,1,8611,59,1,8605,4,2,97,105,15776,15781,105,108,59,1,10522,111,4,2,59,110,15788,15790,1,8758,97,108,115,59,1,8474,4,3,97,98,114,15804,15809,15814,114,114,59,1,10509,114,107,59,1,10099,4,2,97,107,15820,15833,99,4,2,101,107,15827,15830,59,1,125,59,1,93,4,2,101,115,15839,15842,59,1,10636,108,4,2,100,117,15849,15852,59,1,10638,59,1,10640,4,4,97,101,117,121,15865,15871,15886,15890,114,111,110,59,1,345,4,2,100,105,15877,15882,105,108,59,1,343,108,59,1,8969,98,59,1,125,59,1,1088,4,4,99,108,113,115,15903,15907,15914,15927,97,59,1,10551,100,104,97,114,59,1,10601,117,111,4,2,59,114,15922,15924,1,8221,59,1,8221,104,59,1,8627,4,3,97,99,103,15939,15966,15970,108,4,4,59,105,112,115,15950,15952,15957,15963,1,8476,110,101,59,1,8475,97,114,116,59,1,8476,59,1,8477,116,59,1,9645,5,174,1,59,15975,1,174,4,3,105,108,114,15985,15991,15997,115,104,116,59,1,10621,111,111,114,59,1,8971,59,3,55349,56623,4,2,97,111,16007,16028,114,4,2,100,117,16014,16017,59,1,8641,4,2,59,108,16023,16025,1,8640,59,1,10604,4,2,59,118,16034,16036,1,961,59,1,1009,4,3,103,110,115,16047,16167,16171,104,116,4,6,97,104,108,114,115,116,16063,16081,16103,16130,16143,16155,114,114,111,119,4,2,59,116,16073,16075,1,8594,97,105,108,59,1,8611,97,114,112,111,111,110,4,2,100,117,16093,16099,111,119,110,59,1,8641,112,59,1,8640,101,102,116,4,2,97,104,16112,16120,114,114,111,119,115,59,1,8644,97,114,112,111,111,110,115,59,1,8652,105,103,104,116,97,114,114,111,119,115,59,1,8649,113,117,105,103,97,114,114,111,119,59,1,8605,104,114,101,101,116,105,109,101,115,59,1,8908,103,59,1,730,105,110,103,100,111,116,115,101,113,59,1,8787,4,3,97,104,109,16191,16196,16201,114,114,59,1,8644,97,114,59,1,8652,59,1,8207,111,117,115,116,4,2,59,97,16214,16216,1,9137,99,104,101,59,1,9137,109,105,100,59,1,10990,4,4,97,98,112,116,16238,16252,16257,16278,4,2,110,114,16244,16248,103,59,1,10221,114,59,1,8702,114,107,59,1,10215,4,3,97,102,108,16265,16269,16273,114,59,1,10630,59,3,55349,56675,117,115,59,1,10798,105,109,101,115,59,1,10805,4,2,97,112,16291,16304,114,4,2,59,103,16298,16300,1,41,116,59,1,10644,111,108,105,110,116,59,1,10770,97,114,114,59,1,8649,4,4,97,99,104,113,16328,16334,16339,16342,113,117,111,59,1,8250,114,59,3,55349,56519,59,1,8625,4,2,98,117,16348,16351,59,1,93,111,4,2,59,114,16358,16360,1,8217,59,1,8217,4,3,104,105,114,16371,16377,16383,114,101,101,59,1,8908,109,101,115,59,1,8906,105,4,4,59,101,102,108,16394,16396,16399,16402,1,9657,59,1,8885,59,1,9656,116,114,105,59,1,10702,108,117,104,97,114,59,1,10600,59,1,8478,4,19,97,98,99,100,101,102,104,105,108,109,111,112,113,114,115,116,117,119,122,16459,16466,16472,16572,16590,16672,16687,16746,16844,16850,16924,16963,16988,17115,17121,17154,17206,17614,17656,99,117,116,101,59,1,347,113,117,111,59,1,8218,4,10,59,69,97,99,101,105,110,112,115,121,16494,16496,16499,16513,16518,16531,16536,16556,16564,16569,1,8827,59,1,10932,4,2,112,114,16505,16508,59,1,10936,111,110,59,1,353,117,101,59,1,8829,4,2,59,100,16524,16526,1,10928,105,108,59,1,351,114,99,59,1,349,4,3,69,97,115,16544,16547,16551,59,1,10934,112,59,1,10938,105,109,59,1,8937,111,108,105,110,116,59,1,10771,105,109,59,1,8831,59,1,1089,111,116,4,3,59,98,101,16582,16584,16587,1,8901,59,1,8865,59,1,10854,4,7,65,97,99,109,115,116,120,16606,16611,16634,16642,16646,16652,16668,114,114,59,1,8664,114,4,2,104,114,16618,16622,107,59,1,10533,4,2,59,111,16628,16630,1,8600,119,59,1,8600,116,5,167,1,59,16640,1,167,105,59,1,59,119,97,114,59,1,10537,109,4,2,105,110,16659,16665,110,117,115,59,1,8726,59,1,8726,116,59,1,10038,114,4,2,59,111,16679,16682,3,55349,56624,119,110,59,1,8994,4,4,97,99,111,121,16697,16702,16716,16739,114,112,59,1,9839,4,2,104,121,16708,16713,99,121,59,1,1097,59,1,1096,114,116,4,2,109,112,16724,16729,105,100,59,1,8739,97,114,97,108,108,101,108,59,1,8741,5,173,1,59,16744,1,173,4,2,103,109,16752,16770,109,97,4,3,59,102,118,16762,16764,16767,1,963,59,1,962,59,1,962,4,8,59,100,101,103,108,110,112,114,16788,16790,16795,16806,16817,16828,16832,16838,1,8764,111,116,59,1,10858,4,2,59,113,16801,16803,1,8771,59,1,8771,4,2,59,69,16812,16814,1,10910,59,1,10912,4,2,59,69,16823,16825,1,10909,59,1,10911,101,59,1,8774,108,117,115,59,1,10788,97,114,114,59,1,10610,97,114,114,59,1,8592,4,4,97,101,105,116,16860,16883,16891,16904,4,2,108,115,16866,16878,108,115,101,116,109,105,110,117,115,59,1,8726,104,112,59,1,10803,112,97,114,115,108,59,1,10724,4,2,100,108,16897,16900,59,1,8739,101,59,1,8995,4,2,59,101,16910,16912,1,10922,4,2,59,115,16918,16920,1,10924,59,3,10924,65024,4,3,102,108,112,16932,16938,16958,116,99,121,59,1,1100,4,2,59,98,16944,16946,1,47,4,2,59,97,16952,16954,1,10692,114,59,1,9023,102,59,3,55349,56676,97,4,2,100,114,16970,16985,101,115,4,2,59,117,16978,16980,1,9824,105,116,59,1,9824,59,1,8741,4,3,99,115,117,16996,17028,17089,4,2,97,117,17002,17015,112,4,2,59,115,17009,17011,1,8851,59,3,8851,65024,112,4,2,59,115,17022,17024,1,8852,59,3,8852,65024,117,4,2,98,112,17035,17062,4,3,59,101,115,17043,17045,17048,1,8847,59,1,8849,101,116,4,2,59,101,17056,17058,1,8847,113,59,1,8849,4,3,59,101,115,17070,17072,17075,1,8848,59,1,8850,101,116,4,2,59,101,17083,17085,1,8848,113,59,1,8850,4,3,59,97,102,17097,17099,17112,1,9633,114,4,2,101,102,17106,17109,59,1,9633,59,1,9642,59,1,9642,97,114,114,59,1,8594,4,4,99,101,109,116,17131,17136,17142,17148,114,59,3,55349,56520,116,109,110,59,1,8726,105,108,101,59,1,8995,97,114,102,59,1,8902,4,2,97,114,17160,17172,114,4,2,59,102,17167,17169,1,9734,59,1,9733,4,2,97,110,17178,17202,105,103,104,116,4,2,101,112,17188,17197,112,115,105,108,111,110,59,1,1013,104,105,59,1,981,115,59,1,175,4,5,98,99,109,110,112,17218,17351,17420,17423,17427,4,9,59,69,100,101,109,110,112,114,115,17238,17240,17243,17248,17261,17267,17279,17285,17291,1,8834,59,1,10949,111,116,59,1,10941,4,2,59,100,17254,17256,1,8838,111,116,59,1,10947,117,108,116,59,1,10945,4,2,69,101,17273,17276,59,1,10955,59,1,8842,108,117,115,59,1,10943,97,114,114,59,1,10617,4,3,101,105,117,17299,17335,17339,116,4,3,59,101,110,17308,17310,17322,1,8834,113,4,2,59,113,17317,17319,1,8838,59,1,10949,101,113,4,2,59,113,17330,17332,1,8842,59,1,10955,109,59,1,10951,4,2,98,112,17345,17348,59,1,10965,59,1,10963,99,4,6,59,97,99,101,110,115,17366,17368,17376,17385,17389,17415,1,8827,112,112,114,111,120,59,1,10936,117,114,108,121,101,113,59,1,8829,113,59,1,10928,4,3,97,101,115,17397,17405,17410,112,112,114,111,120,59,1,10938,113,113,59,1,10934,105,109,59,1,8937,105,109,59,1,8831,59,1,8721,103,59,1,9834,4,13,49,50,51,59,69,100,101,104,108,109,110,112,115,17455,17462,17469,17476,17478,17481,17496,17509,17524,17530,17536,17548,17554,5,185,1,59,17460,1,185,5,178,1,59,17467,1,178,5,179,1,59,17474,1,179,1,8835,59,1,10950,4,2,111,115,17487,17491,116,59,1,10942,117,98,59,1,10968,4,2,59,100,17502,17504,1,8839,111,116,59,1,10948,115,4,2,111,117,17516,17520,108,59,1,10185,98,59,1,10967,97,114,114,59,1,10619,117,108,116,59,1,10946,4,2,69,101,17542,17545,59,1,10956,59,1,8843,108,117,115,59,1,10944,4,3,101,105,117,17562,17598,17602,116,4,3,59,101,110,17571,17573,17585,1,8835,113,4,2,59,113,17580,17582,1,8839,59,1,10950,101,113,4,2,59,113,17593,17595,1,8843,59,1,10956,109,59,1,10952,4,2,98,112,17608,17611,59,1,10964,59,1,10966,4,3,65,97,110,17622,17627,17650,114,114,59,1,8665,114,4,2,104,114,17634,17638,107,59,1,10534,4,2,59,111,17644,17646,1,8601,119,59,1,8601,119,97,114,59,1,10538,108,105,103,5,223,1,59,17664,1,223,4,13,97,98,99,100,101,102,104,105,111,112,114,115,119,17694,17709,17714,17737,17742,17749,17754,17860,17905,17957,17964,18090,18122,4,2,114,117,17700,17706,103,101,116,59,1,8982,59,1,964,114,107,59,1,9140,4,3,97,101,121,17722,17728,17734,114,111,110,59,1,357,100,105,108,59,1,355,59,1,1090,111,116,59,1,8411,108,114,101,99,59,1,8981,114,59,3,55349,56625,4,4,101,105,107,111,17764,17805,17836,17851,4,2,114,116,17770,17786,101,4,2,52,102,17777,17780,59,1,8756,111,114,101,59,1,8756,97,4,3,59,115,118,17795,17797,17802,1,952,121,109,59,1,977,59,1,977,4,2,99,110,17811,17831,107,4,2,97,115,17818,17826,112,112,114,111,120,59,1,8776,105,109,59,1,8764,115,112,59,1,8201,4,2,97,115,17842,17846,112,59,1,8776,105,109,59,1,8764,114,110,5,254,1,59,17858,1,254,4,3,108,109,110,17868,17873,17901,100,101,59,1,732,101,115,5,215,3,59,98,100,17884,17886,17898,1,215,4,2,59,97,17892,17894,1,8864,114,59,1,10801,59,1,10800,116,59,1,8749,4,3,101,112,115,17913,17917,17953,97,59,1,10536,4,4,59,98,99,102,17927,17929,17934,17939,1,8868,111,116,59,1,9014,105,114,59,1,10993,4,2,59,111,17945,17948,3,55349,56677,114,107,59,1,10970,97,59,1,10537,114,105,109,101,59,1,8244,4,3,97,105,112,17972,17977,18082,100,101,59,1,8482,4,7,97,100,101,109,112,115,116,17993,18051,18056,18059,18066,18072,18076,110,103,108,101,4,5,59,100,108,113,114,18009,18011,18017,18032,18035,1,9653,111,119,110,59,1,9663,101,102,116,4,2,59,101,18026,18028,1,9667,113,59,1,8884,59,1,8796,105,103,104,116,4,2,59,101,18045,18047,1,9657,113,59,1,8885,111,116,59,1,9708,59,1,8796,105,110,117,115,59,1,10810,108,117,115,59,1,10809,98,59,1,10701,105,109,101,59,1,10811,101,122,105,117,109,59,1,9186,4,3,99,104,116,18098,18111,18116,4,2,114,121,18104,18108,59,3,55349,56521,59,1,1094,99,121,59,1,1115,114,111,107,59,1,359,4,2,105,111,18128,18133,120,116,59,1,8812,104,101,97,100,4,2,108,114,18143,18154,101,102,116,97,114,114,111,119,59,1,8606,105,103,104,116,97,114,114,111,119,59,1,8608,4,18,65,72,97,98,99,100,102,103,104,108,109,111,112,114,115,116,117,119,18204,18209,18214,18234,18250,18268,18292,18308,18319,18343,18379,18397,18413,18504,18547,18553,18584,18603,114,114,59,1,8657,97,114,59,1,10595,4,2,99,114,18220,18230,117,116,101,5,250,1,59,18228,1,250,114,59,1,8593,114,4,2,99,101,18241,18245,121,59,1,1118,118,101,59,1,365,4,2,105,121,18256,18265,114,99,5,251,1,59,18263,1,251,59,1,1091,4,3,97,98,104,18276,18281,18287,114,114,59,1,8645,108,97,99,59,1,369,97,114,59,1,10606,4,2,105,114,18298,18304,115,104,116,59,1,10622,59,3,55349,56626,114,97,118,101,5,249,1,59,18317,1,249,4,2,97,98,18325,18338,114,4,2,108,114,18332,18335,59,1,8639,59,1,8638,108,107,59,1,9600,4,2,99,116,18349,18374,4,2,111,114,18355,18369,114,110,4,2,59,101,18363,18365,1,8988,114,59,1,8988,111,112,59,1,8975,114,105,59,1,9720,4,2,97,108,18385,18390,99,114,59,1,363,5,168,1,59,18395,1,168,4,2,103,112,18403,18408,111,110,59,1,371,102,59,3,55349,56678,4,6,97,100,104,108,115,117,18427,18434,18445,18470,18475,18494,114,114,111,119,59,1,8593,111,119,110,97,114,114,111,119,59,1,8597,97,114,112,111,111,110,4,2,108,114,18457,18463,101,102,116,59,1,8639,105,103,104,116,59,1,8638,117,115,59,1,8846,105,4,3,59,104,108,18484,18486,18489,1,965,59,1,978,111,110,59,1,965,112,97,114,114,111,119,115,59,1,8648,4,3,99,105,116,18512,18537,18542,4,2,111,114,18518,18532,114,110,4,2,59,101,18526,18528,1,8989,114,59,1,8989,111,112,59,1,8974,110,103,59,1,367,114,105,59,1,9721,99,114,59,3,55349,56522,4,3,100,105,114,18561,18566,18572,111,116,59,1,8944,108,100,101,59,1,361,105,4,2,59,102,18579,18581,1,9653,59,1,9652,4,2,97,109,18590,18595,114,114,59,1,8648,108,5,252,1,59,18601,1,252,97,110,103,108,101,59,1,10663,4,15,65,66,68,97,99,100,101,102,108,110,111,112,114,115,122,18643,18648,18661,18667,18847,18851,18857,18904,18909,18915,18931,18937,18943,18949,18996,114,114,59,1,8661,97,114,4,2,59,118,18656,18658,1,10984,59,1,10985,97,115,104,59,1,8872,4,2,110,114,18673,18679,103,114,116,59,1,10652,4,7,101,107,110,112,114,115,116,18695,18704,18711,18720,18742,18754,18810,112,115,105,108,111,110,59,1,1013,97,112,112,97,59,1,1008,111,116,104,105,110,103,59,1,8709,4,3,104,105,114,18728,18732,18735,105,59,1,981,59,1,982,111,112,116,111,59,1,8733,4,2,59,104,18748,18750,1,8597,111,59,1,1009,4,2,105,117,18760,18766,103,109,97,59,1,962,4,2,98,112,18772,18791,115,101,116,110,101,113,4,2,59,113,18784,18787,3,8842,65024,59,3,10955,65024,115,101,116,110,101,113,4,2,59,113,18803,18806,3,8843,65024,59,3,10956,65024,4,2,104,114,18816,18822,101,116,97,59,1,977,105,97,110,103,108,101,4,2,108,114,18834,18840,101,102,116,59,1,8882,105,103,104,116,59,1,8883,121,59,1,1074,97,115,104,59,1,8866,4,3,101,108,114,18865,18884,18890,4,3,59,98,101,18873,18875,18880,1,8744,97,114,59,1,8891,113,59,1,8794,108,105,112,59,1,8942,4,2,98,116,18896,18901,97,114,59,1,124,59,1,124,114,59,3,55349,56627,116,114,105,59,1,8882,115,117,4,2,98,112,18923,18927,59,3,8834,8402,59,3,8835,8402,112,102,59,3,55349,56679,114,111,112,59,1,8733,116,114,105,59,1,8883,4,2,99,117,18955,18960,114,59,3,55349,56523,4,2,98,112,18966,18981,110,4,2,69,101,18973,18977,59,3,10955,65024,59,3,8842,65024,110,4,2,69,101,18988,18992,59,3,10956,65024,59,3,8843,65024,105,103,122,97,103,59,1,10650,4,7,99,101,102,111,112,114,115,19020,19026,19061,19066,19072,19075,19089,105,114,99,59,1,373,4,2,100,105,19032,19055,4,2,98,103,19038,19043,97,114,59,1,10847,101,4,2,59,113,19050,19052,1,8743,59,1,8793,101,114,112,59,1,8472,114,59,3,55349,56628,112,102,59,3,55349,56680,59,1,8472,4,2,59,101,19081,19083,1,8768,97,116,104,59,1,8768,99,114,59,3,55349,56524,4,14,99,100,102,104,105,108,109,110,111,114,115,117,118,119,19125,19146,19152,19157,19173,19176,19192,19197,19202,19236,19252,19269,19286,19291,4,3,97,105,117,19133,19137,19142,112,59,1,8898,114,99,59,1,9711,112,59,1,8899,116,114,105,59,1,9661,114,59,3,55349,56629,4,2,65,97,19163,19168,114,114,59,1,10234,114,114,59,1,10231,59,1,958,4,2,65,97,19182,19187,114,114,59,1,10232,114,114,59,1,10229,97,112,59,1,10236,105,115,59,1,8955,4,3,100,112,116,19210,19215,19230,111,116,59,1,10752,4,2,102,108,19221,19225,59,3,55349,56681,117,115,59,1,10753,105,109,101,59,1,10754,4,2,65,97,19242,19247,114,114,59,1,10233,114,114,59,1,10230,4,2,99,113,19258,19263,114,59,3,55349,56525,99,117,112,59,1,10758,4,2,112,116,19275,19281,108,117,115,59,1,10756,114,105,59,1,9651,101,101,59,1,8897,101,100,103,101,59,1,8896,4,8,97,99,101,102,105,111,115,117,19316,19335,19349,19357,19362,19367,19373,19379,99,4,2,117,121,19323,19332,116,101,5,253,1,59,19330,1,253,59,1,1103,4,2,105,121,19341,19346,114,99,59,1,375,59,1,1099,110,5,165,1,59,19355,1,165,114,59,3,55349,56630,99,121,59,1,1111,112,102,59,3,55349,56682,99,114,59,3,55349,56526,4,2,99,109,19385,19389,121,59,1,1102,108,5,255,1,59,19395,1,255,4,10,97,99,100,101,102,104,105,111,115,119,19419,19426,19441,19446,19462,19467,19472,19480,19486,19492,99,117,116,101,59,1,378,4,2,97,121,19432,19438,114,111,110,59,1,382,59,1,1079,111,116,59,1,380,4,2,101,116,19452,19458,116,114,102,59,1,8488,97,59,1,950,114,59,3,55349,56631,99,121,59,1,1078,103,114,97,114,114,59,1,8669,112,102,59,3,55349,56683,99,114,59,3,55349,56527,4,2,106,110,19498,19501,59,1,8205,106,59,1,8204]);

	const Preprocessor = preprocessor;
	const unicode$1 = unicode$3;
	const neTree = namedEntityData;
	const ERR$1 = errorCodes;

	//Aliases
	const $$6 = unicode$1.CODE_POINTS;
	const $$ = unicode$1.CODE_POINT_SEQUENCES;

	//C1 Unicode control character reference replacements
	const C1_CONTROLS_REFERENCE_REPLACEMENTS = {
	    0x80: 0x20ac,
	    0x82: 0x201a,
	    0x83: 0x0192,
	    0x84: 0x201e,
	    0x85: 0x2026,
	    0x86: 0x2020,
	    0x87: 0x2021,
	    0x88: 0x02c6,
	    0x89: 0x2030,
	    0x8a: 0x0160,
	    0x8b: 0x2039,
	    0x8c: 0x0152,
	    0x8e: 0x017d,
	    0x91: 0x2018,
	    0x92: 0x2019,
	    0x93: 0x201c,
	    0x94: 0x201d,
	    0x95: 0x2022,
	    0x96: 0x2013,
	    0x97: 0x2014,
	    0x98: 0x02dc,
	    0x99: 0x2122,
	    0x9a: 0x0161,
	    0x9b: 0x203a,
	    0x9c: 0x0153,
	    0x9e: 0x017e,
	    0x9f: 0x0178
	};

	// Named entity tree flags
	const HAS_DATA_FLAG = 1 << 0;
	const DATA_DUPLET_FLAG = 1 << 1;
	const HAS_BRANCHES_FLAG = 1 << 2;
	const MAX_BRANCH_MARKER_VALUE = HAS_DATA_FLAG | DATA_DUPLET_FLAG | HAS_BRANCHES_FLAG;

	//States
	const DATA_STATE = 'DATA_STATE';
	const RCDATA_STATE = 'RCDATA_STATE';
	const RAWTEXT_STATE = 'RAWTEXT_STATE';
	const SCRIPT_DATA_STATE = 'SCRIPT_DATA_STATE';
	const PLAINTEXT_STATE = 'PLAINTEXT_STATE';
	const TAG_OPEN_STATE = 'TAG_OPEN_STATE';
	const END_TAG_OPEN_STATE = 'END_TAG_OPEN_STATE';
	const TAG_NAME_STATE = 'TAG_NAME_STATE';
	const RCDATA_LESS_THAN_SIGN_STATE = 'RCDATA_LESS_THAN_SIGN_STATE';
	const RCDATA_END_TAG_OPEN_STATE = 'RCDATA_END_TAG_OPEN_STATE';
	const RCDATA_END_TAG_NAME_STATE = 'RCDATA_END_TAG_NAME_STATE';
	const RAWTEXT_LESS_THAN_SIGN_STATE = 'RAWTEXT_LESS_THAN_SIGN_STATE';
	const RAWTEXT_END_TAG_OPEN_STATE = 'RAWTEXT_END_TAG_OPEN_STATE';
	const RAWTEXT_END_TAG_NAME_STATE = 'RAWTEXT_END_TAG_NAME_STATE';
	const SCRIPT_DATA_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_LESS_THAN_SIGN_STATE';
	const SCRIPT_DATA_END_TAG_OPEN_STATE = 'SCRIPT_DATA_END_TAG_OPEN_STATE';
	const SCRIPT_DATA_END_TAG_NAME_STATE = 'SCRIPT_DATA_END_TAG_NAME_STATE';
	const SCRIPT_DATA_ESCAPE_START_STATE = 'SCRIPT_DATA_ESCAPE_START_STATE';
	const SCRIPT_DATA_ESCAPE_START_DASH_STATE = 'SCRIPT_DATA_ESCAPE_START_DASH_STATE';
	const SCRIPT_DATA_ESCAPED_STATE = 'SCRIPT_DATA_ESCAPED_STATE';
	const SCRIPT_DATA_ESCAPED_DASH_STATE = 'SCRIPT_DATA_ESCAPED_DASH_STATE';
	const SCRIPT_DATA_ESCAPED_DASH_DASH_STATE = 'SCRIPT_DATA_ESCAPED_DASH_DASH_STATE';
	const SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE';
	const SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE = 'SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE';
	const SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE = 'SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE';
	const SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE';
	const SCRIPT_DATA_DOUBLE_ESCAPED_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_STATE';
	const SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE';
	const SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE';
	const SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE';
	const SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE';
	const BEFORE_ATTRIBUTE_NAME_STATE = 'BEFORE_ATTRIBUTE_NAME_STATE';
	const ATTRIBUTE_NAME_STATE = 'ATTRIBUTE_NAME_STATE';
	const AFTER_ATTRIBUTE_NAME_STATE = 'AFTER_ATTRIBUTE_NAME_STATE';
	const BEFORE_ATTRIBUTE_VALUE_STATE = 'BEFORE_ATTRIBUTE_VALUE_STATE';
	const ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE = 'ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE';
	const ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE = 'ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE';
	const ATTRIBUTE_VALUE_UNQUOTED_STATE = 'ATTRIBUTE_VALUE_UNQUOTED_STATE';
	const AFTER_ATTRIBUTE_VALUE_QUOTED_STATE = 'AFTER_ATTRIBUTE_VALUE_QUOTED_STATE';
	const SELF_CLOSING_START_TAG_STATE = 'SELF_CLOSING_START_TAG_STATE';
	const BOGUS_COMMENT_STATE = 'BOGUS_COMMENT_STATE';
	const MARKUP_DECLARATION_OPEN_STATE = 'MARKUP_DECLARATION_OPEN_STATE';
	const COMMENT_START_STATE = 'COMMENT_START_STATE';
	const COMMENT_START_DASH_STATE = 'COMMENT_START_DASH_STATE';
	const COMMENT_STATE = 'COMMENT_STATE';
	const COMMENT_LESS_THAN_SIGN_STATE = 'COMMENT_LESS_THAN_SIGN_STATE';
	const COMMENT_LESS_THAN_SIGN_BANG_STATE = 'COMMENT_LESS_THAN_SIGN_BANG_STATE';
	const COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE = 'COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE';
	const COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE = 'COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE';
	const COMMENT_END_DASH_STATE = 'COMMENT_END_DASH_STATE';
	const COMMENT_END_STATE = 'COMMENT_END_STATE';
	const COMMENT_END_BANG_STATE = 'COMMENT_END_BANG_STATE';
	const DOCTYPE_STATE = 'DOCTYPE_STATE';
	const BEFORE_DOCTYPE_NAME_STATE = 'BEFORE_DOCTYPE_NAME_STATE';
	const DOCTYPE_NAME_STATE = 'DOCTYPE_NAME_STATE';
	const AFTER_DOCTYPE_NAME_STATE = 'AFTER_DOCTYPE_NAME_STATE';
	const AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE = 'AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE';
	const BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE = 'BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE';
	const DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE = 'DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE';
	const DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE = 'DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE';
	const AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE = 'AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE';
	const BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE = 'BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE';
	const AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE = 'AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE';
	const BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE = 'BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE';
	const DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE = 'DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE';
	const DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE = 'DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE';
	const AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE = 'AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE';
	const BOGUS_DOCTYPE_STATE = 'BOGUS_DOCTYPE_STATE';
	const CDATA_SECTION_STATE = 'CDATA_SECTION_STATE';
	const CDATA_SECTION_BRACKET_STATE = 'CDATA_SECTION_BRACKET_STATE';
	const CDATA_SECTION_END_STATE = 'CDATA_SECTION_END_STATE';
	const CHARACTER_REFERENCE_STATE = 'CHARACTER_REFERENCE_STATE';
	const NAMED_CHARACTER_REFERENCE_STATE = 'NAMED_CHARACTER_REFERENCE_STATE';
	const AMBIGUOUS_AMPERSAND_STATE = 'AMBIGUOS_AMPERSAND_STATE';
	const NUMERIC_CHARACTER_REFERENCE_STATE = 'NUMERIC_CHARACTER_REFERENCE_STATE';
	const HEXADEMICAL_CHARACTER_REFERENCE_START_STATE = 'HEXADEMICAL_CHARACTER_REFERENCE_START_STATE';
	const DECIMAL_CHARACTER_REFERENCE_START_STATE = 'DECIMAL_CHARACTER_REFERENCE_START_STATE';
	const HEXADEMICAL_CHARACTER_REFERENCE_STATE = 'HEXADEMICAL_CHARACTER_REFERENCE_STATE';
	const DECIMAL_CHARACTER_REFERENCE_STATE = 'DECIMAL_CHARACTER_REFERENCE_STATE';
	const NUMERIC_CHARACTER_REFERENCE_END_STATE = 'NUMERIC_CHARACTER_REFERENCE_END_STATE';

	//Utils

	//OPTIMIZATION: these utility functions should not be moved out of this module. V8 Crankshaft will not inline
	//this functions if they will be situated in another module due to context switch.
	//Always perform inlining check before modifying this functions ('node --trace-inlining').
	function isWhitespace(cp) {
	    return cp === $$6.SPACE || cp === $$6.LINE_FEED || cp === $$6.TABULATION || cp === $$6.FORM_FEED;
	}

	function isAsciiDigit(cp) {
	    return cp >= $$6.DIGIT_0 && cp <= $$6.DIGIT_9;
	}

	function isAsciiUpper(cp) {
	    return cp >= $$6.LATIN_CAPITAL_A && cp <= $$6.LATIN_CAPITAL_Z;
	}

	function isAsciiLower(cp) {
	    return cp >= $$6.LATIN_SMALL_A && cp <= $$6.LATIN_SMALL_Z;
	}

	function isAsciiLetter(cp) {
	    return isAsciiLower(cp) || isAsciiUpper(cp);
	}

	function isAsciiAlphaNumeric(cp) {
	    return isAsciiLetter(cp) || isAsciiDigit(cp);
	}

	function isAsciiUpperHexDigit(cp) {
	    return cp >= $$6.LATIN_CAPITAL_A && cp <= $$6.LATIN_CAPITAL_F;
	}

	function isAsciiLowerHexDigit(cp) {
	    return cp >= $$6.LATIN_SMALL_A && cp <= $$6.LATIN_SMALL_F;
	}

	function isAsciiHexDigit(cp) {
	    return isAsciiDigit(cp) || isAsciiUpperHexDigit(cp) || isAsciiLowerHexDigit(cp);
	}

	function toAsciiLowerCodePoint(cp) {
	    return cp + 0x0020;
	}

	//NOTE: String.fromCharCode() function can handle only characters from BMP subset.
	//So, we need to workaround this manually.
	//(see: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/fromCharCode#Getting_it_to_work_with_higher_values)
	function toChar(cp) {
	    if (cp <= 0xffff) {
	        return String.fromCharCode(cp);
	    }

	    cp -= 0x10000;
	    return String.fromCharCode(((cp >>> 10) & 0x3ff) | 0xd800) + String.fromCharCode(0xdc00 | (cp & 0x3ff));
	}

	function toAsciiLowerChar(cp) {
	    return String.fromCharCode(toAsciiLowerCodePoint(cp));
	}

	function findNamedEntityTreeBranch(nodeIx, cp) {
	    const branchCount = neTree[++nodeIx];
	    let lo = ++nodeIx;
	    let hi = lo + branchCount - 1;

	    while (lo <= hi) {
	        const mid = (lo + hi) >>> 1;
	        const midCp = neTree[mid];

	        if (midCp < cp) {
	            lo = mid + 1;
	        } else if (midCp > cp) {
	            hi = mid - 1;
	        } else {
	            return neTree[mid + branchCount];
	        }
	    }

	    return -1;
	}

	//Tokenizer
	let Tokenizer$4 = class Tokenizer {
	    constructor() {
	        this.preprocessor = new Preprocessor();

	        this.tokenQueue = [];

	        this.allowCDATA = false;

	        this.state = DATA_STATE;
	        this.returnState = '';

	        this.charRefCode = -1;
	        this.tempBuff = [];
	        this.lastStartTagName = '';

	        this.consumedAfterSnapshot = -1;
	        this.active = false;

	        this.currentCharacterToken = null;
	        this.currentToken = null;
	        this.currentAttr = null;
	    }

	    //Errors
	    _err() {
	        // NOTE: err reporting is noop by default. Enabled by mixin.
	    }

	    _errOnNextCodePoint(err) {
	        this._consume();
	        this._err(err);
	        this._unconsume();
	    }

	    //API
	    getNextToken() {
	        while (!this.tokenQueue.length && this.active) {
	            this.consumedAfterSnapshot = 0;

	            const cp = this._consume();

	            if (!this._ensureHibernation()) {
	                this[this.state](cp);
	            }
	        }

	        return this.tokenQueue.shift();
	    }

	    write(chunk, isLastChunk) {
	        this.active = true;
	        this.preprocessor.write(chunk, isLastChunk);
	    }

	    insertHtmlAtCurrentPos(chunk) {
	        this.active = true;
	        this.preprocessor.insertHtmlAtCurrentPos(chunk);
	    }

	    //Hibernation
	    _ensureHibernation() {
	        if (this.preprocessor.endOfChunkHit) {
	            for (; this.consumedAfterSnapshot > 0; this.consumedAfterSnapshot--) {
	                this.preprocessor.retreat();
	            }

	            this.active = false;
	            this.tokenQueue.push({ type: Tokenizer.HIBERNATION_TOKEN });

	            return true;
	        }

	        return false;
	    }

	    //Consumption
	    _consume() {
	        this.consumedAfterSnapshot++;
	        return this.preprocessor.advance();
	    }

	    _unconsume() {
	        this.consumedAfterSnapshot--;
	        this.preprocessor.retreat();
	    }

	    _reconsumeInState(state) {
	        this.state = state;
	        this._unconsume();
	    }

	    _consumeSequenceIfMatch(pattern, startCp, caseSensitive) {
	        let consumedCount = 0;
	        let isMatch = true;
	        const patternLength = pattern.length;
	        let patternPos = 0;
	        let cp = startCp;
	        let patternCp = void 0;

	        for (; patternPos < patternLength; patternPos++) {
	            if (patternPos > 0) {
	                cp = this._consume();
	                consumedCount++;
	            }

	            if (cp === $$6.EOF) {
	                isMatch = false;
	                break;
	            }

	            patternCp = pattern[patternPos];

	            if (cp !== patternCp && (caseSensitive || cp !== toAsciiLowerCodePoint(patternCp))) {
	                isMatch = false;
	                break;
	            }
	        }

	        if (!isMatch) {
	            while (consumedCount--) {
	                this._unconsume();
	            }
	        }

	        return isMatch;
	    }

	    //Temp buffer
	    _isTempBufferEqualToScriptString() {
	        if (this.tempBuff.length !== $$.SCRIPT_STRING.length) {
	            return false;
	        }

	        for (let i = 0; i < this.tempBuff.length; i++) {
	            if (this.tempBuff[i] !== $$.SCRIPT_STRING[i]) {
	                return false;
	            }
	        }

	        return true;
	    }

	    //Token creation
	    _createStartTagToken() {
	        this.currentToken = {
	            type: Tokenizer.START_TAG_TOKEN,
	            tagName: '',
	            selfClosing: false,
	            ackSelfClosing: false,
	            attrs: []
	        };
	    }

	    _createEndTagToken() {
	        this.currentToken = {
	            type: Tokenizer.END_TAG_TOKEN,
	            tagName: '',
	            selfClosing: false,
	            attrs: []
	        };
	    }

	    _createCommentToken() {
	        this.currentToken = {
	            type: Tokenizer.COMMENT_TOKEN,
	            data: ''
	        };
	    }

	    _createDoctypeToken(initialName) {
	        this.currentToken = {
	            type: Tokenizer.DOCTYPE_TOKEN,
	            name: initialName,
	            forceQuirks: false,
	            publicId: null,
	            systemId: null
	        };
	    }

	    _createCharacterToken(type, ch) {
	        this.currentCharacterToken = {
	            type: type,
	            chars: ch
	        };
	    }

	    _createEOFToken() {
	        this.currentToken = { type: Tokenizer.EOF_TOKEN };
	    }

	    //Tag attributes
	    _createAttr(attrNameFirstCh) {
	        this.currentAttr = {
	            name: attrNameFirstCh,
	            value: ''
	        };
	    }

	    _leaveAttrName(toState) {
	        if (Tokenizer.getTokenAttr(this.currentToken, this.currentAttr.name) === null) {
	            this.currentToken.attrs.push(this.currentAttr);
	        } else {
	            this._err(ERR$1.duplicateAttribute);
	        }

	        this.state = toState;
	    }

	    _leaveAttrValue(toState) {
	        this.state = toState;
	    }

	    //Token emission
	    _emitCurrentToken() {
	        this._emitCurrentCharacterToken();

	        const ct = this.currentToken;

	        this.currentToken = null;

	        //NOTE: store emited start tag's tagName to determine is the following end tag token is appropriate.
	        if (ct.type === Tokenizer.START_TAG_TOKEN) {
	            this.lastStartTagName = ct.tagName;
	        } else if (ct.type === Tokenizer.END_TAG_TOKEN) {
	            if (ct.attrs.length > 0) {
	                this._err(ERR$1.endTagWithAttributes);
	            }

	            if (ct.selfClosing) {
	                this._err(ERR$1.endTagWithTrailingSolidus);
	            }
	        }

	        this.tokenQueue.push(ct);
	    }

	    _emitCurrentCharacterToken() {
	        if (this.currentCharacterToken) {
	            this.tokenQueue.push(this.currentCharacterToken);
	            this.currentCharacterToken = null;
	        }
	    }

	    _emitEOFToken() {
	        this._createEOFToken();
	        this._emitCurrentToken();
	    }

	    //Characters emission

	    //OPTIMIZATION: specification uses only one type of character tokens (one token per character).
	    //This causes a huge memory overhead and a lot of unnecessary parser loops. parse5 uses 3 groups of characters.
	    //If we have a sequence of characters that belong to the same group, parser can process it
	    //as a single solid character token.
	    //So, there are 3 types of character tokens in parse5:
	    //1)NULL_CHARACTER_TOKEN - \u0000-character sequences (e.g. '\u0000\u0000\u0000')
	    //2)WHITESPACE_CHARACTER_TOKEN - any whitespace/new-line character sequences (e.g. '\n  \r\t   \f')
	    //3)CHARACTER_TOKEN - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^')
	    _appendCharToCurrentCharacterToken(type, ch) {
	        if (this.currentCharacterToken && this.currentCharacterToken.type !== type) {
	            this._emitCurrentCharacterToken();
	        }

	        if (this.currentCharacterToken) {
	            this.currentCharacterToken.chars += ch;
	        } else {
	            this._createCharacterToken(type, ch);
	        }
	    }

	    _emitCodePoint(cp) {
	        let type = Tokenizer.CHARACTER_TOKEN;

	        if (isWhitespace(cp)) {
	            type = Tokenizer.WHITESPACE_CHARACTER_TOKEN;
	        } else if (cp === $$6.NULL) {
	            type = Tokenizer.NULL_CHARACTER_TOKEN;
	        }

	        this._appendCharToCurrentCharacterToken(type, toChar(cp));
	    }

	    _emitSeveralCodePoints(codePoints) {
	        for (let i = 0; i < codePoints.length; i++) {
	            this._emitCodePoint(codePoints[i]);
	        }
	    }

	    //NOTE: used then we emit character explicitly. This is always a non-whitespace and a non-null character.
	    //So we can avoid additional checks here.
	    _emitChars(ch) {
	        this._appendCharToCurrentCharacterToken(Tokenizer.CHARACTER_TOKEN, ch);
	    }

	    // Character reference helpers
	    _matchNamedCharacterReference(startCp) {
	        let result = null;
	        let excess = 1;
	        let i = findNamedEntityTreeBranch(0, startCp);

	        this.tempBuff.push(startCp);

	        while (i > -1) {
	            const current = neTree[i];
	            const inNode = current < MAX_BRANCH_MARKER_VALUE;
	            const nodeWithData = inNode && current & HAS_DATA_FLAG;

	            if (nodeWithData) {
	                //NOTE: we use greedy search, so we continue lookup at this point
	                result = current & DATA_DUPLET_FLAG ? [neTree[++i], neTree[++i]] : [neTree[++i]];
	                excess = 0;
	            }

	            const cp = this._consume();

	            this.tempBuff.push(cp);
	            excess++;

	            if (cp === $$6.EOF) {
	                break;
	            }

	            if (inNode) {
	                i = current & HAS_BRANCHES_FLAG ? findNamedEntityTreeBranch(i, cp) : -1;
	            } else {
	                i = cp === current ? ++i : -1;
	            }
	        }

	        while (excess--) {
	            this.tempBuff.pop();
	            this._unconsume();
	        }

	        return result;
	    }

	    _isCharacterReferenceInAttribute() {
	        return (
	            this.returnState === ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE ||
	            this.returnState === ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE ||
	            this.returnState === ATTRIBUTE_VALUE_UNQUOTED_STATE
	        );
	    }

	    _isCharacterReferenceAttributeQuirk(withSemicolon) {
	        if (!withSemicolon && this._isCharacterReferenceInAttribute()) {
	            const nextCp = this._consume();

	            this._unconsume();

	            return nextCp === $$6.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp);
	        }

	        return false;
	    }

	    _flushCodePointsConsumedAsCharacterReference() {
	        if (this._isCharacterReferenceInAttribute()) {
	            for (let i = 0; i < this.tempBuff.length; i++) {
	                this.currentAttr.value += toChar(this.tempBuff[i]);
	            }
	        } else {
	            this._emitSeveralCodePoints(this.tempBuff);
	        }

	        this.tempBuff = [];
	    }

	    // State machine

	    // Data state
	    //------------------------------------------------------------------
	    [DATA_STATE](cp) {
	        this.preprocessor.dropParsedChunk();

	        if (cp === $$6.LESS_THAN_SIGN) {
	            this.state = TAG_OPEN_STATE;
	        } else if (cp === $$6.AMPERSAND) {
	            this.returnState = DATA_STATE;
	            this.state = CHARACTER_REFERENCE_STATE;
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this._emitCodePoint(cp);
	        } else if (cp === $$6.EOF) {
	            this._emitEOFToken();
	        } else {
	            this._emitCodePoint(cp);
	        }
	    }

	    //  RCDATA state
	    //------------------------------------------------------------------
	    [RCDATA_STATE](cp) {
	        this.preprocessor.dropParsedChunk();

	        if (cp === $$6.AMPERSAND) {
	            this.returnState = RCDATA_STATE;
	            this.state = CHARACTER_REFERENCE_STATE;
	        } else if (cp === $$6.LESS_THAN_SIGN) {
	            this.state = RCDATA_LESS_THAN_SIGN_STATE;
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this._emitChars(unicode$1.REPLACEMENT_CHARACTER);
	        } else if (cp === $$6.EOF) {
	            this._emitEOFToken();
	        } else {
	            this._emitCodePoint(cp);
	        }
	    }

	    // RAWTEXT state
	    //------------------------------------------------------------------
	    [RAWTEXT_STATE](cp) {
	        this.preprocessor.dropParsedChunk();

	        if (cp === $$6.LESS_THAN_SIGN) {
	            this.state = RAWTEXT_LESS_THAN_SIGN_STATE;
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this._emitChars(unicode$1.REPLACEMENT_CHARACTER);
	        } else if (cp === $$6.EOF) {
	            this._emitEOFToken();
	        } else {
	            this._emitCodePoint(cp);
	        }
	    }

	    // Script data state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_STATE](cp) {
	        this.preprocessor.dropParsedChunk();

	        if (cp === $$6.LESS_THAN_SIGN) {
	            this.state = SCRIPT_DATA_LESS_THAN_SIGN_STATE;
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this._emitChars(unicode$1.REPLACEMENT_CHARACTER);
	        } else if (cp === $$6.EOF) {
	            this._emitEOFToken();
	        } else {
	            this._emitCodePoint(cp);
	        }
	    }

	    // PLAINTEXT state
	    //------------------------------------------------------------------
	    [PLAINTEXT_STATE](cp) {
	        this.preprocessor.dropParsedChunk();

	        if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this._emitChars(unicode$1.REPLACEMENT_CHARACTER);
	        } else if (cp === $$6.EOF) {
	            this._emitEOFToken();
	        } else {
	            this._emitCodePoint(cp);
	        }
	    }

	    // Tag open state
	    //------------------------------------------------------------------
	    [TAG_OPEN_STATE](cp) {
	        if (cp === $$6.EXCLAMATION_MARK) {
	            this.state = MARKUP_DECLARATION_OPEN_STATE;
	        } else if (cp === $$6.SOLIDUS) {
	            this.state = END_TAG_OPEN_STATE;
	        } else if (isAsciiLetter(cp)) {
	            this._createStartTagToken();
	            this._reconsumeInState(TAG_NAME_STATE);
	        } else if (cp === $$6.QUESTION_MARK) {
	            this._err(ERR$1.unexpectedQuestionMarkInsteadOfTagName);
	            this._createCommentToken();
	            this._reconsumeInState(BOGUS_COMMENT_STATE);
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofBeforeTagName);
	            this._emitChars('<');
	            this._emitEOFToken();
	        } else {
	            this._err(ERR$1.invalidFirstCharacterOfTagName);
	            this._emitChars('<');
	            this._reconsumeInState(DATA_STATE);
	        }
	    }

	    // End tag open state
	    //------------------------------------------------------------------
	    [END_TAG_OPEN_STATE](cp) {
	        if (isAsciiLetter(cp)) {
	            this._createEndTagToken();
	            this._reconsumeInState(TAG_NAME_STATE);
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._err(ERR$1.missingEndTagName);
	            this.state = DATA_STATE;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofBeforeTagName);
	            this._emitChars('</');
	            this._emitEOFToken();
	        } else {
	            this._err(ERR$1.invalidFirstCharacterOfTagName);
	            this._createCommentToken();
	            this._reconsumeInState(BOGUS_COMMENT_STATE);
	        }
	    }

	    // Tag name state
	    //------------------------------------------------------------------
	    [TAG_NAME_STATE](cp) {
	        if (isWhitespace(cp)) {
	            this.state = BEFORE_ATTRIBUTE_NAME_STATE;
	        } else if (cp === $$6.SOLIDUS) {
	            this.state = SELF_CLOSING_START_TAG_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else if (isAsciiUpper(cp)) {
	            this.currentToken.tagName += toAsciiLowerChar(cp);
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.currentToken.tagName += unicode$1.REPLACEMENT_CHARACTER;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInTag);
	            this._emitEOFToken();
	        } else {
	            this.currentToken.tagName += toChar(cp);
	        }
	    }

	    // RCDATA less-than sign state
	    //------------------------------------------------------------------
	    [RCDATA_LESS_THAN_SIGN_STATE](cp) {
	        if (cp === $$6.SOLIDUS) {
	            this.tempBuff = [];
	            this.state = RCDATA_END_TAG_OPEN_STATE;
	        } else {
	            this._emitChars('<');
	            this._reconsumeInState(RCDATA_STATE);
	        }
	    }

	    // RCDATA end tag open state
	    //------------------------------------------------------------------
	    [RCDATA_END_TAG_OPEN_STATE](cp) {
	        if (isAsciiLetter(cp)) {
	            this._createEndTagToken();
	            this._reconsumeInState(RCDATA_END_TAG_NAME_STATE);
	        } else {
	            this._emitChars('</');
	            this._reconsumeInState(RCDATA_STATE);
	        }
	    }

	    // RCDATA end tag name state
	    //------------------------------------------------------------------
	    [RCDATA_END_TAG_NAME_STATE](cp) {
	        if (isAsciiUpper(cp)) {
	            this.currentToken.tagName += toAsciiLowerChar(cp);
	            this.tempBuff.push(cp);
	        } else if (isAsciiLower(cp)) {
	            this.currentToken.tagName += toChar(cp);
	            this.tempBuff.push(cp);
	        } else {
	            if (this.lastStartTagName === this.currentToken.tagName) {
	                if (isWhitespace(cp)) {
	                    this.state = BEFORE_ATTRIBUTE_NAME_STATE;
	                    return;
	                }

	                if (cp === $$6.SOLIDUS) {
	                    this.state = SELF_CLOSING_START_TAG_STATE;
	                    return;
	                }

	                if (cp === $$6.GREATER_THAN_SIGN) {
	                    this.state = DATA_STATE;
	                    this._emitCurrentToken();
	                    return;
	                }
	            }

	            this._emitChars('</');
	            this._emitSeveralCodePoints(this.tempBuff);
	            this._reconsumeInState(RCDATA_STATE);
	        }
	    }

	    // RAWTEXT less-than sign state
	    //------------------------------------------------------------------
	    [RAWTEXT_LESS_THAN_SIGN_STATE](cp) {
	        if (cp === $$6.SOLIDUS) {
	            this.tempBuff = [];
	            this.state = RAWTEXT_END_TAG_OPEN_STATE;
	        } else {
	            this._emitChars('<');
	            this._reconsumeInState(RAWTEXT_STATE);
	        }
	    }

	    // RAWTEXT end tag open state
	    //------------------------------------------------------------------
	    [RAWTEXT_END_TAG_OPEN_STATE](cp) {
	        if (isAsciiLetter(cp)) {
	            this._createEndTagToken();
	            this._reconsumeInState(RAWTEXT_END_TAG_NAME_STATE);
	        } else {
	            this._emitChars('</');
	            this._reconsumeInState(RAWTEXT_STATE);
	        }
	    }

	    // RAWTEXT end tag name state
	    //------------------------------------------------------------------
	    [RAWTEXT_END_TAG_NAME_STATE](cp) {
	        if (isAsciiUpper(cp)) {
	            this.currentToken.tagName += toAsciiLowerChar(cp);
	            this.tempBuff.push(cp);
	        } else if (isAsciiLower(cp)) {
	            this.currentToken.tagName += toChar(cp);
	            this.tempBuff.push(cp);
	        } else {
	            if (this.lastStartTagName === this.currentToken.tagName) {
	                if (isWhitespace(cp)) {
	                    this.state = BEFORE_ATTRIBUTE_NAME_STATE;
	                    return;
	                }

	                if (cp === $$6.SOLIDUS) {
	                    this.state = SELF_CLOSING_START_TAG_STATE;
	                    return;
	                }

	                if (cp === $$6.GREATER_THAN_SIGN) {
	                    this._emitCurrentToken();
	                    this.state = DATA_STATE;
	                    return;
	                }
	            }

	            this._emitChars('</');
	            this._emitSeveralCodePoints(this.tempBuff);
	            this._reconsumeInState(RAWTEXT_STATE);
	        }
	    }

	    // Script data less-than sign state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_LESS_THAN_SIGN_STATE](cp) {
	        if (cp === $$6.SOLIDUS) {
	            this.tempBuff = [];
	            this.state = SCRIPT_DATA_END_TAG_OPEN_STATE;
	        } else if (cp === $$6.EXCLAMATION_MARK) {
	            this.state = SCRIPT_DATA_ESCAPE_START_STATE;
	            this._emitChars('<!');
	        } else {
	            this._emitChars('<');
	            this._reconsumeInState(SCRIPT_DATA_STATE);
	        }
	    }

	    // Script data end tag open state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_END_TAG_OPEN_STATE](cp) {
	        if (isAsciiLetter(cp)) {
	            this._createEndTagToken();
	            this._reconsumeInState(SCRIPT_DATA_END_TAG_NAME_STATE);
	        } else {
	            this._emitChars('</');
	            this._reconsumeInState(SCRIPT_DATA_STATE);
	        }
	    }

	    // Script data end tag name state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_END_TAG_NAME_STATE](cp) {
	        if (isAsciiUpper(cp)) {
	            this.currentToken.tagName += toAsciiLowerChar(cp);
	            this.tempBuff.push(cp);
	        } else if (isAsciiLower(cp)) {
	            this.currentToken.tagName += toChar(cp);
	            this.tempBuff.push(cp);
	        } else {
	            if (this.lastStartTagName === this.currentToken.tagName) {
	                if (isWhitespace(cp)) {
	                    this.state = BEFORE_ATTRIBUTE_NAME_STATE;
	                    return;
	                } else if (cp === $$6.SOLIDUS) {
	                    this.state = SELF_CLOSING_START_TAG_STATE;
	                    return;
	                } else if (cp === $$6.GREATER_THAN_SIGN) {
	                    this._emitCurrentToken();
	                    this.state = DATA_STATE;
	                    return;
	                }
	            }

	            this._emitChars('</');
	            this._emitSeveralCodePoints(this.tempBuff);
	            this._reconsumeInState(SCRIPT_DATA_STATE);
	        }
	    }

	    // Script data escape start state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_ESCAPE_START_STATE](cp) {
	        if (cp === $$6.HYPHEN_MINUS) {
	            this.state = SCRIPT_DATA_ESCAPE_START_DASH_STATE;
	            this._emitChars('-');
	        } else {
	            this._reconsumeInState(SCRIPT_DATA_STATE);
	        }
	    }

	    // Script data escape start dash state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_ESCAPE_START_DASH_STATE](cp) {
	        if (cp === $$6.HYPHEN_MINUS) {
	            this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE;
	            this._emitChars('-');
	        } else {
	            this._reconsumeInState(SCRIPT_DATA_STATE);
	        }
	    }

	    // Script data escaped state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_ESCAPED_STATE](cp) {
	        if (cp === $$6.HYPHEN_MINUS) {
	            this.state = SCRIPT_DATA_ESCAPED_DASH_STATE;
	            this._emitChars('-');
	        } else if (cp === $$6.LESS_THAN_SIGN) {
	            this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this._emitChars(unicode$1.REPLACEMENT_CHARACTER);
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInScriptHtmlCommentLikeText);
	            this._emitEOFToken();
	        } else {
	            this._emitCodePoint(cp);
	        }
	    }

	    // Script data escaped dash state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_ESCAPED_DASH_STATE](cp) {
	        if (cp === $$6.HYPHEN_MINUS) {
	            this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE;
	            this._emitChars('-');
	        } else if (cp === $$6.LESS_THAN_SIGN) {
	            this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.state = SCRIPT_DATA_ESCAPED_STATE;
	            this._emitChars(unicode$1.REPLACEMENT_CHARACTER);
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInScriptHtmlCommentLikeText);
	            this._emitEOFToken();
	        } else {
	            this.state = SCRIPT_DATA_ESCAPED_STATE;
	            this._emitCodePoint(cp);
	        }
	    }

	    // Script data escaped dash dash state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_ESCAPED_DASH_DASH_STATE](cp) {
	        if (cp === $$6.HYPHEN_MINUS) {
	            this._emitChars('-');
	        } else if (cp === $$6.LESS_THAN_SIGN) {
	            this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this.state = SCRIPT_DATA_STATE;
	            this._emitChars('>');
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.state = SCRIPT_DATA_ESCAPED_STATE;
	            this._emitChars(unicode$1.REPLACEMENT_CHARACTER);
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInScriptHtmlCommentLikeText);
	            this._emitEOFToken();
	        } else {
	            this.state = SCRIPT_DATA_ESCAPED_STATE;
	            this._emitCodePoint(cp);
	        }
	    }

	    // Script data escaped less-than sign state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE](cp) {
	        if (cp === $$6.SOLIDUS) {
	            this.tempBuff = [];
	            this.state = SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE;
	        } else if (isAsciiLetter(cp)) {
	            this.tempBuff = [];
	            this._emitChars('<');
	            this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE);
	        } else {
	            this._emitChars('<');
	            this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
	        }
	    }

	    // Script data escaped end tag open state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE](cp) {
	        if (isAsciiLetter(cp)) {
	            this._createEndTagToken();
	            this._reconsumeInState(SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE);
	        } else {
	            this._emitChars('</');
	            this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
	        }
	    }

	    // Script data escaped end tag name state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE](cp) {
	        if (isAsciiUpper(cp)) {
	            this.currentToken.tagName += toAsciiLowerChar(cp);
	            this.tempBuff.push(cp);
	        } else if (isAsciiLower(cp)) {
	            this.currentToken.tagName += toChar(cp);
	            this.tempBuff.push(cp);
	        } else {
	            if (this.lastStartTagName === this.currentToken.tagName) {
	                if (isWhitespace(cp)) {
	                    this.state = BEFORE_ATTRIBUTE_NAME_STATE;
	                    return;
	                }

	                if (cp === $$6.SOLIDUS) {
	                    this.state = SELF_CLOSING_START_TAG_STATE;
	                    return;
	                }

	                if (cp === $$6.GREATER_THAN_SIGN) {
	                    this._emitCurrentToken();
	                    this.state = DATA_STATE;
	                    return;
	                }
	            }

	            this._emitChars('</');
	            this._emitSeveralCodePoints(this.tempBuff);
	            this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
	        }
	    }

	    // Script data double escape start state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE](cp) {
	        if (isWhitespace(cp) || cp === $$6.SOLIDUS || cp === $$6.GREATER_THAN_SIGN) {
	            this.state = this._isTempBufferEqualToScriptString()
	                ? SCRIPT_DATA_DOUBLE_ESCAPED_STATE
	                : SCRIPT_DATA_ESCAPED_STATE;
	            this._emitCodePoint(cp);
	        } else if (isAsciiUpper(cp)) {
	            this.tempBuff.push(toAsciiLowerCodePoint(cp));
	            this._emitCodePoint(cp);
	        } else if (isAsciiLower(cp)) {
	            this.tempBuff.push(cp);
	            this._emitCodePoint(cp);
	        } else {
	            this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
	        }
	    }

	    // Script data double escaped state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_DOUBLE_ESCAPED_STATE](cp) {
	        if (cp === $$6.HYPHEN_MINUS) {
	            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE;
	            this._emitChars('-');
	        } else if (cp === $$6.LESS_THAN_SIGN) {
	            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;
	            this._emitChars('<');
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this._emitChars(unicode$1.REPLACEMENT_CHARACTER);
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInScriptHtmlCommentLikeText);
	            this._emitEOFToken();
	        } else {
	            this._emitCodePoint(cp);
	        }
	    }

	    // Script data double escaped dash state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE](cp) {
	        if (cp === $$6.HYPHEN_MINUS) {
	            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE;
	            this._emitChars('-');
	        } else if (cp === $$6.LESS_THAN_SIGN) {
	            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;
	            this._emitChars('<');
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
	            this._emitChars(unicode$1.REPLACEMENT_CHARACTER);
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInScriptHtmlCommentLikeText);
	            this._emitEOFToken();
	        } else {
	            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
	            this._emitCodePoint(cp);
	        }
	    }

	    // Script data double escaped dash dash state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE](cp) {
	        if (cp === $$6.HYPHEN_MINUS) {
	            this._emitChars('-');
	        } else if (cp === $$6.LESS_THAN_SIGN) {
	            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;
	            this._emitChars('<');
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this.state = SCRIPT_DATA_STATE;
	            this._emitChars('>');
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
	            this._emitChars(unicode$1.REPLACEMENT_CHARACTER);
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInScriptHtmlCommentLikeText);
	            this._emitEOFToken();
	        } else {
	            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
	            this._emitCodePoint(cp);
	        }
	    }

	    // Script data double escaped less-than sign state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE](cp) {
	        if (cp === $$6.SOLIDUS) {
	            this.tempBuff = [];
	            this.state = SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE;
	            this._emitChars('/');
	        } else {
	            this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPED_STATE);
	        }
	    }

	    // Script data double escape end state
	    //------------------------------------------------------------------
	    [SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE](cp) {
	        if (isWhitespace(cp) || cp === $$6.SOLIDUS || cp === $$6.GREATER_THAN_SIGN) {
	            this.state = this._isTempBufferEqualToScriptString()
	                ? SCRIPT_DATA_ESCAPED_STATE
	                : SCRIPT_DATA_DOUBLE_ESCAPED_STATE;

	            this._emitCodePoint(cp);
	        } else if (isAsciiUpper(cp)) {
	            this.tempBuff.push(toAsciiLowerCodePoint(cp));
	            this._emitCodePoint(cp);
	        } else if (isAsciiLower(cp)) {
	            this.tempBuff.push(cp);
	            this._emitCodePoint(cp);
	        } else {
	            this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPED_STATE);
	        }
	    }

	    // Before attribute name state
	    //------------------------------------------------------------------
	    [BEFORE_ATTRIBUTE_NAME_STATE](cp) {
	        if (isWhitespace(cp)) {
	            return;
	        }

	        if (cp === $$6.SOLIDUS || cp === $$6.GREATER_THAN_SIGN || cp === $$6.EOF) {
	            this._reconsumeInState(AFTER_ATTRIBUTE_NAME_STATE);
	        } else if (cp === $$6.EQUALS_SIGN) {
	            this._err(ERR$1.unexpectedEqualsSignBeforeAttributeName);
	            this._createAttr('=');
	            this.state = ATTRIBUTE_NAME_STATE;
	        } else {
	            this._createAttr('');
	            this._reconsumeInState(ATTRIBUTE_NAME_STATE);
	        }
	    }

	    // Attribute name state
	    //------------------------------------------------------------------
	    [ATTRIBUTE_NAME_STATE](cp) {
	        if (isWhitespace(cp) || cp === $$6.SOLIDUS || cp === $$6.GREATER_THAN_SIGN || cp === $$6.EOF) {
	            this._leaveAttrName(AFTER_ATTRIBUTE_NAME_STATE);
	            this._unconsume();
	        } else if (cp === $$6.EQUALS_SIGN) {
	            this._leaveAttrName(BEFORE_ATTRIBUTE_VALUE_STATE);
	        } else if (isAsciiUpper(cp)) {
	            this.currentAttr.name += toAsciiLowerChar(cp);
	        } else if (cp === $$6.QUOTATION_MARK || cp === $$6.APOSTROPHE || cp === $$6.LESS_THAN_SIGN) {
	            this._err(ERR$1.unexpectedCharacterInAttributeName);
	            this.currentAttr.name += toChar(cp);
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.currentAttr.name += unicode$1.REPLACEMENT_CHARACTER;
	        } else {
	            this.currentAttr.name += toChar(cp);
	        }
	    }

	    // After attribute name state
	    //------------------------------------------------------------------
	    [AFTER_ATTRIBUTE_NAME_STATE](cp) {
	        if (isWhitespace(cp)) {
	            return;
	        }

	        if (cp === $$6.SOLIDUS) {
	            this.state = SELF_CLOSING_START_TAG_STATE;
	        } else if (cp === $$6.EQUALS_SIGN) {
	            this.state = BEFORE_ATTRIBUTE_VALUE_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInTag);
	            this._emitEOFToken();
	        } else {
	            this._createAttr('');
	            this._reconsumeInState(ATTRIBUTE_NAME_STATE);
	        }
	    }

	    // Before attribute value state
	    //------------------------------------------------------------------
	    [BEFORE_ATTRIBUTE_VALUE_STATE](cp) {
	        if (isWhitespace(cp)) {
	            return;
	        }

	        if (cp === $$6.QUOTATION_MARK) {
	            this.state = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
	        } else if (cp === $$6.APOSTROPHE) {
	            this.state = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._err(ERR$1.missingAttributeValue);
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else {
	            this._reconsumeInState(ATTRIBUTE_VALUE_UNQUOTED_STATE);
	        }
	    }

	    // Attribute value (double-quoted) state
	    //------------------------------------------------------------------
	    [ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE](cp) {
	        if (cp === $$6.QUOTATION_MARK) {
	            this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
	        } else if (cp === $$6.AMPERSAND) {
	            this.returnState = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
	            this.state = CHARACTER_REFERENCE_STATE;
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.currentAttr.value += unicode$1.REPLACEMENT_CHARACTER;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInTag);
	            this._emitEOFToken();
	        } else {
	            this.currentAttr.value += toChar(cp);
	        }
	    }

	    // Attribute value (single-quoted) state
	    //------------------------------------------------------------------
	    [ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE](cp) {
	        if (cp === $$6.APOSTROPHE) {
	            this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
	        } else if (cp === $$6.AMPERSAND) {
	            this.returnState = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
	            this.state = CHARACTER_REFERENCE_STATE;
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.currentAttr.value += unicode$1.REPLACEMENT_CHARACTER;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInTag);
	            this._emitEOFToken();
	        } else {
	            this.currentAttr.value += toChar(cp);
	        }
	    }

	    // Attribute value (unquoted) state
	    //------------------------------------------------------------------
	    [ATTRIBUTE_VALUE_UNQUOTED_STATE](cp) {
	        if (isWhitespace(cp)) {
	            this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE);
	        } else if (cp === $$6.AMPERSAND) {
	            this.returnState = ATTRIBUTE_VALUE_UNQUOTED_STATE;
	            this.state = CHARACTER_REFERENCE_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._leaveAttrValue(DATA_STATE);
	            this._emitCurrentToken();
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.currentAttr.value += unicode$1.REPLACEMENT_CHARACTER;
	        } else if (
	            cp === $$6.QUOTATION_MARK ||
	            cp === $$6.APOSTROPHE ||
	            cp === $$6.LESS_THAN_SIGN ||
	            cp === $$6.EQUALS_SIGN ||
	            cp === $$6.GRAVE_ACCENT
	        ) {
	            this._err(ERR$1.unexpectedCharacterInUnquotedAttributeValue);
	            this.currentAttr.value += toChar(cp);
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInTag);
	            this._emitEOFToken();
	        } else {
	            this.currentAttr.value += toChar(cp);
	        }
	    }

	    // After attribute value (quoted) state
	    //------------------------------------------------------------------
	    [AFTER_ATTRIBUTE_VALUE_QUOTED_STATE](cp) {
	        if (isWhitespace(cp)) {
	            this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE);
	        } else if (cp === $$6.SOLIDUS) {
	            this._leaveAttrValue(SELF_CLOSING_START_TAG_STATE);
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._leaveAttrValue(DATA_STATE);
	            this._emitCurrentToken();
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInTag);
	            this._emitEOFToken();
	        } else {
	            this._err(ERR$1.missingWhitespaceBetweenAttributes);
	            this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE);
	        }
	    }

	    // Self-closing start tag state
	    //------------------------------------------------------------------
	    [SELF_CLOSING_START_TAG_STATE](cp) {
	        if (cp === $$6.GREATER_THAN_SIGN) {
	            this.currentToken.selfClosing = true;
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInTag);
	            this._emitEOFToken();
	        } else {
	            this._err(ERR$1.unexpectedSolidusInTag);
	            this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE);
	        }
	    }

	    // Bogus comment state
	    //------------------------------------------------------------------
	    [BOGUS_COMMENT_STATE](cp) {
	        if (cp === $$6.GREATER_THAN_SIGN) {
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else if (cp === $$6.EOF) {
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.currentToken.data += unicode$1.REPLACEMENT_CHARACTER;
	        } else {
	            this.currentToken.data += toChar(cp);
	        }
	    }

	    // Markup declaration open state
	    //------------------------------------------------------------------
	    [MARKUP_DECLARATION_OPEN_STATE](cp) {
	        if (this._consumeSequenceIfMatch($$.DASH_DASH_STRING, cp, true)) {
	            this._createCommentToken();
	            this.state = COMMENT_START_STATE;
	        } else if (this._consumeSequenceIfMatch($$.DOCTYPE_STRING, cp, false)) {
	            this.state = DOCTYPE_STATE;
	        } else if (this._consumeSequenceIfMatch($$.CDATA_START_STRING, cp, true)) {
	            if (this.allowCDATA) {
	                this.state = CDATA_SECTION_STATE;
	            } else {
	                this._err(ERR$1.cdataInHtmlContent);
	                this._createCommentToken();
	                this.currentToken.data = '[CDATA[';
	                this.state = BOGUS_COMMENT_STATE;
	            }
	        }

	        //NOTE: sequence lookup can be abrupted by hibernation. In that case lookup
	        //results are no longer valid and we will need to start over.
	        else if (!this._ensureHibernation()) {
	            this._err(ERR$1.incorrectlyOpenedComment);
	            this._createCommentToken();
	            this._reconsumeInState(BOGUS_COMMENT_STATE);
	        }
	    }

	    // Comment start state
	    //------------------------------------------------------------------
	    [COMMENT_START_STATE](cp) {
	        if (cp === $$6.HYPHEN_MINUS) {
	            this.state = COMMENT_START_DASH_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._err(ERR$1.abruptClosingOfEmptyComment);
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else {
	            this._reconsumeInState(COMMENT_STATE);
	        }
	    }

	    // Comment start dash state
	    //------------------------------------------------------------------
	    [COMMENT_START_DASH_STATE](cp) {
	        if (cp === $$6.HYPHEN_MINUS) {
	            this.state = COMMENT_END_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._err(ERR$1.abruptClosingOfEmptyComment);
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInComment);
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this.currentToken.data += '-';
	            this._reconsumeInState(COMMENT_STATE);
	        }
	    }

	    // Comment state
	    //------------------------------------------------------------------
	    [COMMENT_STATE](cp) {
	        if (cp === $$6.HYPHEN_MINUS) {
	            this.state = COMMENT_END_DASH_STATE;
	        } else if (cp === $$6.LESS_THAN_SIGN) {
	            this.currentToken.data += '<';
	            this.state = COMMENT_LESS_THAN_SIGN_STATE;
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.currentToken.data += unicode$1.REPLACEMENT_CHARACTER;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInComment);
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this.currentToken.data += toChar(cp);
	        }
	    }

	    // Comment less-than sign state
	    //------------------------------------------------------------------
	    [COMMENT_LESS_THAN_SIGN_STATE](cp) {
	        if (cp === $$6.EXCLAMATION_MARK) {
	            this.currentToken.data += '!';
	            this.state = COMMENT_LESS_THAN_SIGN_BANG_STATE;
	        } else if (cp === $$6.LESS_THAN_SIGN) {
	            this.currentToken.data += '!';
	        } else {
	            this._reconsumeInState(COMMENT_STATE);
	        }
	    }

	    // Comment less-than sign bang state
	    //------------------------------------------------------------------
	    [COMMENT_LESS_THAN_SIGN_BANG_STATE](cp) {
	        if (cp === $$6.HYPHEN_MINUS) {
	            this.state = COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE;
	        } else {
	            this._reconsumeInState(COMMENT_STATE);
	        }
	    }

	    // Comment less-than sign bang dash state
	    //------------------------------------------------------------------
	    [COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE](cp) {
	        if (cp === $$6.HYPHEN_MINUS) {
	            this.state = COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE;
	        } else {
	            this._reconsumeInState(COMMENT_END_DASH_STATE);
	        }
	    }

	    // Comment less-than sign bang dash dash state
	    //------------------------------------------------------------------
	    [COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE](cp) {
	        if (cp !== $$6.GREATER_THAN_SIGN && cp !== $$6.EOF) {
	            this._err(ERR$1.nestedComment);
	        }

	        this._reconsumeInState(COMMENT_END_STATE);
	    }

	    // Comment end dash state
	    //------------------------------------------------------------------
	    [COMMENT_END_DASH_STATE](cp) {
	        if (cp === $$6.HYPHEN_MINUS) {
	            this.state = COMMENT_END_STATE;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInComment);
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this.currentToken.data += '-';
	            this._reconsumeInState(COMMENT_STATE);
	        }
	    }

	    // Comment end state
	    //------------------------------------------------------------------
	    [COMMENT_END_STATE](cp) {
	        if (cp === $$6.GREATER_THAN_SIGN) {
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else if (cp === $$6.EXCLAMATION_MARK) {
	            this.state = COMMENT_END_BANG_STATE;
	        } else if (cp === $$6.HYPHEN_MINUS) {
	            this.currentToken.data += '-';
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInComment);
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this.currentToken.data += '--';
	            this._reconsumeInState(COMMENT_STATE);
	        }
	    }

	    // Comment end bang state
	    //------------------------------------------------------------------
	    [COMMENT_END_BANG_STATE](cp) {
	        if (cp === $$6.HYPHEN_MINUS) {
	            this.currentToken.data += '--!';
	            this.state = COMMENT_END_DASH_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._err(ERR$1.incorrectlyClosedComment);
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInComment);
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this.currentToken.data += '--!';
	            this._reconsumeInState(COMMENT_STATE);
	        }
	    }

	    // DOCTYPE state
	    //------------------------------------------------------------------
	    [DOCTYPE_STATE](cp) {
	        if (isWhitespace(cp)) {
	            this.state = BEFORE_DOCTYPE_NAME_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._reconsumeInState(BEFORE_DOCTYPE_NAME_STATE);
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInDoctype);
	            this._createDoctypeToken(null);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this._err(ERR$1.missingWhitespaceBeforeDoctypeName);
	            this._reconsumeInState(BEFORE_DOCTYPE_NAME_STATE);
	        }
	    }

	    // Before DOCTYPE name state
	    //------------------------------------------------------------------
	    [BEFORE_DOCTYPE_NAME_STATE](cp) {
	        if (isWhitespace(cp)) {
	            return;
	        }

	        if (isAsciiUpper(cp)) {
	            this._createDoctypeToken(toAsciiLowerChar(cp));
	            this.state = DOCTYPE_NAME_STATE;
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this._createDoctypeToken(unicode$1.REPLACEMENT_CHARACTER);
	            this.state = DOCTYPE_NAME_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._err(ERR$1.missingDoctypeName);
	            this._createDoctypeToken(null);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this.state = DATA_STATE;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInDoctype);
	            this._createDoctypeToken(null);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this._createDoctypeToken(toChar(cp));
	            this.state = DOCTYPE_NAME_STATE;
	        }
	    }

	    // DOCTYPE name state
	    //------------------------------------------------------------------
	    [DOCTYPE_NAME_STATE](cp) {
	        if (isWhitespace(cp)) {
	            this.state = AFTER_DOCTYPE_NAME_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else if (isAsciiUpper(cp)) {
	            this.currentToken.name += toAsciiLowerChar(cp);
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.currentToken.name += unicode$1.REPLACEMENT_CHARACTER;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInDoctype);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this.currentToken.name += toChar(cp);
	        }
	    }

	    // After DOCTYPE name state
	    //------------------------------------------------------------------
	    [AFTER_DOCTYPE_NAME_STATE](cp) {
	        if (isWhitespace(cp)) {
	            return;
	        }

	        if (cp === $$6.GREATER_THAN_SIGN) {
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInDoctype);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else if (this._consumeSequenceIfMatch($$.PUBLIC_STRING, cp, false)) {
	            this.state = AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE;
	        } else if (this._consumeSequenceIfMatch($$.SYSTEM_STRING, cp, false)) {
	            this.state = AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE;
	        }
	        //NOTE: sequence lookup can be abrupted by hibernation. In that case lookup
	        //results are no longer valid and we will need to start over.
	        else if (!this._ensureHibernation()) {
	            this._err(ERR$1.invalidCharacterSequenceAfterDoctypeName);
	            this.currentToken.forceQuirks = true;
	            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
	        }
	    }

	    // After DOCTYPE public keyword state
	    //------------------------------------------------------------------
	    [AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE](cp) {
	        if (isWhitespace(cp)) {
	            this.state = BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
	        } else if (cp === $$6.QUOTATION_MARK) {
	            this._err(ERR$1.missingWhitespaceAfterDoctypePublicKeyword);
	            this.currentToken.publicId = '';
	            this.state = DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE;
	        } else if (cp === $$6.APOSTROPHE) {
	            this._err(ERR$1.missingWhitespaceAfterDoctypePublicKeyword);
	            this.currentToken.publicId = '';
	            this.state = DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._err(ERR$1.missingDoctypePublicIdentifier);
	            this.currentToken.forceQuirks = true;
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInDoctype);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this._err(ERR$1.missingQuoteBeforeDoctypePublicIdentifier);
	            this.currentToken.forceQuirks = true;
	            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
	        }
	    }

	    // Before DOCTYPE public identifier state
	    //------------------------------------------------------------------
	    [BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE](cp) {
	        if (isWhitespace(cp)) {
	            return;
	        }

	        if (cp === $$6.QUOTATION_MARK) {
	            this.currentToken.publicId = '';
	            this.state = DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE;
	        } else if (cp === $$6.APOSTROPHE) {
	            this.currentToken.publicId = '';
	            this.state = DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._err(ERR$1.missingDoctypePublicIdentifier);
	            this.currentToken.forceQuirks = true;
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInDoctype);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this._err(ERR$1.missingQuoteBeforeDoctypePublicIdentifier);
	            this.currentToken.forceQuirks = true;
	            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
	        }
	    }

	    // DOCTYPE public identifier (double-quoted) state
	    //------------------------------------------------------------------
	    [DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE](cp) {
	        if (cp === $$6.QUOTATION_MARK) {
	            this.state = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.currentToken.publicId += unicode$1.REPLACEMENT_CHARACTER;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._err(ERR$1.abruptDoctypePublicIdentifier);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this.state = DATA_STATE;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInDoctype);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this.currentToken.publicId += toChar(cp);
	        }
	    }

	    // DOCTYPE public identifier (single-quoted) state
	    //------------------------------------------------------------------
	    [DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE](cp) {
	        if (cp === $$6.APOSTROPHE) {
	            this.state = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.currentToken.publicId += unicode$1.REPLACEMENT_CHARACTER;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._err(ERR$1.abruptDoctypePublicIdentifier);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this.state = DATA_STATE;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInDoctype);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this.currentToken.publicId += toChar(cp);
	        }
	    }

	    // After DOCTYPE public identifier state
	    //------------------------------------------------------------------
	    [AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE](cp) {
	        if (isWhitespace(cp)) {
	            this.state = BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else if (cp === $$6.QUOTATION_MARK) {
	            this._err(ERR$1.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);
	            this.currentToken.systemId = '';
	            this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
	        } else if (cp === $$6.APOSTROPHE) {
	            this._err(ERR$1.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);
	            this.currentToken.systemId = '';
	            this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInDoctype);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this._err(ERR$1.missingQuoteBeforeDoctypeSystemIdentifier);
	            this.currentToken.forceQuirks = true;
	            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
	        }
	    }

	    // Between DOCTYPE public and system identifiers state
	    //------------------------------------------------------------------
	    [BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE](cp) {
	        if (isWhitespace(cp)) {
	            return;
	        }

	        if (cp === $$6.GREATER_THAN_SIGN) {
	            this._emitCurrentToken();
	            this.state = DATA_STATE;
	        } else if (cp === $$6.QUOTATION_MARK) {
	            this.currentToken.systemId = '';
	            this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
	        } else if (cp === $$6.APOSTROPHE) {
	            this.currentToken.systemId = '';
	            this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInDoctype);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this._err(ERR$1.missingQuoteBeforeDoctypeSystemIdentifier);
	            this.currentToken.forceQuirks = true;
	            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
	        }
	    }

	    // After DOCTYPE system keyword state
	    //------------------------------------------------------------------
	    [AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE](cp) {
	        if (isWhitespace(cp)) {
	            this.state = BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
	        } else if (cp === $$6.QUOTATION_MARK) {
	            this._err(ERR$1.missingWhitespaceAfterDoctypeSystemKeyword);
	            this.currentToken.systemId = '';
	            this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
	        } else if (cp === $$6.APOSTROPHE) {
	            this._err(ERR$1.missingWhitespaceAfterDoctypeSystemKeyword);
	            this.currentToken.systemId = '';
	            this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._err(ERR$1.missingDoctypeSystemIdentifier);
	            this.currentToken.forceQuirks = true;
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInDoctype);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this._err(ERR$1.missingQuoteBeforeDoctypeSystemIdentifier);
	            this.currentToken.forceQuirks = true;
	            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
	        }
	    }

	    // Before DOCTYPE system identifier state
	    //------------------------------------------------------------------
	    [BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE](cp) {
	        if (isWhitespace(cp)) {
	            return;
	        }

	        if (cp === $$6.QUOTATION_MARK) {
	            this.currentToken.systemId = '';
	            this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
	        } else if (cp === $$6.APOSTROPHE) {
	            this.currentToken.systemId = '';
	            this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._err(ERR$1.missingDoctypeSystemIdentifier);
	            this.currentToken.forceQuirks = true;
	            this.state = DATA_STATE;
	            this._emitCurrentToken();
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInDoctype);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this._err(ERR$1.missingQuoteBeforeDoctypeSystemIdentifier);
	            this.currentToken.forceQuirks = true;
	            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
	        }
	    }

	    // DOCTYPE system identifier (double-quoted) state
	    //------------------------------------------------------------------
	    [DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE](cp) {
	        if (cp === $$6.QUOTATION_MARK) {
	            this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.currentToken.systemId += unicode$1.REPLACEMENT_CHARACTER;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._err(ERR$1.abruptDoctypeSystemIdentifier);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this.state = DATA_STATE;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInDoctype);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this.currentToken.systemId += toChar(cp);
	        }
	    }

	    // DOCTYPE system identifier (single-quoted) state
	    //------------------------------------------------------------------
	    [DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE](cp) {
	        if (cp === $$6.APOSTROPHE) {
	            this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	            this.currentToken.systemId += unicode$1.REPLACEMENT_CHARACTER;
	        } else if (cp === $$6.GREATER_THAN_SIGN) {
	            this._err(ERR$1.abruptDoctypeSystemIdentifier);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this.state = DATA_STATE;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInDoctype);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this.currentToken.systemId += toChar(cp);
	        }
	    }

	    // After DOCTYPE system identifier state
	    //------------------------------------------------------------------
	    [AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE](cp) {
	        if (isWhitespace(cp)) {
	            return;
	        }

	        if (cp === $$6.GREATER_THAN_SIGN) {
	            this._emitCurrentToken();
	            this.state = DATA_STATE;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInDoctype);
	            this.currentToken.forceQuirks = true;
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        } else {
	            this._err(ERR$1.unexpectedCharacterAfterDoctypeSystemIdentifier);
	            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
	        }
	    }

	    // Bogus DOCTYPE state
	    //------------------------------------------------------------------
	    [BOGUS_DOCTYPE_STATE](cp) {
	        if (cp === $$6.GREATER_THAN_SIGN) {
	            this._emitCurrentToken();
	            this.state = DATA_STATE;
	        } else if (cp === $$6.NULL) {
	            this._err(ERR$1.unexpectedNullCharacter);
	        } else if (cp === $$6.EOF) {
	            this._emitCurrentToken();
	            this._emitEOFToken();
	        }
	    }

	    // CDATA section state
	    //------------------------------------------------------------------
	    [CDATA_SECTION_STATE](cp) {
	        if (cp === $$6.RIGHT_SQUARE_BRACKET) {
	            this.state = CDATA_SECTION_BRACKET_STATE;
	        } else if (cp === $$6.EOF) {
	            this._err(ERR$1.eofInCdata);
	            this._emitEOFToken();
	        } else {
	            this._emitCodePoint(cp);
	        }
	    }

	    // CDATA section bracket state
	    //------------------------------------------------------------------
	    [CDATA_SECTION_BRACKET_STATE](cp) {
	        if (cp === $$6.RIGHT_SQUARE_BRACKET) {
	            this.state = CDATA_SECTION_END_STATE;
	        } else {
	            this._emitChars(']');
	            this._reconsumeInState(CDATA_SECTION_STATE);
	        }
	    }

	    // CDATA section end state
	    //------------------------------------------------------------------
	    [CDATA_SECTION_END_STATE](cp) {
	        if (cp === $$6.GREATER_THAN_SIGN) {
	            this.state = DATA_STATE;
	        } else if (cp === $$6.RIGHT_SQUARE_BRACKET) {
	            this._emitChars(']');
	        } else {
	            this._emitChars(']]');
	            this._reconsumeInState(CDATA_SECTION_STATE);
	        }
	    }

	    // Character reference state
	    //------------------------------------------------------------------
	    [CHARACTER_REFERENCE_STATE](cp) {
	        this.tempBuff = [$$6.AMPERSAND];

	        if (cp === $$6.NUMBER_SIGN) {
	            this.tempBuff.push(cp);
	            this.state = NUMERIC_CHARACTER_REFERENCE_STATE;
	        } else if (isAsciiAlphaNumeric(cp)) {
	            this._reconsumeInState(NAMED_CHARACTER_REFERENCE_STATE);
	        } else {
	            this._flushCodePointsConsumedAsCharacterReference();
	            this._reconsumeInState(this.returnState);
	        }
	    }

	    // Named character reference state
	    //------------------------------------------------------------------
	    [NAMED_CHARACTER_REFERENCE_STATE](cp) {
	        const matchResult = this._matchNamedCharacterReference(cp);

	        //NOTE: matching can be abrupted by hibernation. In that case match
	        //results are no longer valid and we will need to start over.
	        if (this._ensureHibernation()) {
	            this.tempBuff = [$$6.AMPERSAND];
	        } else if (matchResult) {
	            const withSemicolon = this.tempBuff[this.tempBuff.length - 1] === $$6.SEMICOLON;

	            if (!this._isCharacterReferenceAttributeQuirk(withSemicolon)) {
	                if (!withSemicolon) {
	                    this._errOnNextCodePoint(ERR$1.missingSemicolonAfterCharacterReference);
	                }

	                this.tempBuff = matchResult;
	            }

	            this._flushCodePointsConsumedAsCharacterReference();
	            this.state = this.returnState;
	        } else {
	            this._flushCodePointsConsumedAsCharacterReference();
	            this.state = AMBIGUOUS_AMPERSAND_STATE;
	        }
	    }

	    // Ambiguos ampersand state
	    //------------------------------------------------------------------
	    [AMBIGUOUS_AMPERSAND_STATE](cp) {
	        if (isAsciiAlphaNumeric(cp)) {
	            if (this._isCharacterReferenceInAttribute()) {
	                this.currentAttr.value += toChar(cp);
	            } else {
	                this._emitCodePoint(cp);
	            }
	        } else {
	            if (cp === $$6.SEMICOLON) {
	                this._err(ERR$1.unknownNamedCharacterReference);
	            }

	            this._reconsumeInState(this.returnState);
	        }
	    }

	    // Numeric character reference state
	    //------------------------------------------------------------------
	    [NUMERIC_CHARACTER_REFERENCE_STATE](cp) {
	        this.charRefCode = 0;

	        if (cp === $$6.LATIN_SMALL_X || cp === $$6.LATIN_CAPITAL_X) {
	            this.tempBuff.push(cp);
	            this.state = HEXADEMICAL_CHARACTER_REFERENCE_START_STATE;
	        } else {
	            this._reconsumeInState(DECIMAL_CHARACTER_REFERENCE_START_STATE);
	        }
	    }

	    // Hexademical character reference start state
	    //------------------------------------------------------------------
	    [HEXADEMICAL_CHARACTER_REFERENCE_START_STATE](cp) {
	        if (isAsciiHexDigit(cp)) {
	            this._reconsumeInState(HEXADEMICAL_CHARACTER_REFERENCE_STATE);
	        } else {
	            this._err(ERR$1.absenceOfDigitsInNumericCharacterReference);
	            this._flushCodePointsConsumedAsCharacterReference();
	            this._reconsumeInState(this.returnState);
	        }
	    }

	    // Decimal character reference start state
	    //------------------------------------------------------------------
	    [DECIMAL_CHARACTER_REFERENCE_START_STATE](cp) {
	        if (isAsciiDigit(cp)) {
	            this._reconsumeInState(DECIMAL_CHARACTER_REFERENCE_STATE);
	        } else {
	            this._err(ERR$1.absenceOfDigitsInNumericCharacterReference);
	            this._flushCodePointsConsumedAsCharacterReference();
	            this._reconsumeInState(this.returnState);
	        }
	    }

	    // Hexademical character reference state
	    //------------------------------------------------------------------
	    [HEXADEMICAL_CHARACTER_REFERENCE_STATE](cp) {
	        if (isAsciiUpperHexDigit(cp)) {
	            this.charRefCode = this.charRefCode * 16 + cp - 0x37;
	        } else if (isAsciiLowerHexDigit(cp)) {
	            this.charRefCode = this.charRefCode * 16 + cp - 0x57;
	        } else if (isAsciiDigit(cp)) {
	            this.charRefCode = this.charRefCode * 16 + cp - 0x30;
	        } else if (cp === $$6.SEMICOLON) {
	            this.state = NUMERIC_CHARACTER_REFERENCE_END_STATE;
	        } else {
	            this._err(ERR$1.missingSemicolonAfterCharacterReference);
	            this._reconsumeInState(NUMERIC_CHARACTER_REFERENCE_END_STATE);
	        }
	    }

	    // Decimal character reference state
	    //------------------------------------------------------------------
	    [DECIMAL_CHARACTER_REFERENCE_STATE](cp) {
	        if (isAsciiDigit(cp)) {
	            this.charRefCode = this.charRefCode * 10 + cp - 0x30;
	        } else if (cp === $$6.SEMICOLON) {
	            this.state = NUMERIC_CHARACTER_REFERENCE_END_STATE;
	        } else {
	            this._err(ERR$1.missingSemicolonAfterCharacterReference);
	            this._reconsumeInState(NUMERIC_CHARACTER_REFERENCE_END_STATE);
	        }
	    }

	    // Numeric character reference end state
	    //------------------------------------------------------------------
	    [NUMERIC_CHARACTER_REFERENCE_END_STATE]() {
	        if (this.charRefCode === $$6.NULL) {
	            this._err(ERR$1.nullCharacterReference);
	            this.charRefCode = $$6.REPLACEMENT_CHARACTER;
	        } else if (this.charRefCode > 0x10ffff) {
	            this._err(ERR$1.characterReferenceOutsideUnicodeRange);
	            this.charRefCode = $$6.REPLACEMENT_CHARACTER;
	        } else if (unicode$1.isSurrogate(this.charRefCode)) {
	            this._err(ERR$1.surrogateCharacterReference);
	            this.charRefCode = $$6.REPLACEMENT_CHARACTER;
	        } else if (unicode$1.isUndefinedCodePoint(this.charRefCode)) {
	            this._err(ERR$1.noncharacterCharacterReference);
	        } else if (unicode$1.isControlCodePoint(this.charRefCode) || this.charRefCode === $$6.CARRIAGE_RETURN) {
	            this._err(ERR$1.controlCharacterReference);

	            const replacement = C1_CONTROLS_REFERENCE_REPLACEMENTS[this.charRefCode];

	            if (replacement) {
	                this.charRefCode = replacement;
	            }
	        }

	        this.tempBuff = [this.charRefCode];

	        this._flushCodePointsConsumedAsCharacterReference();
	        this._reconsumeInState(this.returnState);
	    }
	};

	//Token types
	Tokenizer$4.CHARACTER_TOKEN = 'CHARACTER_TOKEN';
	Tokenizer$4.NULL_CHARACTER_TOKEN = 'NULL_CHARACTER_TOKEN';
	Tokenizer$4.WHITESPACE_CHARACTER_TOKEN = 'WHITESPACE_CHARACTER_TOKEN';
	Tokenizer$4.START_TAG_TOKEN = 'START_TAG_TOKEN';
	Tokenizer$4.END_TAG_TOKEN = 'END_TAG_TOKEN';
	Tokenizer$4.COMMENT_TOKEN = 'COMMENT_TOKEN';
	Tokenizer$4.DOCTYPE_TOKEN = 'DOCTYPE_TOKEN';
	Tokenizer$4.EOF_TOKEN = 'EOF_TOKEN';
	Tokenizer$4.HIBERNATION_TOKEN = 'HIBERNATION_TOKEN';

	//Tokenizer initial states for different modes
	Tokenizer$4.MODE = {
	    DATA: DATA_STATE,
	    RCDATA: RCDATA_STATE,
	    RAWTEXT: RAWTEXT_STATE,
	    SCRIPT_DATA: SCRIPT_DATA_STATE,
	    PLAINTEXT: PLAINTEXT_STATE
	};

	//Static
	Tokenizer$4.getTokenAttr = function(token, attrName) {
	    for (let i = token.attrs.length - 1; i >= 0; i--) {
	        if (token.attrs[i].name === attrName) {
	            return token.attrs[i].value;
	        }
	    }

	    return null;
	};

	var tokenizer = Tokenizer$4;

	var html$5 = {};

	const NS$3 = (html$5.NAMESPACES = {
	    HTML: 'http://www.w3.org/1999/xhtml',
	    MATHML: 'http://www.w3.org/1998/Math/MathML',
	    SVG: 'http://www.w3.org/2000/svg',
	    XLINK: 'http://www.w3.org/1999/xlink',
	    XML: 'http://www.w3.org/XML/1998/namespace',
	    XMLNS: 'http://www.w3.org/2000/xmlns/'
	});

	html$5.ATTRS = {
	    TYPE: 'type',
	    ACTION: 'action',
	    ENCODING: 'encoding',
	    PROMPT: 'prompt',
	    NAME: 'name',
	    COLOR: 'color',
	    FACE: 'face',
	    SIZE: 'size'
	};

	html$5.DOCUMENT_MODE = {
	    NO_QUIRKS: 'no-quirks',
	    QUIRKS: 'quirks',
	    LIMITED_QUIRKS: 'limited-quirks'
	};

	const $$5 = (html$5.TAG_NAMES = {
	    A: 'a',
	    ADDRESS: 'address',
	    ANNOTATION_XML: 'annotation-xml',
	    APPLET: 'applet',
	    AREA: 'area',
	    ARTICLE: 'article',
	    ASIDE: 'aside',

	    B: 'b',
	    BASE: 'base',
	    BASEFONT: 'basefont',
	    BGSOUND: 'bgsound',
	    BIG: 'big',
	    BLOCKQUOTE: 'blockquote',
	    BODY: 'body',
	    BR: 'br',
	    BUTTON: 'button',

	    CAPTION: 'caption',
	    CENTER: 'center',
	    CODE: 'code',
	    COL: 'col',
	    COLGROUP: 'colgroup',

	    DD: 'dd',
	    DESC: 'desc',
	    DETAILS: 'details',
	    DIALOG: 'dialog',
	    DIR: 'dir',
	    DIV: 'div',
	    DL: 'dl',
	    DT: 'dt',

	    EM: 'em',
	    EMBED: 'embed',

	    FIELDSET: 'fieldset',
	    FIGCAPTION: 'figcaption',
	    FIGURE: 'figure',
	    FONT: 'font',
	    FOOTER: 'footer',
	    FOREIGN_OBJECT: 'foreignObject',
	    FORM: 'form',
	    FRAME: 'frame',
	    FRAMESET: 'frameset',

	    H1: 'h1',
	    H2: 'h2',
	    H3: 'h3',
	    H4: 'h4',
	    H5: 'h5',
	    H6: 'h6',
	    HEAD: 'head',
	    HEADER: 'header',
	    HGROUP: 'hgroup',
	    HR: 'hr',
	    HTML: 'html',

	    I: 'i',
	    IMG: 'img',
	    IMAGE: 'image',
	    INPUT: 'input',
	    IFRAME: 'iframe',

	    KEYGEN: 'keygen',

	    LABEL: 'label',
	    LI: 'li',
	    LINK: 'link',
	    LISTING: 'listing',

	    MAIN: 'main',
	    MALIGNMARK: 'malignmark',
	    MARQUEE: 'marquee',
	    MATH: 'math',
	    MENU: 'menu',
	    META: 'meta',
	    MGLYPH: 'mglyph',
	    MI: 'mi',
	    MO: 'mo',
	    MN: 'mn',
	    MS: 'ms',
	    MTEXT: 'mtext',

	    NAV: 'nav',
	    NOBR: 'nobr',
	    NOFRAMES: 'noframes',
	    NOEMBED: 'noembed',
	    NOSCRIPT: 'noscript',

	    OBJECT: 'object',
	    OL: 'ol',
	    OPTGROUP: 'optgroup',
	    OPTION: 'option',

	    P: 'p',
	    PARAM: 'param',
	    PLAINTEXT: 'plaintext',
	    PRE: 'pre',

	    RB: 'rb',
	    RP: 'rp',
	    RT: 'rt',
	    RTC: 'rtc',
	    RUBY: 'ruby',

	    S: 's',
	    SCRIPT: 'script',
	    SECTION: 'section',
	    SELECT: 'select',
	    SOURCE: 'source',
	    SMALL: 'small',
	    SPAN: 'span',
	    STRIKE: 'strike',
	    STRONG: 'strong',
	    STYLE: 'style',
	    SUB: 'sub',
	    SUMMARY: 'summary',
	    SUP: 'sup',

	    TABLE: 'table',
	    TBODY: 'tbody',
	    TEMPLATE: 'template',
	    TEXTAREA: 'textarea',
	    TFOOT: 'tfoot',
	    TD: 'td',
	    TH: 'th',
	    THEAD: 'thead',
	    TITLE: 'title',
	    TR: 'tr',
	    TRACK: 'track',
	    TT: 'tt',

	    U: 'u',
	    UL: 'ul',

	    SVG: 'svg',

	    VAR: 'var',

	    WBR: 'wbr',

	    XMP: 'xmp'
	});

	html$5.SPECIAL_ELEMENTS = {
	    [NS$3.HTML]: {
	        [$$5.ADDRESS]: true,
	        [$$5.APPLET]: true,
	        [$$5.AREA]: true,
	        [$$5.ARTICLE]: true,
	        [$$5.ASIDE]: true,
	        [$$5.BASE]: true,
	        [$$5.BASEFONT]: true,
	        [$$5.BGSOUND]: true,
	        [$$5.BLOCKQUOTE]: true,
	        [$$5.BODY]: true,
	        [$$5.BR]: true,
	        [$$5.BUTTON]: true,
	        [$$5.CAPTION]: true,
	        [$$5.CENTER]: true,
	        [$$5.COL]: true,
	        [$$5.COLGROUP]: true,
	        [$$5.DD]: true,
	        [$$5.DETAILS]: true,
	        [$$5.DIR]: true,
	        [$$5.DIV]: true,
	        [$$5.DL]: true,
	        [$$5.DT]: true,
	        [$$5.EMBED]: true,
	        [$$5.FIELDSET]: true,
	        [$$5.FIGCAPTION]: true,
	        [$$5.FIGURE]: true,
	        [$$5.FOOTER]: true,
	        [$$5.FORM]: true,
	        [$$5.FRAME]: true,
	        [$$5.FRAMESET]: true,
	        [$$5.H1]: true,
	        [$$5.H2]: true,
	        [$$5.H3]: true,
	        [$$5.H4]: true,
	        [$$5.H5]: true,
	        [$$5.H6]: true,
	        [$$5.HEAD]: true,
	        [$$5.HEADER]: true,
	        [$$5.HGROUP]: true,
	        [$$5.HR]: true,
	        [$$5.HTML]: true,
	        [$$5.IFRAME]: true,
	        [$$5.IMG]: true,
	        [$$5.INPUT]: true,
	        [$$5.LI]: true,
	        [$$5.LINK]: true,
	        [$$5.LISTING]: true,
	        [$$5.MAIN]: true,
	        [$$5.MARQUEE]: true,
	        [$$5.MENU]: true,
	        [$$5.META]: true,
	        [$$5.NAV]: true,
	        [$$5.NOEMBED]: true,
	        [$$5.NOFRAMES]: true,
	        [$$5.NOSCRIPT]: true,
	        [$$5.OBJECT]: true,
	        [$$5.OL]: true,
	        [$$5.P]: true,
	        [$$5.PARAM]: true,
	        [$$5.PLAINTEXT]: true,
	        [$$5.PRE]: true,
	        [$$5.SCRIPT]: true,
	        [$$5.SECTION]: true,
	        [$$5.SELECT]: true,
	        [$$5.SOURCE]: true,
	        [$$5.STYLE]: true,
	        [$$5.SUMMARY]: true,
	        [$$5.TABLE]: true,
	        [$$5.TBODY]: true,
	        [$$5.TD]: true,
	        [$$5.TEMPLATE]: true,
	        [$$5.TEXTAREA]: true,
	        [$$5.TFOOT]: true,
	        [$$5.TH]: true,
	        [$$5.THEAD]: true,
	        [$$5.TITLE]: true,
	        [$$5.TR]: true,
	        [$$5.TRACK]: true,
	        [$$5.UL]: true,
	        [$$5.WBR]: true,
	        [$$5.XMP]: true
	    },
	    [NS$3.MATHML]: {
	        [$$5.MI]: true,
	        [$$5.MO]: true,
	        [$$5.MN]: true,
	        [$$5.MS]: true,
	        [$$5.MTEXT]: true,
	        [$$5.ANNOTATION_XML]: true
	    },
	    [NS$3.SVG]: {
	        [$$5.TITLE]: true,
	        [$$5.FOREIGN_OBJECT]: true,
	        [$$5.DESC]: true
	    }
	};

	const HTML$3 = html$5;

	//Aliases
	const $$4 = HTML$3.TAG_NAMES;
	const NS$2 = HTML$3.NAMESPACES;

	//Element utils

	//OPTIMIZATION: Integer comparisons are low-cost, so we can use very fast tag name length filters here.
	//It's faster than using dictionary.
	function isImpliedEndTagRequired(tn) {
	    switch (tn.length) {
	        case 1:
	            return tn === $$4.P;

	        case 2:
	            return tn === $$4.RB || tn === $$4.RP || tn === $$4.RT || tn === $$4.DD || tn === $$4.DT || tn === $$4.LI;

	        case 3:
	            return tn === $$4.RTC;

	        case 6:
	            return tn === $$4.OPTION;

	        case 8:
	            return tn === $$4.OPTGROUP;
	    }

	    return false;
	}

	function isImpliedEndTagRequiredThoroughly(tn) {
	    switch (tn.length) {
	        case 1:
	            return tn === $$4.P;

	        case 2:
	            return (
	                tn === $$4.RB ||
	                tn === $$4.RP ||
	                tn === $$4.RT ||
	                tn === $$4.DD ||
	                tn === $$4.DT ||
	                tn === $$4.LI ||
	                tn === $$4.TD ||
	                tn === $$4.TH ||
	                tn === $$4.TR
	            );

	        case 3:
	            return tn === $$4.RTC;

	        case 5:
	            return tn === $$4.TBODY || tn === $$4.TFOOT || tn === $$4.THEAD;

	        case 6:
	            return tn === $$4.OPTION;

	        case 7:
	            return tn === $$4.CAPTION;

	        case 8:
	            return tn === $$4.OPTGROUP || tn === $$4.COLGROUP;
	    }

	    return false;
	}

	function isScopingElement(tn, ns) {
	    switch (tn.length) {
	        case 2:
	            if (tn === $$4.TD || tn === $$4.TH) {
	                return ns === NS$2.HTML;
	            } else if (tn === $$4.MI || tn === $$4.MO || tn === $$4.MN || tn === $$4.MS) {
	                return ns === NS$2.MATHML;
	            }

	            break;

	        case 4:
	            if (tn === $$4.HTML) {
	                return ns === NS$2.HTML;
	            } else if (tn === $$4.DESC) {
	                return ns === NS$2.SVG;
	            }

	            break;

	        case 5:
	            if (tn === $$4.TABLE) {
	                return ns === NS$2.HTML;
	            } else if (tn === $$4.MTEXT) {
	                return ns === NS$2.MATHML;
	            } else if (tn === $$4.TITLE) {
	                return ns === NS$2.SVG;
	            }

	            break;

	        case 6:
	            return (tn === $$4.APPLET || tn === $$4.OBJECT) && ns === NS$2.HTML;

	        case 7:
	            return (tn === $$4.CAPTION || tn === $$4.MARQUEE) && ns === NS$2.HTML;

	        case 8:
	            return tn === $$4.TEMPLATE && ns === NS$2.HTML;

	        case 13:
	            return tn === $$4.FOREIGN_OBJECT && ns === NS$2.SVG;

	        case 14:
	            return tn === $$4.ANNOTATION_XML && ns === NS$2.MATHML;
	    }

	    return false;
	}

	//Stack of open elements
	let OpenElementStack$1 = class OpenElementStack {
	    constructor(document, treeAdapter) {
	        this.stackTop = -1;
	        this.items = [];
	        this.current = document;
	        this.currentTagName = null;
	        this.currentTmplContent = null;
	        this.tmplCount = 0;
	        this.treeAdapter = treeAdapter;
	    }

	    //Index of element
	    _indexOf(element) {
	        let idx = -1;

	        for (let i = this.stackTop; i >= 0; i--) {
	            if (this.items[i] === element) {
	                idx = i;
	                break;
	            }
	        }
	        return idx;
	    }

	    //Update current element
	    _isInTemplate() {
	        return this.currentTagName === $$4.TEMPLATE && this.treeAdapter.getNamespaceURI(this.current) === NS$2.HTML;
	    }

	    _updateCurrentElement() {
	        this.current = this.items[this.stackTop];
	        this.currentTagName = this.current && this.treeAdapter.getTagName(this.current);

	        this.currentTmplContent = this._isInTemplate() ? this.treeAdapter.getTemplateContent(this.current) : null;
	    }

	    //Mutations
	    push(element) {
	        this.items[++this.stackTop] = element;
	        this._updateCurrentElement();

	        if (this._isInTemplate()) {
	            this.tmplCount++;
	        }
	    }

	    pop() {
	        this.stackTop--;

	        if (this.tmplCount > 0 && this._isInTemplate()) {
	            this.tmplCount--;
	        }

	        this._updateCurrentElement();
	    }

	    replace(oldElement, newElement) {
	        const idx = this._indexOf(oldElement);

	        this.items[idx] = newElement;

	        if (idx === this.stackTop) {
	            this._updateCurrentElement();
	        }
	    }

	    insertAfter(referenceElement, newElement) {
	        const insertionIdx = this._indexOf(referenceElement) + 1;

	        this.items.splice(insertionIdx, 0, newElement);

	        if (insertionIdx === ++this.stackTop) {
	            this._updateCurrentElement();
	        }
	    }

	    popUntilTagNamePopped(tagName) {
	        while (this.stackTop > -1) {
	            const tn = this.currentTagName;
	            const ns = this.treeAdapter.getNamespaceURI(this.current);

	            this.pop();

	            if (tn === tagName && ns === NS$2.HTML) {
	                break;
	            }
	        }
	    }

	    popUntilElementPopped(element) {
	        while (this.stackTop > -1) {
	            const poppedElement = this.current;

	            this.pop();

	            if (poppedElement === element) {
	                break;
	            }
	        }
	    }

	    popUntilNumberedHeaderPopped() {
	        while (this.stackTop > -1) {
	            const tn = this.currentTagName;
	            const ns = this.treeAdapter.getNamespaceURI(this.current);

	            this.pop();

	            if (
	                tn === $$4.H1 ||
	                tn === $$4.H2 ||
	                tn === $$4.H3 ||
	                tn === $$4.H4 ||
	                tn === $$4.H5 ||
	                (tn === $$4.H6 && ns === NS$2.HTML)
	            ) {
	                break;
	            }
	        }
	    }

	    popUntilTableCellPopped() {
	        while (this.stackTop > -1) {
	            const tn = this.currentTagName;
	            const ns = this.treeAdapter.getNamespaceURI(this.current);

	            this.pop();

	            if (tn === $$4.TD || (tn === $$4.TH && ns === NS$2.HTML)) {
	                break;
	            }
	        }
	    }

	    popAllUpToHtmlElement() {
	        //NOTE: here we assume that root <html> element is always first in the open element stack, so
	        //we perform this fast stack clean up.
	        this.stackTop = 0;
	        this._updateCurrentElement();
	    }

	    clearBackToTableContext() {
	        while (
	            (this.currentTagName !== $$4.TABLE && this.currentTagName !== $$4.TEMPLATE && this.currentTagName !== $$4.HTML) ||
	            this.treeAdapter.getNamespaceURI(this.current) !== NS$2.HTML
	        ) {
	            this.pop();
	        }
	    }

	    clearBackToTableBodyContext() {
	        while (
	            (this.currentTagName !== $$4.TBODY &&
	                this.currentTagName !== $$4.TFOOT &&
	                this.currentTagName !== $$4.THEAD &&
	                this.currentTagName !== $$4.TEMPLATE &&
	                this.currentTagName !== $$4.HTML) ||
	            this.treeAdapter.getNamespaceURI(this.current) !== NS$2.HTML
	        ) {
	            this.pop();
	        }
	    }

	    clearBackToTableRowContext() {
	        while (
	            (this.currentTagName !== $$4.TR && this.currentTagName !== $$4.TEMPLATE && this.currentTagName !== $$4.HTML) ||
	            this.treeAdapter.getNamespaceURI(this.current) !== NS$2.HTML
	        ) {
	            this.pop();
	        }
	    }

	    remove(element) {
	        for (let i = this.stackTop; i >= 0; i--) {
	            if (this.items[i] === element) {
	                this.items.splice(i, 1);
	                this.stackTop--;
	                this._updateCurrentElement();
	                break;
	            }
	        }
	    }

	    //Search
	    tryPeekProperlyNestedBodyElement() {
	        //Properly nested <body> element (should be second element in stack).
	        const element = this.items[1];

	        return element && this.treeAdapter.getTagName(element) === $$4.BODY ? element : null;
	    }

	    contains(element) {
	        return this._indexOf(element) > -1;
	    }

	    getCommonAncestor(element) {
	        let elementIdx = this._indexOf(element);

	        return --elementIdx >= 0 ? this.items[elementIdx] : null;
	    }

	    isRootHtmlElementCurrent() {
	        return this.stackTop === 0 && this.currentTagName === $$4.HTML;
	    }

	    //Element in scope
	    hasInScope(tagName) {
	        for (let i = this.stackTop; i >= 0; i--) {
	            const tn = this.treeAdapter.getTagName(this.items[i]);
	            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);

	            if (tn === tagName && ns === NS$2.HTML) {
	                return true;
	            }

	            if (isScopingElement(tn, ns)) {
	                return false;
	            }
	        }

	        return true;
	    }

	    hasNumberedHeaderInScope() {
	        for (let i = this.stackTop; i >= 0; i--) {
	            const tn = this.treeAdapter.getTagName(this.items[i]);
	            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);

	            if (
	                (tn === $$4.H1 || tn === $$4.H2 || tn === $$4.H3 || tn === $$4.H4 || tn === $$4.H5 || tn === $$4.H6) &&
	                ns === NS$2.HTML
	            ) {
	                return true;
	            }

	            if (isScopingElement(tn, ns)) {
	                return false;
	            }
	        }

	        return true;
	    }

	    hasInListItemScope(tagName) {
	        for (let i = this.stackTop; i >= 0; i--) {
	            const tn = this.treeAdapter.getTagName(this.items[i]);
	            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);

	            if (tn === tagName && ns === NS$2.HTML) {
	                return true;
	            }

	            if (((tn === $$4.UL || tn === $$4.OL) && ns === NS$2.HTML) || isScopingElement(tn, ns)) {
	                return false;
	            }
	        }

	        return true;
	    }

	    hasInButtonScope(tagName) {
	        for (let i = this.stackTop; i >= 0; i--) {
	            const tn = this.treeAdapter.getTagName(this.items[i]);
	            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);

	            if (tn === tagName && ns === NS$2.HTML) {
	                return true;
	            }

	            if ((tn === $$4.BUTTON && ns === NS$2.HTML) || isScopingElement(tn, ns)) {
	                return false;
	            }
	        }

	        return true;
	    }

	    hasInTableScope(tagName) {
	        for (let i = this.stackTop; i >= 0; i--) {
	            const tn = this.treeAdapter.getTagName(this.items[i]);
	            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);

	            if (ns !== NS$2.HTML) {
	                continue;
	            }

	            if (tn === tagName) {
	                return true;
	            }

	            if (tn === $$4.TABLE || tn === $$4.TEMPLATE || tn === $$4.HTML) {
	                return false;
	            }
	        }

	        return true;
	    }

	    hasTableBodyContextInTableScope() {
	        for (let i = this.stackTop; i >= 0; i--) {
	            const tn = this.treeAdapter.getTagName(this.items[i]);
	            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);

	            if (ns !== NS$2.HTML) {
	                continue;
	            }

	            if (tn === $$4.TBODY || tn === $$4.THEAD || tn === $$4.TFOOT) {
	                return true;
	            }

	            if (tn === $$4.TABLE || tn === $$4.HTML) {
	                return false;
	            }
	        }

	        return true;
	    }

	    hasInSelectScope(tagName) {
	        for (let i = this.stackTop; i >= 0; i--) {
	            const tn = this.treeAdapter.getTagName(this.items[i]);
	            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);

	            if (ns !== NS$2.HTML) {
	                continue;
	            }

	            if (tn === tagName) {
	                return true;
	            }

	            if (tn !== $$4.OPTION && tn !== $$4.OPTGROUP) {
	                return false;
	            }
	        }

	        return true;
	    }

	    //Implied end tags
	    generateImpliedEndTags() {
	        while (isImpliedEndTagRequired(this.currentTagName)) {
	            this.pop();
	        }
	    }

	    generateImpliedEndTagsThoroughly() {
	        while (isImpliedEndTagRequiredThoroughly(this.currentTagName)) {
	            this.pop();
	        }
	    }

	    generateImpliedEndTagsWithExclusion(exclusionTagName) {
	        while (isImpliedEndTagRequired(this.currentTagName) && this.currentTagName !== exclusionTagName) {
	            this.pop();
	        }
	    }
	};

	var openElementStack = OpenElementStack$1;

	//Const
	const NOAH_ARK_CAPACITY = 3;

	//List of formatting elements
	let FormattingElementList$1 = class FormattingElementList {
	    constructor(treeAdapter) {
	        this.length = 0;
	        this.entries = [];
	        this.treeAdapter = treeAdapter;
	        this.bookmark = null;
	    }

	    //Noah Ark's condition
	    //OPTIMIZATION: at first we try to find possible candidates for exclusion using
	    //lightweight heuristics without thorough attributes check.
	    _getNoahArkConditionCandidates(newElement) {
	        const candidates = [];

	        if (this.length >= NOAH_ARK_CAPACITY) {
	            const neAttrsLength = this.treeAdapter.getAttrList(newElement).length;
	            const neTagName = this.treeAdapter.getTagName(newElement);
	            const neNamespaceURI = this.treeAdapter.getNamespaceURI(newElement);

	            for (let i = this.length - 1; i >= 0; i--) {
	                const entry = this.entries[i];

	                if (entry.type === FormattingElementList.MARKER_ENTRY) {
	                    break;
	                }

	                const element = entry.element;
	                const elementAttrs = this.treeAdapter.getAttrList(element);

	                const isCandidate =
	                    this.treeAdapter.getTagName(element) === neTagName &&
	                    this.treeAdapter.getNamespaceURI(element) === neNamespaceURI &&
	                    elementAttrs.length === neAttrsLength;

	                if (isCandidate) {
	                    candidates.push({ idx: i, attrs: elementAttrs });
	                }
	            }
	        }

	        return candidates.length < NOAH_ARK_CAPACITY ? [] : candidates;
	    }

	    _ensureNoahArkCondition(newElement) {
	        const candidates = this._getNoahArkConditionCandidates(newElement);
	        let cLength = candidates.length;

	        if (cLength) {
	            const neAttrs = this.treeAdapter.getAttrList(newElement);
	            const neAttrsLength = neAttrs.length;
	            const neAttrsMap = Object.create(null);

	            //NOTE: build attrs map for the new element so we can perform fast lookups
	            for (let i = 0; i < neAttrsLength; i++) {
	                const neAttr = neAttrs[i];

	                neAttrsMap[neAttr.name] = neAttr.value;
	            }

	            for (let i = 0; i < neAttrsLength; i++) {
	                for (let j = 0; j < cLength; j++) {
	                    const cAttr = candidates[j].attrs[i];

	                    if (neAttrsMap[cAttr.name] !== cAttr.value) {
	                        candidates.splice(j, 1);
	                        cLength--;
	                    }

	                    if (candidates.length < NOAH_ARK_CAPACITY) {
	                        return;
	                    }
	                }
	            }

	            //NOTE: remove bottommost candidates until Noah's Ark condition will not be met
	            for (let i = cLength - 1; i >= NOAH_ARK_CAPACITY - 1; i--) {
	                this.entries.splice(candidates[i].idx, 1);
	                this.length--;
	            }
	        }
	    }

	    //Mutations
	    insertMarker() {
	        this.entries.push({ type: FormattingElementList.MARKER_ENTRY });
	        this.length++;
	    }

	    pushElement(element, token) {
	        this._ensureNoahArkCondition(element);

	        this.entries.push({
	            type: FormattingElementList.ELEMENT_ENTRY,
	            element: element,
	            token: token
	        });

	        this.length++;
	    }

	    insertElementAfterBookmark(element, token) {
	        let bookmarkIdx = this.length - 1;

	        for (; bookmarkIdx >= 0; bookmarkIdx--) {
	            if (this.entries[bookmarkIdx] === this.bookmark) {
	                break;
	            }
	        }

	        this.entries.splice(bookmarkIdx + 1, 0, {
	            type: FormattingElementList.ELEMENT_ENTRY,
	            element: element,
	            token: token
	        });

	        this.length++;
	    }

	    removeEntry(entry) {
	        for (let i = this.length - 1; i >= 0; i--) {
	            if (this.entries[i] === entry) {
	                this.entries.splice(i, 1);
	                this.length--;
	                break;
	            }
	        }
	    }

	    clearToLastMarker() {
	        while (this.length) {
	            const entry = this.entries.pop();

	            this.length--;

	            if (entry.type === FormattingElementList.MARKER_ENTRY) {
	                break;
	            }
	        }
	    }

	    //Search
	    getElementEntryInScopeWithTagName(tagName) {
	        for (let i = this.length - 1; i >= 0; i--) {
	            const entry = this.entries[i];

	            if (entry.type === FormattingElementList.MARKER_ENTRY) {
	                return null;
	            }

	            if (this.treeAdapter.getTagName(entry.element) === tagName) {
	                return entry;
	            }
	        }

	        return null;
	    }

	    getElementEntry(element) {
	        for (let i = this.length - 1; i >= 0; i--) {
	            const entry = this.entries[i];

	            if (entry.type === FormattingElementList.ELEMENT_ENTRY && entry.element === element) {
	                return entry;
	            }
	        }

	        return null;
	    }
	};

	//Entry types
	FormattingElementList$1.MARKER_ENTRY = 'MARKER_ENTRY';
	FormattingElementList$1.ELEMENT_ENTRY = 'ELEMENT_ENTRY';

	var formattingElementList = FormattingElementList$1;

	let Mixin$9 = class Mixin {
	    constructor(host) {
	        const originalMethods = {};
	        const overriddenMethods = this._getOverriddenMethods(this, originalMethods);

	        for (const key of Object.keys(overriddenMethods)) {
	            if (typeof overriddenMethods[key] === 'function') {
	                originalMethods[key] = host[key];
	                host[key] = overriddenMethods[key];
	            }
	        }
	    }

	    _getOverriddenMethods() {
	        throw new Error('Not implemented');
	    }
	};

	Mixin$9.install = function(host, Ctor, opts) {
	    if (!host.__mixins) {
	        host.__mixins = [];
	    }

	    for (let i = 0; i < host.__mixins.length; i++) {
	        if (host.__mixins[i].constructor === Ctor) {
	            return host.__mixins[i];
	        }
	    }

	    const mixin = new Ctor(host, opts);

	    host.__mixins.push(mixin);

	    return mixin;
	};

	var mixin = Mixin$9;

	const Mixin$8 = mixin;

	let PositionTrackingPreprocessorMixin$2 = class PositionTrackingPreprocessorMixin extends Mixin$8 {
	    constructor(preprocessor) {
	        super(preprocessor);

	        this.preprocessor = preprocessor;
	        this.isEol = false;
	        this.lineStartPos = 0;
	        this.droppedBufferSize = 0;

	        this.offset = 0;
	        this.col = 0;
	        this.line = 1;
	    }

	    _getOverriddenMethods(mxn, orig) {
	        return {
	            advance() {
	                const pos = this.pos + 1;
	                const ch = this.html[pos];

	                //NOTE: LF should be in the last column of the line
	                if (mxn.isEol) {
	                    mxn.isEol = false;
	                    mxn.line++;
	                    mxn.lineStartPos = pos;
	                }

	                if (ch === '\n' || (ch === '\r' && this.html[pos + 1] !== '\n')) {
	                    mxn.isEol = true;
	                }

	                mxn.col = pos - mxn.lineStartPos + 1;
	                mxn.offset = mxn.droppedBufferSize + pos;

	                return orig.advance.call(this);
	            },

	            retreat() {
	                orig.retreat.call(this);

	                mxn.isEol = false;
	                mxn.col = this.pos - mxn.lineStartPos + 1;
	            },

	            dropParsedChunk() {
	                const prevPos = this.pos;

	                orig.dropParsedChunk.call(this);

	                const reduction = prevPos - this.pos;

	                mxn.lineStartPos -= reduction;
	                mxn.droppedBufferSize += reduction;
	                mxn.offset = mxn.droppedBufferSize + this.pos;
	            }
	        };
	    }
	};

	var preprocessorMixin$1 = PositionTrackingPreprocessorMixin$2;

	const Mixin$7 = mixin;
	const Tokenizer$3 = tokenizer;
	const PositionTrackingPreprocessorMixin$1 = preprocessorMixin$1;

	let LocationInfoTokenizerMixin$2 = class LocationInfoTokenizerMixin extends Mixin$7 {
	    constructor(tokenizer) {
	        super(tokenizer);

	        this.tokenizer = tokenizer;
	        this.posTracker = Mixin$7.install(tokenizer.preprocessor, PositionTrackingPreprocessorMixin$1);
	        this.currentAttrLocation = null;
	        this.ctLoc = null;
	    }

	    _getCurrentLocation() {
	        return {
	            startLine: this.posTracker.line,
	            startCol: this.posTracker.col,
	            startOffset: this.posTracker.offset,
	            endLine: -1,
	            endCol: -1,
	            endOffset: -1
	        };
	    }

	    _attachCurrentAttrLocationInfo() {
	        this.currentAttrLocation.endLine = this.posTracker.line;
	        this.currentAttrLocation.endCol = this.posTracker.col;
	        this.currentAttrLocation.endOffset = this.posTracker.offset;

	        const currentToken = this.tokenizer.currentToken;
	        const currentAttr = this.tokenizer.currentAttr;

	        if (!currentToken.location.attrs) {
	            currentToken.location.attrs = Object.create(null);
	        }

	        currentToken.location.attrs[currentAttr.name] = this.currentAttrLocation;
	    }

	    _getOverriddenMethods(mxn, orig) {
	        const methods = {
	            _createStartTagToken() {
	                orig._createStartTagToken.call(this);
	                this.currentToken.location = mxn.ctLoc;
	            },

	            _createEndTagToken() {
	                orig._createEndTagToken.call(this);
	                this.currentToken.location = mxn.ctLoc;
	            },

	            _createCommentToken() {
	                orig._createCommentToken.call(this);
	                this.currentToken.location = mxn.ctLoc;
	            },

	            _createDoctypeToken(initialName) {
	                orig._createDoctypeToken.call(this, initialName);
	                this.currentToken.location = mxn.ctLoc;
	            },

	            _createCharacterToken(type, ch) {
	                orig._createCharacterToken.call(this, type, ch);
	                this.currentCharacterToken.location = mxn.ctLoc;
	            },

	            _createEOFToken() {
	                orig._createEOFToken.call(this);
	                this.currentToken.location = mxn._getCurrentLocation();
	            },

	            _createAttr(attrNameFirstCh) {
	                orig._createAttr.call(this, attrNameFirstCh);
	                mxn.currentAttrLocation = mxn._getCurrentLocation();
	            },

	            _leaveAttrName(toState) {
	                orig._leaveAttrName.call(this, toState);
	                mxn._attachCurrentAttrLocationInfo();
	            },

	            _leaveAttrValue(toState) {
	                orig._leaveAttrValue.call(this, toState);
	                mxn._attachCurrentAttrLocationInfo();
	            },

	            _emitCurrentToken() {
	                const ctLoc = this.currentToken.location;

	                //NOTE: if we have pending character token make it's end location equal to the
	                //current token's start location.
	                if (this.currentCharacterToken) {
	                    this.currentCharacterToken.location.endLine = ctLoc.startLine;
	                    this.currentCharacterToken.location.endCol = ctLoc.startCol;
	                    this.currentCharacterToken.location.endOffset = ctLoc.startOffset;
	                }

	                if (this.currentToken.type === Tokenizer$3.EOF_TOKEN) {
	                    ctLoc.endLine = ctLoc.startLine;
	                    ctLoc.endCol = ctLoc.startCol;
	                    ctLoc.endOffset = ctLoc.startOffset;
	                } else {
	                    ctLoc.endLine = mxn.posTracker.line;
	                    ctLoc.endCol = mxn.posTracker.col + 1;
	                    ctLoc.endOffset = mxn.posTracker.offset + 1;
	                }

	                orig._emitCurrentToken.call(this);
	            },

	            _emitCurrentCharacterToken() {
	                const ctLoc = this.currentCharacterToken && this.currentCharacterToken.location;

	                //NOTE: if we have character token and it's location wasn't set in the _emitCurrentToken(),
	                //then set it's location at the current preprocessor position.
	                //We don't need to increment preprocessor position, since character token
	                //emission is always forced by the start of the next character token here.
	                //So, we already have advanced position.
	                if (ctLoc && ctLoc.endOffset === -1) {
	                    ctLoc.endLine = mxn.posTracker.line;
	                    ctLoc.endCol = mxn.posTracker.col;
	                    ctLoc.endOffset = mxn.posTracker.offset;
	                }

	                orig._emitCurrentCharacterToken.call(this);
	            }
	        };

	        //NOTE: patch initial states for each mode to obtain token start position
	        Object.keys(Tokenizer$3.MODE).forEach(modeName => {
	            const state = Tokenizer$3.MODE[modeName];

	            methods[state] = function(cp) {
	                mxn.ctLoc = mxn._getCurrentLocation();
	                orig[state].call(this, cp);
	            };
	        });

	        return methods;
	    }
	};

	var tokenizerMixin$1 = LocationInfoTokenizerMixin$2;

	const Mixin$6 = mixin;

	let LocationInfoOpenElementStackMixin$1 = class LocationInfoOpenElementStackMixin extends Mixin$6 {
	    constructor(stack, opts) {
	        super(stack);

	        this.onItemPop = opts.onItemPop;
	    }

	    _getOverriddenMethods(mxn, orig) {
	        return {
	            pop() {
	                mxn.onItemPop(this.current);
	                orig.pop.call(this);
	            },

	            popAllUpToHtmlElement() {
	                for (let i = this.stackTop; i > 0; i--) {
	                    mxn.onItemPop(this.items[i]);
	                }

	                orig.popAllUpToHtmlElement.call(this);
	            },

	            remove(element) {
	                mxn.onItemPop(this.current);
	                orig.remove.call(this, element);
	            }
	        };
	    }
	};

	var openElementStackMixin = LocationInfoOpenElementStackMixin$1;

	const Mixin$5 = mixin;
	const Tokenizer$2 = tokenizer;
	const LocationInfoTokenizerMixin$1 = tokenizerMixin$1;
	const LocationInfoOpenElementStackMixin = openElementStackMixin;
	const HTML$2 = html$5;

	//Aliases
	const $$3 = HTML$2.TAG_NAMES;

	let LocationInfoParserMixin$1 = class LocationInfoParserMixin extends Mixin$5 {
	    constructor(parser) {
	        super(parser);

	        this.parser = parser;
	        this.treeAdapter = this.parser.treeAdapter;
	        this.posTracker = null;
	        this.lastStartTagToken = null;
	        this.lastFosterParentingLocation = null;
	        this.currentToken = null;
	    }

	    _setStartLocation(element) {
	        let loc = null;

	        if (this.lastStartTagToken) {
	            loc = Object.assign({}, this.lastStartTagToken.location);
	            loc.startTag = this.lastStartTagToken.location;
	        }

	        this.treeAdapter.setNodeSourceCodeLocation(element, loc);
	    }

	    _setEndLocation(element, closingToken) {
	        const loc = this.treeAdapter.getNodeSourceCodeLocation(element);

	        if (loc) {
	            if (closingToken.location) {
	                const ctLoc = closingToken.location;
	                const tn = this.treeAdapter.getTagName(element);

	                // NOTE: For cases like <p> <p> </p> - First 'p' closes without a closing
	                // tag and for cases like <td> <p> </td> - 'p' closes without a closing tag.
	                const isClosingEndTag = closingToken.type === Tokenizer$2.END_TAG_TOKEN && tn === closingToken.tagName;
	                const endLoc = {};
	                if (isClosingEndTag) {
	                    endLoc.endTag = Object.assign({}, ctLoc);
	                    endLoc.endLine = ctLoc.endLine;
	                    endLoc.endCol = ctLoc.endCol;
	                    endLoc.endOffset = ctLoc.endOffset;
	                } else {
	                    endLoc.endLine = ctLoc.startLine;
	                    endLoc.endCol = ctLoc.startCol;
	                    endLoc.endOffset = ctLoc.startOffset;
	                }

	                this.treeAdapter.updateNodeSourceCodeLocation(element, endLoc);
	            }
	        }
	    }

	    _getOverriddenMethods(mxn, orig) {
	        return {
	            _bootstrap(document, fragmentContext) {
	                orig._bootstrap.call(this, document, fragmentContext);

	                mxn.lastStartTagToken = null;
	                mxn.lastFosterParentingLocation = null;
	                mxn.currentToken = null;

	                const tokenizerMixin = Mixin$5.install(this.tokenizer, LocationInfoTokenizerMixin$1);

	                mxn.posTracker = tokenizerMixin.posTracker;

	                Mixin$5.install(this.openElements, LocationInfoOpenElementStackMixin, {
	                    onItemPop: function(element) {
	                        mxn._setEndLocation(element, mxn.currentToken);
	                    }
	                });
	            },

	            _runParsingLoop(scriptHandler) {
	                orig._runParsingLoop.call(this, scriptHandler);

	                // NOTE: generate location info for elements
	                // that remains on open element stack
	                for (let i = this.openElements.stackTop; i >= 0; i--) {
	                    mxn._setEndLocation(this.openElements.items[i], mxn.currentToken);
	                }
	            },

	            //Token processing
	            _processTokenInForeignContent(token) {
	                mxn.currentToken = token;
	                orig._processTokenInForeignContent.call(this, token);
	            },

	            _processToken(token) {
	                mxn.currentToken = token;
	                orig._processToken.call(this, token);

	                //NOTE: <body> and <html> are never popped from the stack, so we need to updated
	                //their end location explicitly.
	                const requireExplicitUpdate =
	                    token.type === Tokenizer$2.END_TAG_TOKEN &&
	                    (token.tagName === $$3.HTML || (token.tagName === $$3.BODY && this.openElements.hasInScope($$3.BODY)));

	                if (requireExplicitUpdate) {
	                    for (let i = this.openElements.stackTop; i >= 0; i--) {
	                        const element = this.openElements.items[i];

	                        if (this.treeAdapter.getTagName(element) === token.tagName) {
	                            mxn._setEndLocation(element, token);
	                            break;
	                        }
	                    }
	                }
	            },

	            //Doctype
	            _setDocumentType(token) {
	                orig._setDocumentType.call(this, token);

	                const documentChildren = this.treeAdapter.getChildNodes(this.document);
	                const cnLength = documentChildren.length;

	                for (let i = 0; i < cnLength; i++) {
	                    const node = documentChildren[i];

	                    if (this.treeAdapter.isDocumentTypeNode(node)) {
	                        this.treeAdapter.setNodeSourceCodeLocation(node, token.location);
	                        break;
	                    }
	                }
	            },

	            //Elements
	            _attachElementToTree(element) {
	                //NOTE: _attachElementToTree is called from _appendElement, _insertElement and _insertTemplate methods.
	                //So we will use token location stored in this methods for the element.
	                mxn._setStartLocation(element);
	                mxn.lastStartTagToken = null;
	                orig._attachElementToTree.call(this, element);
	            },

	            _appendElement(token, namespaceURI) {
	                mxn.lastStartTagToken = token;
	                orig._appendElement.call(this, token, namespaceURI);
	            },

	            _insertElement(token, namespaceURI) {
	                mxn.lastStartTagToken = token;
	                orig._insertElement.call(this, token, namespaceURI);
	            },

	            _insertTemplate(token) {
	                mxn.lastStartTagToken = token;
	                orig._insertTemplate.call(this, token);

	                const tmplContent = this.treeAdapter.getTemplateContent(this.openElements.current);

	                this.treeAdapter.setNodeSourceCodeLocation(tmplContent, null);
	            },

	            _insertFakeRootElement() {
	                orig._insertFakeRootElement.call(this);
	                this.treeAdapter.setNodeSourceCodeLocation(this.openElements.current, null);
	            },

	            //Comments
	            _appendCommentNode(token, parent) {
	                orig._appendCommentNode.call(this, token, parent);

	                const children = this.treeAdapter.getChildNodes(parent);
	                const commentNode = children[children.length - 1];

	                this.treeAdapter.setNodeSourceCodeLocation(commentNode, token.location);
	            },

	            //Text
	            _findFosterParentingLocation() {
	                //NOTE: store last foster parenting location, so we will be able to find inserted text
	                //in case of foster parenting
	                mxn.lastFosterParentingLocation = orig._findFosterParentingLocation.call(this);

	                return mxn.lastFosterParentingLocation;
	            },

	            _insertCharacters(token) {
	                orig._insertCharacters.call(this, token);

	                const hasFosterParent = this._shouldFosterParentOnInsertion();

	                const parent =
	                    (hasFosterParent && mxn.lastFosterParentingLocation.parent) ||
	                    this.openElements.currentTmplContent ||
	                    this.openElements.current;

	                const siblings = this.treeAdapter.getChildNodes(parent);

	                const textNodeIdx =
	                    hasFosterParent && mxn.lastFosterParentingLocation.beforeElement
	                        ? siblings.indexOf(mxn.lastFosterParentingLocation.beforeElement) - 1
	                        : siblings.length - 1;

	                const textNode = siblings[textNodeIdx];

	                //NOTE: if we have location assigned by another token, then just update end position
	                const tnLoc = this.treeAdapter.getNodeSourceCodeLocation(textNode);

	                if (tnLoc) {
	                    const { endLine, endCol, endOffset } = token.location;
	                    this.treeAdapter.updateNodeSourceCodeLocation(textNode, { endLine, endCol, endOffset });
	                } else {
	                    this.treeAdapter.setNodeSourceCodeLocation(textNode, token.location);
	                }
	            }
	        };
	    }
	};

	var parserMixin$1 = LocationInfoParserMixin$1;

	const Mixin$4 = mixin;

	let ErrorReportingMixinBase$3 = class ErrorReportingMixinBase extends Mixin$4 {
	    constructor(host, opts) {
	        super(host);

	        this.posTracker = null;
	        this.onParseError = opts.onParseError;
	    }

	    _setErrorLocation(err) {
	        err.startLine = err.endLine = this.posTracker.line;
	        err.startCol = err.endCol = this.posTracker.col;
	        err.startOffset = err.endOffset = this.posTracker.offset;
	    }

	    _reportError(code) {
	        const err = {
	            code: code,
	            startLine: -1,
	            startCol: -1,
	            startOffset: -1,
	            endLine: -1,
	            endCol: -1,
	            endOffset: -1
	        };

	        this._setErrorLocation(err);
	        this.onParseError(err);
	    }

	    _getOverriddenMethods(mxn) {
	        return {
	            _err(code) {
	                mxn._reportError(code);
	            }
	        };
	    }
	};

	var mixinBase = ErrorReportingMixinBase$3;

	const ErrorReportingMixinBase$2 = mixinBase;
	const PositionTrackingPreprocessorMixin = preprocessorMixin$1;
	const Mixin$3 = mixin;

	let ErrorReportingPreprocessorMixin$1 = class ErrorReportingPreprocessorMixin extends ErrorReportingMixinBase$2 {
	    constructor(preprocessor, opts) {
	        super(preprocessor, opts);

	        this.posTracker = Mixin$3.install(preprocessor, PositionTrackingPreprocessorMixin);
	        this.lastErrOffset = -1;
	    }

	    _reportError(code) {
	        //NOTE: avoid reporting error twice on advance/retreat
	        if (this.lastErrOffset !== this.posTracker.offset) {
	            this.lastErrOffset = this.posTracker.offset;
	            super._reportError(code);
	        }
	    }
	};

	var preprocessorMixin = ErrorReportingPreprocessorMixin$1;

	const ErrorReportingMixinBase$1 = mixinBase;
	const ErrorReportingPreprocessorMixin = preprocessorMixin;
	const Mixin$2 = mixin;

	let ErrorReportingTokenizerMixin$1 = class ErrorReportingTokenizerMixin extends ErrorReportingMixinBase$1 {
	    constructor(tokenizer, opts) {
	        super(tokenizer, opts);

	        const preprocessorMixin = Mixin$2.install(tokenizer.preprocessor, ErrorReportingPreprocessorMixin, opts);

	        this.posTracker = preprocessorMixin.posTracker;
	    }
	};

	var tokenizerMixin = ErrorReportingTokenizerMixin$1;

	const ErrorReportingMixinBase = mixinBase;
	const ErrorReportingTokenizerMixin = tokenizerMixin;
	const LocationInfoTokenizerMixin = tokenizerMixin$1;
	const Mixin$1 = mixin;

	let ErrorReportingParserMixin$1 = class ErrorReportingParserMixin extends ErrorReportingMixinBase {
	    constructor(parser, opts) {
	        super(parser, opts);

	        this.opts = opts;
	        this.ctLoc = null;
	        this.locBeforeToken = false;
	    }

	    _setErrorLocation(err) {
	        if (this.ctLoc) {
	            err.startLine = this.ctLoc.startLine;
	            err.startCol = this.ctLoc.startCol;
	            err.startOffset = this.ctLoc.startOffset;

	            err.endLine = this.locBeforeToken ? this.ctLoc.startLine : this.ctLoc.endLine;
	            err.endCol = this.locBeforeToken ? this.ctLoc.startCol : this.ctLoc.endCol;
	            err.endOffset = this.locBeforeToken ? this.ctLoc.startOffset : this.ctLoc.endOffset;
	        }
	    }

	    _getOverriddenMethods(mxn, orig) {
	        return {
	            _bootstrap(document, fragmentContext) {
	                orig._bootstrap.call(this, document, fragmentContext);

	                Mixin$1.install(this.tokenizer, ErrorReportingTokenizerMixin, mxn.opts);
	                Mixin$1.install(this.tokenizer, LocationInfoTokenizerMixin);
	            },

	            _processInputToken(token) {
	                mxn.ctLoc = token.location;

	                orig._processInputToken.call(this, token);
	            },

	            _err(code, options) {
	                mxn.locBeforeToken = options && options.beforeToken;
	                mxn._reportError(code);
	            }
	        };
	    }
	};

	var parserMixin = ErrorReportingParserMixin$1;

	var _default$1 = {};

	const { DOCUMENT_MODE: DOCUMENT_MODE$1 } = html$5;

	//Node construction
	_default$1.createDocument = function() {
	    return {
	        nodeName: '#document',
	        mode: DOCUMENT_MODE$1.NO_QUIRKS,
	        childNodes: []
	    };
	};

	_default$1.createDocumentFragment = function() {
	    return {
	        nodeName: '#document-fragment',
	        childNodes: []
	    };
	};

	_default$1.createElement = function(tagName, namespaceURI, attrs) {
	    return {
	        nodeName: tagName,
	        tagName: tagName,
	        attrs: attrs,
	        namespaceURI: namespaceURI,
	        childNodes: [],
	        parentNode: null
	    };
	};

	_default$1.createCommentNode = function(data) {
	    return {
	        nodeName: '#comment',
	        data: data,
	        parentNode: null
	    };
	};

	const createTextNode = function(value) {
	    return {
	        nodeName: '#text',
	        value: value,
	        parentNode: null
	    };
	};

	//Tree mutation
	const appendChild = (_default$1.appendChild = function(parentNode, newNode) {
	    parentNode.childNodes.push(newNode);
	    newNode.parentNode = parentNode;
	});

	const insertBefore = (_default$1.insertBefore = function(parentNode, newNode, referenceNode) {
	    const insertionIdx = parentNode.childNodes.indexOf(referenceNode);

	    parentNode.childNodes.splice(insertionIdx, 0, newNode);
	    newNode.parentNode = parentNode;
	});

	_default$1.setTemplateContent = function(templateElement, contentElement) {
	    templateElement.content = contentElement;
	};

	_default$1.getTemplateContent = function(templateElement) {
	    return templateElement.content;
	};

	_default$1.setDocumentType = function(document, name, publicId, systemId) {
	    let doctypeNode = null;

	    for (let i = 0; i < document.childNodes.length; i++) {
	        if (document.childNodes[i].nodeName === '#documentType') {
	            doctypeNode = document.childNodes[i];
	            break;
	        }
	    }

	    if (doctypeNode) {
	        doctypeNode.name = name;
	        doctypeNode.publicId = publicId;
	        doctypeNode.systemId = systemId;
	    } else {
	        appendChild(document, {
	            nodeName: '#documentType',
	            name: name,
	            publicId: publicId,
	            systemId: systemId
	        });
	    }
	};

	_default$1.setDocumentMode = function(document, mode) {
	    document.mode = mode;
	};

	_default$1.getDocumentMode = function(document) {
	    return document.mode;
	};

	_default$1.detachNode = function(node) {
	    if (node.parentNode) {
	        const idx = node.parentNode.childNodes.indexOf(node);

	        node.parentNode.childNodes.splice(idx, 1);
	        node.parentNode = null;
	    }
	};

	_default$1.insertText = function(parentNode, text) {
	    if (parentNode.childNodes.length) {
	        const prevNode = parentNode.childNodes[parentNode.childNodes.length - 1];

	        if (prevNode.nodeName === '#text') {
	            prevNode.value += text;
	            return;
	        }
	    }

	    appendChild(parentNode, createTextNode(text));
	};

	_default$1.insertTextBefore = function(parentNode, text, referenceNode) {
	    const prevNode = parentNode.childNodes[parentNode.childNodes.indexOf(referenceNode) - 1];

	    if (prevNode && prevNode.nodeName === '#text') {
	        prevNode.value += text;
	    } else {
	        insertBefore(parentNode, createTextNode(text), referenceNode);
	    }
	};

	_default$1.adoptAttributes = function(recipient, attrs) {
	    const recipientAttrsMap = [];

	    for (let i = 0; i < recipient.attrs.length; i++) {
	        recipientAttrsMap.push(recipient.attrs[i].name);
	    }

	    for (let j = 0; j < attrs.length; j++) {
	        if (recipientAttrsMap.indexOf(attrs[j].name) === -1) {
	            recipient.attrs.push(attrs[j]);
	        }
	    }
	};

	//Tree traversing
	_default$1.getFirstChild = function(node) {
	    return node.childNodes[0];
	};

	_default$1.getChildNodes = function(node) {
	    return node.childNodes;
	};

	_default$1.getParentNode = function(node) {
	    return node.parentNode;
	};

	_default$1.getAttrList = function(element) {
	    return element.attrs;
	};

	//Node data
	_default$1.getTagName = function(element) {
	    return element.tagName;
	};

	_default$1.getNamespaceURI = function(element) {
	    return element.namespaceURI;
	};

	_default$1.getTextNodeContent = function(textNode) {
	    return textNode.value;
	};

	_default$1.getCommentNodeContent = function(commentNode) {
	    return commentNode.data;
	};

	_default$1.getDocumentTypeNodeName = function(doctypeNode) {
	    return doctypeNode.name;
	};

	_default$1.getDocumentTypeNodePublicId = function(doctypeNode) {
	    return doctypeNode.publicId;
	};

	_default$1.getDocumentTypeNodeSystemId = function(doctypeNode) {
	    return doctypeNode.systemId;
	};

	//Node types
	_default$1.isTextNode = function(node) {
	    return node.nodeName === '#text';
	};

	_default$1.isCommentNode = function(node) {
	    return node.nodeName === '#comment';
	};

	_default$1.isDocumentTypeNode = function(node) {
	    return node.nodeName === '#documentType';
	};

	_default$1.isElementNode = function(node) {
	    return !!node.tagName;
	};

	// Source code location
	_default$1.setNodeSourceCodeLocation = function(node, location) {
	    node.sourceCodeLocation = location;
	};

	_default$1.getNodeSourceCodeLocation = function(node) {
	    return node.sourceCodeLocation;
	};

	_default$1.updateNodeSourceCodeLocation = function(node, endLocation) {
	    node.sourceCodeLocation = Object.assign(node.sourceCodeLocation, endLocation);
	};

	var mergeOptions$1 = function mergeOptions(defaults, options) {
	    options = options || Object.create(null);

	    return [defaults, options].reduce((merged, optObj) => {
	        Object.keys(optObj).forEach(key => {
	            merged[key] = optObj[key];
	        });

	        return merged;
	    }, Object.create(null));
	};

	var doctype$4 = {};

	const { DOCUMENT_MODE } = html$5;

	//Const
	const VALID_DOCTYPE_NAME = 'html';
	const VALID_SYSTEM_ID = 'about:legacy-compat';
	const QUIRKS_MODE_SYSTEM_ID = 'http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd';

	const QUIRKS_MODE_PUBLIC_ID_PREFIXES = [
	    '+//silmaril//dtd html pro v0r11 19970101//',
	    '-//as//dtd html 3.0 aswedit + extensions//',
	    '-//advasoft ltd//dtd html 3.0 aswedit + extensions//',
	    '-//ietf//dtd html 2.0 level 1//',
	    '-//ietf//dtd html 2.0 level 2//',
	    '-//ietf//dtd html 2.0 strict level 1//',
	    '-//ietf//dtd html 2.0 strict level 2//',
	    '-//ietf//dtd html 2.0 strict//',
	    '-//ietf//dtd html 2.0//',
	    '-//ietf//dtd html 2.1e//',
	    '-//ietf//dtd html 3.0//',
	    '-//ietf//dtd html 3.2 final//',
	    '-//ietf//dtd html 3.2//',
	    '-//ietf//dtd html 3//',
	    '-//ietf//dtd html level 0//',
	    '-//ietf//dtd html level 1//',
	    '-//ietf//dtd html level 2//',
	    '-//ietf//dtd html level 3//',
	    '-//ietf//dtd html strict level 0//',
	    '-//ietf//dtd html strict level 1//',
	    '-//ietf//dtd html strict level 2//',
	    '-//ietf//dtd html strict level 3//',
	    '-//ietf//dtd html strict//',
	    '-//ietf//dtd html//',
	    '-//metrius//dtd metrius presentational//',
	    '-//microsoft//dtd internet explorer 2.0 html strict//',
	    '-//microsoft//dtd internet explorer 2.0 html//',
	    '-//microsoft//dtd internet explorer 2.0 tables//',
	    '-//microsoft//dtd internet explorer 3.0 html strict//',
	    '-//microsoft//dtd internet explorer 3.0 html//',
	    '-//microsoft//dtd internet explorer 3.0 tables//',
	    '-//netscape comm. corp.//dtd html//',
	    '-//netscape comm. corp.//dtd strict html//',
	    "-//o'reilly and associates//dtd html 2.0//",
	    "-//o'reilly and associates//dtd html extended 1.0//",
	    "-//o'reilly and associates//dtd html extended relaxed 1.0//",
	    '-//sq//dtd html 2.0 hotmetal + extensions//',
	    '-//softquad software//dtd hotmetal pro 6.0::19990601::extensions to html 4.0//',
	    '-//softquad//dtd hotmetal pro 4.0::19971010::extensions to html 4.0//',
	    '-//spyglass//dtd html 2.0 extended//',
	    '-//sun microsystems corp.//dtd hotjava html//',
	    '-//sun microsystems corp.//dtd hotjava strict html//',
	    '-//w3c//dtd html 3 1995-03-24//',
	    '-//w3c//dtd html 3.2 draft//',
	    '-//w3c//dtd html 3.2 final//',
	    '-//w3c//dtd html 3.2//',
	    '-//w3c//dtd html 3.2s draft//',
	    '-//w3c//dtd html 4.0 frameset//',
	    '-//w3c//dtd html 4.0 transitional//',
	    '-//w3c//dtd html experimental 19960712//',
	    '-//w3c//dtd html experimental 970421//',
	    '-//w3c//dtd w3 html//',
	    '-//w3o//dtd w3 html 3.0//',
	    '-//webtechs//dtd mozilla html 2.0//',
	    '-//webtechs//dtd mozilla html//'
	];

	const QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES = QUIRKS_MODE_PUBLIC_ID_PREFIXES.concat([
	    '-//w3c//dtd html 4.01 frameset//',
	    '-//w3c//dtd html 4.01 transitional//'
	]);

	const QUIRKS_MODE_PUBLIC_IDS = ['-//w3o//dtd w3 html strict 3.0//en//', '-/w3c/dtd html 4.0 transitional/en', 'html'];
	const LIMITED_QUIRKS_PUBLIC_ID_PREFIXES = ['-//w3c//dtd xhtml 1.0 frameset//', '-//w3c//dtd xhtml 1.0 transitional//'];

	const LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES = LIMITED_QUIRKS_PUBLIC_ID_PREFIXES.concat([
	    '-//w3c//dtd html 4.01 frameset//',
	    '-//w3c//dtd html 4.01 transitional//'
	]);

	//Utils
	function enquoteDoctypeId(id) {
	    const quote = id.indexOf('"') !== -1 ? "'" : '"';

	    return quote + id + quote;
	}

	function hasPrefix(publicId, prefixes) {
	    for (let i = 0; i < prefixes.length; i++) {
	        if (publicId.indexOf(prefixes[i]) === 0) {
	            return true;
	        }
	    }

	    return false;
	}

	//API
	doctype$4.isConforming = function(token) {
	    return (
	        token.name === VALID_DOCTYPE_NAME &&
	        token.publicId === null &&
	        (token.systemId === null || token.systemId === VALID_SYSTEM_ID)
	    );
	};

	doctype$4.getDocumentMode = function(token) {
	    if (token.name !== VALID_DOCTYPE_NAME) {
	        return DOCUMENT_MODE.QUIRKS;
	    }

	    const systemId = token.systemId;

	    if (systemId && systemId.toLowerCase() === QUIRKS_MODE_SYSTEM_ID) {
	        return DOCUMENT_MODE.QUIRKS;
	    }

	    let publicId = token.publicId;

	    if (publicId !== null) {
	        publicId = publicId.toLowerCase();

	        if (QUIRKS_MODE_PUBLIC_IDS.indexOf(publicId) > -1) {
	            return DOCUMENT_MODE.QUIRKS;
	        }

	        let prefixes = systemId === null ? QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES : QUIRKS_MODE_PUBLIC_ID_PREFIXES;

	        if (hasPrefix(publicId, prefixes)) {
	            return DOCUMENT_MODE.QUIRKS;
	        }

	        prefixes =
	            systemId === null ? LIMITED_QUIRKS_PUBLIC_ID_PREFIXES : LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES;

	        if (hasPrefix(publicId, prefixes)) {
	            return DOCUMENT_MODE.LIMITED_QUIRKS;
	        }
	    }

	    return DOCUMENT_MODE.NO_QUIRKS;
	};

	doctype$4.serializeContent = function(name, publicId, systemId) {
	    let str = '!DOCTYPE ';

	    if (name) {
	        str += name;
	    }

	    if (publicId) {
	        str += ' PUBLIC ' + enquoteDoctypeId(publicId);
	    } else if (systemId) {
	        str += ' SYSTEM';
	    }

	    if (systemId !== null) {
	        str += ' ' + enquoteDoctypeId(systemId);
	    }

	    return str;
	};

	var foreignContent$1 = {};

	const Tokenizer$1 = tokenizer;
	const HTML$1 = html$5;

	//Aliases
	const $$2 = HTML$1.TAG_NAMES;
	const NS$1 = HTML$1.NAMESPACES;
	const ATTRS$1 = HTML$1.ATTRS;

	//MIME types
	const MIME_TYPES = {
	    TEXT_HTML: 'text/html',
	    APPLICATION_XML: 'application/xhtml+xml'
	};

	//Attributes
	const DEFINITION_URL_ATTR = 'definitionurl';
	const ADJUSTED_DEFINITION_URL_ATTR = 'definitionURL';
	const SVG_ATTRS_ADJUSTMENT_MAP = {
	    attributename: 'attributeName',
	    attributetype: 'attributeType',
	    basefrequency: 'baseFrequency',
	    baseprofile: 'baseProfile',
	    calcmode: 'calcMode',
	    clippathunits: 'clipPathUnits',
	    diffuseconstant: 'diffuseConstant',
	    edgemode: 'edgeMode',
	    filterunits: 'filterUnits',
	    glyphref: 'glyphRef',
	    gradienttransform: 'gradientTransform',
	    gradientunits: 'gradientUnits',
	    kernelmatrix: 'kernelMatrix',
	    kernelunitlength: 'kernelUnitLength',
	    keypoints: 'keyPoints',
	    keysplines: 'keySplines',
	    keytimes: 'keyTimes',
	    lengthadjust: 'lengthAdjust',
	    limitingconeangle: 'limitingConeAngle',
	    markerheight: 'markerHeight',
	    markerunits: 'markerUnits',
	    markerwidth: 'markerWidth',
	    maskcontentunits: 'maskContentUnits',
	    maskunits: 'maskUnits',
	    numoctaves: 'numOctaves',
	    pathlength: 'pathLength',
	    patterncontentunits: 'patternContentUnits',
	    patterntransform: 'patternTransform',
	    patternunits: 'patternUnits',
	    pointsatx: 'pointsAtX',
	    pointsaty: 'pointsAtY',
	    pointsatz: 'pointsAtZ',
	    preservealpha: 'preserveAlpha',
	    preserveaspectratio: 'preserveAspectRatio',
	    primitiveunits: 'primitiveUnits',
	    refx: 'refX',
	    refy: 'refY',
	    repeatcount: 'repeatCount',
	    repeatdur: 'repeatDur',
	    requiredextensions: 'requiredExtensions',
	    requiredfeatures: 'requiredFeatures',
	    specularconstant: 'specularConstant',
	    specularexponent: 'specularExponent',
	    spreadmethod: 'spreadMethod',
	    startoffset: 'startOffset',
	    stddeviation: 'stdDeviation',
	    stitchtiles: 'stitchTiles',
	    surfacescale: 'surfaceScale',
	    systemlanguage: 'systemLanguage',
	    tablevalues: 'tableValues',
	    targetx: 'targetX',
	    targety: 'targetY',
	    textlength: 'textLength',
	    viewbox: 'viewBox',
	    viewtarget: 'viewTarget',
	    xchannelselector: 'xChannelSelector',
	    ychannelselector: 'yChannelSelector',
	    zoomandpan: 'zoomAndPan'
	};

	const XML_ATTRS_ADJUSTMENT_MAP = {
	    'xlink:actuate': { prefix: 'xlink', name: 'actuate', namespace: NS$1.XLINK },
	    'xlink:arcrole': { prefix: 'xlink', name: 'arcrole', namespace: NS$1.XLINK },
	    'xlink:href': { prefix: 'xlink', name: 'href', namespace: NS$1.XLINK },
	    'xlink:role': { prefix: 'xlink', name: 'role', namespace: NS$1.XLINK },
	    'xlink:show': { prefix: 'xlink', name: 'show', namespace: NS$1.XLINK },
	    'xlink:title': { prefix: 'xlink', name: 'title', namespace: NS$1.XLINK },
	    'xlink:type': { prefix: 'xlink', name: 'type', namespace: NS$1.XLINK },
	    'xml:base': { prefix: 'xml', name: 'base', namespace: NS$1.XML },
	    'xml:lang': { prefix: 'xml', name: 'lang', namespace: NS$1.XML },
	    'xml:space': { prefix: 'xml', name: 'space', namespace: NS$1.XML },
	    xmlns: { prefix: '', name: 'xmlns', namespace: NS$1.XMLNS },
	    'xmlns:xlink': { prefix: 'xmlns', name: 'xlink', namespace: NS$1.XMLNS }
	};

	//SVG tag names adjustment map
	const SVG_TAG_NAMES_ADJUSTMENT_MAP = (foreignContent$1.SVG_TAG_NAMES_ADJUSTMENT_MAP = {
	    altglyph: 'altGlyph',
	    altglyphdef: 'altGlyphDef',
	    altglyphitem: 'altGlyphItem',
	    animatecolor: 'animateColor',
	    animatemotion: 'animateMotion',
	    animatetransform: 'animateTransform',
	    clippath: 'clipPath',
	    feblend: 'feBlend',
	    fecolormatrix: 'feColorMatrix',
	    fecomponenttransfer: 'feComponentTransfer',
	    fecomposite: 'feComposite',
	    feconvolvematrix: 'feConvolveMatrix',
	    fediffuselighting: 'feDiffuseLighting',
	    fedisplacementmap: 'feDisplacementMap',
	    fedistantlight: 'feDistantLight',
	    feflood: 'feFlood',
	    fefunca: 'feFuncA',
	    fefuncb: 'feFuncB',
	    fefuncg: 'feFuncG',
	    fefuncr: 'feFuncR',
	    fegaussianblur: 'feGaussianBlur',
	    feimage: 'feImage',
	    femerge: 'feMerge',
	    femergenode: 'feMergeNode',
	    femorphology: 'feMorphology',
	    feoffset: 'feOffset',
	    fepointlight: 'fePointLight',
	    fespecularlighting: 'feSpecularLighting',
	    fespotlight: 'feSpotLight',
	    fetile: 'feTile',
	    feturbulence: 'feTurbulence',
	    foreignobject: 'foreignObject',
	    glyphref: 'glyphRef',
	    lineargradient: 'linearGradient',
	    radialgradient: 'radialGradient',
	    textpath: 'textPath'
	});

	//Tags that causes exit from foreign content
	const EXITS_FOREIGN_CONTENT = {
	    [$$2.B]: true,
	    [$$2.BIG]: true,
	    [$$2.BLOCKQUOTE]: true,
	    [$$2.BODY]: true,
	    [$$2.BR]: true,
	    [$$2.CENTER]: true,
	    [$$2.CODE]: true,
	    [$$2.DD]: true,
	    [$$2.DIV]: true,
	    [$$2.DL]: true,
	    [$$2.DT]: true,
	    [$$2.EM]: true,
	    [$$2.EMBED]: true,
	    [$$2.H1]: true,
	    [$$2.H2]: true,
	    [$$2.H3]: true,
	    [$$2.H4]: true,
	    [$$2.H5]: true,
	    [$$2.H6]: true,
	    [$$2.HEAD]: true,
	    [$$2.HR]: true,
	    [$$2.I]: true,
	    [$$2.IMG]: true,
	    [$$2.LI]: true,
	    [$$2.LISTING]: true,
	    [$$2.MENU]: true,
	    [$$2.META]: true,
	    [$$2.NOBR]: true,
	    [$$2.OL]: true,
	    [$$2.P]: true,
	    [$$2.PRE]: true,
	    [$$2.RUBY]: true,
	    [$$2.S]: true,
	    [$$2.SMALL]: true,
	    [$$2.SPAN]: true,
	    [$$2.STRONG]: true,
	    [$$2.STRIKE]: true,
	    [$$2.SUB]: true,
	    [$$2.SUP]: true,
	    [$$2.TABLE]: true,
	    [$$2.TT]: true,
	    [$$2.U]: true,
	    [$$2.UL]: true,
	    [$$2.VAR]: true
	};

	//Check exit from foreign content
	foreignContent$1.causesExit = function(startTagToken) {
	    const tn = startTagToken.tagName;
	    const isFontWithAttrs =
	        tn === $$2.FONT &&
	        (Tokenizer$1.getTokenAttr(startTagToken, ATTRS$1.COLOR) !== null ||
	            Tokenizer$1.getTokenAttr(startTagToken, ATTRS$1.SIZE) !== null ||
	            Tokenizer$1.getTokenAttr(startTagToken, ATTRS$1.FACE) !== null);

	    return isFontWithAttrs ? true : EXITS_FOREIGN_CONTENT[tn];
	};

	//Token adjustments
	foreignContent$1.adjustTokenMathMLAttrs = function(token) {
	    for (let i = 0; i < token.attrs.length; i++) {
	        if (token.attrs[i].name === DEFINITION_URL_ATTR) {
	            token.attrs[i].name = ADJUSTED_DEFINITION_URL_ATTR;
	            break;
	        }
	    }
	};

	foreignContent$1.adjustTokenSVGAttrs = function(token) {
	    for (let i = 0; i < token.attrs.length; i++) {
	        const adjustedAttrName = SVG_ATTRS_ADJUSTMENT_MAP[token.attrs[i].name];

	        if (adjustedAttrName) {
	            token.attrs[i].name = adjustedAttrName;
	        }
	    }
	};

	foreignContent$1.adjustTokenXMLAttrs = function(token) {
	    for (let i = 0; i < token.attrs.length; i++) {
	        const adjustedAttrEntry = XML_ATTRS_ADJUSTMENT_MAP[token.attrs[i].name];

	        if (adjustedAttrEntry) {
	            token.attrs[i].prefix = adjustedAttrEntry.prefix;
	            token.attrs[i].name = adjustedAttrEntry.name;
	            token.attrs[i].namespace = adjustedAttrEntry.namespace;
	        }
	    }
	};

	foreignContent$1.adjustTokenSVGTagName = function(token) {
	    const adjustedTagName = SVG_TAG_NAMES_ADJUSTMENT_MAP[token.tagName];

	    if (adjustedTagName) {
	        token.tagName = adjustedTagName;
	    }
	};

	//Integration points
	function isMathMLTextIntegrationPoint(tn, ns) {
	    return ns === NS$1.MATHML && (tn === $$2.MI || tn === $$2.MO || tn === $$2.MN || tn === $$2.MS || tn === $$2.MTEXT);
	}

	function isHtmlIntegrationPoint(tn, ns, attrs) {
	    if (ns === NS$1.MATHML && tn === $$2.ANNOTATION_XML) {
	        for (let i = 0; i < attrs.length; i++) {
	            if (attrs[i].name === ATTRS$1.ENCODING) {
	                const value = attrs[i].value.toLowerCase();

	                return value === MIME_TYPES.TEXT_HTML || value === MIME_TYPES.APPLICATION_XML;
	            }
	        }
	    }

	    return ns === NS$1.SVG && (tn === $$2.FOREIGN_OBJECT || tn === $$2.DESC || tn === $$2.TITLE);
	}

	foreignContent$1.isIntegrationPoint = function(tn, ns, attrs, foreignNS) {
	    if ((!foreignNS || foreignNS === NS$1.HTML) && isHtmlIntegrationPoint(tn, ns, attrs)) {
	        return true;
	    }

	    if ((!foreignNS || foreignNS === NS$1.MATHML) && isMathMLTextIntegrationPoint(tn, ns)) {
	        return true;
	    }

	    return false;
	};

	const Tokenizer = tokenizer;
	const OpenElementStack = openElementStack;
	const FormattingElementList = formattingElementList;
	const LocationInfoParserMixin = parserMixin$1;
	const ErrorReportingParserMixin = parserMixin;
	const Mixin = mixin;
	const defaultTreeAdapter = _default$1;
	const mergeOptions = mergeOptions$1;
	const doctype$3 = doctype$4;
	const foreignContent = foreignContent$1;
	const ERR = errorCodes;
	const unicode = unicode$3;
	const HTML = html$5;

	//Aliases
	const $$1 = HTML.TAG_NAMES;
	const NS = HTML.NAMESPACES;
	const ATTRS = HTML.ATTRS;

	const DEFAULT_OPTIONS = {
	    scriptingEnabled: true,
	    sourceCodeLocationInfo: false,
	    onParseError: null,
	    treeAdapter: defaultTreeAdapter
	};

	//Misc constants
	const HIDDEN_INPUT_TYPE = 'hidden';

	//Adoption agency loops iteration count
	const AA_OUTER_LOOP_ITER = 8;
	const AA_INNER_LOOP_ITER = 3;

	//Insertion modes
	const INITIAL_MODE = 'INITIAL_MODE';
	const BEFORE_HTML_MODE = 'BEFORE_HTML_MODE';
	const BEFORE_HEAD_MODE = 'BEFORE_HEAD_MODE';
	const IN_HEAD_MODE = 'IN_HEAD_MODE';
	const IN_HEAD_NO_SCRIPT_MODE = 'IN_HEAD_NO_SCRIPT_MODE';
	const AFTER_HEAD_MODE = 'AFTER_HEAD_MODE';
	const IN_BODY_MODE = 'IN_BODY_MODE';
	const TEXT_MODE = 'TEXT_MODE';
	const IN_TABLE_MODE = 'IN_TABLE_MODE';
	const IN_TABLE_TEXT_MODE = 'IN_TABLE_TEXT_MODE';
	const IN_CAPTION_MODE = 'IN_CAPTION_MODE';
	const IN_COLUMN_GROUP_MODE = 'IN_COLUMN_GROUP_MODE';
	const IN_TABLE_BODY_MODE = 'IN_TABLE_BODY_MODE';
	const IN_ROW_MODE = 'IN_ROW_MODE';
	const IN_CELL_MODE = 'IN_CELL_MODE';
	const IN_SELECT_MODE = 'IN_SELECT_MODE';
	const IN_SELECT_IN_TABLE_MODE = 'IN_SELECT_IN_TABLE_MODE';
	const IN_TEMPLATE_MODE = 'IN_TEMPLATE_MODE';
	const AFTER_BODY_MODE = 'AFTER_BODY_MODE';
	const IN_FRAMESET_MODE = 'IN_FRAMESET_MODE';
	const AFTER_FRAMESET_MODE = 'AFTER_FRAMESET_MODE';
	const AFTER_AFTER_BODY_MODE = 'AFTER_AFTER_BODY_MODE';
	const AFTER_AFTER_FRAMESET_MODE = 'AFTER_AFTER_FRAMESET_MODE';

	//Insertion mode reset map
	const INSERTION_MODE_RESET_MAP = {
	    [$$1.TR]: IN_ROW_MODE,
	    [$$1.TBODY]: IN_TABLE_BODY_MODE,
	    [$$1.THEAD]: IN_TABLE_BODY_MODE,
	    [$$1.TFOOT]: IN_TABLE_BODY_MODE,
	    [$$1.CAPTION]: IN_CAPTION_MODE,
	    [$$1.COLGROUP]: IN_COLUMN_GROUP_MODE,
	    [$$1.TABLE]: IN_TABLE_MODE,
	    [$$1.BODY]: IN_BODY_MODE,
	    [$$1.FRAMESET]: IN_FRAMESET_MODE
	};

	//Template insertion mode switch map
	const TEMPLATE_INSERTION_MODE_SWITCH_MAP = {
	    [$$1.CAPTION]: IN_TABLE_MODE,
	    [$$1.COLGROUP]: IN_TABLE_MODE,
	    [$$1.TBODY]: IN_TABLE_MODE,
	    [$$1.TFOOT]: IN_TABLE_MODE,
	    [$$1.THEAD]: IN_TABLE_MODE,
	    [$$1.COL]: IN_COLUMN_GROUP_MODE,
	    [$$1.TR]: IN_TABLE_BODY_MODE,
	    [$$1.TD]: IN_ROW_MODE,
	    [$$1.TH]: IN_ROW_MODE
	};

	//Token handlers map for insertion modes
	const TOKEN_HANDLERS = {
	    [INITIAL_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: tokenInInitialMode,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInInitialMode,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: doctypeInInitialMode,
	        [Tokenizer.START_TAG_TOKEN]: tokenInInitialMode,
	        [Tokenizer.END_TAG_TOKEN]: tokenInInitialMode,
	        [Tokenizer.EOF_TOKEN]: tokenInInitialMode
	    },
	    [BEFORE_HTML_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: tokenBeforeHtml,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenBeforeHtml,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagBeforeHtml,
	        [Tokenizer.END_TAG_TOKEN]: endTagBeforeHtml,
	        [Tokenizer.EOF_TOKEN]: tokenBeforeHtml
	    },
	    [BEFORE_HEAD_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: tokenBeforeHead,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenBeforeHead,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,
	        [Tokenizer.START_TAG_TOKEN]: startTagBeforeHead,
	        [Tokenizer.END_TAG_TOKEN]: endTagBeforeHead,
	        [Tokenizer.EOF_TOKEN]: tokenBeforeHead
	    },
	    [IN_HEAD_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: tokenInHead,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInHead,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,
	        [Tokenizer.START_TAG_TOKEN]: startTagInHead,
	        [Tokenizer.END_TAG_TOKEN]: endTagInHead,
	        [Tokenizer.EOF_TOKEN]: tokenInHead
	    },
	    [IN_HEAD_NO_SCRIPT_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: tokenInHeadNoScript,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInHeadNoScript,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,
	        [Tokenizer.START_TAG_TOKEN]: startTagInHeadNoScript,
	        [Tokenizer.END_TAG_TOKEN]: endTagInHeadNoScript,
	        [Tokenizer.EOF_TOKEN]: tokenInHeadNoScript
	    },
	    [AFTER_HEAD_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: tokenAfterHead,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenAfterHead,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,
	        [Tokenizer.START_TAG_TOKEN]: startTagAfterHead,
	        [Tokenizer.END_TAG_TOKEN]: endTagAfterHead,
	        [Tokenizer.EOF_TOKEN]: tokenAfterHead
	    },
	    [IN_BODY_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: characterInBody,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagInBody,
	        [Tokenizer.END_TAG_TOKEN]: endTagInBody,
	        [Tokenizer.EOF_TOKEN]: eofInBody
	    },
	    [TEXT_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: insertCharacters,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: insertCharacters,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
	        [Tokenizer.COMMENT_TOKEN]: ignoreToken,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: ignoreToken,
	        [Tokenizer.END_TAG_TOKEN]: endTagInText,
	        [Tokenizer.EOF_TOKEN]: eofInText
	    },
	    [IN_TABLE_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: characterInTable,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: characterInTable,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: characterInTable,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagInTable,
	        [Tokenizer.END_TAG_TOKEN]: endTagInTable,
	        [Tokenizer.EOF_TOKEN]: eofInBody
	    },
	    [IN_TABLE_TEXT_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: characterInTableText,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInTableText,
	        [Tokenizer.COMMENT_TOKEN]: tokenInTableText,
	        [Tokenizer.DOCTYPE_TOKEN]: tokenInTableText,
	        [Tokenizer.START_TAG_TOKEN]: tokenInTableText,
	        [Tokenizer.END_TAG_TOKEN]: tokenInTableText,
	        [Tokenizer.EOF_TOKEN]: tokenInTableText
	    },
	    [IN_CAPTION_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: characterInBody,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagInCaption,
	        [Tokenizer.END_TAG_TOKEN]: endTagInCaption,
	        [Tokenizer.EOF_TOKEN]: eofInBody
	    },
	    [IN_COLUMN_GROUP_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: tokenInColumnGroup,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInColumnGroup,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagInColumnGroup,
	        [Tokenizer.END_TAG_TOKEN]: endTagInColumnGroup,
	        [Tokenizer.EOF_TOKEN]: eofInBody
	    },
	    [IN_TABLE_BODY_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: characterInTable,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: characterInTable,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: characterInTable,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagInTableBody,
	        [Tokenizer.END_TAG_TOKEN]: endTagInTableBody,
	        [Tokenizer.EOF_TOKEN]: eofInBody
	    },
	    [IN_ROW_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: characterInTable,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: characterInTable,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: characterInTable,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagInRow,
	        [Tokenizer.END_TAG_TOKEN]: endTagInRow,
	        [Tokenizer.EOF_TOKEN]: eofInBody
	    },
	    [IN_CELL_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: characterInBody,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagInCell,
	        [Tokenizer.END_TAG_TOKEN]: endTagInCell,
	        [Tokenizer.EOF_TOKEN]: eofInBody
	    },
	    [IN_SELECT_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: insertCharacters,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagInSelect,
	        [Tokenizer.END_TAG_TOKEN]: endTagInSelect,
	        [Tokenizer.EOF_TOKEN]: eofInBody
	    },
	    [IN_SELECT_IN_TABLE_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: insertCharacters,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagInSelectInTable,
	        [Tokenizer.END_TAG_TOKEN]: endTagInSelectInTable,
	        [Tokenizer.EOF_TOKEN]: eofInBody
	    },
	    [IN_TEMPLATE_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: characterInBody,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagInTemplate,
	        [Tokenizer.END_TAG_TOKEN]: endTagInTemplate,
	        [Tokenizer.EOF_TOKEN]: eofInTemplate
	    },
	    [AFTER_BODY_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: tokenAfterBody,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenAfterBody,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
	        [Tokenizer.COMMENT_TOKEN]: appendCommentToRootHtmlElement,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagAfterBody,
	        [Tokenizer.END_TAG_TOKEN]: endTagAfterBody,
	        [Tokenizer.EOF_TOKEN]: stopParsing
	    },
	    [IN_FRAMESET_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagInFrameset,
	        [Tokenizer.END_TAG_TOKEN]: endTagInFrameset,
	        [Tokenizer.EOF_TOKEN]: stopParsing
	    },
	    [AFTER_FRAMESET_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
	        [Tokenizer.COMMENT_TOKEN]: appendComment,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagAfterFrameset,
	        [Tokenizer.END_TAG_TOKEN]: endTagAfterFrameset,
	        [Tokenizer.EOF_TOKEN]: stopParsing
	    },
	    [AFTER_AFTER_BODY_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: tokenAfterAfterBody,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenAfterAfterBody,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
	        [Tokenizer.COMMENT_TOKEN]: appendCommentToDocument,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagAfterAfterBody,
	        [Tokenizer.END_TAG_TOKEN]: tokenAfterAfterBody,
	        [Tokenizer.EOF_TOKEN]: stopParsing
	    },
	    [AFTER_AFTER_FRAMESET_MODE]: {
	        [Tokenizer.CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
	        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
	        [Tokenizer.COMMENT_TOKEN]: appendCommentToDocument,
	        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
	        [Tokenizer.START_TAG_TOKEN]: startTagAfterAfterFrameset,
	        [Tokenizer.END_TAG_TOKEN]: ignoreToken,
	        [Tokenizer.EOF_TOKEN]: stopParsing
	    }
	};

	//Parser
	class Parser {
	    constructor(options) {
	        this.options = mergeOptions(DEFAULT_OPTIONS, options);

	        this.treeAdapter = this.options.treeAdapter;
	        this.pendingScript = null;

	        if (this.options.sourceCodeLocationInfo) {
	            Mixin.install(this, LocationInfoParserMixin);
	        }

	        if (this.options.onParseError) {
	            Mixin.install(this, ErrorReportingParserMixin, { onParseError: this.options.onParseError });
	        }
	    }

	    // API
	    parse(html) {
	        const document = this.treeAdapter.createDocument();

	        this._bootstrap(document, null);
	        this.tokenizer.write(html, true);
	        this._runParsingLoop(null);

	        return document;
	    }

	    parseFragment(html, fragmentContext) {
	        //NOTE: use <template> element as a fragment context if context element was not provided,
	        //so we will parse in "forgiving" manner
	        if (!fragmentContext) {
	            fragmentContext = this.treeAdapter.createElement($$1.TEMPLATE, NS.HTML, []);
	        }

	        //NOTE: create fake element which will be used as 'document' for fragment parsing.
	        //This is important for jsdom there 'document' can't be recreated, therefore
	        //fragment parsing causes messing of the main `document`.
	        const documentMock = this.treeAdapter.createElement('documentmock', NS.HTML, []);

	        this._bootstrap(documentMock, fragmentContext);

	        if (this.treeAdapter.getTagName(fragmentContext) === $$1.TEMPLATE) {
	            this._pushTmplInsertionMode(IN_TEMPLATE_MODE);
	        }

	        this._initTokenizerForFragmentParsing();
	        this._insertFakeRootElement();
	        this._resetInsertionMode();
	        this._findFormInFragmentContext();
	        this.tokenizer.write(html, true);
	        this._runParsingLoop(null);

	        const rootElement = this.treeAdapter.getFirstChild(documentMock);
	        const fragment = this.treeAdapter.createDocumentFragment();

	        this._adoptNodes(rootElement, fragment);

	        return fragment;
	    }

	    //Bootstrap parser
	    _bootstrap(document, fragmentContext) {
	        this.tokenizer = new Tokenizer(this.options);

	        this.stopped = false;

	        this.insertionMode = INITIAL_MODE;
	        this.originalInsertionMode = '';

	        this.document = document;
	        this.fragmentContext = fragmentContext;

	        this.headElement = null;
	        this.formElement = null;

	        this.openElements = new OpenElementStack(this.document, this.treeAdapter);
	        this.activeFormattingElements = new FormattingElementList(this.treeAdapter);

	        this.tmplInsertionModeStack = [];
	        this.tmplInsertionModeStackTop = -1;
	        this.currentTmplInsertionMode = null;

	        this.pendingCharacterTokens = [];
	        this.hasNonWhitespacePendingCharacterToken = false;

	        this.framesetOk = true;
	        this.skipNextNewLine = false;
	        this.fosterParentingEnabled = false;
	    }

	    //Errors
	    _err() {
	        // NOTE: err reporting is noop by default. Enabled by mixin.
	    }

	    //Parsing loop
	    _runParsingLoop(scriptHandler) {
	        while (!this.stopped) {
	            this._setupTokenizerCDATAMode();

	            const token = this.tokenizer.getNextToken();

	            if (token.type === Tokenizer.HIBERNATION_TOKEN) {
	                break;
	            }

	            if (this.skipNextNewLine) {
	                this.skipNextNewLine = false;

	                if (token.type === Tokenizer.WHITESPACE_CHARACTER_TOKEN && token.chars[0] === '\n') {
	                    if (token.chars.length === 1) {
	                        continue;
	                    }

	                    token.chars = token.chars.substr(1);
	                }
	            }

	            this._processInputToken(token);

	            if (scriptHandler && this.pendingScript) {
	                break;
	            }
	        }
	    }

	    runParsingLoopForCurrentChunk(writeCallback, scriptHandler) {
	        this._runParsingLoop(scriptHandler);

	        if (scriptHandler && this.pendingScript) {
	            const script = this.pendingScript;

	            this.pendingScript = null;

	            scriptHandler(script);

	            return;
	        }

	        if (writeCallback) {
	            writeCallback();
	        }
	    }

	    //Text parsing
	    _setupTokenizerCDATAMode() {
	        const current = this._getAdjustedCurrentElement();

	        this.tokenizer.allowCDATA =
	            current &&
	            current !== this.document &&
	            this.treeAdapter.getNamespaceURI(current) !== NS.HTML &&
	            !this._isIntegrationPoint(current);
	    }

	    _switchToTextParsing(currentToken, nextTokenizerState) {
	        this._insertElement(currentToken, NS.HTML);
	        this.tokenizer.state = nextTokenizerState;
	        this.originalInsertionMode = this.insertionMode;
	        this.insertionMode = TEXT_MODE;
	    }

	    switchToPlaintextParsing() {
	        this.insertionMode = TEXT_MODE;
	        this.originalInsertionMode = IN_BODY_MODE;
	        this.tokenizer.state = Tokenizer.MODE.PLAINTEXT;
	    }

	    //Fragment parsing
	    _getAdjustedCurrentElement() {
	        return this.openElements.stackTop === 0 && this.fragmentContext
	            ? this.fragmentContext
	            : this.openElements.current;
	    }

	    _findFormInFragmentContext() {
	        let node = this.fragmentContext;

	        do {
	            if (this.treeAdapter.getTagName(node) === $$1.FORM) {
	                this.formElement = node;
	                break;
	            }

	            node = this.treeAdapter.getParentNode(node);
	        } while (node);
	    }

	    _initTokenizerForFragmentParsing() {
	        if (this.treeAdapter.getNamespaceURI(this.fragmentContext) === NS.HTML) {
	            const tn = this.treeAdapter.getTagName(this.fragmentContext);

	            if (tn === $$1.TITLE || tn === $$1.TEXTAREA) {
	                this.tokenizer.state = Tokenizer.MODE.RCDATA;
	            } else if (
	                tn === $$1.STYLE ||
	                tn === $$1.XMP ||
	                tn === $$1.IFRAME ||
	                tn === $$1.NOEMBED ||
	                tn === $$1.NOFRAMES ||
	                tn === $$1.NOSCRIPT
	            ) {
	                this.tokenizer.state = Tokenizer.MODE.RAWTEXT;
	            } else if (tn === $$1.SCRIPT) {
	                this.tokenizer.state = Tokenizer.MODE.SCRIPT_DATA;
	            } else if (tn === $$1.PLAINTEXT) {
	                this.tokenizer.state = Tokenizer.MODE.PLAINTEXT;
	            }
	        }
	    }

	    //Tree mutation
	    _setDocumentType(token) {
	        const name = token.name || '';
	        const publicId = token.publicId || '';
	        const systemId = token.systemId || '';

	        this.treeAdapter.setDocumentType(this.document, name, publicId, systemId);
	    }

	    _attachElementToTree(element) {
	        if (this._shouldFosterParentOnInsertion()) {
	            this._fosterParentElement(element);
	        } else {
	            const parent = this.openElements.currentTmplContent || this.openElements.current;

	            this.treeAdapter.appendChild(parent, element);
	        }
	    }

	    _appendElement(token, namespaceURI) {
	        const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);

	        this._attachElementToTree(element);
	    }

	    _insertElement(token, namespaceURI) {
	        const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);

	        this._attachElementToTree(element);
	        this.openElements.push(element);
	    }

	    _insertFakeElement(tagName) {
	        const element = this.treeAdapter.createElement(tagName, NS.HTML, []);

	        this._attachElementToTree(element);
	        this.openElements.push(element);
	    }

	    _insertTemplate(token) {
	        const tmpl = this.treeAdapter.createElement(token.tagName, NS.HTML, token.attrs);
	        const content = this.treeAdapter.createDocumentFragment();

	        this.treeAdapter.setTemplateContent(tmpl, content);
	        this._attachElementToTree(tmpl);
	        this.openElements.push(tmpl);
	    }

	    _insertFakeRootElement() {
	        const element = this.treeAdapter.createElement($$1.HTML, NS.HTML, []);

	        this.treeAdapter.appendChild(this.openElements.current, element);
	        this.openElements.push(element);
	    }

	    _appendCommentNode(token, parent) {
	        const commentNode = this.treeAdapter.createCommentNode(token.data);

	        this.treeAdapter.appendChild(parent, commentNode);
	    }

	    _insertCharacters(token) {
	        if (this._shouldFosterParentOnInsertion()) {
	            this._fosterParentText(token.chars);
	        } else {
	            const parent = this.openElements.currentTmplContent || this.openElements.current;

	            this.treeAdapter.insertText(parent, token.chars);
	        }
	    }

	    _adoptNodes(donor, recipient) {
	        for (let child = this.treeAdapter.getFirstChild(donor); child; child = this.treeAdapter.getFirstChild(donor)) {
	            this.treeAdapter.detachNode(child);
	            this.treeAdapter.appendChild(recipient, child);
	        }
	    }

	    //Token processing
	    _shouldProcessTokenInForeignContent(token) {
	        const current = this._getAdjustedCurrentElement();

	        if (!current || current === this.document) {
	            return false;
	        }

	        const ns = this.treeAdapter.getNamespaceURI(current);

	        if (ns === NS.HTML) {
	            return false;
	        }

	        if (
	            this.treeAdapter.getTagName(current) === $$1.ANNOTATION_XML &&
	            ns === NS.MATHML &&
	            token.type === Tokenizer.START_TAG_TOKEN &&
	            token.tagName === $$1.SVG
	        ) {
	            return false;
	        }

	        const isCharacterToken =
	            token.type === Tokenizer.CHARACTER_TOKEN ||
	            token.type === Tokenizer.NULL_CHARACTER_TOKEN ||
	            token.type === Tokenizer.WHITESPACE_CHARACTER_TOKEN;

	        const isMathMLTextStartTag =
	            token.type === Tokenizer.START_TAG_TOKEN && token.tagName !== $$1.MGLYPH && token.tagName !== $$1.MALIGNMARK;

	        if ((isMathMLTextStartTag || isCharacterToken) && this._isIntegrationPoint(current, NS.MATHML)) {
	            return false;
	        }

	        if (
	            (token.type === Tokenizer.START_TAG_TOKEN || isCharacterToken) &&
	            this._isIntegrationPoint(current, NS.HTML)
	        ) {
	            return false;
	        }

	        return token.type !== Tokenizer.EOF_TOKEN;
	    }

	    _processToken(token) {
	        TOKEN_HANDLERS[this.insertionMode][token.type](this, token);
	    }

	    _processTokenInBodyMode(token) {
	        TOKEN_HANDLERS[IN_BODY_MODE][token.type](this, token);
	    }

	    _processTokenInForeignContent(token) {
	        if (token.type === Tokenizer.CHARACTER_TOKEN) {
	            characterInForeignContent(this, token);
	        } else if (token.type === Tokenizer.NULL_CHARACTER_TOKEN) {
	            nullCharacterInForeignContent(this, token);
	        } else if (token.type === Tokenizer.WHITESPACE_CHARACTER_TOKEN) {
	            insertCharacters(this, token);
	        } else if (token.type === Tokenizer.COMMENT_TOKEN) {
	            appendComment(this, token);
	        } else if (token.type === Tokenizer.START_TAG_TOKEN) {
	            startTagInForeignContent(this, token);
	        } else if (token.type === Tokenizer.END_TAG_TOKEN) {
	            endTagInForeignContent(this, token);
	        }
	    }

	    _processInputToken(token) {
	        if (this._shouldProcessTokenInForeignContent(token)) {
	            this._processTokenInForeignContent(token);
	        } else {
	            this._processToken(token);
	        }

	        if (token.type === Tokenizer.START_TAG_TOKEN && token.selfClosing && !token.ackSelfClosing) {
	            this._err(ERR.nonVoidHtmlElementStartTagWithTrailingSolidus);
	        }
	    }

	    //Integration points
	    _isIntegrationPoint(element, foreignNS) {
	        const tn = this.treeAdapter.getTagName(element);
	        const ns = this.treeAdapter.getNamespaceURI(element);
	        const attrs = this.treeAdapter.getAttrList(element);

	        return foreignContent.isIntegrationPoint(tn, ns, attrs, foreignNS);
	    }

	    //Active formatting elements reconstruction
	    _reconstructActiveFormattingElements() {
	        const listLength = this.activeFormattingElements.length;

	        if (listLength) {
	            let unopenIdx = listLength;
	            let entry = null;

	            do {
	                unopenIdx--;
	                entry = this.activeFormattingElements.entries[unopenIdx];

	                if (entry.type === FormattingElementList.MARKER_ENTRY || this.openElements.contains(entry.element)) {
	                    unopenIdx++;
	                    break;
	                }
	            } while (unopenIdx > 0);

	            for (let i = unopenIdx; i < listLength; i++) {
	                entry = this.activeFormattingElements.entries[i];
	                this._insertElement(entry.token, this.treeAdapter.getNamespaceURI(entry.element));
	                entry.element = this.openElements.current;
	            }
	        }
	    }

	    //Close elements
	    _closeTableCell() {
	        this.openElements.generateImpliedEndTags();
	        this.openElements.popUntilTableCellPopped();
	        this.activeFormattingElements.clearToLastMarker();
	        this.insertionMode = IN_ROW_MODE;
	    }

	    _closePElement() {
	        this.openElements.generateImpliedEndTagsWithExclusion($$1.P);
	        this.openElements.popUntilTagNamePopped($$1.P);
	    }

	    //Insertion modes
	    _resetInsertionMode() {
	        for (let i = this.openElements.stackTop, last = false; i >= 0; i--) {
	            let element = this.openElements.items[i];

	            if (i === 0) {
	                last = true;

	                if (this.fragmentContext) {
	                    element = this.fragmentContext;
	                }
	            }

	            const tn = this.treeAdapter.getTagName(element);
	            const newInsertionMode = INSERTION_MODE_RESET_MAP[tn];

	            if (newInsertionMode) {
	                this.insertionMode = newInsertionMode;
	                break;
	            } else if (!last && (tn === $$1.TD || tn === $$1.TH)) {
	                this.insertionMode = IN_CELL_MODE;
	                break;
	            } else if (!last && tn === $$1.HEAD) {
	                this.insertionMode = IN_HEAD_MODE;
	                break;
	            } else if (tn === $$1.SELECT) {
	                this._resetInsertionModeForSelect(i);
	                break;
	            } else if (tn === $$1.TEMPLATE) {
	                this.insertionMode = this.currentTmplInsertionMode;
	                break;
	            } else if (tn === $$1.HTML) {
	                this.insertionMode = this.headElement ? AFTER_HEAD_MODE : BEFORE_HEAD_MODE;
	                break;
	            } else if (last) {
	                this.insertionMode = IN_BODY_MODE;
	                break;
	            }
	        }
	    }

	    _resetInsertionModeForSelect(selectIdx) {
	        if (selectIdx > 0) {
	            for (let i = selectIdx - 1; i > 0; i--) {
	                const ancestor = this.openElements.items[i];
	                const tn = this.treeAdapter.getTagName(ancestor);

	                if (tn === $$1.TEMPLATE) {
	                    break;
	                } else if (tn === $$1.TABLE) {
	                    this.insertionMode = IN_SELECT_IN_TABLE_MODE;
	                    return;
	                }
	            }
	        }

	        this.insertionMode = IN_SELECT_MODE;
	    }

	    _pushTmplInsertionMode(mode) {
	        this.tmplInsertionModeStack.push(mode);
	        this.tmplInsertionModeStackTop++;
	        this.currentTmplInsertionMode = mode;
	    }

	    _popTmplInsertionMode() {
	        this.tmplInsertionModeStack.pop();
	        this.tmplInsertionModeStackTop--;
	        this.currentTmplInsertionMode = this.tmplInsertionModeStack[this.tmplInsertionModeStackTop];
	    }

	    //Foster parenting
	    _isElementCausesFosterParenting(element) {
	        const tn = this.treeAdapter.getTagName(element);

	        return tn === $$1.TABLE || tn === $$1.TBODY || tn === $$1.TFOOT || tn === $$1.THEAD || tn === $$1.TR;
	    }

	    _shouldFosterParentOnInsertion() {
	        return this.fosterParentingEnabled && this._isElementCausesFosterParenting(this.openElements.current);
	    }

	    _findFosterParentingLocation() {
	        const location = {
	            parent: null,
	            beforeElement: null
	        };

	        for (let i = this.openElements.stackTop; i >= 0; i--) {
	            const openElement = this.openElements.items[i];
	            const tn = this.treeAdapter.getTagName(openElement);
	            const ns = this.treeAdapter.getNamespaceURI(openElement);

	            if (tn === $$1.TEMPLATE && ns === NS.HTML) {
	                location.parent = this.treeAdapter.getTemplateContent(openElement);
	                break;
	            } else if (tn === $$1.TABLE) {
	                location.parent = this.treeAdapter.getParentNode(openElement);

	                if (location.parent) {
	                    location.beforeElement = openElement;
	                } else {
	                    location.parent = this.openElements.items[i - 1];
	                }

	                break;
	            }
	        }

	        if (!location.parent) {
	            location.parent = this.openElements.items[0];
	        }

	        return location;
	    }

	    _fosterParentElement(element) {
	        const location = this._findFosterParentingLocation();

	        if (location.beforeElement) {
	            this.treeAdapter.insertBefore(location.parent, element, location.beforeElement);
	        } else {
	            this.treeAdapter.appendChild(location.parent, element);
	        }
	    }

	    _fosterParentText(chars) {
	        const location = this._findFosterParentingLocation();

	        if (location.beforeElement) {
	            this.treeAdapter.insertTextBefore(location.parent, chars, location.beforeElement);
	        } else {
	            this.treeAdapter.insertText(location.parent, chars);
	        }
	    }

	    //Special elements
	    _isSpecialElement(element) {
	        const tn = this.treeAdapter.getTagName(element);
	        const ns = this.treeAdapter.getNamespaceURI(element);

	        return HTML.SPECIAL_ELEMENTS[ns][tn];
	    }
	}

	var parser = Parser;

	//Adoption agency algorithm
	//(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#adoptionAgency)
	//------------------------------------------------------------------

	//Steps 5-8 of the algorithm
	function aaObtainFormattingElementEntry(p, token) {
	    let formattingElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName(token.tagName);

	    if (formattingElementEntry) {
	        if (!p.openElements.contains(formattingElementEntry.element)) {
	            p.activeFormattingElements.removeEntry(formattingElementEntry);
	            formattingElementEntry = null;
	        } else if (!p.openElements.hasInScope(token.tagName)) {
	            formattingElementEntry = null;
	        }
	    } else {
	        genericEndTagInBody(p, token);
	    }

	    return formattingElementEntry;
	}

	//Steps 9 and 10 of the algorithm
	function aaObtainFurthestBlock(p, formattingElementEntry) {
	    let furthestBlock = null;

	    for (let i = p.openElements.stackTop; i >= 0; i--) {
	        const element = p.openElements.items[i];

	        if (element === formattingElementEntry.element) {
	            break;
	        }

	        if (p._isSpecialElement(element)) {
	            furthestBlock = element;
	        }
	    }

	    if (!furthestBlock) {
	        p.openElements.popUntilElementPopped(formattingElementEntry.element);
	        p.activeFormattingElements.removeEntry(formattingElementEntry);
	    }

	    return furthestBlock;
	}

	//Step 13 of the algorithm
	function aaInnerLoop(p, furthestBlock, formattingElement) {
	    let lastElement = furthestBlock;
	    let nextElement = p.openElements.getCommonAncestor(furthestBlock);

	    for (let i = 0, element = nextElement; element !== formattingElement; i++, element = nextElement) {
	        //NOTE: store next element for the next loop iteration (it may be deleted from the stack by step 9.5)
	        nextElement = p.openElements.getCommonAncestor(element);

	        const elementEntry = p.activeFormattingElements.getElementEntry(element);
	        const counterOverflow = elementEntry && i >= AA_INNER_LOOP_ITER;
	        const shouldRemoveFromOpenElements = !elementEntry || counterOverflow;

	        if (shouldRemoveFromOpenElements) {
	            if (counterOverflow) {
	                p.activeFormattingElements.removeEntry(elementEntry);
	            }

	            p.openElements.remove(element);
	        } else {
	            element = aaRecreateElementFromEntry(p, elementEntry);

	            if (lastElement === furthestBlock) {
	                p.activeFormattingElements.bookmark = elementEntry;
	            }

	            p.treeAdapter.detachNode(lastElement);
	            p.treeAdapter.appendChild(element, lastElement);
	            lastElement = element;
	        }
	    }

	    return lastElement;
	}

	//Step 13.7 of the algorithm
	function aaRecreateElementFromEntry(p, elementEntry) {
	    const ns = p.treeAdapter.getNamespaceURI(elementEntry.element);
	    const newElement = p.treeAdapter.createElement(elementEntry.token.tagName, ns, elementEntry.token.attrs);

	    p.openElements.replace(elementEntry.element, newElement);
	    elementEntry.element = newElement;

	    return newElement;
	}

	//Step 14 of the algorithm
	function aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement) {
	    if (p._isElementCausesFosterParenting(commonAncestor)) {
	        p._fosterParentElement(lastElement);
	    } else {
	        const tn = p.treeAdapter.getTagName(commonAncestor);
	        const ns = p.treeAdapter.getNamespaceURI(commonAncestor);

	        if (tn === $$1.TEMPLATE && ns === NS.HTML) {
	            commonAncestor = p.treeAdapter.getTemplateContent(commonAncestor);
	        }

	        p.treeAdapter.appendChild(commonAncestor, lastElement);
	    }
	}

	//Steps 15-19 of the algorithm
	function aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry) {
	    const ns = p.treeAdapter.getNamespaceURI(formattingElementEntry.element);
	    const token = formattingElementEntry.token;
	    const newElement = p.treeAdapter.createElement(token.tagName, ns, token.attrs);

	    p._adoptNodes(furthestBlock, newElement);
	    p.treeAdapter.appendChild(furthestBlock, newElement);

	    p.activeFormattingElements.insertElementAfterBookmark(newElement, formattingElementEntry.token);
	    p.activeFormattingElements.removeEntry(formattingElementEntry);

	    p.openElements.remove(formattingElementEntry.element);
	    p.openElements.insertAfter(furthestBlock, newElement);
	}

	//Algorithm entry point
	function callAdoptionAgency(p, token) {
	    let formattingElementEntry;

	    for (let i = 0; i < AA_OUTER_LOOP_ITER; i++) {
	        formattingElementEntry = aaObtainFormattingElementEntry(p, token);

	        if (!formattingElementEntry) {
	            break;
	        }

	        const furthestBlock = aaObtainFurthestBlock(p, formattingElementEntry);

	        if (!furthestBlock) {
	            break;
	        }

	        p.activeFormattingElements.bookmark = formattingElementEntry;

	        const lastElement = aaInnerLoop(p, furthestBlock, formattingElementEntry.element);
	        const commonAncestor = p.openElements.getCommonAncestor(formattingElementEntry.element);

	        p.treeAdapter.detachNode(lastElement);
	        aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement);
	        aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry);
	    }
	}

	//Generic token handlers
	//------------------------------------------------------------------
	function ignoreToken() {
	    //NOTE: do nothing =)
	}

	function misplacedDoctype(p) {
	    p._err(ERR.misplacedDoctype);
	}

	function appendComment(p, token) {
	    p._appendCommentNode(token, p.openElements.currentTmplContent || p.openElements.current);
	}

	function appendCommentToRootHtmlElement(p, token) {
	    p._appendCommentNode(token, p.openElements.items[0]);
	}

	function appendCommentToDocument(p, token) {
	    p._appendCommentNode(token, p.document);
	}

	function insertCharacters(p, token) {
	    p._insertCharacters(token);
	}

	function stopParsing(p) {
	    p.stopped = true;
	}

	// The "initial" insertion mode
	//------------------------------------------------------------------
	function doctypeInInitialMode(p, token) {
	    p._setDocumentType(token);

	    const mode = token.forceQuirks ? HTML.DOCUMENT_MODE.QUIRKS : doctype$3.getDocumentMode(token);

	    if (!doctype$3.isConforming(token)) {
	        p._err(ERR.nonConformingDoctype);
	    }

	    p.treeAdapter.setDocumentMode(p.document, mode);

	    p.insertionMode = BEFORE_HTML_MODE;
	}

	function tokenInInitialMode(p, token) {
	    p._err(ERR.missingDoctype, { beforeToken: true });
	    p.treeAdapter.setDocumentMode(p.document, HTML.DOCUMENT_MODE.QUIRKS);
	    p.insertionMode = BEFORE_HTML_MODE;
	    p._processToken(token);
	}

	// The "before html" insertion mode
	//------------------------------------------------------------------
	function startTagBeforeHtml(p, token) {
	    if (token.tagName === $$1.HTML) {
	        p._insertElement(token, NS.HTML);
	        p.insertionMode = BEFORE_HEAD_MODE;
	    } else {
	        tokenBeforeHtml(p, token);
	    }
	}

	function endTagBeforeHtml(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.HTML || tn === $$1.HEAD || tn === $$1.BODY || tn === $$1.BR) {
	        tokenBeforeHtml(p, token);
	    }
	}

	function tokenBeforeHtml(p, token) {
	    p._insertFakeRootElement();
	    p.insertionMode = BEFORE_HEAD_MODE;
	    p._processToken(token);
	}

	// The "before head" insertion mode
	//------------------------------------------------------------------
	function startTagBeforeHead(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.HTML) {
	        startTagInBody(p, token);
	    } else if (tn === $$1.HEAD) {
	        p._insertElement(token, NS.HTML);
	        p.headElement = p.openElements.current;
	        p.insertionMode = IN_HEAD_MODE;
	    } else {
	        tokenBeforeHead(p, token);
	    }
	}

	function endTagBeforeHead(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.HEAD || tn === $$1.BODY || tn === $$1.HTML || tn === $$1.BR) {
	        tokenBeforeHead(p, token);
	    } else {
	        p._err(ERR.endTagWithoutMatchingOpenElement);
	    }
	}

	function tokenBeforeHead(p, token) {
	    p._insertFakeElement($$1.HEAD);
	    p.headElement = p.openElements.current;
	    p.insertionMode = IN_HEAD_MODE;
	    p._processToken(token);
	}

	// The "in head" insertion mode
	//------------------------------------------------------------------
	function startTagInHead(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.HTML) {
	        startTagInBody(p, token);
	    } else if (tn === $$1.BASE || tn === $$1.BASEFONT || tn === $$1.BGSOUND || tn === $$1.LINK || tn === $$1.META) {
	        p._appendElement(token, NS.HTML);
	        token.ackSelfClosing = true;
	    } else if (tn === $$1.TITLE) {
	        p._switchToTextParsing(token, Tokenizer.MODE.RCDATA);
	    } else if (tn === $$1.NOSCRIPT) {
	        if (p.options.scriptingEnabled) {
	            p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);
	        } else {
	            p._insertElement(token, NS.HTML);
	            p.insertionMode = IN_HEAD_NO_SCRIPT_MODE;
	        }
	    } else if (tn === $$1.NOFRAMES || tn === $$1.STYLE) {
	        p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);
	    } else if (tn === $$1.SCRIPT) {
	        p._switchToTextParsing(token, Tokenizer.MODE.SCRIPT_DATA);
	    } else if (tn === $$1.TEMPLATE) {
	        p._insertTemplate(token, NS.HTML);
	        p.activeFormattingElements.insertMarker();
	        p.framesetOk = false;
	        p.insertionMode = IN_TEMPLATE_MODE;
	        p._pushTmplInsertionMode(IN_TEMPLATE_MODE);
	    } else if (tn === $$1.HEAD) {
	        p._err(ERR.misplacedStartTagForHeadElement);
	    } else {
	        tokenInHead(p, token);
	    }
	}

	function endTagInHead(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.HEAD) {
	        p.openElements.pop();
	        p.insertionMode = AFTER_HEAD_MODE;
	    } else if (tn === $$1.BODY || tn === $$1.BR || tn === $$1.HTML) {
	        tokenInHead(p, token);
	    } else if (tn === $$1.TEMPLATE) {
	        if (p.openElements.tmplCount > 0) {
	            p.openElements.generateImpliedEndTagsThoroughly();

	            if (p.openElements.currentTagName !== $$1.TEMPLATE) {
	                p._err(ERR.closingOfElementWithOpenChildElements);
	            }

	            p.openElements.popUntilTagNamePopped($$1.TEMPLATE);
	            p.activeFormattingElements.clearToLastMarker();
	            p._popTmplInsertionMode();
	            p._resetInsertionMode();
	        } else {
	            p._err(ERR.endTagWithoutMatchingOpenElement);
	        }
	    } else {
	        p._err(ERR.endTagWithoutMatchingOpenElement);
	    }
	}

	function tokenInHead(p, token) {
	    p.openElements.pop();
	    p.insertionMode = AFTER_HEAD_MODE;
	    p._processToken(token);
	}

	// The "in head no script" insertion mode
	//------------------------------------------------------------------
	function startTagInHeadNoScript(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.HTML) {
	        startTagInBody(p, token);
	    } else if (
	        tn === $$1.BASEFONT ||
	        tn === $$1.BGSOUND ||
	        tn === $$1.HEAD ||
	        tn === $$1.LINK ||
	        tn === $$1.META ||
	        tn === $$1.NOFRAMES ||
	        tn === $$1.STYLE
	    ) {
	        startTagInHead(p, token);
	    } else if (tn === $$1.NOSCRIPT) {
	        p._err(ERR.nestedNoscriptInHead);
	    } else {
	        tokenInHeadNoScript(p, token);
	    }
	}

	function endTagInHeadNoScript(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.NOSCRIPT) {
	        p.openElements.pop();
	        p.insertionMode = IN_HEAD_MODE;
	    } else if (tn === $$1.BR) {
	        tokenInHeadNoScript(p, token);
	    } else {
	        p._err(ERR.endTagWithoutMatchingOpenElement);
	    }
	}

	function tokenInHeadNoScript(p, token) {
	    const errCode =
	        token.type === Tokenizer.EOF_TOKEN ? ERR.openElementsLeftAfterEof : ERR.disallowedContentInNoscriptInHead;

	    p._err(errCode);
	    p.openElements.pop();
	    p.insertionMode = IN_HEAD_MODE;
	    p._processToken(token);
	}

	// The "after head" insertion mode
	//------------------------------------------------------------------
	function startTagAfterHead(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.HTML) {
	        startTagInBody(p, token);
	    } else if (tn === $$1.BODY) {
	        p._insertElement(token, NS.HTML);
	        p.framesetOk = false;
	        p.insertionMode = IN_BODY_MODE;
	    } else if (tn === $$1.FRAMESET) {
	        p._insertElement(token, NS.HTML);
	        p.insertionMode = IN_FRAMESET_MODE;
	    } else if (
	        tn === $$1.BASE ||
	        tn === $$1.BASEFONT ||
	        tn === $$1.BGSOUND ||
	        tn === $$1.LINK ||
	        tn === $$1.META ||
	        tn === $$1.NOFRAMES ||
	        tn === $$1.SCRIPT ||
	        tn === $$1.STYLE ||
	        tn === $$1.TEMPLATE ||
	        tn === $$1.TITLE
	    ) {
	        p._err(ERR.abandonedHeadElementChild);
	        p.openElements.push(p.headElement);
	        startTagInHead(p, token);
	        p.openElements.remove(p.headElement);
	    } else if (tn === $$1.HEAD) {
	        p._err(ERR.misplacedStartTagForHeadElement);
	    } else {
	        tokenAfterHead(p, token);
	    }
	}

	function endTagAfterHead(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.BODY || tn === $$1.HTML || tn === $$1.BR) {
	        tokenAfterHead(p, token);
	    } else if (tn === $$1.TEMPLATE) {
	        endTagInHead(p, token);
	    } else {
	        p._err(ERR.endTagWithoutMatchingOpenElement);
	    }
	}

	function tokenAfterHead(p, token) {
	    p._insertFakeElement($$1.BODY);
	    p.insertionMode = IN_BODY_MODE;
	    p._processToken(token);
	}

	// The "in body" insertion mode
	//------------------------------------------------------------------
	function whitespaceCharacterInBody(p, token) {
	    p._reconstructActiveFormattingElements();
	    p._insertCharacters(token);
	}

	function characterInBody(p, token) {
	    p._reconstructActiveFormattingElements();
	    p._insertCharacters(token);
	    p.framesetOk = false;
	}

	function htmlStartTagInBody(p, token) {
	    if (p.openElements.tmplCount === 0) {
	        p.treeAdapter.adoptAttributes(p.openElements.items[0], token.attrs);
	    }
	}

	function bodyStartTagInBody(p, token) {
	    const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();

	    if (bodyElement && p.openElements.tmplCount === 0) {
	        p.framesetOk = false;
	        p.treeAdapter.adoptAttributes(bodyElement, token.attrs);
	    }
	}

	function framesetStartTagInBody(p, token) {
	    const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();

	    if (p.framesetOk && bodyElement) {
	        p.treeAdapter.detachNode(bodyElement);
	        p.openElements.popAllUpToHtmlElement();
	        p._insertElement(token, NS.HTML);
	        p.insertionMode = IN_FRAMESET_MODE;
	    }
	}

	function addressStartTagInBody(p, token) {
	    if (p.openElements.hasInButtonScope($$1.P)) {
	        p._closePElement();
	    }

	    p._insertElement(token, NS.HTML);
	}

	function numberedHeaderStartTagInBody(p, token) {
	    if (p.openElements.hasInButtonScope($$1.P)) {
	        p._closePElement();
	    }

	    const tn = p.openElements.currentTagName;

	    if (tn === $$1.H1 || tn === $$1.H2 || tn === $$1.H3 || tn === $$1.H4 || tn === $$1.H5 || tn === $$1.H6) {
	        p.openElements.pop();
	    }

	    p._insertElement(token, NS.HTML);
	}

	function preStartTagInBody(p, token) {
	    if (p.openElements.hasInButtonScope($$1.P)) {
	        p._closePElement();
	    }

	    p._insertElement(token, NS.HTML);
	    //NOTE: If the next token is a U+000A LINE FEED (LF) character token, then ignore that token and move
	    //on to the next one. (Newlines at the start of pre blocks are ignored as an authoring convenience.)
	    p.skipNextNewLine = true;
	    p.framesetOk = false;
	}

	function formStartTagInBody(p, token) {
	    const inTemplate = p.openElements.tmplCount > 0;

	    if (!p.formElement || inTemplate) {
	        if (p.openElements.hasInButtonScope($$1.P)) {
	            p._closePElement();
	        }

	        p._insertElement(token, NS.HTML);

	        if (!inTemplate) {
	            p.formElement = p.openElements.current;
	        }
	    }
	}

	function listItemStartTagInBody(p, token) {
	    p.framesetOk = false;

	    const tn = token.tagName;

	    for (let i = p.openElements.stackTop; i >= 0; i--) {
	        const element = p.openElements.items[i];
	        const elementTn = p.treeAdapter.getTagName(element);
	        let closeTn = null;

	        if (tn === $$1.LI && elementTn === $$1.LI) {
	            closeTn = $$1.LI;
	        } else if ((tn === $$1.DD || tn === $$1.DT) && (elementTn === $$1.DD || elementTn === $$1.DT)) {
	            closeTn = elementTn;
	        }

	        if (closeTn) {
	            p.openElements.generateImpliedEndTagsWithExclusion(closeTn);
	            p.openElements.popUntilTagNamePopped(closeTn);
	            break;
	        }

	        if (elementTn !== $$1.ADDRESS && elementTn !== $$1.DIV && elementTn !== $$1.P && p._isSpecialElement(element)) {
	            break;
	        }
	    }

	    if (p.openElements.hasInButtonScope($$1.P)) {
	        p._closePElement();
	    }

	    p._insertElement(token, NS.HTML);
	}

	function plaintextStartTagInBody(p, token) {
	    if (p.openElements.hasInButtonScope($$1.P)) {
	        p._closePElement();
	    }

	    p._insertElement(token, NS.HTML);
	    p.tokenizer.state = Tokenizer.MODE.PLAINTEXT;
	}

	function buttonStartTagInBody(p, token) {
	    if (p.openElements.hasInScope($$1.BUTTON)) {
	        p.openElements.generateImpliedEndTags();
	        p.openElements.popUntilTagNamePopped($$1.BUTTON);
	    }

	    p._reconstructActiveFormattingElements();
	    p._insertElement(token, NS.HTML);
	    p.framesetOk = false;
	}

	function aStartTagInBody(p, token) {
	    const activeElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName($$1.A);

	    if (activeElementEntry) {
	        callAdoptionAgency(p, token);
	        p.openElements.remove(activeElementEntry.element);
	        p.activeFormattingElements.removeEntry(activeElementEntry);
	    }

	    p._reconstructActiveFormattingElements();
	    p._insertElement(token, NS.HTML);
	    p.activeFormattingElements.pushElement(p.openElements.current, token);
	}

	function bStartTagInBody(p, token) {
	    p._reconstructActiveFormattingElements();
	    p._insertElement(token, NS.HTML);
	    p.activeFormattingElements.pushElement(p.openElements.current, token);
	}

	function nobrStartTagInBody(p, token) {
	    p._reconstructActiveFormattingElements();

	    if (p.openElements.hasInScope($$1.NOBR)) {
	        callAdoptionAgency(p, token);
	        p._reconstructActiveFormattingElements();
	    }

	    p._insertElement(token, NS.HTML);
	    p.activeFormattingElements.pushElement(p.openElements.current, token);
	}

	function appletStartTagInBody(p, token) {
	    p._reconstructActiveFormattingElements();
	    p._insertElement(token, NS.HTML);
	    p.activeFormattingElements.insertMarker();
	    p.framesetOk = false;
	}

	function tableStartTagInBody(p, token) {
	    if (
	        p.treeAdapter.getDocumentMode(p.document) !== HTML.DOCUMENT_MODE.QUIRKS &&
	        p.openElements.hasInButtonScope($$1.P)
	    ) {
	        p._closePElement();
	    }

	    p._insertElement(token, NS.HTML);
	    p.framesetOk = false;
	    p.insertionMode = IN_TABLE_MODE;
	}

	function areaStartTagInBody(p, token) {
	    p._reconstructActiveFormattingElements();
	    p._appendElement(token, NS.HTML);
	    p.framesetOk = false;
	    token.ackSelfClosing = true;
	}

	function inputStartTagInBody(p, token) {
	    p._reconstructActiveFormattingElements();
	    p._appendElement(token, NS.HTML);

	    const inputType = Tokenizer.getTokenAttr(token, ATTRS.TYPE);

	    if (!inputType || inputType.toLowerCase() !== HIDDEN_INPUT_TYPE) {
	        p.framesetOk = false;
	    }

	    token.ackSelfClosing = true;
	}

	function paramStartTagInBody(p, token) {
	    p._appendElement(token, NS.HTML);
	    token.ackSelfClosing = true;
	}

	function hrStartTagInBody(p, token) {
	    if (p.openElements.hasInButtonScope($$1.P)) {
	        p._closePElement();
	    }

	    p._appendElement(token, NS.HTML);
	    p.framesetOk = false;
	    token.ackSelfClosing = true;
	}

	function imageStartTagInBody(p, token) {
	    token.tagName = $$1.IMG;
	    areaStartTagInBody(p, token);
	}

	function textareaStartTagInBody(p, token) {
	    p._insertElement(token, NS.HTML);
	    //NOTE: If the next token is a U+000A LINE FEED (LF) character token, then ignore that token and move
	    //on to the next one. (Newlines at the start of textarea elements are ignored as an authoring convenience.)
	    p.skipNextNewLine = true;
	    p.tokenizer.state = Tokenizer.MODE.RCDATA;
	    p.originalInsertionMode = p.insertionMode;
	    p.framesetOk = false;
	    p.insertionMode = TEXT_MODE;
	}

	function xmpStartTagInBody(p, token) {
	    if (p.openElements.hasInButtonScope($$1.P)) {
	        p._closePElement();
	    }

	    p._reconstructActiveFormattingElements();
	    p.framesetOk = false;
	    p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);
	}

	function iframeStartTagInBody(p, token) {
	    p.framesetOk = false;
	    p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);
	}

	//NOTE: here we assume that we always act as an user agent with enabled plugins, so we parse
	//<noembed> as a rawtext.
	function noembedStartTagInBody(p, token) {
	    p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);
	}

	function selectStartTagInBody(p, token) {
	    p._reconstructActiveFormattingElements();
	    p._insertElement(token, NS.HTML);
	    p.framesetOk = false;

	    if (
	        p.insertionMode === IN_TABLE_MODE ||
	        p.insertionMode === IN_CAPTION_MODE ||
	        p.insertionMode === IN_TABLE_BODY_MODE ||
	        p.insertionMode === IN_ROW_MODE ||
	        p.insertionMode === IN_CELL_MODE
	    ) {
	        p.insertionMode = IN_SELECT_IN_TABLE_MODE;
	    } else {
	        p.insertionMode = IN_SELECT_MODE;
	    }
	}

	function optgroupStartTagInBody(p, token) {
	    if (p.openElements.currentTagName === $$1.OPTION) {
	        p.openElements.pop();
	    }

	    p._reconstructActiveFormattingElements();
	    p._insertElement(token, NS.HTML);
	}

	function rbStartTagInBody(p, token) {
	    if (p.openElements.hasInScope($$1.RUBY)) {
	        p.openElements.generateImpliedEndTags();
	    }

	    p._insertElement(token, NS.HTML);
	}

	function rtStartTagInBody(p, token) {
	    if (p.openElements.hasInScope($$1.RUBY)) {
	        p.openElements.generateImpliedEndTagsWithExclusion($$1.RTC);
	    }

	    p._insertElement(token, NS.HTML);
	}

	function menuStartTagInBody(p, token) {
	    if (p.openElements.hasInButtonScope($$1.P)) {
	        p._closePElement();
	    }

	    p._insertElement(token, NS.HTML);
	}

	function mathStartTagInBody(p, token) {
	    p._reconstructActiveFormattingElements();

	    foreignContent.adjustTokenMathMLAttrs(token);
	    foreignContent.adjustTokenXMLAttrs(token);

	    if (token.selfClosing) {
	        p._appendElement(token, NS.MATHML);
	    } else {
	        p._insertElement(token, NS.MATHML);
	    }

	    token.ackSelfClosing = true;
	}

	function svgStartTagInBody(p, token) {
	    p._reconstructActiveFormattingElements();

	    foreignContent.adjustTokenSVGAttrs(token);
	    foreignContent.adjustTokenXMLAttrs(token);

	    if (token.selfClosing) {
	        p._appendElement(token, NS.SVG);
	    } else {
	        p._insertElement(token, NS.SVG);
	    }

	    token.ackSelfClosing = true;
	}

	function genericStartTagInBody(p, token) {
	    p._reconstructActiveFormattingElements();
	    p._insertElement(token, NS.HTML);
	}

	//OPTIMIZATION: Integer comparisons are low-cost, so we can use very fast tag name length filters here.
	//It's faster than using dictionary.
	function startTagInBody(p, token) {
	    const tn = token.tagName;

	    switch (tn.length) {
	        case 1:
	            if (tn === $$1.I || tn === $$1.S || tn === $$1.B || tn === $$1.U) {
	                bStartTagInBody(p, token);
	            } else if (tn === $$1.P) {
	                addressStartTagInBody(p, token);
	            } else if (tn === $$1.A) {
	                aStartTagInBody(p, token);
	            } else {
	                genericStartTagInBody(p, token);
	            }

	            break;

	        case 2:
	            if (tn === $$1.DL || tn === $$1.OL || tn === $$1.UL) {
	                addressStartTagInBody(p, token);
	            } else if (tn === $$1.H1 || tn === $$1.H2 || tn === $$1.H3 || tn === $$1.H4 || tn === $$1.H5 || tn === $$1.H6) {
	                numberedHeaderStartTagInBody(p, token);
	            } else if (tn === $$1.LI || tn === $$1.DD || tn === $$1.DT) {
	                listItemStartTagInBody(p, token);
	            } else if (tn === $$1.EM || tn === $$1.TT) {
	                bStartTagInBody(p, token);
	            } else if (tn === $$1.BR) {
	                areaStartTagInBody(p, token);
	            } else if (tn === $$1.HR) {
	                hrStartTagInBody(p, token);
	            } else if (tn === $$1.RB) {
	                rbStartTagInBody(p, token);
	            } else if (tn === $$1.RT || tn === $$1.RP) {
	                rtStartTagInBody(p, token);
	            } else if (tn !== $$1.TH && tn !== $$1.TD && tn !== $$1.TR) {
	                genericStartTagInBody(p, token);
	            }

	            break;

	        case 3:
	            if (tn === $$1.DIV || tn === $$1.DIR || tn === $$1.NAV) {
	                addressStartTagInBody(p, token);
	            } else if (tn === $$1.PRE) {
	                preStartTagInBody(p, token);
	            } else if (tn === $$1.BIG) {
	                bStartTagInBody(p, token);
	            } else if (tn === $$1.IMG || tn === $$1.WBR) {
	                areaStartTagInBody(p, token);
	            } else if (tn === $$1.XMP) {
	                xmpStartTagInBody(p, token);
	            } else if (tn === $$1.SVG) {
	                svgStartTagInBody(p, token);
	            } else if (tn === $$1.RTC) {
	                rbStartTagInBody(p, token);
	            } else if (tn !== $$1.COL) {
	                genericStartTagInBody(p, token);
	            }

	            break;

	        case 4:
	            if (tn === $$1.HTML) {
	                htmlStartTagInBody(p, token);
	            } else if (tn === $$1.BASE || tn === $$1.LINK || tn === $$1.META) {
	                startTagInHead(p, token);
	            } else if (tn === $$1.BODY) {
	                bodyStartTagInBody(p, token);
	            } else if (tn === $$1.MAIN || tn === $$1.MENU) {
	                addressStartTagInBody(p, token);
	            } else if (tn === $$1.FORM) {
	                formStartTagInBody(p, token);
	            } else if (tn === $$1.CODE || tn === $$1.FONT) {
	                bStartTagInBody(p, token);
	            } else if (tn === $$1.NOBR) {
	                nobrStartTagInBody(p, token);
	            } else if (tn === $$1.AREA) {
	                areaStartTagInBody(p, token);
	            } else if (tn === $$1.MATH) {
	                mathStartTagInBody(p, token);
	            } else if (tn === $$1.MENU) {
	                menuStartTagInBody(p, token);
	            } else if (tn !== $$1.HEAD) {
	                genericStartTagInBody(p, token);
	            }

	            break;

	        case 5:
	            if (tn === $$1.STYLE || tn === $$1.TITLE) {
	                startTagInHead(p, token);
	            } else if (tn === $$1.ASIDE) {
	                addressStartTagInBody(p, token);
	            } else if (tn === $$1.SMALL) {
	                bStartTagInBody(p, token);
	            } else if (tn === $$1.TABLE) {
	                tableStartTagInBody(p, token);
	            } else if (tn === $$1.EMBED) {
	                areaStartTagInBody(p, token);
	            } else if (tn === $$1.INPUT) {
	                inputStartTagInBody(p, token);
	            } else if (tn === $$1.PARAM || tn === $$1.TRACK) {
	                paramStartTagInBody(p, token);
	            } else if (tn === $$1.IMAGE) {
	                imageStartTagInBody(p, token);
	            } else if (tn !== $$1.FRAME && tn !== $$1.TBODY && tn !== $$1.TFOOT && tn !== $$1.THEAD) {
	                genericStartTagInBody(p, token);
	            }

	            break;

	        case 6:
	            if (tn === $$1.SCRIPT) {
	                startTagInHead(p, token);
	            } else if (
	                tn === $$1.CENTER ||
	                tn === $$1.FIGURE ||
	                tn === $$1.FOOTER ||
	                tn === $$1.HEADER ||
	                tn === $$1.HGROUP ||
	                tn === $$1.DIALOG
	            ) {
	                addressStartTagInBody(p, token);
	            } else if (tn === $$1.BUTTON) {
	                buttonStartTagInBody(p, token);
	            } else if (tn === $$1.STRIKE || tn === $$1.STRONG) {
	                bStartTagInBody(p, token);
	            } else if (tn === $$1.APPLET || tn === $$1.OBJECT) {
	                appletStartTagInBody(p, token);
	            } else if (tn === $$1.KEYGEN) {
	                areaStartTagInBody(p, token);
	            } else if (tn === $$1.SOURCE) {
	                paramStartTagInBody(p, token);
	            } else if (tn === $$1.IFRAME) {
	                iframeStartTagInBody(p, token);
	            } else if (tn === $$1.SELECT) {
	                selectStartTagInBody(p, token);
	            } else if (tn === $$1.OPTION) {
	                optgroupStartTagInBody(p, token);
	            } else {
	                genericStartTagInBody(p, token);
	            }

	            break;

	        case 7:
	            if (tn === $$1.BGSOUND) {
	                startTagInHead(p, token);
	            } else if (
	                tn === $$1.DETAILS ||
	                tn === $$1.ADDRESS ||
	                tn === $$1.ARTICLE ||
	                tn === $$1.SECTION ||
	                tn === $$1.SUMMARY
	            ) {
	                addressStartTagInBody(p, token);
	            } else if (tn === $$1.LISTING) {
	                preStartTagInBody(p, token);
	            } else if (tn === $$1.MARQUEE) {
	                appletStartTagInBody(p, token);
	            } else if (tn === $$1.NOEMBED) {
	                noembedStartTagInBody(p, token);
	            } else if (tn !== $$1.CAPTION) {
	                genericStartTagInBody(p, token);
	            }

	            break;

	        case 8:
	            if (tn === $$1.BASEFONT) {
	                startTagInHead(p, token);
	            } else if (tn === $$1.FRAMESET) {
	                framesetStartTagInBody(p, token);
	            } else if (tn === $$1.FIELDSET) {
	                addressStartTagInBody(p, token);
	            } else if (tn === $$1.TEXTAREA) {
	                textareaStartTagInBody(p, token);
	            } else if (tn === $$1.TEMPLATE) {
	                startTagInHead(p, token);
	            } else if (tn === $$1.NOSCRIPT) {
	                if (p.options.scriptingEnabled) {
	                    noembedStartTagInBody(p, token);
	                } else {
	                    genericStartTagInBody(p, token);
	                }
	            } else if (tn === $$1.OPTGROUP) {
	                optgroupStartTagInBody(p, token);
	            } else if (tn !== $$1.COLGROUP) {
	                genericStartTagInBody(p, token);
	            }

	            break;

	        case 9:
	            if (tn === $$1.PLAINTEXT) {
	                plaintextStartTagInBody(p, token);
	            } else {
	                genericStartTagInBody(p, token);
	            }

	            break;

	        case 10:
	            if (tn === $$1.BLOCKQUOTE || tn === $$1.FIGCAPTION) {
	                addressStartTagInBody(p, token);
	            } else {
	                genericStartTagInBody(p, token);
	            }

	            break;

	        default:
	            genericStartTagInBody(p, token);
	    }
	}

	function bodyEndTagInBody(p) {
	    if (p.openElements.hasInScope($$1.BODY)) {
	        p.insertionMode = AFTER_BODY_MODE;
	    }
	}

	function htmlEndTagInBody(p, token) {
	    if (p.openElements.hasInScope($$1.BODY)) {
	        p.insertionMode = AFTER_BODY_MODE;
	        p._processToken(token);
	    }
	}

	function addressEndTagInBody(p, token) {
	    const tn = token.tagName;

	    if (p.openElements.hasInScope(tn)) {
	        p.openElements.generateImpliedEndTags();
	        p.openElements.popUntilTagNamePopped(tn);
	    }
	}

	function formEndTagInBody(p) {
	    const inTemplate = p.openElements.tmplCount > 0;
	    const formElement = p.formElement;

	    if (!inTemplate) {
	        p.formElement = null;
	    }

	    if ((formElement || inTemplate) && p.openElements.hasInScope($$1.FORM)) {
	        p.openElements.generateImpliedEndTags();

	        if (inTemplate) {
	            p.openElements.popUntilTagNamePopped($$1.FORM);
	        } else {
	            p.openElements.remove(formElement);
	        }
	    }
	}

	function pEndTagInBody(p) {
	    if (!p.openElements.hasInButtonScope($$1.P)) {
	        p._insertFakeElement($$1.P);
	    }

	    p._closePElement();
	}

	function liEndTagInBody(p) {
	    if (p.openElements.hasInListItemScope($$1.LI)) {
	        p.openElements.generateImpliedEndTagsWithExclusion($$1.LI);
	        p.openElements.popUntilTagNamePopped($$1.LI);
	    }
	}

	function ddEndTagInBody(p, token) {
	    const tn = token.tagName;

	    if (p.openElements.hasInScope(tn)) {
	        p.openElements.generateImpliedEndTagsWithExclusion(tn);
	        p.openElements.popUntilTagNamePopped(tn);
	    }
	}

	function numberedHeaderEndTagInBody(p) {
	    if (p.openElements.hasNumberedHeaderInScope()) {
	        p.openElements.generateImpliedEndTags();
	        p.openElements.popUntilNumberedHeaderPopped();
	    }
	}

	function appletEndTagInBody(p, token) {
	    const tn = token.tagName;

	    if (p.openElements.hasInScope(tn)) {
	        p.openElements.generateImpliedEndTags();
	        p.openElements.popUntilTagNamePopped(tn);
	        p.activeFormattingElements.clearToLastMarker();
	    }
	}

	function brEndTagInBody(p) {
	    p._reconstructActiveFormattingElements();
	    p._insertFakeElement($$1.BR);
	    p.openElements.pop();
	    p.framesetOk = false;
	}

	function genericEndTagInBody(p, token) {
	    const tn = token.tagName;

	    for (let i = p.openElements.stackTop; i > 0; i--) {
	        const element = p.openElements.items[i];

	        if (p.treeAdapter.getTagName(element) === tn) {
	            p.openElements.generateImpliedEndTagsWithExclusion(tn);
	            p.openElements.popUntilElementPopped(element);
	            break;
	        }

	        if (p._isSpecialElement(element)) {
	            break;
	        }
	    }
	}

	//OPTIMIZATION: Integer comparisons are low-cost, so we can use very fast tag name length filters here.
	//It's faster than using dictionary.
	function endTagInBody(p, token) {
	    const tn = token.tagName;

	    switch (tn.length) {
	        case 1:
	            if (tn === $$1.A || tn === $$1.B || tn === $$1.I || tn === $$1.S || tn === $$1.U) {
	                callAdoptionAgency(p, token);
	            } else if (tn === $$1.P) {
	                pEndTagInBody(p);
	            } else {
	                genericEndTagInBody(p, token);
	            }

	            break;

	        case 2:
	            if (tn === $$1.DL || tn === $$1.UL || tn === $$1.OL) {
	                addressEndTagInBody(p, token);
	            } else if (tn === $$1.LI) {
	                liEndTagInBody(p);
	            } else if (tn === $$1.DD || tn === $$1.DT) {
	                ddEndTagInBody(p, token);
	            } else if (tn === $$1.H1 || tn === $$1.H2 || tn === $$1.H3 || tn === $$1.H4 || tn === $$1.H5 || tn === $$1.H6) {
	                numberedHeaderEndTagInBody(p);
	            } else if (tn === $$1.BR) {
	                brEndTagInBody(p);
	            } else if (tn === $$1.EM || tn === $$1.TT) {
	                callAdoptionAgency(p, token);
	            } else {
	                genericEndTagInBody(p, token);
	            }

	            break;

	        case 3:
	            if (tn === $$1.BIG) {
	                callAdoptionAgency(p, token);
	            } else if (tn === $$1.DIR || tn === $$1.DIV || tn === $$1.NAV || tn === $$1.PRE) {
	                addressEndTagInBody(p, token);
	            } else {
	                genericEndTagInBody(p, token);
	            }

	            break;

	        case 4:
	            if (tn === $$1.BODY) {
	                bodyEndTagInBody(p);
	            } else if (tn === $$1.HTML) {
	                htmlEndTagInBody(p, token);
	            } else if (tn === $$1.FORM) {
	                formEndTagInBody(p);
	            } else if (tn === $$1.CODE || tn === $$1.FONT || tn === $$1.NOBR) {
	                callAdoptionAgency(p, token);
	            } else if (tn === $$1.MAIN || tn === $$1.MENU) {
	                addressEndTagInBody(p, token);
	            } else {
	                genericEndTagInBody(p, token);
	            }

	            break;

	        case 5:
	            if (tn === $$1.ASIDE) {
	                addressEndTagInBody(p, token);
	            } else if (tn === $$1.SMALL) {
	                callAdoptionAgency(p, token);
	            } else {
	                genericEndTagInBody(p, token);
	            }

	            break;

	        case 6:
	            if (
	                tn === $$1.CENTER ||
	                tn === $$1.FIGURE ||
	                tn === $$1.FOOTER ||
	                tn === $$1.HEADER ||
	                tn === $$1.HGROUP ||
	                tn === $$1.DIALOG
	            ) {
	                addressEndTagInBody(p, token);
	            } else if (tn === $$1.APPLET || tn === $$1.OBJECT) {
	                appletEndTagInBody(p, token);
	            } else if (tn === $$1.STRIKE || tn === $$1.STRONG) {
	                callAdoptionAgency(p, token);
	            } else {
	                genericEndTagInBody(p, token);
	            }

	            break;

	        case 7:
	            if (
	                tn === $$1.ADDRESS ||
	                tn === $$1.ARTICLE ||
	                tn === $$1.DETAILS ||
	                tn === $$1.SECTION ||
	                tn === $$1.SUMMARY ||
	                tn === $$1.LISTING
	            ) {
	                addressEndTagInBody(p, token);
	            } else if (tn === $$1.MARQUEE) {
	                appletEndTagInBody(p, token);
	            } else {
	                genericEndTagInBody(p, token);
	            }

	            break;

	        case 8:
	            if (tn === $$1.FIELDSET) {
	                addressEndTagInBody(p, token);
	            } else if (tn === $$1.TEMPLATE) {
	                endTagInHead(p, token);
	            } else {
	                genericEndTagInBody(p, token);
	            }

	            break;

	        case 10:
	            if (tn === $$1.BLOCKQUOTE || tn === $$1.FIGCAPTION) {
	                addressEndTagInBody(p, token);
	            } else {
	                genericEndTagInBody(p, token);
	            }

	            break;

	        default:
	            genericEndTagInBody(p, token);
	    }
	}

	function eofInBody(p, token) {
	    if (p.tmplInsertionModeStackTop > -1) {
	        eofInTemplate(p, token);
	    } else {
	        p.stopped = true;
	    }
	}

	// The "text" insertion mode
	//------------------------------------------------------------------
	function endTagInText(p, token) {
	    if (token.tagName === $$1.SCRIPT) {
	        p.pendingScript = p.openElements.current;
	    }

	    p.openElements.pop();
	    p.insertionMode = p.originalInsertionMode;
	}

	function eofInText(p, token) {
	    p._err(ERR.eofInElementThatCanContainOnlyText);
	    p.openElements.pop();
	    p.insertionMode = p.originalInsertionMode;
	    p._processToken(token);
	}

	// The "in table" insertion mode
	//------------------------------------------------------------------
	function characterInTable(p, token) {
	    const curTn = p.openElements.currentTagName;

	    if (curTn === $$1.TABLE || curTn === $$1.TBODY || curTn === $$1.TFOOT || curTn === $$1.THEAD || curTn === $$1.TR) {
	        p.pendingCharacterTokens = [];
	        p.hasNonWhitespacePendingCharacterToken = false;
	        p.originalInsertionMode = p.insertionMode;
	        p.insertionMode = IN_TABLE_TEXT_MODE;
	        p._processToken(token);
	    } else {
	        tokenInTable(p, token);
	    }
	}

	function captionStartTagInTable(p, token) {
	    p.openElements.clearBackToTableContext();
	    p.activeFormattingElements.insertMarker();
	    p._insertElement(token, NS.HTML);
	    p.insertionMode = IN_CAPTION_MODE;
	}

	function colgroupStartTagInTable(p, token) {
	    p.openElements.clearBackToTableContext();
	    p._insertElement(token, NS.HTML);
	    p.insertionMode = IN_COLUMN_GROUP_MODE;
	}

	function colStartTagInTable(p, token) {
	    p.openElements.clearBackToTableContext();
	    p._insertFakeElement($$1.COLGROUP);
	    p.insertionMode = IN_COLUMN_GROUP_MODE;
	    p._processToken(token);
	}

	function tbodyStartTagInTable(p, token) {
	    p.openElements.clearBackToTableContext();
	    p._insertElement(token, NS.HTML);
	    p.insertionMode = IN_TABLE_BODY_MODE;
	}

	function tdStartTagInTable(p, token) {
	    p.openElements.clearBackToTableContext();
	    p._insertFakeElement($$1.TBODY);
	    p.insertionMode = IN_TABLE_BODY_MODE;
	    p._processToken(token);
	}

	function tableStartTagInTable(p, token) {
	    if (p.openElements.hasInTableScope($$1.TABLE)) {
	        p.openElements.popUntilTagNamePopped($$1.TABLE);
	        p._resetInsertionMode();
	        p._processToken(token);
	    }
	}

	function inputStartTagInTable(p, token) {
	    const inputType = Tokenizer.getTokenAttr(token, ATTRS.TYPE);

	    if (inputType && inputType.toLowerCase() === HIDDEN_INPUT_TYPE) {
	        p._appendElement(token, NS.HTML);
	    } else {
	        tokenInTable(p, token);
	    }

	    token.ackSelfClosing = true;
	}

	function formStartTagInTable(p, token) {
	    if (!p.formElement && p.openElements.tmplCount === 0) {
	        p._insertElement(token, NS.HTML);
	        p.formElement = p.openElements.current;
	        p.openElements.pop();
	    }
	}

	function startTagInTable(p, token) {
	    const tn = token.tagName;

	    switch (tn.length) {
	        case 2:
	            if (tn === $$1.TD || tn === $$1.TH || tn === $$1.TR) {
	                tdStartTagInTable(p, token);
	            } else {
	                tokenInTable(p, token);
	            }

	            break;

	        case 3:
	            if (tn === $$1.COL) {
	                colStartTagInTable(p, token);
	            } else {
	                tokenInTable(p, token);
	            }

	            break;

	        case 4:
	            if (tn === $$1.FORM) {
	                formStartTagInTable(p, token);
	            } else {
	                tokenInTable(p, token);
	            }

	            break;

	        case 5:
	            if (tn === $$1.TABLE) {
	                tableStartTagInTable(p, token);
	            } else if (tn === $$1.STYLE) {
	                startTagInHead(p, token);
	            } else if (tn === $$1.TBODY || tn === $$1.TFOOT || tn === $$1.THEAD) {
	                tbodyStartTagInTable(p, token);
	            } else if (tn === $$1.INPUT) {
	                inputStartTagInTable(p, token);
	            } else {
	                tokenInTable(p, token);
	            }

	            break;

	        case 6:
	            if (tn === $$1.SCRIPT) {
	                startTagInHead(p, token);
	            } else {
	                tokenInTable(p, token);
	            }

	            break;

	        case 7:
	            if (tn === $$1.CAPTION) {
	                captionStartTagInTable(p, token);
	            } else {
	                tokenInTable(p, token);
	            }

	            break;

	        case 8:
	            if (tn === $$1.COLGROUP) {
	                colgroupStartTagInTable(p, token);
	            } else if (tn === $$1.TEMPLATE) {
	                startTagInHead(p, token);
	            } else {
	                tokenInTable(p, token);
	            }

	            break;

	        default:
	            tokenInTable(p, token);
	    }
	}

	function endTagInTable(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.TABLE) {
	        if (p.openElements.hasInTableScope($$1.TABLE)) {
	            p.openElements.popUntilTagNamePopped($$1.TABLE);
	            p._resetInsertionMode();
	        }
	    } else if (tn === $$1.TEMPLATE) {
	        endTagInHead(p, token);
	    } else if (
	        tn !== $$1.BODY &&
	        tn !== $$1.CAPTION &&
	        tn !== $$1.COL &&
	        tn !== $$1.COLGROUP &&
	        tn !== $$1.HTML &&
	        tn !== $$1.TBODY &&
	        tn !== $$1.TD &&
	        tn !== $$1.TFOOT &&
	        tn !== $$1.TH &&
	        tn !== $$1.THEAD &&
	        tn !== $$1.TR
	    ) {
	        tokenInTable(p, token);
	    }
	}

	function tokenInTable(p, token) {
	    const savedFosterParentingState = p.fosterParentingEnabled;

	    p.fosterParentingEnabled = true;
	    p._processTokenInBodyMode(token);
	    p.fosterParentingEnabled = savedFosterParentingState;
	}

	// The "in table text" insertion mode
	//------------------------------------------------------------------
	function whitespaceCharacterInTableText(p, token) {
	    p.pendingCharacterTokens.push(token);
	}

	function characterInTableText(p, token) {
	    p.pendingCharacterTokens.push(token);
	    p.hasNonWhitespacePendingCharacterToken = true;
	}

	function tokenInTableText(p, token) {
	    let i = 0;

	    if (p.hasNonWhitespacePendingCharacterToken) {
	        for (; i < p.pendingCharacterTokens.length; i++) {
	            tokenInTable(p, p.pendingCharacterTokens[i]);
	        }
	    } else {
	        for (; i < p.pendingCharacterTokens.length; i++) {
	            p._insertCharacters(p.pendingCharacterTokens[i]);
	        }
	    }

	    p.insertionMode = p.originalInsertionMode;
	    p._processToken(token);
	}

	// The "in caption" insertion mode
	//------------------------------------------------------------------
	function startTagInCaption(p, token) {
	    const tn = token.tagName;

	    if (
	        tn === $$1.CAPTION ||
	        tn === $$1.COL ||
	        tn === $$1.COLGROUP ||
	        tn === $$1.TBODY ||
	        tn === $$1.TD ||
	        tn === $$1.TFOOT ||
	        tn === $$1.TH ||
	        tn === $$1.THEAD ||
	        tn === $$1.TR
	    ) {
	        if (p.openElements.hasInTableScope($$1.CAPTION)) {
	            p.openElements.generateImpliedEndTags();
	            p.openElements.popUntilTagNamePopped($$1.CAPTION);
	            p.activeFormattingElements.clearToLastMarker();
	            p.insertionMode = IN_TABLE_MODE;
	            p._processToken(token);
	        }
	    } else {
	        startTagInBody(p, token);
	    }
	}

	function endTagInCaption(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.CAPTION || tn === $$1.TABLE) {
	        if (p.openElements.hasInTableScope($$1.CAPTION)) {
	            p.openElements.generateImpliedEndTags();
	            p.openElements.popUntilTagNamePopped($$1.CAPTION);
	            p.activeFormattingElements.clearToLastMarker();
	            p.insertionMode = IN_TABLE_MODE;

	            if (tn === $$1.TABLE) {
	                p._processToken(token);
	            }
	        }
	    } else if (
	        tn !== $$1.BODY &&
	        tn !== $$1.COL &&
	        tn !== $$1.COLGROUP &&
	        tn !== $$1.HTML &&
	        tn !== $$1.TBODY &&
	        tn !== $$1.TD &&
	        tn !== $$1.TFOOT &&
	        tn !== $$1.TH &&
	        tn !== $$1.THEAD &&
	        tn !== $$1.TR
	    ) {
	        endTagInBody(p, token);
	    }
	}

	// The "in column group" insertion mode
	//------------------------------------------------------------------
	function startTagInColumnGroup(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.HTML) {
	        startTagInBody(p, token);
	    } else if (tn === $$1.COL) {
	        p._appendElement(token, NS.HTML);
	        token.ackSelfClosing = true;
	    } else if (tn === $$1.TEMPLATE) {
	        startTagInHead(p, token);
	    } else {
	        tokenInColumnGroup(p, token);
	    }
	}

	function endTagInColumnGroup(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.COLGROUP) {
	        if (p.openElements.currentTagName === $$1.COLGROUP) {
	            p.openElements.pop();
	            p.insertionMode = IN_TABLE_MODE;
	        }
	    } else if (tn === $$1.TEMPLATE) {
	        endTagInHead(p, token);
	    } else if (tn !== $$1.COL) {
	        tokenInColumnGroup(p, token);
	    }
	}

	function tokenInColumnGroup(p, token) {
	    if (p.openElements.currentTagName === $$1.COLGROUP) {
	        p.openElements.pop();
	        p.insertionMode = IN_TABLE_MODE;
	        p._processToken(token);
	    }
	}

	// The "in table body" insertion mode
	//------------------------------------------------------------------
	function startTagInTableBody(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.TR) {
	        p.openElements.clearBackToTableBodyContext();
	        p._insertElement(token, NS.HTML);
	        p.insertionMode = IN_ROW_MODE;
	    } else if (tn === $$1.TH || tn === $$1.TD) {
	        p.openElements.clearBackToTableBodyContext();
	        p._insertFakeElement($$1.TR);
	        p.insertionMode = IN_ROW_MODE;
	        p._processToken(token);
	    } else if (
	        tn === $$1.CAPTION ||
	        tn === $$1.COL ||
	        tn === $$1.COLGROUP ||
	        tn === $$1.TBODY ||
	        tn === $$1.TFOOT ||
	        tn === $$1.THEAD
	    ) {
	        if (p.openElements.hasTableBodyContextInTableScope()) {
	            p.openElements.clearBackToTableBodyContext();
	            p.openElements.pop();
	            p.insertionMode = IN_TABLE_MODE;
	            p._processToken(token);
	        }
	    } else {
	        startTagInTable(p, token);
	    }
	}

	function endTagInTableBody(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.TBODY || tn === $$1.TFOOT || tn === $$1.THEAD) {
	        if (p.openElements.hasInTableScope(tn)) {
	            p.openElements.clearBackToTableBodyContext();
	            p.openElements.pop();
	            p.insertionMode = IN_TABLE_MODE;
	        }
	    } else if (tn === $$1.TABLE) {
	        if (p.openElements.hasTableBodyContextInTableScope()) {
	            p.openElements.clearBackToTableBodyContext();
	            p.openElements.pop();
	            p.insertionMode = IN_TABLE_MODE;
	            p._processToken(token);
	        }
	    } else if (
	        (tn !== $$1.BODY && tn !== $$1.CAPTION && tn !== $$1.COL && tn !== $$1.COLGROUP) ||
	        (tn !== $$1.HTML && tn !== $$1.TD && tn !== $$1.TH && tn !== $$1.TR)
	    ) {
	        endTagInTable(p, token);
	    }
	}

	// The "in row" insertion mode
	//------------------------------------------------------------------
	function startTagInRow(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.TH || tn === $$1.TD) {
	        p.openElements.clearBackToTableRowContext();
	        p._insertElement(token, NS.HTML);
	        p.insertionMode = IN_CELL_MODE;
	        p.activeFormattingElements.insertMarker();
	    } else if (
	        tn === $$1.CAPTION ||
	        tn === $$1.COL ||
	        tn === $$1.COLGROUP ||
	        tn === $$1.TBODY ||
	        tn === $$1.TFOOT ||
	        tn === $$1.THEAD ||
	        tn === $$1.TR
	    ) {
	        if (p.openElements.hasInTableScope($$1.TR)) {
	            p.openElements.clearBackToTableRowContext();
	            p.openElements.pop();
	            p.insertionMode = IN_TABLE_BODY_MODE;
	            p._processToken(token);
	        }
	    } else {
	        startTagInTable(p, token);
	    }
	}

	function endTagInRow(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.TR) {
	        if (p.openElements.hasInTableScope($$1.TR)) {
	            p.openElements.clearBackToTableRowContext();
	            p.openElements.pop();
	            p.insertionMode = IN_TABLE_BODY_MODE;
	        }
	    } else if (tn === $$1.TABLE) {
	        if (p.openElements.hasInTableScope($$1.TR)) {
	            p.openElements.clearBackToTableRowContext();
	            p.openElements.pop();
	            p.insertionMode = IN_TABLE_BODY_MODE;
	            p._processToken(token);
	        }
	    } else if (tn === $$1.TBODY || tn === $$1.TFOOT || tn === $$1.THEAD) {
	        if (p.openElements.hasInTableScope(tn) || p.openElements.hasInTableScope($$1.TR)) {
	            p.openElements.clearBackToTableRowContext();
	            p.openElements.pop();
	            p.insertionMode = IN_TABLE_BODY_MODE;
	            p._processToken(token);
	        }
	    } else if (
	        (tn !== $$1.BODY && tn !== $$1.CAPTION && tn !== $$1.COL && tn !== $$1.COLGROUP) ||
	        (tn !== $$1.HTML && tn !== $$1.TD && tn !== $$1.TH)
	    ) {
	        endTagInTable(p, token);
	    }
	}

	// The "in cell" insertion mode
	//------------------------------------------------------------------
	function startTagInCell(p, token) {
	    const tn = token.tagName;

	    if (
	        tn === $$1.CAPTION ||
	        tn === $$1.COL ||
	        tn === $$1.COLGROUP ||
	        tn === $$1.TBODY ||
	        tn === $$1.TD ||
	        tn === $$1.TFOOT ||
	        tn === $$1.TH ||
	        tn === $$1.THEAD ||
	        tn === $$1.TR
	    ) {
	        if (p.openElements.hasInTableScope($$1.TD) || p.openElements.hasInTableScope($$1.TH)) {
	            p._closeTableCell();
	            p._processToken(token);
	        }
	    } else {
	        startTagInBody(p, token);
	    }
	}

	function endTagInCell(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.TD || tn === $$1.TH) {
	        if (p.openElements.hasInTableScope(tn)) {
	            p.openElements.generateImpliedEndTags();
	            p.openElements.popUntilTagNamePopped(tn);
	            p.activeFormattingElements.clearToLastMarker();
	            p.insertionMode = IN_ROW_MODE;
	        }
	    } else if (tn === $$1.TABLE || tn === $$1.TBODY || tn === $$1.TFOOT || tn === $$1.THEAD || tn === $$1.TR) {
	        if (p.openElements.hasInTableScope(tn)) {
	            p._closeTableCell();
	            p._processToken(token);
	        }
	    } else if (tn !== $$1.BODY && tn !== $$1.CAPTION && tn !== $$1.COL && tn !== $$1.COLGROUP && tn !== $$1.HTML) {
	        endTagInBody(p, token);
	    }
	}

	// The "in select" insertion mode
	//------------------------------------------------------------------
	function startTagInSelect(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.HTML) {
	        startTagInBody(p, token);
	    } else if (tn === $$1.OPTION) {
	        if (p.openElements.currentTagName === $$1.OPTION) {
	            p.openElements.pop();
	        }

	        p._insertElement(token, NS.HTML);
	    } else if (tn === $$1.OPTGROUP) {
	        if (p.openElements.currentTagName === $$1.OPTION) {
	            p.openElements.pop();
	        }

	        if (p.openElements.currentTagName === $$1.OPTGROUP) {
	            p.openElements.pop();
	        }

	        p._insertElement(token, NS.HTML);
	    } else if (tn === $$1.INPUT || tn === $$1.KEYGEN || tn === $$1.TEXTAREA || tn === $$1.SELECT) {
	        if (p.openElements.hasInSelectScope($$1.SELECT)) {
	            p.openElements.popUntilTagNamePopped($$1.SELECT);
	            p._resetInsertionMode();

	            if (tn !== $$1.SELECT) {
	                p._processToken(token);
	            }
	        }
	    } else if (tn === $$1.SCRIPT || tn === $$1.TEMPLATE) {
	        startTagInHead(p, token);
	    }
	}

	function endTagInSelect(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.OPTGROUP) {
	        const prevOpenElement = p.openElements.items[p.openElements.stackTop - 1];
	        const prevOpenElementTn = prevOpenElement && p.treeAdapter.getTagName(prevOpenElement);

	        if (p.openElements.currentTagName === $$1.OPTION && prevOpenElementTn === $$1.OPTGROUP) {
	            p.openElements.pop();
	        }

	        if (p.openElements.currentTagName === $$1.OPTGROUP) {
	            p.openElements.pop();
	        }
	    } else if (tn === $$1.OPTION) {
	        if (p.openElements.currentTagName === $$1.OPTION) {
	            p.openElements.pop();
	        }
	    } else if (tn === $$1.SELECT && p.openElements.hasInSelectScope($$1.SELECT)) {
	        p.openElements.popUntilTagNamePopped($$1.SELECT);
	        p._resetInsertionMode();
	    } else if (tn === $$1.TEMPLATE) {
	        endTagInHead(p, token);
	    }
	}

	//12.2.5.4.17 The "in select in table" insertion mode
	//------------------------------------------------------------------
	function startTagInSelectInTable(p, token) {
	    const tn = token.tagName;

	    if (
	        tn === $$1.CAPTION ||
	        tn === $$1.TABLE ||
	        tn === $$1.TBODY ||
	        tn === $$1.TFOOT ||
	        tn === $$1.THEAD ||
	        tn === $$1.TR ||
	        tn === $$1.TD ||
	        tn === $$1.TH
	    ) {
	        p.openElements.popUntilTagNamePopped($$1.SELECT);
	        p._resetInsertionMode();
	        p._processToken(token);
	    } else {
	        startTagInSelect(p, token);
	    }
	}

	function endTagInSelectInTable(p, token) {
	    const tn = token.tagName;

	    if (
	        tn === $$1.CAPTION ||
	        tn === $$1.TABLE ||
	        tn === $$1.TBODY ||
	        tn === $$1.TFOOT ||
	        tn === $$1.THEAD ||
	        tn === $$1.TR ||
	        tn === $$1.TD ||
	        tn === $$1.TH
	    ) {
	        if (p.openElements.hasInTableScope(tn)) {
	            p.openElements.popUntilTagNamePopped($$1.SELECT);
	            p._resetInsertionMode();
	            p._processToken(token);
	        }
	    } else {
	        endTagInSelect(p, token);
	    }
	}

	// The "in template" insertion mode
	//------------------------------------------------------------------
	function startTagInTemplate(p, token) {
	    const tn = token.tagName;

	    if (
	        tn === $$1.BASE ||
	        tn === $$1.BASEFONT ||
	        tn === $$1.BGSOUND ||
	        tn === $$1.LINK ||
	        tn === $$1.META ||
	        tn === $$1.NOFRAMES ||
	        tn === $$1.SCRIPT ||
	        tn === $$1.STYLE ||
	        tn === $$1.TEMPLATE ||
	        tn === $$1.TITLE
	    ) {
	        startTagInHead(p, token);
	    } else {
	        const newInsertionMode = TEMPLATE_INSERTION_MODE_SWITCH_MAP[tn] || IN_BODY_MODE;

	        p._popTmplInsertionMode();
	        p._pushTmplInsertionMode(newInsertionMode);
	        p.insertionMode = newInsertionMode;
	        p._processToken(token);
	    }
	}

	function endTagInTemplate(p, token) {
	    if (token.tagName === $$1.TEMPLATE) {
	        endTagInHead(p, token);
	    }
	}

	function eofInTemplate(p, token) {
	    if (p.openElements.tmplCount > 0) {
	        p.openElements.popUntilTagNamePopped($$1.TEMPLATE);
	        p.activeFormattingElements.clearToLastMarker();
	        p._popTmplInsertionMode();
	        p._resetInsertionMode();
	        p._processToken(token);
	    } else {
	        p.stopped = true;
	    }
	}

	// The "after body" insertion mode
	//------------------------------------------------------------------
	function startTagAfterBody(p, token) {
	    if (token.tagName === $$1.HTML) {
	        startTagInBody(p, token);
	    } else {
	        tokenAfterBody(p, token);
	    }
	}

	function endTagAfterBody(p, token) {
	    if (token.tagName === $$1.HTML) {
	        if (!p.fragmentContext) {
	            p.insertionMode = AFTER_AFTER_BODY_MODE;
	        }
	    } else {
	        tokenAfterBody(p, token);
	    }
	}

	function tokenAfterBody(p, token) {
	    p.insertionMode = IN_BODY_MODE;
	    p._processToken(token);
	}

	// The "in frameset" insertion mode
	//------------------------------------------------------------------
	function startTagInFrameset(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.HTML) {
	        startTagInBody(p, token);
	    } else if (tn === $$1.FRAMESET) {
	        p._insertElement(token, NS.HTML);
	    } else if (tn === $$1.FRAME) {
	        p._appendElement(token, NS.HTML);
	        token.ackSelfClosing = true;
	    } else if (tn === $$1.NOFRAMES) {
	        startTagInHead(p, token);
	    }
	}

	function endTagInFrameset(p, token) {
	    if (token.tagName === $$1.FRAMESET && !p.openElements.isRootHtmlElementCurrent()) {
	        p.openElements.pop();

	        if (!p.fragmentContext && p.openElements.currentTagName !== $$1.FRAMESET) {
	            p.insertionMode = AFTER_FRAMESET_MODE;
	        }
	    }
	}

	// The "after frameset" insertion mode
	//------------------------------------------------------------------
	function startTagAfterFrameset(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.HTML) {
	        startTagInBody(p, token);
	    } else if (tn === $$1.NOFRAMES) {
	        startTagInHead(p, token);
	    }
	}

	function endTagAfterFrameset(p, token) {
	    if (token.tagName === $$1.HTML) {
	        p.insertionMode = AFTER_AFTER_FRAMESET_MODE;
	    }
	}

	// The "after after body" insertion mode
	//------------------------------------------------------------------
	function startTagAfterAfterBody(p, token) {
	    if (token.tagName === $$1.HTML) {
	        startTagInBody(p, token);
	    } else {
	        tokenAfterAfterBody(p, token);
	    }
	}

	function tokenAfterAfterBody(p, token) {
	    p.insertionMode = IN_BODY_MODE;
	    p._processToken(token);
	}

	// The "after after frameset" insertion mode
	//------------------------------------------------------------------
	function startTagAfterAfterFrameset(p, token) {
	    const tn = token.tagName;

	    if (tn === $$1.HTML) {
	        startTagInBody(p, token);
	    } else if (tn === $$1.NOFRAMES) {
	        startTagInHead(p, token);
	    }
	}

	// The rules for parsing tokens in foreign content
	//------------------------------------------------------------------
	function nullCharacterInForeignContent(p, token) {
	    token.chars = unicode.REPLACEMENT_CHARACTER;
	    p._insertCharacters(token);
	}

	function characterInForeignContent(p, token) {
	    p._insertCharacters(token);
	    p.framesetOk = false;
	}

	function startTagInForeignContent(p, token) {
	    if (foreignContent.causesExit(token) && !p.fragmentContext) {
	        while (
	            p.treeAdapter.getNamespaceURI(p.openElements.current) !== NS.HTML &&
	            !p._isIntegrationPoint(p.openElements.current)
	        ) {
	            p.openElements.pop();
	        }

	        p._processToken(token);
	    } else {
	        const current = p._getAdjustedCurrentElement();
	        const currentNs = p.treeAdapter.getNamespaceURI(current);

	        if (currentNs === NS.MATHML) {
	            foreignContent.adjustTokenMathMLAttrs(token);
	        } else if (currentNs === NS.SVG) {
	            foreignContent.adjustTokenSVGTagName(token);
	            foreignContent.adjustTokenSVGAttrs(token);
	        }

	        foreignContent.adjustTokenXMLAttrs(token);

	        if (token.selfClosing) {
	            p._appendElement(token, currentNs);
	        } else {
	            p._insertElement(token, currentNs);
	        }

	        token.ackSelfClosing = true;
	    }
	}

	function endTagInForeignContent(p, token) {
	    for (let i = p.openElements.stackTop; i > 0; i--) {
	        const element = p.openElements.items[i];

	        if (p.treeAdapter.getNamespaceURI(element) === NS.HTML) {
	            p._processToken(token);
	            break;
	        }

	        if (p.treeAdapter.getTagName(element).toLowerCase() === token.tagName) {
	            p.openElements.popUntilElementPopped(element);
	            break;
	        }
	    }
	}

	var Parser$1 = /*@__PURE__*/getDefaultExportFromCjs(parser);

	/**
	 * @typedef {import('unist').Position} Position
	 * @typedef {import('unist').Node} Node
	 * @typedef {Record<string, unknown> & {type: string, position?: PositionLike|undefined}} NodeLike
	 * @typedef {import('unist').Point} Point
	 *
	 * @typedef {Partial<Point>} PointLike
	 *
	 * @typedef PositionLike
	 * @property {PointLike} [start]
	 * @property {PointLike} [end]
	 */

	const pointStart = point$2('start');
	const pointEnd = point$2('end');

	/**
	 * Get the positional info of `node`.
	 *
	 * @param {'start'|'end'} type
	 */
	function point$2(type) {
	  return point

	  /**
	   * Get the positional info of `node`.
	   *
	   * @param {NodeLike|Node} [node]
	   * @returns {Point}
	   */
	  function point(node) {
	    const point = (node && node.position && node.position[type]) || {};

	    return {
	      line: point.line || null,
	      column: point.column || null,
	      offset: point.offset > -1 ? point.offset : null
	    }
	  }
	}

	/**
	 * @typedef {import('./info.js').Info} Info
	 * @typedef {Record<string, Info>} Properties
	 * @typedef {Record<string, string>} Normal
	 */

	class Schema {
	  /**
	   * @constructor
	   * @param {Properties} property
	   * @param {Normal} normal
	   * @param {string} [space]
	   */
	  constructor(property, normal, space) {
	    this.property = property;
	    this.normal = normal;
	    if (space) {
	      this.space = space;
	    }
	  }
	}

	/** @type {Properties} */
	Schema.prototype.property = {};
	/** @type {Normal} */
	Schema.prototype.normal = {};
	/** @type {string|null} */
	Schema.prototype.space = null;

	/**
	 * @typedef {import('./schema.js').Properties} Properties
	 * @typedef {import('./schema.js').Normal} Normal
	 */


	/**
	 * @param {Schema[]} definitions
	 * @param {string} [space]
	 * @returns {Schema}
	 */
	function merge(definitions, space) {
	  /** @type {Properties} */
	  const property = {};
	  /** @type {Normal} */
	  const normal = {};
	  let index = -1;

	  while (++index < definitions.length) {
	    Object.assign(property, definitions[index].property);
	    Object.assign(normal, definitions[index].normal);
	  }

	  return new Schema(property, normal, space)
	}

	/**
	 * @param {string} value
	 * @returns {string}
	 */
	function normalize$2(value) {
	  return value.toLowerCase()
	}

	class Info {
	  /**
	   * @constructor
	   * @param {string} property
	   * @param {string} attribute
	   */
	  constructor(property, attribute) {
	    /** @type {string} */
	    this.property = property;
	    /** @type {string} */
	    this.attribute = attribute;
	  }
	}

	/** @type {string|null} */
	Info.prototype.space = null;
	Info.prototype.boolean = false;
	Info.prototype.booleanish = false;
	Info.prototype.overloadedBoolean = false;
	Info.prototype.number = false;
	Info.prototype.commaSeparated = false;
	Info.prototype.spaceSeparated = false;
	Info.prototype.commaOrSpaceSeparated = false;
	Info.prototype.mustUseProperty = false;
	Info.prototype.defined = false;

	let powers = 0;

	const boolean = increment();
	const booleanish = increment();
	const overloadedBoolean = increment();
	const number = increment();
	const spaceSeparated = increment();
	const commaSeparated = increment();
	const commaOrSpaceSeparated = increment();

	function increment() {
	  return 2 ** ++powers
	}

	var types = /*#__PURE__*/Object.freeze({
		__proto__: null,
		boolean: boolean,
		booleanish: booleanish,
		commaOrSpaceSeparated: commaOrSpaceSeparated,
		commaSeparated: commaSeparated,
		number: number,
		overloadedBoolean: overloadedBoolean,
		spaceSeparated: spaceSeparated
	});

	/** @type {Array<keyof types>} */
	// @ts-expect-error: hush.
	const checks = Object.keys(types);

	class DefinedInfo extends Info {
	  /**
	   * @constructor
	   * @param {string} property
	   * @param {string} attribute
	   * @param {number|null} [mask]
	   * @param {string} [space]
	   */
	  constructor(property, attribute, mask, space) {
	    let index = -1;

	    super(property, attribute);

	    mark(this, 'space', space);

	    if (typeof mask === 'number') {
	      while (++index < checks.length) {
	        const check = checks[index];
	        mark(this, checks[index], (mask & types[check]) === types[check]);
	      }
	    }
	  }
	}

	DefinedInfo.prototype.defined = true;

	/**
	 * @param {DefinedInfo} values
	 * @param {string} key
	 * @param {unknown} value
	 */
	function mark(values, key, value) {
	  if (value) {
	    // @ts-expect-error: assume `value` matches the expected value of `key`.
	    values[key] = value;
	  }
	}

	/**
	 * @typedef {import('./schema.js').Properties} Properties
	 * @typedef {import('./schema.js').Normal} Normal
	 *
	 * @typedef {Record<string, string>} Attributes
	 *
	 * @typedef {Object} Definition
	 * @property {Record<string, number|null>} properties
	 * @property {(attributes: Attributes, property: string) => string} transform
	 * @property {string} [space]
	 * @property {Attributes} [attributes]
	 * @property {Array<string>} [mustUseProperty]
	 */


	const own$f = {}.hasOwnProperty;

	/**
	 * @param {Definition} definition
	 * @returns {Schema}
	 */
	function create(definition) {
	  /** @type {Properties} */
	  const property = {};
	  /** @type {Normal} */
	  const normal = {};
	  /** @type {string} */
	  let prop;

	  for (prop in definition.properties) {
	    if (own$f.call(definition.properties, prop)) {
	      const value = definition.properties[prop];
	      const info = new DefinedInfo(
	        prop,
	        definition.transform(definition.attributes || {}, prop),
	        value,
	        definition.space
	      );

	      if (
	        definition.mustUseProperty &&
	        definition.mustUseProperty.includes(prop)
	      ) {
	        info.mustUseProperty = true;
	      }

	      property[prop] = info;

	      normal[normalize$2(prop)] = prop;
	      normal[normalize$2(info.attribute)] = prop;
	    }
	  }

	  return new Schema(property, normal, definition.space)
	}

	const xlink = create({
	  space: 'xlink',
	  transform(_, prop) {
	    return 'xlink:' + prop.slice(5).toLowerCase()
	  },
	  properties: {
	    xLinkActuate: null,
	    xLinkArcRole: null,
	    xLinkHref: null,
	    xLinkRole: null,
	    xLinkShow: null,
	    xLinkTitle: null,
	    xLinkType: null
	  }
	});

	const xml = create({
	  space: 'xml',
	  transform(_, prop) {
	    return 'xml:' + prop.slice(3).toLowerCase()
	  },
	  properties: {xmlLang: null, xmlBase: null, xmlSpace: null}
	});

	/**
	 * @param {Record<string, string>} attributes
	 * @param {string} attribute
	 * @returns {string}
	 */
	function caseSensitiveTransform(attributes, attribute) {
	  return attribute in attributes ? attributes[attribute] : attribute
	}

	/**
	 * @param {Record<string, string>} attributes
	 * @param {string} property
	 * @returns {string}
	 */
	function caseInsensitiveTransform(attributes, property) {
	  return caseSensitiveTransform(attributes, property.toLowerCase())
	}

	const xmlns = create({
	  space: 'xmlns',
	  attributes: {xmlnsxlink: 'xmlns:xlink'},
	  transform: caseInsensitiveTransform,
	  properties: {xmlns: null, xmlnsXLink: null}
	});

	const aria = create({
	  transform(_, prop) {
	    return prop === 'role' ? prop : 'aria-' + prop.slice(4).toLowerCase()
	  },
	  properties: {
	    ariaActiveDescendant: null,
	    ariaAtomic: booleanish,
	    ariaAutoComplete: null,
	    ariaBusy: booleanish,
	    ariaChecked: booleanish,
	    ariaColCount: number,
	    ariaColIndex: number,
	    ariaColSpan: number,
	    ariaControls: spaceSeparated,
	    ariaCurrent: null,
	    ariaDescribedBy: spaceSeparated,
	    ariaDetails: null,
	    ariaDisabled: booleanish,
	    ariaDropEffect: spaceSeparated,
	    ariaErrorMessage: null,
	    ariaExpanded: booleanish,
	    ariaFlowTo: spaceSeparated,
	    ariaGrabbed: booleanish,
	    ariaHasPopup: null,
	    ariaHidden: booleanish,
	    ariaInvalid: null,
	    ariaKeyShortcuts: null,
	    ariaLabel: null,
	    ariaLabelledBy: spaceSeparated,
	    ariaLevel: number,
	    ariaLive: null,
	    ariaModal: booleanish,
	    ariaMultiLine: booleanish,
	    ariaMultiSelectable: booleanish,
	    ariaOrientation: null,
	    ariaOwns: spaceSeparated,
	    ariaPlaceholder: null,
	    ariaPosInSet: number,
	    ariaPressed: booleanish,
	    ariaReadOnly: booleanish,
	    ariaRelevant: null,
	    ariaRequired: booleanish,
	    ariaRoleDescription: spaceSeparated,
	    ariaRowCount: number,
	    ariaRowIndex: number,
	    ariaRowSpan: number,
	    ariaSelected: booleanish,
	    ariaSetSize: number,
	    ariaSort: null,
	    ariaValueMax: number,
	    ariaValueMin: number,
	    ariaValueNow: number,
	    ariaValueText: null,
	    role: null
	  }
	});

	const html$4 = create({
	  space: 'html',
	  attributes: {
	    acceptcharset: 'accept-charset',
	    classname: 'class',
	    htmlfor: 'for',
	    httpequiv: 'http-equiv'
	  },
	  transform: caseInsensitiveTransform,
	  mustUseProperty: ['checked', 'multiple', 'muted', 'selected'],
	  properties: {
	    // Standard Properties.
	    abbr: null,
	    accept: commaSeparated,
	    acceptCharset: spaceSeparated,
	    accessKey: spaceSeparated,
	    action: null,
	    allow: null,
	    allowFullScreen: boolean,
	    allowPaymentRequest: boolean,
	    allowUserMedia: boolean,
	    alt: null,
	    as: null,
	    async: boolean,
	    autoCapitalize: null,
	    autoComplete: spaceSeparated,
	    autoFocus: boolean,
	    autoPlay: boolean,
	    capture: boolean,
	    charSet: null,
	    checked: boolean,
	    cite: null,
	    className: spaceSeparated,
	    cols: number,
	    colSpan: null,
	    content: null,
	    contentEditable: booleanish,
	    controls: boolean,
	    controlsList: spaceSeparated,
	    coords: number | commaSeparated,
	    crossOrigin: null,
	    data: null,
	    dateTime: null,
	    decoding: null,
	    default: boolean,
	    defer: boolean,
	    dir: null,
	    dirName: null,
	    disabled: boolean,
	    download: overloadedBoolean,
	    draggable: booleanish,
	    encType: null,
	    enterKeyHint: null,
	    form: null,
	    formAction: null,
	    formEncType: null,
	    formMethod: null,
	    formNoValidate: boolean,
	    formTarget: null,
	    headers: spaceSeparated,
	    height: number,
	    hidden: boolean,
	    high: number,
	    href: null,
	    hrefLang: null,
	    htmlFor: spaceSeparated,
	    httpEquiv: spaceSeparated,
	    id: null,
	    imageSizes: null,
	    imageSrcSet: null,
	    inputMode: null,
	    integrity: null,
	    is: null,
	    isMap: boolean,
	    itemId: null,
	    itemProp: spaceSeparated,
	    itemRef: spaceSeparated,
	    itemScope: boolean,
	    itemType: spaceSeparated,
	    kind: null,
	    label: null,
	    lang: null,
	    language: null,
	    list: null,
	    loading: null,
	    loop: boolean,
	    low: number,
	    manifest: null,
	    max: null,
	    maxLength: number,
	    media: null,
	    method: null,
	    min: null,
	    minLength: number,
	    multiple: boolean,
	    muted: boolean,
	    name: null,
	    nonce: null,
	    noModule: boolean,
	    noValidate: boolean,
	    onAbort: null,
	    onAfterPrint: null,
	    onAuxClick: null,
	    onBeforeMatch: null,
	    onBeforePrint: null,
	    onBeforeUnload: null,
	    onBlur: null,
	    onCancel: null,
	    onCanPlay: null,
	    onCanPlayThrough: null,
	    onChange: null,
	    onClick: null,
	    onClose: null,
	    onContextLost: null,
	    onContextMenu: null,
	    onContextRestored: null,
	    onCopy: null,
	    onCueChange: null,
	    onCut: null,
	    onDblClick: null,
	    onDrag: null,
	    onDragEnd: null,
	    onDragEnter: null,
	    onDragExit: null,
	    onDragLeave: null,
	    onDragOver: null,
	    onDragStart: null,
	    onDrop: null,
	    onDurationChange: null,
	    onEmptied: null,
	    onEnded: null,
	    onError: null,
	    onFocus: null,
	    onFormData: null,
	    onHashChange: null,
	    onInput: null,
	    onInvalid: null,
	    onKeyDown: null,
	    onKeyPress: null,
	    onKeyUp: null,
	    onLanguageChange: null,
	    onLoad: null,
	    onLoadedData: null,
	    onLoadedMetadata: null,
	    onLoadEnd: null,
	    onLoadStart: null,
	    onMessage: null,
	    onMessageError: null,
	    onMouseDown: null,
	    onMouseEnter: null,
	    onMouseLeave: null,
	    onMouseMove: null,
	    onMouseOut: null,
	    onMouseOver: null,
	    onMouseUp: null,
	    onOffline: null,
	    onOnline: null,
	    onPageHide: null,
	    onPageShow: null,
	    onPaste: null,
	    onPause: null,
	    onPlay: null,
	    onPlaying: null,
	    onPopState: null,
	    onProgress: null,
	    onRateChange: null,
	    onRejectionHandled: null,
	    onReset: null,
	    onResize: null,
	    onScroll: null,
	    onScrollEnd: null,
	    onSecurityPolicyViolation: null,
	    onSeeked: null,
	    onSeeking: null,
	    onSelect: null,
	    onSlotChange: null,
	    onStalled: null,
	    onStorage: null,
	    onSubmit: null,
	    onSuspend: null,
	    onTimeUpdate: null,
	    onToggle: null,
	    onUnhandledRejection: null,
	    onUnload: null,
	    onVolumeChange: null,
	    onWaiting: null,
	    onWheel: null,
	    open: boolean,
	    optimum: number,
	    pattern: null,
	    ping: spaceSeparated,
	    placeholder: null,
	    playsInline: boolean,
	    poster: null,
	    preload: null,
	    readOnly: boolean,
	    referrerPolicy: null,
	    rel: spaceSeparated,
	    required: boolean,
	    reversed: boolean,
	    rows: number,
	    rowSpan: number,
	    sandbox: spaceSeparated,
	    scope: null,
	    scoped: boolean,
	    seamless: boolean,
	    selected: boolean,
	    shape: null,
	    size: number,
	    sizes: null,
	    slot: null,
	    span: number,
	    spellCheck: booleanish,
	    src: null,
	    srcDoc: null,
	    srcLang: null,
	    srcSet: null,
	    start: number,
	    step: null,
	    style: null,
	    tabIndex: number,
	    target: null,
	    title: null,
	    translate: null,
	    type: null,
	    typeMustMatch: boolean,
	    useMap: null,
	    value: booleanish,
	    width: number,
	    wrap: null,

	    // Legacy.
	    // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis
	    align: null, // Several. Use CSS `text-align` instead,
	    aLink: null, // `<body>`. Use CSS `a:active {color}` instead
	    archive: spaceSeparated, // `<object>`. List of URIs to archives
	    axis: null, // `<td>` and `<th>`. Use `scope` on `<th>`
	    background: null, // `<body>`. Use CSS `background-image` instead
	    bgColor: null, // `<body>` and table elements. Use CSS `background-color` instead
	    border: number, // `<table>`. Use CSS `border-width` instead,
	    borderColor: null, // `<table>`. Use CSS `border-color` instead,
	    bottomMargin: number, // `<body>`
	    cellPadding: null, // `<table>`
	    cellSpacing: null, // `<table>`
	    char: null, // Several table elements. When `align=char`, sets the character to align on
	    charOff: null, // Several table elements. When `char`, offsets the alignment
	    classId: null, // `<object>`
	    clear: null, // `<br>`. Use CSS `clear` instead
	    code: null, // `<object>`
	    codeBase: null, // `<object>`
	    codeType: null, // `<object>`
	    color: null, // `<font>` and `<hr>`. Use CSS instead
	    compact: boolean, // Lists. Use CSS to reduce space between items instead
	    declare: boolean, // `<object>`
	    event: null, // `<script>`
	    face: null, // `<font>`. Use CSS instead
	    frame: null, // `<table>`
	    frameBorder: null, // `<iframe>`. Use CSS `border` instead
	    hSpace: number, // `<img>` and `<object>`
	    leftMargin: number, // `<body>`
	    link: null, // `<body>`. Use CSS `a:link {color: *}` instead
	    longDesc: null, // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`
	    lowSrc: null, // `<img>`. Use a `<picture>`
	    marginHeight: number, // `<body>`
	    marginWidth: number, // `<body>`
	    noResize: boolean, // `<frame>`
	    noHref: boolean, // `<area>`. Use no href instead of an explicit `nohref`
	    noShade: boolean, // `<hr>`. Use background-color and height instead of borders
	    noWrap: boolean, // `<td>` and `<th>`
	    object: null, // `<applet>`
	    profile: null, // `<head>`
	    prompt: null, // `<isindex>`
	    rev: null, // `<link>`
	    rightMargin: number, // `<body>`
	    rules: null, // `<table>`
	    scheme: null, // `<meta>`
	    scrolling: booleanish, // `<frame>`. Use overflow in the child context
	    standby: null, // `<object>`
	    summary: null, // `<table>`
	    text: null, // `<body>`. Use CSS `color` instead
	    topMargin: number, // `<body>`
	    valueType: null, // `<param>`
	    version: null, // `<html>`. Use a doctype.
	    vAlign: null, // Several. Use CSS `vertical-align` instead
	    vLink: null, // `<body>`. Use CSS `a:visited {color}` instead
	    vSpace: number, // `<img>` and `<object>`

	    // Non-standard Properties.
	    allowTransparency: null,
	    autoCorrect: null,
	    autoSave: null,
	    disablePictureInPicture: boolean,
	    disableRemotePlayback: boolean,
	    prefix: null,
	    property: null,
	    results: number,
	    security: null,
	    unselectable: null
	  }
	});

	const svg$1 = create({
	  space: 'svg',
	  attributes: {
	    accentHeight: 'accent-height',
	    alignmentBaseline: 'alignment-baseline',
	    arabicForm: 'arabic-form',
	    baselineShift: 'baseline-shift',
	    capHeight: 'cap-height',
	    className: 'class',
	    clipPath: 'clip-path',
	    clipRule: 'clip-rule',
	    colorInterpolation: 'color-interpolation',
	    colorInterpolationFilters: 'color-interpolation-filters',
	    colorProfile: 'color-profile',
	    colorRendering: 'color-rendering',
	    crossOrigin: 'crossorigin',
	    dataType: 'datatype',
	    dominantBaseline: 'dominant-baseline',
	    enableBackground: 'enable-background',
	    fillOpacity: 'fill-opacity',
	    fillRule: 'fill-rule',
	    floodColor: 'flood-color',
	    floodOpacity: 'flood-opacity',
	    fontFamily: 'font-family',
	    fontSize: 'font-size',
	    fontSizeAdjust: 'font-size-adjust',
	    fontStretch: 'font-stretch',
	    fontStyle: 'font-style',
	    fontVariant: 'font-variant',
	    fontWeight: 'font-weight',
	    glyphName: 'glyph-name',
	    glyphOrientationHorizontal: 'glyph-orientation-horizontal',
	    glyphOrientationVertical: 'glyph-orientation-vertical',
	    hrefLang: 'hreflang',
	    horizAdvX: 'horiz-adv-x',
	    horizOriginX: 'horiz-origin-x',
	    horizOriginY: 'horiz-origin-y',
	    imageRendering: 'image-rendering',
	    letterSpacing: 'letter-spacing',
	    lightingColor: 'lighting-color',
	    markerEnd: 'marker-end',
	    markerMid: 'marker-mid',
	    markerStart: 'marker-start',
	    navDown: 'nav-down',
	    navDownLeft: 'nav-down-left',
	    navDownRight: 'nav-down-right',
	    navLeft: 'nav-left',
	    navNext: 'nav-next',
	    navPrev: 'nav-prev',
	    navRight: 'nav-right',
	    navUp: 'nav-up',
	    navUpLeft: 'nav-up-left',
	    navUpRight: 'nav-up-right',
	    onAbort: 'onabort',
	    onActivate: 'onactivate',
	    onAfterPrint: 'onafterprint',
	    onBeforePrint: 'onbeforeprint',
	    onBegin: 'onbegin',
	    onCancel: 'oncancel',
	    onCanPlay: 'oncanplay',
	    onCanPlayThrough: 'oncanplaythrough',
	    onChange: 'onchange',
	    onClick: 'onclick',
	    onClose: 'onclose',
	    onCopy: 'oncopy',
	    onCueChange: 'oncuechange',
	    onCut: 'oncut',
	    onDblClick: 'ondblclick',
	    onDrag: 'ondrag',
	    onDragEnd: 'ondragend',
	    onDragEnter: 'ondragenter',
	    onDragExit: 'ondragexit',
	    onDragLeave: 'ondragleave',
	    onDragOver: 'ondragover',
	    onDragStart: 'ondragstart',
	    onDrop: 'ondrop',
	    onDurationChange: 'ondurationchange',
	    onEmptied: 'onemptied',
	    onEnd: 'onend',
	    onEnded: 'onended',
	    onError: 'onerror',
	    onFocus: 'onfocus',
	    onFocusIn: 'onfocusin',
	    onFocusOut: 'onfocusout',
	    onHashChange: 'onhashchange',
	    onInput: 'oninput',
	    onInvalid: 'oninvalid',
	    onKeyDown: 'onkeydown',
	    onKeyPress: 'onkeypress',
	    onKeyUp: 'onkeyup',
	    onLoad: 'onload',
	    onLoadedData: 'onloadeddata',
	    onLoadedMetadata: 'onloadedmetadata',
	    onLoadStart: 'onloadstart',
	    onMessage: 'onmessage',
	    onMouseDown: 'onmousedown',
	    onMouseEnter: 'onmouseenter',
	    onMouseLeave: 'onmouseleave',
	    onMouseMove: 'onmousemove',
	    onMouseOut: 'onmouseout',
	    onMouseOver: 'onmouseover',
	    onMouseUp: 'onmouseup',
	    onMouseWheel: 'onmousewheel',
	    onOffline: 'onoffline',
	    onOnline: 'ononline',
	    onPageHide: 'onpagehide',
	    onPageShow: 'onpageshow',
	    onPaste: 'onpaste',
	    onPause: 'onpause',
	    onPlay: 'onplay',
	    onPlaying: 'onplaying',
	    onPopState: 'onpopstate',
	    onProgress: 'onprogress',
	    onRateChange: 'onratechange',
	    onRepeat: 'onrepeat',
	    onReset: 'onreset',
	    onResize: 'onresize',
	    onScroll: 'onscroll',
	    onSeeked: 'onseeked',
	    onSeeking: 'onseeking',
	    onSelect: 'onselect',
	    onShow: 'onshow',
	    onStalled: 'onstalled',
	    onStorage: 'onstorage',
	    onSubmit: 'onsubmit',
	    onSuspend: 'onsuspend',
	    onTimeUpdate: 'ontimeupdate',
	    onToggle: 'ontoggle',
	    onUnload: 'onunload',
	    onVolumeChange: 'onvolumechange',
	    onWaiting: 'onwaiting',
	    onZoom: 'onzoom',
	    overlinePosition: 'overline-position',
	    overlineThickness: 'overline-thickness',
	    paintOrder: 'paint-order',
	    panose1: 'panose-1',
	    pointerEvents: 'pointer-events',
	    referrerPolicy: 'referrerpolicy',
	    renderingIntent: 'rendering-intent',
	    shapeRendering: 'shape-rendering',
	    stopColor: 'stop-color',
	    stopOpacity: 'stop-opacity',
	    strikethroughPosition: 'strikethrough-position',
	    strikethroughThickness: 'strikethrough-thickness',
	    strokeDashArray: 'stroke-dasharray',
	    strokeDashOffset: 'stroke-dashoffset',
	    strokeLineCap: 'stroke-linecap',
	    strokeLineJoin: 'stroke-linejoin',
	    strokeMiterLimit: 'stroke-miterlimit',
	    strokeOpacity: 'stroke-opacity',
	    strokeWidth: 'stroke-width',
	    tabIndex: 'tabindex',
	    textAnchor: 'text-anchor',
	    textDecoration: 'text-decoration',
	    textRendering: 'text-rendering',
	    typeOf: 'typeof',
	    underlinePosition: 'underline-position',
	    underlineThickness: 'underline-thickness',
	    unicodeBidi: 'unicode-bidi',
	    unicodeRange: 'unicode-range',
	    unitsPerEm: 'units-per-em',
	    vAlphabetic: 'v-alphabetic',
	    vHanging: 'v-hanging',
	    vIdeographic: 'v-ideographic',
	    vMathematical: 'v-mathematical',
	    vectorEffect: 'vector-effect',
	    vertAdvY: 'vert-adv-y',
	    vertOriginX: 'vert-origin-x',
	    vertOriginY: 'vert-origin-y',
	    wordSpacing: 'word-spacing',
	    writingMode: 'writing-mode',
	    xHeight: 'x-height',
	    // These were camelcased in Tiny. Now lowercased in SVG 2
	    playbackOrder: 'playbackorder',
	    timelineBegin: 'timelinebegin'
	  },
	  transform: caseSensitiveTransform,
	  properties: {
	    about: commaOrSpaceSeparated,
	    accentHeight: number,
	    accumulate: null,
	    additive: null,
	    alignmentBaseline: null,
	    alphabetic: number,
	    amplitude: number,
	    arabicForm: null,
	    ascent: number,
	    attributeName: null,
	    attributeType: null,
	    azimuth: number,
	    bandwidth: null,
	    baselineShift: null,
	    baseFrequency: null,
	    baseProfile: null,
	    bbox: null,
	    begin: null,
	    bias: number,
	    by: null,
	    calcMode: null,
	    capHeight: number,
	    className: spaceSeparated,
	    clip: null,
	    clipPath: null,
	    clipPathUnits: null,
	    clipRule: null,
	    color: null,
	    colorInterpolation: null,
	    colorInterpolationFilters: null,
	    colorProfile: null,
	    colorRendering: null,
	    content: null,
	    contentScriptType: null,
	    contentStyleType: null,
	    crossOrigin: null,
	    cursor: null,
	    cx: null,
	    cy: null,
	    d: null,
	    dataType: null,
	    defaultAction: null,
	    descent: number,
	    diffuseConstant: number,
	    direction: null,
	    display: null,
	    dur: null,
	    divisor: number,
	    dominantBaseline: null,
	    download: boolean,
	    dx: null,
	    dy: null,
	    edgeMode: null,
	    editable: null,
	    elevation: number,
	    enableBackground: null,
	    end: null,
	    event: null,
	    exponent: number,
	    externalResourcesRequired: null,
	    fill: null,
	    fillOpacity: number,
	    fillRule: null,
	    filter: null,
	    filterRes: null,
	    filterUnits: null,
	    floodColor: null,
	    floodOpacity: null,
	    focusable: null,
	    focusHighlight: null,
	    fontFamily: null,
	    fontSize: null,
	    fontSizeAdjust: null,
	    fontStretch: null,
	    fontStyle: null,
	    fontVariant: null,
	    fontWeight: null,
	    format: null,
	    fr: null,
	    from: null,
	    fx: null,
	    fy: null,
	    g1: commaSeparated,
	    g2: commaSeparated,
	    glyphName: commaSeparated,
	    glyphOrientationHorizontal: null,
	    glyphOrientationVertical: null,
	    glyphRef: null,
	    gradientTransform: null,
	    gradientUnits: null,
	    handler: null,
	    hanging: number,
	    hatchContentUnits: null,
	    hatchUnits: null,
	    height: null,
	    href: null,
	    hrefLang: null,
	    horizAdvX: number,
	    horizOriginX: number,
	    horizOriginY: number,
	    id: null,
	    ideographic: number,
	    imageRendering: null,
	    initialVisibility: null,
	    in: null,
	    in2: null,
	    intercept: number,
	    k: number,
	    k1: number,
	    k2: number,
	    k3: number,
	    k4: number,
	    kernelMatrix: commaOrSpaceSeparated,
	    kernelUnitLength: null,
	    keyPoints: null, // SEMI_COLON_SEPARATED
	    keySplines: null, // SEMI_COLON_SEPARATED
	    keyTimes: null, // SEMI_COLON_SEPARATED
	    kerning: null,
	    lang: null,
	    lengthAdjust: null,
	    letterSpacing: null,
	    lightingColor: null,
	    limitingConeAngle: number,
	    local: null,
	    markerEnd: null,
	    markerMid: null,
	    markerStart: null,
	    markerHeight: null,
	    markerUnits: null,
	    markerWidth: null,
	    mask: null,
	    maskContentUnits: null,
	    maskUnits: null,
	    mathematical: null,
	    max: null,
	    media: null,
	    mediaCharacterEncoding: null,
	    mediaContentEncodings: null,
	    mediaSize: number,
	    mediaTime: null,
	    method: null,
	    min: null,
	    mode: null,
	    name: null,
	    navDown: null,
	    navDownLeft: null,
	    navDownRight: null,
	    navLeft: null,
	    navNext: null,
	    navPrev: null,
	    navRight: null,
	    navUp: null,
	    navUpLeft: null,
	    navUpRight: null,
	    numOctaves: null,
	    observer: null,
	    offset: null,
	    onAbort: null,
	    onActivate: null,
	    onAfterPrint: null,
	    onBeforePrint: null,
	    onBegin: null,
	    onCancel: null,
	    onCanPlay: null,
	    onCanPlayThrough: null,
	    onChange: null,
	    onClick: null,
	    onClose: null,
	    onCopy: null,
	    onCueChange: null,
	    onCut: null,
	    onDblClick: null,
	    onDrag: null,
	    onDragEnd: null,
	    onDragEnter: null,
	    onDragExit: null,
	    onDragLeave: null,
	    onDragOver: null,
	    onDragStart: null,
	    onDrop: null,
	    onDurationChange: null,
	    onEmptied: null,
	    onEnd: null,
	    onEnded: null,
	    onError: null,
	    onFocus: null,
	    onFocusIn: null,
	    onFocusOut: null,
	    onHashChange: null,
	    onInput: null,
	    onInvalid: null,
	    onKeyDown: null,
	    onKeyPress: null,
	    onKeyUp: null,
	    onLoad: null,
	    onLoadedData: null,
	    onLoadedMetadata: null,
	    onLoadStart: null,
	    onMessage: null,
	    onMouseDown: null,
	    onMouseEnter: null,
	    onMouseLeave: null,
	    onMouseMove: null,
	    onMouseOut: null,
	    onMouseOver: null,
	    onMouseUp: null,
	    onMouseWheel: null,
	    onOffline: null,
	    onOnline: null,
	    onPageHide: null,
	    onPageShow: null,
	    onPaste: null,
	    onPause: null,
	    onPlay: null,
	    onPlaying: null,
	    onPopState: null,
	    onProgress: null,
	    onRateChange: null,
	    onRepeat: null,
	    onReset: null,
	    onResize: null,
	    onScroll: null,
	    onSeeked: null,
	    onSeeking: null,
	    onSelect: null,
	    onShow: null,
	    onStalled: null,
	    onStorage: null,
	    onSubmit: null,
	    onSuspend: null,
	    onTimeUpdate: null,
	    onToggle: null,
	    onUnload: null,
	    onVolumeChange: null,
	    onWaiting: null,
	    onZoom: null,
	    opacity: null,
	    operator: null,
	    order: null,
	    orient: null,
	    orientation: null,
	    origin: null,
	    overflow: null,
	    overlay: null,
	    overlinePosition: number,
	    overlineThickness: number,
	    paintOrder: null,
	    panose1: null,
	    path: null,
	    pathLength: number,
	    patternContentUnits: null,
	    patternTransform: null,
	    patternUnits: null,
	    phase: null,
	    ping: spaceSeparated,
	    pitch: null,
	    playbackOrder: null,
	    pointerEvents: null,
	    points: null,
	    pointsAtX: number,
	    pointsAtY: number,
	    pointsAtZ: number,
	    preserveAlpha: null,
	    preserveAspectRatio: null,
	    primitiveUnits: null,
	    propagate: null,
	    property: commaOrSpaceSeparated,
	    r: null,
	    radius: null,
	    referrerPolicy: null,
	    refX: null,
	    refY: null,
	    rel: commaOrSpaceSeparated,
	    rev: commaOrSpaceSeparated,
	    renderingIntent: null,
	    repeatCount: null,
	    repeatDur: null,
	    requiredExtensions: commaOrSpaceSeparated,
	    requiredFeatures: commaOrSpaceSeparated,
	    requiredFonts: commaOrSpaceSeparated,
	    requiredFormats: commaOrSpaceSeparated,
	    resource: null,
	    restart: null,
	    result: null,
	    rotate: null,
	    rx: null,
	    ry: null,
	    scale: null,
	    seed: null,
	    shapeRendering: null,
	    side: null,
	    slope: null,
	    snapshotTime: null,
	    specularConstant: number,
	    specularExponent: number,
	    spreadMethod: null,
	    spacing: null,
	    startOffset: null,
	    stdDeviation: null,
	    stemh: null,
	    stemv: null,
	    stitchTiles: null,
	    stopColor: null,
	    stopOpacity: null,
	    strikethroughPosition: number,
	    strikethroughThickness: number,
	    string: null,
	    stroke: null,
	    strokeDashArray: commaOrSpaceSeparated,
	    strokeDashOffset: null,
	    strokeLineCap: null,
	    strokeLineJoin: null,
	    strokeMiterLimit: number,
	    strokeOpacity: number,
	    strokeWidth: null,
	    style: null,
	    surfaceScale: number,
	    syncBehavior: null,
	    syncBehaviorDefault: null,
	    syncMaster: null,
	    syncTolerance: null,
	    syncToleranceDefault: null,
	    systemLanguage: commaOrSpaceSeparated,
	    tabIndex: number,
	    tableValues: null,
	    target: null,
	    targetX: number,
	    targetY: number,
	    textAnchor: null,
	    textDecoration: null,
	    textRendering: null,
	    textLength: null,
	    timelineBegin: null,
	    title: null,
	    transformBehavior: null,
	    type: null,
	    typeOf: commaOrSpaceSeparated,
	    to: null,
	    transform: null,
	    u1: null,
	    u2: null,
	    underlinePosition: number,
	    underlineThickness: number,
	    unicode: null,
	    unicodeBidi: null,
	    unicodeRange: null,
	    unitsPerEm: number,
	    values: null,
	    vAlphabetic: number,
	    vMathematical: number,
	    vectorEffect: null,
	    vHanging: number,
	    vIdeographic: number,
	    version: null,
	    vertAdvY: number,
	    vertOriginX: number,
	    vertOriginY: number,
	    viewBox: null,
	    viewTarget: null,
	    visibility: null,
	    width: null,
	    widths: null,
	    wordSpacing: null,
	    writingMode: null,
	    x: null,
	    x1: null,
	    x2: null,
	    xChannelSelector: null,
	    xHeight: number,
	    y: null,
	    y1: null,
	    y2: null,
	    yChannelSelector: null,
	    z: null,
	    zoomAndPan: null
	  }
	});

	/**
	 * @typedef {import('./util/schema.js').Schema} Schema
	 */


	const valid = /^data[-\w.:]+$/i;
	const dash = /-[a-z]/g;
	const cap = /[A-Z]/g;

	/**
	 * @param {Schema} schema
	 * @param {string} value
	 * @returns {Info}
	 */
	function find$1(schema, value) {
	  const normal = normalize$2(value);
	  let prop = value;
	  let Type = Info;

	  if (normal in schema.normal) {
	    return schema.property[schema.normal[normal]]
	  }

	  if (normal.length > 4 && normal.slice(0, 4) === 'data' && valid.test(value)) {
	    // Attribute or property.
	    if (value.charAt(4) === '-') {
	      // Turn it into a property.
	      const rest = value.slice(5).replace(dash, camelcase);
	      prop = 'data' + rest.charAt(0).toUpperCase() + rest.slice(1);
	    } else {
	      // Turn it into an attribute.
	      const rest = value.slice(4);

	      if (!dash.test(rest)) {
	        let dashes = rest.replace(cap, kebab);

	        if (dashes.charAt(0) !== '-') {
	          dashes = '-' + dashes;
	        }

	        value = 'data' + dashes;
	      }
	    }

	    Type = DefinedInfo;
	  }

	  return new Type(prop, value)
	}

	/**
	 * @param {string} $0
	 * @returns {string}
	 */
	function kebab($0) {
	  return '-' + $0.toLowerCase()
	}

	/**
	 * @param {string} $0
	 * @returns {string}
	 */
	function camelcase($0) {
	  return $0.charAt(1).toUpperCase()
	}

	/**
	 * `hast` is close to `React`, but differs in a couple of cases.
	 *
	 * To get a React property from a hast property, check if it is in
	 * `hastToReact`, if it is, then use the corresponding value,
	 * otherwise, use the hast property.
	 *
	 * @type {Record<string, string>}
	 */
	const hastToReact = {
	  classId: 'classID',
	  dataType: 'datatype',
	  itemId: 'itemID',
	  strokeDashArray: 'strokeDasharray',
	  strokeDashOffset: 'strokeDashoffset',
	  strokeLineCap: 'strokeLinecap',
	  strokeLineJoin: 'strokeLinejoin',
	  strokeMiterLimit: 'strokeMiterlimit',
	  typeOf: 'typeof',
	  xLinkActuate: 'xlinkActuate',
	  xLinkArcRole: 'xlinkArcrole',
	  xLinkHref: 'xlinkHref',
	  xLinkRole: 'xlinkRole',
	  xLinkShow: 'xlinkShow',
	  xLinkTitle: 'xlinkTitle',
	  xLinkType: 'xlinkType',
	  xmlnsXLink: 'xmlnsXlink'
	};

	/**
	 * @typedef {import('./lib/util/info.js').Info} Info
	 * @typedef {import('./lib/util/schema.js').Schema} Schema
	 */

	const html$3 = merge([xml, xlink, xmlns, aria, html$4], 'html');
	const svg = merge([xml, xlink, xmlns, aria, svg$1], 'svg');

	/**
	 * @typedef {import('hast').Properties} Properties
	 * @typedef {import('hast').Element} Element
	 */

	var search$1 = /[#.]/g;

	/**
	 * Create a hast element from a simple CSS selector.
	 *
	 * @param selector A simple CSS selector.
	 *   Can contain a tag-name (`foo`), classes (`.bar`), and an ID (`#baz`).
	 *   Multiple classes are allowed.
	 *   Uses the last ID if multiple IDs are found.
	 * @param [defaultTagName='div'] Tag name to use if `selector` does not specify one.
	 */
	const parseSelector =
	  /**
	   * @type {(
	   *  <Selector extends string, DefaultTagName extends string = 'div'>(selector?: Selector, defaultTagName?: DefaultTagName) => Element & {tagName: import('./extract.js').ExtractTagName<Selector, DefaultTagName>}
	   * )}
	   */
	  (
	    /**
	     * @param {string} [selector]
	     * @param {string} [defaultTagName='div']
	     * @returns {Element}
	     */
	    function (selector, defaultTagName = 'div') {
	      var value = selector || '';
	      /** @type {Properties} */
	      var props = {};
	      var start = 0;
	      /** @type {string} */
	      var subvalue;
	      /** @type {string} */
	      var previous;
	      /** @type {RegExpMatchArray} */
	      var match;

	      while (start < value.length) {
	        search$1.lastIndex = start;
	        match = search$1.exec(value);
	        subvalue = value.slice(start, match ? match.index : value.length);

	        if (subvalue) {
	          if (!previous) {
	            defaultTagName = subvalue;
	          } else if (previous === '#') {
	            props.id = subvalue;
	          } else if (Array.isArray(props.className)) {
	            props.className.push(subvalue);
	          } else {
	            props.className = [subvalue];
	          }

	          start += subvalue.length;
	        }

	        if (match) {
	          previous = match[0];
	          start++;
	        }
	      }

	      return {
	        type: 'element',
	        tagName: defaultTagName,
	        properties: props,
	        children: []
	      }
	    }
	  );

	/**
	 * @typedef Options
	 *   Configuration for `stringify`.
	 * @property {boolean} [padLeft=true]
	 *   Whether to pad a space before a token.
	 * @property {boolean} [padRight=false]
	 *   Whether to pad a space after a token.
	 */

	/**
	 * @typedef {Options} StringifyOptions
	 *   Please use `StringifyOptions` instead.
	 */

	/**
	 * Parse comma-separated tokens to an array.
	 *
	 * @param {string} value
	 *   Comma-separated tokens.
	 * @returns {Array<string>}
	 *   List of tokens.
	 */
	function parse$1(value) {
	  /** @type {Array<string>} */
	  const tokens = [];
	  const input = String(value || '');
	  let index = input.indexOf(',');
	  let start = 0;
	  /** @type {boolean} */
	  let end = false;

	  while (!end) {
	    if (index === -1) {
	      index = input.length;
	      end = true;
	    }

	    const token = input.slice(start, index).trim();

	    if (token || !end) {
	      tokens.push(token);
	    }

	    start = index + 1;
	    index = input.indexOf(',', start);
	  }

	  return tokens
	}

	/**
	 * Serialize an array of strings or numbers to comma-separated tokens.
	 *
	 * @param {Array<string|number>} values
	 *   List of tokens.
	 * @param {Options} [options]
	 *   Configuration for `stringify` (optional).
	 * @returns {string}
	 *   Comma-separated tokens.
	 */
	function stringify(values, options) {
	  const settings = options || {};

	  // Ensure the last empty entry is seen.
	  const input = values[values.length - 1] === '' ? [...values, ''] : values;

	  return input
	    .join(
	      (settings.padRight ? ' ' : '') +
	        ',' +
	        (settings.padLeft === false ? '' : ' ')
	    )
	    .trim()
	}

	/**
	 * @typedef {import('hast').Root} Root
	 * @typedef {import('hast').Element} Element
	 * @typedef {import('hast').Properties} Properties
	 * @typedef {Root['children'][number]} Child
	 * @typedef {Child|Root} Node
	 * @typedef {import('property-information').Info} Info
	 * @typedef {import('property-information').Schema} Schema
	 *
	 * @typedef {Root|Element} HResult
	 * @typedef {string|number} HStyleValue
	 * @typedef {Record<string, HStyleValue>} HStyle
	 * @typedef {string|number|boolean|null|undefined} HPrimitiveValue
	 * @typedef {Array<string|number>} HArrayValue
	 * @typedef {HPrimitiveValue|HArrayValue} HPropertyValue
	 * @typedef {{[property: string]: HPropertyValue|HStyle}} HProperties
	 *   Acceptable properties value.
	 *
	 * @typedef {string|number|null|undefined} HPrimitiveChild
	 * @typedef {Array<Node|HPrimitiveChild>} HArrayChild
	 * @typedef {Node|HPrimitiveChild|HArrayChild} HChild
	 *   Acceptable child value
	 */


	const buttonTypes = new Set(['menu', 'submit', 'reset', 'button']);

	const own$e = {}.hasOwnProperty;

	/**
	 * @param {Schema} schema
	 * @param {string} defaultTagName
	 * @param {Array<string>} [caseSensitive]
	 */
	function core$1(schema, defaultTagName, caseSensitive) {
	  const adjust = caseSensitive && createAdjustMap(caseSensitive);

	  const h =
	    /**
	     * @type {{
	     *   (): Root
	     *   (selector: null|undefined, ...children: Array<HChild>): Root
	     *   (selector: string, properties?: HProperties, ...children: Array<HChild>): Element
	     *   (selector: string, ...children: Array<HChild>): Element
	     * }}
	     */
	    (
	      /**
	       * Hyperscript compatible DSL for creating virtual hast trees.
	       *
	       * @param {string|null} [selector]
	       * @param {HProperties|HChild} [properties]
	       * @param {Array<HChild>} children
	       * @returns {HResult}
	       */
	      function (selector, properties, ...children) {
	        let index = -1;
	        /** @type {HResult} */
	        let node;

	        if (selector === undefined || selector === null) {
	          node = {type: 'root', children: []};
	          // @ts-expect-error Properties are not supported for roots.
	          children.unshift(properties);
	        } else {
	          node = parseSelector(selector, defaultTagName);
	          // Normalize the name.
	          node.tagName = node.tagName.toLowerCase();
	          if (adjust && own$e.call(adjust, node.tagName)) {
	            node.tagName = adjust[node.tagName];
	          }

	          // Handle props.
	          if (isProperties(properties, node.tagName)) {
	            /** @type {string} */
	            let key;

	            for (key in properties) {
	              if (own$e.call(properties, key)) {
	                // @ts-expect-error `node.properties` is set.
	                addProperty(schema, node.properties, key, properties[key]);
	              }
	            }
	          } else {
	            children.unshift(properties);
	          }
	        }

	        // Handle children.
	        while (++index < children.length) {
	          addChild(node.children, children[index]);
	        }

	        if (node.type === 'element' && node.tagName === 'template') {
	          node.content = {type: 'root', children: node.children};
	          node.children = [];
	        }

	        return node
	      }
	    );

	  return h
	}

	/**
	 * @param {HProperties|HChild} value
	 * @param {string} name
	 * @returns {value is HProperties}
	 */
	function isProperties(value, name) {
	  if (
	    value === null ||
	    value === undefined ||
	    typeof value !== 'object' ||
	    Array.isArray(value)
	  ) {
	    return false
	  }

	  if (name === 'input' || !value.type || typeof value.type !== 'string') {
	    return true
	  }

	  if ('children' in value && Array.isArray(value.children)) {
	    return false
	  }

	  if (name === 'button') {
	    return buttonTypes.has(value.type.toLowerCase())
	  }

	  return !('value' in value)
	}

	/**
	 * @param {Schema} schema
	 * @param {Properties} properties
	 * @param {string} key
	 * @param {HStyle|HPropertyValue} value
	 * @returns {void}
	 */
	function addProperty(schema, properties, key, value) {
	  const info = find$1(schema, key);
	  let index = -1;
	  /** @type {HPropertyValue} */
	  let result;

	  // Ignore nullish and NaN values.
	  if (value === undefined || value === null) return

	  if (typeof value === 'number') {
	    // Ignore NaN.
	    if (Number.isNaN(value)) return

	    result = value;
	  }
	  // Booleans.
	  else if (typeof value === 'boolean') {
	    result = value;
	  }
	  // Handle list values.
	  else if (typeof value === 'string') {
	    if (info.spaceSeparated) {
	      result = parse$2(value);
	    } else if (info.commaSeparated) {
	      result = parse$1(value);
	    } else if (info.commaOrSpaceSeparated) {
	      result = parse$2(parse$1(value).join(' '));
	    } else {
	      result = parsePrimitive(info, info.property, value);
	    }
	  } else if (Array.isArray(value)) {
	    result = value.concat();
	  } else {
	    result = info.property === 'style' ? style(value) : String(value);
	  }

	  if (Array.isArray(result)) {
	    /** @type {Array<string|number>} */
	    const finalResult = [];

	    while (++index < result.length) {
	      // @ts-expect-error Assume no booleans in array.
	      finalResult[index] = parsePrimitive(info, info.property, result[index]);
	    }

	    result = finalResult;
	  }

	  // Class names (which can be added both on the `selector` and here).
	  if (info.property === 'className' && Array.isArray(properties.className)) {
	    // @ts-expect-error Assume no booleans in `className`.
	    result = properties.className.concat(result);
	  }

	  properties[info.property] = result;
	}

	/**
	 * @param {Array<Child>} nodes
	 * @param {HChild} value
	 * @returns {void}
	 */
	function addChild(nodes, value) {
	  let index = -1;

	  if (value === undefined || value === null) ; else if (typeof value === 'string' || typeof value === 'number') {
	    nodes.push({type: 'text', value: String(value)});
	  } else if (Array.isArray(value)) {
	    while (++index < value.length) {
	      addChild(nodes, value[index]);
	    }
	  } else if (typeof value === 'object' && 'type' in value) {
	    if (value.type === 'root') {
	      addChild(nodes, value.children);
	    } else {
	      nodes.push(value);
	    }
	  } else {
	    throw new Error('Expected node, nodes, or string, got `' + value + '`')
	  }
	}

	/**
	 * Parse a single primitives.
	 *
	 * @param {Info} info
	 * @param {string} name
	 * @param {HPrimitiveValue} value
	 * @returns {HPrimitiveValue}
	 */
	function parsePrimitive(info, name, value) {
	  if (typeof value === 'string') {
	    if (info.number && value && !Number.isNaN(Number(value))) {
	      return Number(value)
	    }

	    if (
	      (info.boolean || info.overloadedBoolean) &&
	      (value === '' || normalize$2(value) === normalize$2(name))
	    ) {
	      return true
	    }
	  }

	  return value
	}

	/**
	 * @param {HStyle} value
	 * @returns {string}
	 */
	function style(value) {
	  /** @type {Array<string>} */
	  const result = [];
	  /** @type {string} */
	  let key;

	  for (key in value) {
	    if (own$e.call(value, key)) {
	      result.push([key, value[key]].join(': '));
	    }
	  }

	  return result.join('; ')
	}

	/**
	 * @param {Array<string>} values
	 * @returns {Record<string, string>}
	 */
	function createAdjustMap(values) {
	  /** @type {Record<string, string>} */
	  const result = {};
	  let index = -1;

	  while (++index < values.length) {
	    result[values[index].toLowerCase()] = values[index];
	  }

	  return result
	}

	/**
	 * @typedef {import('./core.js').HChild} Child Acceptable child value
	 * @typedef {import('./core.js').HProperties} Properties Acceptable properties value.
	 *
	 * @typedef {import('./jsx-classic').Element} h.JSX.Element
	 * @typedef {import('./jsx-classic').IntrinsicAttributes} h.JSX.IntrinsicAttributes
	 * @typedef {import('./jsx-classic').IntrinsicElements} h.JSX.IntrinsicElements
	 * @typedef {import('./jsx-classic').ElementChildrenAttribute} h.JSX.ElementChildrenAttribute
	 */


	const h$1 = core$1(html$3, 'div');

	const svgCaseSensitiveTagNames = [
	  'altGlyph',
	  'altGlyphDef',
	  'altGlyphItem',
	  'animateColor',
	  'animateMotion',
	  'animateTransform',
	  'clipPath',
	  'feBlend',
	  'feColorMatrix',
	  'feComponentTransfer',
	  'feComposite',
	  'feConvolveMatrix',
	  'feDiffuseLighting',
	  'feDisplacementMap',
	  'feDistantLight',
	  'feDropShadow',
	  'feFlood',
	  'feFuncA',
	  'feFuncB',
	  'feFuncG',
	  'feFuncR',
	  'feGaussianBlur',
	  'feImage',
	  'feMerge',
	  'feMergeNode',
	  'feMorphology',
	  'feOffset',
	  'fePointLight',
	  'feSpecularLighting',
	  'feSpotLight',
	  'feTile',
	  'feTurbulence',
	  'foreignObject',
	  'glyphRef',
	  'linearGradient',
	  'radialGradient',
	  'solidColor',
	  'textArea',
	  'textPath'
	];

	/**
	 * @typedef {import('./core.js').HChild} Child
	 * @typedef {import('./core.js').HProperties} Properties
	 *
	 * @typedef {import('./jsx-classic').Element} s.JSX.Element
	 * @typedef {import('./jsx-classic').IntrinsicAttributes} s.JSX.IntrinsicAttributes
	 * @typedef {import('./jsx-classic').IntrinsicElements} s.JSX.IntrinsicElements
	 * @typedef {import('./jsx-classic').ElementChildrenAttribute} s.JSX.ElementChildrenAttribute
	 */


	const s = core$1(svg, 'g', svgCaseSensitiveTagNames);

	/**
	 * @typedef {import('unist').Point} Point
	 * @typedef {import('vfile').VFile} VFile
	 *
	 * @typedef {Pick<Point, 'line'|'column'>} PositionalPoint
	 * @typedef {Required<Point>} FullPoint
	 * @typedef {NonNullable<Point['offset']>} Offset
	 */

	/**
	 * Get transform functions for the given `document`.
	 *
	 * @param {string|Uint8Array|VFile} file
	 */
	function location$1(file) {
	  var value = String(file);
	  /** @type {Array.<number>} */
	  var indices = [];
	  var search = /\r?\n|\r/g;

	  while (search.test(value)) {
	    indices.push(search.lastIndex);
	  }

	  indices.push(value.length + 1);

	  return {toPoint, toOffset}

	  /**
	   * Get the line and column-based `point` for `offset` in the bound indices.
	   * Returns a point with `undefined` values when given invalid or out of bounds
	   * input.
	   *
	   * @param {Offset} offset
	   * @returns {FullPoint}
	   */
	  function toPoint(offset) {
	    var index = -1;

	    if (offset > -1 && offset < indices[indices.length - 1]) {
	      while (++index < indices.length) {
	        if (indices[index] > offset) {
	          return {
	            line: index + 1,
	            column: offset - (indices[index - 1] || 0) + 1,
	            offset
	          }
	        }
	      }
	    }

	    return {line: undefined, column: undefined, offset: undefined}
	  }

	  /**
	   * Get the `offset` for a line and column-based `point` in the bound indices.
	   * Returns `-1` when given invalid or out of bounds input.
	   *
	   * @param {PositionalPoint} point
	   * @returns {Offset}
	   */
	  function toOffset(point) {
	    var line = point && point.line;
	    var column = point && point.column;
	    /** @type {number} */
	    var offset;

	    if (
	      typeof line === 'number' &&
	      typeof column === 'number' &&
	      !Number.isNaN(line) &&
	      !Number.isNaN(column) &&
	      line - 1 in indices
	    ) {
	      offset = (indices[line - 2] || 0) + column - 1 || 0;
	    }

	    return offset > -1 && offset < indices[indices.length - 1] ? offset : -1
	  }
	}

	/**
	 * Map of web namespaces.
	 *
	 * @type {Record<string, string>}
	 */
	const webNamespaces = {
	  html: 'http://www.w3.org/1999/xhtml',
	  mathml: 'http://www.w3.org/1998/Math/MathML',
	  svg: 'http://www.w3.org/2000/svg',
	  xlink: 'http://www.w3.org/1999/xlink',
	  xml: 'http://www.w3.org/XML/1998/namespace',
	  xmlns: 'http://www.w3.org/2000/xmlns/'
	};

	/**
	 * @typedef {import('vfile').VFile} VFile
	 * @typedef {import('property-information').Schema} Schema
	 * @typedef {import('unist').Position} Position
	 * @typedef {import('unist').Point} Point
	 * @typedef {import('hast').Parent} Parent
	 * @typedef {import('hast').Element} Element
	 * @typedef {import('hast').Root} Root
	 * @typedef {import('hast').Text} Text
	 * @typedef {import('hast').Comment} Comment
	 * @typedef {import('hast').DocType} Doctype
	 * @typedef {Parent['children'][number]} Child
	 * @typedef {Element['children'][number]} ElementChild
	 * @typedef {Child|Root} Node
	 * @typedef {import('parse5').Document} P5Document
	 * @typedef {import('parse5').DocumentType} P5Doctype
	 * @typedef {import('parse5').CommentNode} P5Comment
	 * @typedef {import('parse5').TextNode} P5Text
	 * @typedef {import('parse5').Element} P5Element
	 * @typedef {import('parse5').ElementLocation} P5ElementLocation
	 * @typedef {import('parse5').Location} P5Location
	 * @typedef {import('parse5').Attribute} P5Attribute
	 * @typedef {import('parse5').Node} P5Node
	 *
	 * @typedef {'html'|'svg'} Space
	 *
	 * @callback Handler
	 * @param {Context} ctx
	 * @param {P5Node} node
	 * @param {Array.<Child>} [children]
	 * @returns {Node}
	 *
	 * @typedef Options
	 * @property {Space} [space='html'] Whether the root of the tree is in the `'html'` or `'svg'` space. If an element in with the SVG namespace is found in `ast`, `fromParse5` automatically switches to the SVG space when entering the element, and switches back when leaving
	 * @property {VFile} [file] `VFile`, used to add positional information to nodes. If given, the file should have the original HTML source as its contents
	 * @property {boolean} [verbose=false] Whether to add extra positional information about starting tags, closing tags, and attributes to elements. Note: not used without `file`
	 *
	 * @typedef Context
	 * @property {Schema} schema
	 * @property {VFile|undefined} file
	 * @property {boolean|undefined} verbose
	 * @property {boolean} location
	 */


	const own$d = {}.hasOwnProperty;

	// Handlers.
	const map = {
	  '#document': root$3,
	  '#document-fragment': root$3,
	  '#text': text$7,
	  '#comment': comment$3,
	  '#documentType': doctype$2
	};

	/**
	 * Transform Parse5’s AST to a hast tree.
	 *
	 * @param {P5Node} ast
	 * @param {Options|VFile} [options]
	 */
	function fromParse5(ast, options = {}) {
	  /** @type {Options} */
	  let settings;
	  /** @type {VFile|undefined} */
	  let file;

	  if (isFile(options)) {
	    file = options;
	    settings = {};
	  } else {
	    file = options.file;
	    settings = options;
	  }

	  return transform$1(
	    {
	      schema: settings.space === 'svg' ? svg : html$3,
	      file,
	      verbose: settings.verbose,
	      location: false
	    },
	    ast
	  )
	}

	/**
	 * Transform children.
	 *
	 * @param {Context} ctx
	 * @param {P5Node} ast
	 * @returns {Node}
	 */
	function transform$1(ctx, ast) {
	  const schema = ctx.schema;
	  /** @type {Handler} */
	  // @ts-expect-error: index is fine.
	  const fn = own$d.call(map, ast.nodeName) ? map[ast.nodeName] : element$5;
	  /** @type {Array.<Child>|undefined} */
	  let children;

	  // Element.
	  if ('tagName' in ast) {
	    ctx.schema = ast.namespaceURI === webNamespaces.svg ? svg : html$3;
	  }

	  if ('childNodes' in ast) {
	    children = nodes(ctx, ast.childNodes);
	  }

	  const result = fn(ctx, ast, children);

	  if ('sourceCodeLocation' in ast && ast.sourceCodeLocation && ctx.file) {
	    // @ts-expect-error It’s fine.
	    const position = createLocation(ctx, result, ast.sourceCodeLocation);

	    if (position) {
	      ctx.location = true;
	      result.position = position;
	    }
	  }

	  ctx.schema = schema;

	  return result
	}

	/**
	 * Transform children.
	 *
	 * @param {Context} ctx
	 * @param {Array.<P5Node>} children
	 * @returns {Array.<Child>}
	 */
	function nodes(ctx, children) {
	  let index = -1;
	  /** @type {Array.<Child>} */
	  const result = [];

	  while (++index < children.length) {
	    // @ts-expect-error Assume no roots in children.
	    result[index] = transform$1(ctx, children[index]);
	  }

	  return result
	}

	/**
	 * Transform a document.
	 * Stores `ast.quirksMode` in `node.data.quirksMode`.
	 *
	 * @type {Handler}
	 * @param {P5Document} ast
	 * @param {Array.<Child>} children
	 * @returns {Root}
	 */
	function root$3(ctx, ast, children) {
	  /** @type {Root} */
	  const result = {
	    type: 'root',
	    children,
	    data: {quirksMode: ast.mode === 'quirks' || ast.mode === 'limited-quirks'}
	  };

	  if (ctx.file && ctx.location) {
	    const doc = String(ctx.file);
	    const loc = location$1(doc);
	    result.position = {
	      start: loc.toPoint(0),
	      end: loc.toPoint(doc.length)
	    };
	  }

	  return result
	}

	/**
	 * Transform a doctype.
	 *
	 * @type {Handler}
	 * @returns {Doctype}
	 */
	function doctype$2() {
	  // @ts-expect-error Types are out of date.
	  return {type: 'doctype'}
	}

	/**
	 * Transform a text.
	 *
	 * @type {Handler}
	 * @param {P5Text} ast
	 * @returns {Text}
	 */
	function text$7(_, ast) {
	  return {type: 'text', value: ast.value}
	}

	/**
	 * Transform a comment.
	 *
	 * @type {Handler}
	 * @param {P5Comment} ast
	 * @returns {Comment}
	 */
	function comment$3(_, ast) {
	  return {type: 'comment', value: ast.data}
	}

	/**
	 * Transform an element.
	 *
	 * @type {Handler}
	 * @param {P5Element} ast
	 * @param {Array.<ElementChild>} children
	 * @returns {Element}
	 */
	function element$5(ctx, ast, children) {
	  const fn = ctx.schema.space === 'svg' ? s : h$1;
	  let index = -1;
	  /** @type {Object.<string, string>} */
	  const props = {};

	  while (++index < ast.attrs.length) {
	    const attribute = ast.attrs[index];
	    props[(attribute.prefix ? attribute.prefix + ':' : '') + attribute.name] =
	      attribute.value;
	  }

	  const result = fn(ast.tagName, props, children);

	  if (result.tagName === 'template' && 'content' in ast) {
	    const pos = ast.sourceCodeLocation;
	    const startTag = pos && pos.startTag && position$1(pos.startTag);
	    const endTag = pos && pos.endTag && position$1(pos.endTag);

	    /** @type {Root} */
	    // @ts-expect-error Types are wrong.
	    const content = transform$1(ctx, ast.content);

	    if (startTag && endTag && ctx.file) {
	      content.position = {start: startTag.end, end: endTag.start};
	    }

	    result.content = content;
	  }

	  return result
	}

	/**
	 * Create clean positional information.
	 *
	 * @param {Context} ctx
	 * @param {Node} node
	 * @param {P5ElementLocation} location
	 * @returns {Position|null}
	 */
	function createLocation(ctx, node, location) {
	  const result = position$1(location);

	  if (node.type === 'element') {
	    const tail = node.children[node.children.length - 1];

	    // Bug for unclosed with children.
	    // See: <https://github.com/inikulin/parse5/issues/109>.
	    if (
	      result &&
	      !location.endTag &&
	      tail &&
	      tail.position &&
	      tail.position.end
	    ) {
	      result.end = Object.assign({}, tail.position.end);
	    }

	    if (ctx.verbose) {
	      /** @type {Object.<string, Position|null>} */
	      const props = {};
	      /** @type {string} */
	      let key;

	      for (key in location.attrs) {
	        if (own$d.call(location.attrs, key)) {
	          props[find$1(ctx.schema, key).property] = position$1(location.attrs[key]);
	        }
	      }

	      node.data = {
	        position: {
	          opening: position$1(location.startTag),
	          closing: location.endTag ? position$1(location.endTag) : null,
	          properties: props
	        }
	      };
	    }
	  }

	  return result
	}

	/**
	 * @param {P5Location} loc
	 * @returns {Position|null}
	 */
	function position$1(loc) {
	  const start = point$1({
	    line: loc.startLine,
	    column: loc.startCol,
	    offset: loc.startOffset
	  });
	  const end = point$1({
	    line: loc.endLine,
	    column: loc.endCol,
	    offset: loc.endOffset
	  });
	  // @ts-expect-error `null` is fine.
	  return start || end ? {start, end} : null
	}

	/**
	 * @param {Point} point
	 * @returns {Point|null}
	 */
	function point$1(point) {
	  return point.line && point.column ? point : null
	}

	/**
	 * @param {VFile|Options} value
	 * @returns {value is VFile}
	 */
	function isFile(value) {
	  return 'messages' in value
	}

	/**
	 * @typedef {import('hast').Element} Element
	 * @typedef {import('hast').Root} Root
	 * @typedef {import('hast').Text} Text
	 *
	 * @typedef {import('unist-util-is').AssertPredicate<Element>} AssertElement
	 * @typedef {import('unist-util-is').AssertPredicate<Text>} AssertText
	 * @typedef {import('unist-util-is').AssertPredicate<Root>} AssertRoot
	 *
	 * @callback CreateElementLike
	 * @param {string} name
	 * @param {any} attributes
	 * @param {Array.<string|any>} [children]
	 * @returns {any}
	 *
	 * @typedef Context
	 * @property {html|svg} schema
	 * @property {string|null} prefix
	 * @property {number} key
	 * @property {boolean} react
	 * @property {boolean} vue
	 * @property {boolean} vdom
	 * @property {boolean} hyperscript
	 *
	 * @typedef Options
	 * @property {string|null} [prefix]
	 * @property {'html'|'svg'} [space]
	 */


	const ns$1 = /** @type {Record<string, string>} */ (webNamespaces);
	const toReact = /** @type {Record<string, string>} */ (hastToReact);

	const own$c = {}.hasOwnProperty;

	/** @type {AssertRoot} */
	// @ts-expect-error it’s correct.
	const root$2 = convert$5('root');
	/** @type {AssertElement} */
	// @ts-expect-error it’s correct.
	const element$4 = convert$5('element');
	/** @type {AssertText} */
	// @ts-expect-error it’s correct.
	const text$6 = convert$5('text');

	/**
	 * @template {CreateElementLike} H
	 * @param {H} h
	 * @param {Element|Root} tree
	 * @param {string|boolean|Options} [options]
	 * @returns {ReturnType<H>}
	 */
	function toH(h, tree, options) {
	  if (typeof h !== 'function') {
	    throw new TypeError('h is not a function')
	  }

	  const r = react(h);
	  const v = vue(h);
	  const vd = vdom(h);
	  /** @type {string|boolean|null|undefined} */
	  let prefix;
	  /** @type {Element} */
	  let node;

	  if (typeof options === 'string' || typeof options === 'boolean') {
	    prefix = options;
	    options = {};
	  } else {
	    if (!options) options = {};
	    prefix = options.prefix;
	  }

	  if (root$2(tree)) {
	    // @ts-expect-error Allow `doctypes` in there, we’ll filter them out later.
	    node =
	      tree.children.length === 1 && element$4(tree.children[0])
	        ? tree.children[0]
	        : {
	            type: 'element',
	            tagName: 'div',
	            properties: {},
	            children: tree.children
	          };
	  } else if (element$4(tree)) {
	    node = tree;
	  } else {
	    throw new Error(
	      // @ts-expect-error runtime.
	      'Expected root or element, not `' + ((tree && tree.type) || tree) + '`'
	    )
	  }

	  return transform(h, node, {
	    schema: options.space === 'svg' ? svg : html$3,
	    prefix:
	      prefix === undefined || prefix === null
	        ? r || v || vd
	          ? 'h-'
	          : null
	        : typeof prefix === 'string'
	        ? prefix
	        : prefix
	        ? 'h-'
	        : null,
	    key: 0,
	    react: r,
	    vue: v,
	    vdom: vd,
	    hyperscript: hyperscript(h)
	  })
	}

	/**
	 * Transform a hast node through a hyperscript interface to *anything*!
	 *
	 * @template {CreateElementLike} H
	 * @param {H} h
	 * @param {Element} node
	 * @param {Context} ctx
	 */
	function transform(h, node, ctx) {
	  const parentSchema = ctx.schema;
	  let schema = parentSchema;
	  let name = node.tagName;
	  /** @type {Record<string, unknown>} */
	  const attributes = {};
	  /** @type {Array.<ReturnType<H>|string>} */
	  const nodes = [];
	  let index = -1;
	  /** @type {string} */
	  let key;

	  if (parentSchema.space === 'html' && name.toLowerCase() === 'svg') {
	    schema = svg;
	    ctx.schema = schema;
	  }

	  for (key in node.properties) {
	    if (node.properties && own$c.call(node.properties, key)) {
	      addAttribute$1(attributes, key, node.properties[key], ctx, name);
	    }
	  }

	  if (ctx.vdom) {
	    if (schema.space === 'html') {
	      name = name.toUpperCase();
	    } else if (schema.space) {
	      attributes.namespace = ns$1[schema.space];
	    }
	  }

	  if (ctx.prefix) {
	    ctx.key++;
	    attributes.key = ctx.prefix + ctx.key;
	  }

	  if (node.children) {
	    while (++index < node.children.length) {
	      const value = node.children[index];

	      if (element$4(value)) {
	        nodes.push(transform(h, value, ctx));
	      } else if (text$6(value)) {
	        nodes.push(value.value);
	      }
	    }
	  }

	  // Restore parent schema.
	  ctx.schema = parentSchema;

	  // Ensure no React warnings are triggered for void elements having children
	  // passed in.
	  return nodes.length > 0
	    ? h.call(node, name, attributes, nodes)
	    : h.call(node, name, attributes)
	}

	/**
	 * @param {Record<string, unknown>} props
	 * @param {string} prop
	 * @param {unknown} value
	 * @param {Context} ctx
	 * @param {string} name
	 */
	// eslint-disable-next-line complexity, max-params
	function addAttribute$1(props, prop, value, ctx, name) {
	  const info = find$1(ctx.schema, prop);
	  /** @type {string|undefined} */
	  let subprop;

	  // Ignore nullish and `NaN` values.
	  // Ignore `false` and falsey known booleans for hyperlike DSLs.
	  if (
	    value === undefined ||
	    value === null ||
	    (typeof value === 'number' && Number.isNaN(value)) ||
	    (value === false && (ctx.vue || ctx.vdom || ctx.hyperscript)) ||
	    (!value && info.boolean && (ctx.vue || ctx.vdom || ctx.hyperscript))
	  ) {
	    return
	  }

	  if (Array.isArray(value)) {
	    // Accept `array`.
	    // Most props are space-separated.
	    value = info.commaSeparated ? stringify(value) : stringify$1(value);
	  }

	  // Treat `true` and truthy known booleans.
	  if (info.boolean && ctx.hyperscript) {
	    value = '';
	  }

	  // VDOM, Vue, and React accept `style` as object.
	  if (
	    info.property === 'style' &&
	    typeof value === 'string' &&
	    (ctx.react || ctx.vue || ctx.vdom)
	  ) {
	    value = parseStyle(value, name);
	  }

	  if (ctx.vue) {
	    if (info.property !== 'style') subprop = 'attrs';
	  } else if (!info.mustUseProperty) {
	    if (ctx.vdom) {
	      if (info.property !== 'style') subprop = 'attributes';
	    } else if (ctx.hyperscript) {
	      subprop = 'attrs';
	    }
	  }

	  if (subprop) {
	    props[subprop] = Object.assign(props[subprop] || {}, {
	      [info.attribute]: value
	    });
	  } else if (info.space && ctx.react) {
	    props[toReact[info.property] || info.property] = value;
	  } else {
	    props[info.attribute] = value;
	  }
	}

	/**
	 * Check if `h` is `react.createElement`.
	 *
	 * @param {CreateElementLike} h
	 * @returns {boolean}
	 */
	function react(h) {
	  /** @type {unknown} */
	  const node = h('div', {});
	  return Boolean(
	    node &&
	      // @ts-expect-error Looks like a React node.
	      ('_owner' in node || '_store' in node) &&
	      // @ts-expect-error Looks like a React node.
	      (node.key === undefined || node.key === null)
	  )
	}

	/**
	 * Check if `h` is `hyperscript`.
	 *
	 * @param {CreateElementLike} h
	 * @returns {boolean}
	 */
	function hyperscript(h) {
	  return 'context' in h && 'cleanup' in h
	}

	/**
	 * Check if `h` is `virtual-dom/h`.
	 *
	 * @param {CreateElementLike} h
	 * @returns {boolean}
	 */
	function vdom(h) {
	  /** @type {unknown} */
	  const node = h('div', {});
	  // @ts-expect-error Looks like a vnode.
	  return node.type === 'VirtualNode'
	}

	/**
	 * Check if `h` is Vue.
	 *
	 * @param {CreateElementLike} h
	 * @returns {boolean}
	 */
	function vue(h) {
	  /** @type {unknown} */
	  const node = h('div', {});
	  // @ts-expect-error Looks like a Vue node.
	  return Boolean(node && node.context && node.context._isVue)
	}

	/**
	 * @param {string} value
	 * @param {string} tagName
	 * @returns {Record<string, string>}
	 */
	function parseStyle(value, tagName) {
	  /** @type {Record<string, string>} */
	  const result = {};

	  try {
	    style$1(value, (name, value) => {
	      if (name.slice(0, 4) === '-ms-') name = 'ms-' + name.slice(4);

	      result[
	        name.replace(
	          /-([a-z])/g,
	          /**
	           * @param {string} _
	           * @param {string} $1
	           * @returns {string}
	           */ (_, $1) => $1.toUpperCase()
	        )
	      ] = value;
	    });
	  } catch (error) {
	    error.message =
	      tagName + '[style]' + error.message.slice('undefined'.length);
	    throw error
	  }

	  return result
	}

	var own$b = {}.hasOwnProperty;

	/**
	 * @callback Handler
	 * @param {...unknown} value
	 * @return {unknown}
	 *
	 * @typedef {Record<string, Handler>} Handlers
	 *
	 * @typedef {Object} Options
	 * @property {Handler} [unknown]
	 * @property {Handler} [invalid]
	 * @property {Handlers} [handlers]
	 */

	/**
	 * Handle values based on a property.
	 *
	 * @param {string} key
	 * @param {Options} [options]
	 */
	function zwitch(key, options) {
	  var settings = options || {};

	  /**
	   * Handle one value.
	   * Based on the bound `key`, a respective handler will be called.
	   * If `value` is not an object, or doesn’t have a `key` property, the special
	   * “invalid” handler will be called.
	   * If `value` has an unknown `key`, the special “unknown” handler will be
	   * called.
	   *
	   * All arguments, and the context object, are passed through to the handler,
	   * and it’s result is returned.
	   *
	   * @param {...unknown} [value]
	   * @this {unknown}
	   * @returns {unknown}
	   * @property {Handler} invalid
	   * @property {Handler} unknown
	   * @property {Handlers} handlers
	   */
	  function one(value) {
	    var fn = one.invalid;
	    var handlers = one.handlers;

	    if (value && own$b.call(value, key)) {
	      fn = own$b.call(handlers, value[key]) ? handlers[value[key]] : one.unknown;
	    }

	    if (fn) {
	      return fn.apply(this, arguments)
	    }
	  }

	  one.handlers = settings.handlers || {};
	  one.invalid = settings.invalid;
	  one.unknown = settings.unknown;

	  return one
	}

	/**
	 * @typedef {import('parse5').Node} P5Node
	 * @typedef {import('parse5').Document} P5Document
	 * @typedef {import('parse5').DocumentFragment} P5Fragment
	 * @typedef {import('parse5').DocumentType} P5Doctype
	 * @typedef {import('parse5').CommentNode} P5Comment
	 * @typedef {import('parse5').TextNode} P5Text
	 * @typedef {import('parse5').Element} P5Element
	 * @typedef {import('parse5').Attribute} P5Attribute
	 * @typedef {import('parse5').ParentNode} P5Parent
	 * @typedef {Exclude<P5Node, P5Document|P5Fragment>} P5Child
	 * @typedef {import('property-information').Schema} Schema
	 * @typedef {import('property-information').Info} Info
	 * @typedef {'html'|'svg'} Space
	 * @typedef {import('hast').Parent} Parent
	 * @typedef {import('hast').Root} Root
	 * @typedef {import('hast').DocType} Doctype
	 * @typedef {import('hast').Element} Element
	 * @typedef {import('hast').Text} Text
	 * @typedef {import('hast').Comment} Comment
	 * @typedef {Parent['children'][number]} Child
	 * @typedef {Child|Root} Node
	 *
	 * @callback Handle
	 * @param {Node} node
	 * @param {Schema} schema
	 * @returns {P5Node}
	 */


	var own$a = {}.hasOwnProperty;

	var one$3 = zwitch('type', {handlers: {root: root$1, element: element$3, text: text$5, comment: comment$2, doctype: doctype$1}});

	/**
	 * Transform a tree from hast to Parse5’s AST.
	 *
	 * @param {Node} tree
	 * @param {Space} [space='html']
	 * @returns {P5Node}
	 */
	function toParse5(tree, space) {
	  // @ts-ignore Types are wrong.
	  return one$3(tree, html$3)
	}

	/**
	 * @type {Handle}
	 * @param {Root} node
	 * @returns {P5Document}
	 */
	function root$1(node, schema) {
	  /** @type {P5Document} */
	  var p5 = {
	    nodeName: '#document',
	    mode: (node.data || {}).quirksMode ? 'quirks' : 'no-quirks',
	    childNodes: []
	  };
	  // @ts-ignore Assume correct children.
	  p5.childNodes = all$3(node.children, p5, schema);
	  return patch(node, p5)
	}

	/**
	 * @type {Handle}
	 * @param {Root} node
	 * @returns {P5Fragment}
	 */
	function fragment(node, schema) {
	  /** @type {P5Fragment} */
	  var p5 = {nodeName: '#document-fragment', childNodes: []};
	  // @ts-ignore Assume correct children.
	  p5.childNodes = all$3(node.children, p5, schema);
	  return patch(node, p5)
	}

	/**
	 * @type {Handle}
	 * @param {Doctype} node
	 * @returns {P5Doctype}
	 */
	function doctype$1(node) {
	  return patch(node, {
	    nodeName: '#documentType',
	    name: 'html',
	    publicId: '',
	    systemId: '',
	    parentNode: undefined
	  })
	}

	/**
	 * @type {Handle}
	 * @param {Text} node
	 * @returns {P5Text}
	 */
	function text$5(node) {
	  return patch(node, {
	    nodeName: '#text',
	    value: node.value,
	    parentNode: undefined
	  })
	}

	/**
	 * @type {Handle}
	 * @param {Comment} node
	 * @returns {P5Comment}
	 */
	function comment$2(node) {
	  return patch(node, {
	    nodeName: '#comment',
	    data: node.value,
	    parentNode: undefined
	  })
	}

	/**
	 * @type {Handle}
	 * @param {Element} node
	 * @returns {P5Element}
	 */
	function element$3(node, schema) {
	  /** @type {Space} */
	  // @ts-ignore Assume space.
	  var space = schema.space;
	  return toH(h, Object.assign({}, node, {children: []}), {space})

	  /**
	   * @param {string} name
	   * @param {Object.<string, string|boolean|number>} attrs
	   */
	  function h(name, attrs) {
	    /** @type {Array.<P5Attribute>} */
	    var values = [];
	    /** @type {Info} */
	    var info;
	    /** @type {P5Attribute} */
	    var value;
	    /** @type {string} */
	    var key;
	    /** @type {number} */
	    var index;
	    /** @type {P5Element} */
	    var p5;

	    for (key in attrs) {
	      if (!own$a.call(attrs, key) || attrs[key] === false) {
	        continue
	      }

	      info = find$1(schema, key);

	      if (info.boolean && !attrs[key]) {
	        continue
	      }

	      value = {name: key, value: attrs[key] === true ? '' : String(attrs[key])};

	      if (info.space && info.space !== 'html' && info.space !== 'svg') {
	        index = key.indexOf(':');

	        if (index < 0) {
	          value.prefix = '';
	        } else {
	          value.name = key.slice(index + 1);
	          value.prefix = key.slice(0, index);
	        }

	        value.namespace = webNamespaces[info.space];
	      }

	      values.push(value);
	    }

	    if (schema.space === 'html' && node.tagName === 'svg') schema = svg;

	    p5 = patch(node, {
	      nodeName: name,
	      tagName: name,
	      attrs: values,
	      namespaceURI: webNamespaces[schema.space],
	      childNodes: [],
	      parentNode: undefined
	    });

	    // @ts-ignore Assume correct children.
	    p5.childNodes = all$3(node.children, p5, schema);

	    // @ts-ignore Types are wrong.
	    if (name === 'template') p5.content = fragment(node.content, schema);

	    return p5
	  }
	}

	/**
	 * @param {Array.<Child>} children
	 * @param {P5Parent} p5
	 * @param {Schema} schema
	 * @returns {Array.<P5Child>}
	 */
	function all$3(children, p5, schema) {
	  var index = -1;
	  /** @type {Array.<P5Child>} */
	  var result = [];
	  /** @type {P5Child} */
	  var child;

	  if (children) {
	    while (++index < children.length) {
	      // @ts-ignore Assume child.
	      child = one$3(children[index], schema);

	      // @ts-ignore types are wrong.
	      child.parentNode = p5;

	      result.push(child);
	    }
	  }

	  return result
	}

	/**
	 * Patch specific properties.
	 *
	 * @template {P5Node} T
	 * @param {Node} node
	 * @param {T} p5
	 * @returns {T}
	 */
	function patch(node, p5) {
	  var position = node.position;

	  if (position && position.start && position.end) {
	    // @ts-ignore Types are wrong.
	    p5.sourceCodeLocation = {
	      startLine: position.start.line,
	      startCol: position.start.column,
	      startOffset: position.start.offset,
	      endLine: position.end.line,
	      endCol: position.end.column,
	      endOffset: position.end.offset
	    };
	  }

	  return p5
	}

	/**
	 * List of HTML void tag names.
	 *
	 * @type {Array<string>}
	 */
	const htmlVoidElements = [
	  'area',
	  'base',
	  'basefont',
	  'bgsound',
	  'br',
	  'col',
	  'command',
	  'embed',
	  'frame',
	  'hr',
	  'image',
	  'img',
	  'input',
	  'isindex',
	  'keygen',
	  'link',
	  'menuitem',
	  'meta',
	  'nextid',
	  'param',
	  'source',
	  'track',
	  'wbr'
	];

	/**
	 * @typedef {import('vfile').VFile} VFile
	 * @typedef {import('parse5').Document} P5Document
	 * @typedef {import('parse5').DocumentFragment} P5Fragment
	 * @typedef {Omit<import('parse5').Element, 'parentNode'>} P5Element
	 * @typedef {import('parse5').Attribute} P5Attribute
	 * @typedef {Omit<import('parse5').Location, 'startOffset' | 'endOffset'> & {startOffset: number|undefined, endOffset: number|undefined}} P5Location
	 * @typedef {import('parse5').ParserOptions} P5ParserOptions
	 * @typedef {import('hast').Root} Root
	 * @typedef {import('hast').DocType} Doctype
	 * @typedef {import('hast').Element} Element
	 * @typedef {import('hast').Text} Text
	 * @typedef {import('hast').Comment} Comment
	 * @typedef {import('hast').Content} Content
	 * @typedef {Root|Content} Node
	 * @typedef {import('../complex-types').Raw} Raw
	 *
	 * @typedef {Omit<Comment, 'value'> & {value: {stitch: Node}}} Stitch
	 *
	 * @typedef Options
	 * @property {Array.<string>} [passThrough]
	 *   List of custom hast node types to pass through (keep) in hast.
	 *   If the passed through nodes have children, those children are expected to
	 *   be hast and will be handled.
	 *
	 * @typedef HiddenTokenizer
	 * @property {Array.<HiddenLocationTracker>} __mixins
	 *   Way too simple, but works for us.
	 * @property {HiddenPreprocessor} preprocessor
	 * @property {(value: string) => void} write
	 * @property {() => number} _consume
	 * @property {Array.<HiddenToken>} tokenQueue
	 * @property {string} state
	 * @property {string} returnState
	 * @property {number} charRefCode
	 * @property {Array.<number>} tempBuff
	 * @property {Function} _flushCodePointsConsumedAsCharacterReference
	 * @property {string} lastStartTagName
	 * @property {number} consumedAfterSnapshot
	 * @property {boolean} active
	 * @property {HiddenToken|undefined} currentCharacterToken
	 * @property {HiddenToken|undefined} currentToken
	 * @property {unknown} currentAttr
	 * @property {Function} NAMED_CHARACTER_REFERENCE_STATE
	 * @property {Function} NUMERIC_CHARACTER_REFERENCE_END_STATE
	 *
	 * @typedef {Object.<string, unknown> & {location: P5Location}} HiddenToken
	 *
	 * @typedef HiddenPreprocessor
	 * @property {string|undefined} html
	 * @property {number} pos
	 * @property {number} lastGapPos
	 * @property {number} lastCharPos
	 * @property {Array.<number>} gapStack
	 * @property {boolean} skipNextNewLine
	 * @property {boolean} lastChunkWritten
	 * @property {boolean} endOfChunkHit
	 *
	 * @typedef HiddenLocationTracker
	 * @property {P5Location|undefined} currentAttrLocation
	 * @property {P5Location} ctLoc
	 * @property {HiddenPosTracker} posTracker
	 *
	 * @typedef HiddenPosTracker
	 * @property {boolean} isEol
	 * @property {number} lineStartPos
	 * @property {number} droppedBufferSize
	 * @property {number} offset
	 * @property {number} col
	 * @property {number} line
	 */


	const inTemplateMode = 'IN_TEMPLATE_MODE';
	const dataState = 'DATA_STATE';
	const characterToken = 'CHARACTER_TOKEN';
	const startTagToken = 'START_TAG_TOKEN';
	const endTagToken = 'END_TAG_TOKEN';
	const commentToken = 'COMMENT_TOKEN';
	const doctypeToken = 'DOCTYPE_TOKEN';

	/** @type {P5ParserOptions} */
	const parseOptions = {sourceCodeLocationInfo: true, scriptingEnabled: false};

	/**
	 * Given a hast tree and an optional vfile (for positional info), return a new
	 * parsed-again hast tree.
	 *
	 * @param tree
	 *   Original hast tree.
	 * @param file
	 *   Virtual file for positional info, optional.
	 * @param options
	 *   Configuration.
	 */
	const raw$1 =
	  /**
	   * @type {(
	   *   ((tree: Node, file: VFile|undefined, options?: Options) => Node) &
	   *   ((tree: Node, options?: Options) => Node)
	   * )}
	   */
	  (
	    /**
	     * @param {Node} tree
	     * @param {VFile} [file]
	     * @param {Options} [options]
	     */
	    function (tree, file, options) {
	      let index = -1;
	      const parser = new Parser$1(parseOptions);
	      const one = zwitch('type', {
	        // @ts-expect-error: hush.
	        handlers: {root, element, text, comment, doctype, raw: handleRaw},
	        // @ts-expect-error: hush.
	        unknown: unknown$1
	      });
	      /** @type {boolean|undefined} */
	      let stitches;
	      /** @type {HiddenTokenizer|undefined} */
	      let tokenizer;
	      /** @type {HiddenPreprocessor|undefined} */
	      let preprocessor;
	      /** @type {HiddenPosTracker|undefined} */
	      let posTracker;
	      /** @type {HiddenLocationTracker|undefined} */
	      let locationTracker;

	      if (isOptions(file)) {
	        options = file;
	        file = undefined;
	      }

	      if (options && options.passThrough) {
	        while (++index < options.passThrough.length) {
	          // @ts-expect-error: hush.
	          one.handlers[options.passThrough[index]] = stitch;
	        }
	      }

	      const result = fromParse5(
	        documentMode(tree) ? document() : fragment(),
	        file
	      );

	      if (stitches) {
	        visit$2(result, 'comment', (node, index, parent) => {
	          const stitch = /** @type {Stitch} */ (/** @type {unknown} */ (node));
	          if (stitch.value.stitch && parent !== null && index !== null) {
	            // @ts-expect-error: assume the stitch is allowed.
	            parent.children[index] = stitch.value.stitch;
	            return index
	          }
	        });
	      }

	      // Unpack if possible and when not given a `root`.
	      if (
	        tree.type !== 'root' &&
	        result.type === 'root' &&
	        result.children.length === 1
	      ) {
	        return result.children[0]
	      }

	      return result

	      /**
	       * @returns {P5Fragment}
	       */
	      function fragment() {
	        /** @type {P5Element} */
	        const context = {
	          nodeName: 'template',
	          tagName: 'template',
	          attrs: [],
	          namespaceURI: webNamespaces.html,
	          childNodes: []
	        };
	        /** @type {P5Element} */
	        const mock = {
	          nodeName: 'documentmock',
	          tagName: 'documentmock',
	          attrs: [],
	          namespaceURI: webNamespaces.html,
	          childNodes: []
	        };
	        /** @type {P5Fragment} */
	        const doc = {nodeName: '#document-fragment', childNodes: []};

	        parser._bootstrap(mock, context);
	        parser._pushTmplInsertionMode(inTemplateMode);
	        parser._initTokenizerForFragmentParsing();
	        parser._insertFakeRootElement();
	        parser._resetInsertionMode();
	        parser._findFormInFragmentContext();

	        tokenizer = parser.tokenizer;
	        /* c8 ignore next */
	        if (!tokenizer) throw new Error('Expected `tokenizer`')
	        preprocessor = tokenizer.preprocessor;
	        locationTracker = tokenizer.__mixins[0];
	        posTracker = locationTracker.posTracker;

	        one(tree);

	        parser._adoptNodes(mock.childNodes[0], doc);

	        return doc
	      }

	      /**
	       * @returns {P5Document}
	       */
	      function document() {
	        /** @type {P5Document} */
	        const doc = parser.treeAdapter.createDocument();

	        parser._bootstrap(doc, undefined);
	        tokenizer = parser.tokenizer;
	        /* c8 ignore next */
	        if (!tokenizer) throw new Error('Expected `tokenizer`')
	        preprocessor = tokenizer.preprocessor;
	        locationTracker = tokenizer.__mixins[0];
	        posTracker = locationTracker.posTracker;

	        one(tree);

	        return doc
	      }

	      /**
	       * @param {Content[]} nodes
	       * @returns {void}
	       */
	      function all(nodes) {
	        let index = -1;

	        /* istanbul ignore else - invalid nodes, see rehypejs/rehype-raw#7. */
	        if (nodes) {
	          while (++index < nodes.length) {
	            one(nodes[index]);
	          }
	        }
	      }

	      /**
	       * @param {Root} node
	       * @returns {void}
	       */
	      function root(node) {
	        all(node.children);
	      }

	      /**
	       * @param {Element} node
	       * @returns {void}
	       */
	      function element(node) {
	        resetTokenizer();
	        parser._processToken(startTag(node), webNamespaces.html);

	        all(node.children);

	        if (!htmlVoidElements.includes(node.tagName)) {
	          resetTokenizer();
	          parser._processToken(endTag(node));
	        }
	      }

	      /**
	       * @param {Text} node
	       * @returns {void}
	       */
	      function text(node) {
	        resetTokenizer();
	        parser._processToken({
	          type: characterToken,
	          chars: node.value,
	          location: createParse5Location(node)
	        });
	      }

	      /**
	       * @param {Doctype} node
	       * @returns {void}
	       */
	      function doctype(node) {
	        resetTokenizer();
	        parser._processToken({
	          type: doctypeToken,
	          name: 'html',
	          forceQuirks: false,
	          publicId: '',
	          systemId: '',
	          location: createParse5Location(node)
	        });
	      }

	      /**
	       * @param {Comment|Stitch} node
	       * @returns {void}
	       */
	      function comment(node) {
	        resetTokenizer();
	        parser._processToken({
	          type: commentToken,
	          data: node.value,
	          location: createParse5Location(node)
	        });
	      }

	      /**
	       * @param {Raw} node
	       * @returns {void}
	       */
	      function handleRaw(node) {
	        const start = pointStart(node);
	        const line = start.line || 1;
	        const column = start.column || 1;
	        const offset = start.offset || 0;

	        /* c8 ignore next 4 */
	        if (!preprocessor) throw new Error('Expected `preprocessor`')
	        if (!tokenizer) throw new Error('Expected `tokenizer`')
	        if (!posTracker) throw new Error('Expected `posTracker`')
	        if (!locationTracker) throw new Error('Expected `locationTracker`')

	        // Reset preprocessor:
	        // See: <https://github.com/inikulin/parse5/blob/9c683e1/packages/parse5/lib/tokenizer/preprocessor.js>.
	        preprocessor.html = undefined;
	        preprocessor.pos = -1;
	        preprocessor.lastGapPos = -1;
	        preprocessor.lastCharPos = -1;
	        preprocessor.gapStack = [];
	        preprocessor.skipNextNewLine = false;
	        preprocessor.lastChunkWritten = false;
	        preprocessor.endOfChunkHit = false;

	        // Reset preprocessor mixin:
	        // See: <https://github.com/inikulin/parse5/blob/9c683e1/packages/parse5/lib/extensions/position-tracking/preprocessor-mixin.js>.
	        posTracker.isEol = false;
	        posTracker.lineStartPos = -column + 1; // Looks weird, but ensures we get correct positional info.
	        posTracker.droppedBufferSize = offset;
	        posTracker.offset = 0;
	        posTracker.col = 1;
	        posTracker.line = line;

	        // Reset location tracker:
	        // See: <https://github.com/inikulin/parse5/blob/9c683e1/packages/parse5/lib/extensions/location-info/tokenizer-mixin.js>.
	        locationTracker.currentAttrLocation = undefined;
	        locationTracker.ctLoc = createParse5Location(node);

	        // See the code for `parse` and `parseFragment`:
	        // See: <https://github.com/inikulin/parse5/blob/9c683e1/packages/parse5/lib/parser/index.js#L371>.
	        tokenizer.write(node.value);
	        parser._runParsingLoop(null);

	        // Character references hang, so if we ended there, we need to flush
	        // those too.
	        // We reset the preprocessor as if the document ends here.
	        // Then one single call to the relevant state does the trick, parse5
	        // consumes the whole token.
	        if (
	          tokenizer.state === 'NAMED_CHARACTER_REFERENCE_STATE' ||
	          tokenizer.state === 'NUMERIC_CHARACTER_REFERENCE_END_STATE'
	        ) {
	          preprocessor.lastChunkWritten = true;
	          tokenizer[tokenizer.state](tokenizer._consume());
	        }

	        // Process final characters if they’re still there after hibernating.
	        // Similar to:
	        // See: <https://github.com/inikulin/parse5/blob/9c683e1/packages/parse5/lib/extensions/location-info/tokenizer-mixin.js#L95>.
	        const token = tokenizer.currentCharacterToken;

	        if (token) {
	          token.location.endLine = posTracker.line;
	          token.location.endCol = posTracker.col + 1;
	          token.location.endOffset = posTracker.offset + 1;
	          parser._processToken(token);
	        }
	      }

	      /**
	       * @param {Node} node
	       */
	      function stitch(node) {
	        stitches = true;

	        /** @type {Node} */
	        let clone;

	        // Recurse, because to somewhat handle `[<x>]</x>` (where `[]` denotes the
	        // passed through node).
	        if ('children' in node) {
	          clone = {
	            ...node,
	            children: raw$1(
	              {type: 'root', children: node.children},
	              file,
	              options
	              // @ts-expect-error Assume a given parent yields a parent.
	            ).children
	          };
	        } else {
	          clone = {...node};
	        }

	        // Hack: `value` is supposed to be a string, but as none of the tools
	        // (`parse5` or `hast-util-from-parse5`) looks at it, we can pass nodes
	        // through.
	        comment({type: 'comment', value: {stitch: clone}});
	      }

	      function resetTokenizer() {
	        /* c8 ignore next */
	        if (!tokenizer) throw new Error('Expected `tokenizer`')

	        // Reset tokenizer:
	        // See: <https://github.com/inikulin/parse5/blob/9c683e1/packages/parse5/lib/tokenizer/index.js#L218-L234>.
	        // Especially putting it back in the `data` state is useful: some elements,
	        // like textareas and iframes, change the state.
	        // See GH-7.
	        // But also if broken HTML is in `raw`, and then a correct element is given.
	        // See GH-11.
	        tokenizer.tokenQueue = [];
	        tokenizer.state = dataState;
	        tokenizer.returnState = '';
	        tokenizer.charRefCode = -1;
	        tokenizer.tempBuff = [];
	        tokenizer.lastStartTagName = '';
	        tokenizer.consumedAfterSnapshot = -1;
	        tokenizer.active = false;
	        tokenizer.currentCharacterToken = undefined;
	        tokenizer.currentToken = undefined;
	        tokenizer.currentAttr = undefined;
	      }
	    }
	  );
	/**
	 * @param {Element} node
	 * @returns {HiddenToken}
	 */
	function startTag(node) {
	  /** @type {P5Location} */
	  const location = Object.assign(createParse5Location(node));
	  // @ts-expect-error extra positional info.
	  location.startTag = Object.assign({}, location);

	  // Untyped token.
	  return {
	    type: startTagToken,
	    tagName: node.tagName,
	    selfClosing: false,
	    attrs: attributes(node),
	    location
	  }
	}

	/**
	 * @param {Element} node
	 * @returns {Array.<P5Attribute>}
	 */
	function attributes(node) {
	  return toParse5({
	    tagName: node.tagName,
	    type: 'element',
	    properties: node.properties,
	    children: []
	    // @ts-expect-error Assume element.
	  }).attrs
	}

	/**
	 * @param {Element} node
	 * @returns {HiddenToken}
	 */
	function endTag(node) {
	  /** @type {P5Location} */
	  const location = Object.assign(createParse5Location(node));
	  // @ts-expect-error extra positional info.
	  location.startTag = Object.assign({}, location);

	  // Untyped token.
	  return {
	    type: endTagToken,
	    tagName: node.tagName,
	    attrs: [],
	    location
	  }
	}

	/**
	 * @param {Node} node
	 */
	function unknown$1(node) {
	  throw new Error('Cannot compile `' + node.type + '` node')
	}

	/**
	 * @param {Node} node
	 * @returns {boolean}
	 */
	function documentMode(node) {
	  const head = node.type === 'root' ? node.children[0] : node;
	  return Boolean(
	    head &&
	      (head.type === 'doctype' ||
	        (head.type === 'element' && head.tagName === 'html'))
	  )
	}

	/**
	 * @param {Node|Stitch} node
	 * @returns {P5Location}
	 */
	function createParse5Location(node) {
	  const start = pointStart(node);
	  const end = pointEnd(node);

	  return {
	    startLine: start.line,
	    startCol: start.column,
	    startOffset: start.offset,
	    endLine: end.line,
	    endCol: end.column,
	    endOffset: end.offset
	  }
	}

	/**
	 * @param {VFile|Options|undefined} value
	 * @return {value is Options}
	 */
	function isOptions(value) {
	  return Boolean(value && !('message' in value && 'messages' in value))
	}

	/**
	 * @typedef {import('hast').Root} Root
	 * @typedef {import('hast-util-raw').Options} Options
	 * @typedef {import('hast-util-raw')} DoNotTouchAsThisImportIncludesRawInTree
	 */


	/**
	 * Plugin to parse the tree again (and raw nodes).
	 * Keeping positional info OK.  🙌
	 *
	 * @type {import('unified').Plugin<[Options?] | Array<void>, Root>}
	 */
	function rehypeRaw(options = {}) {
	  return (tree, file) => {
	    // Assume that when a root was given, it’s also returned.
	    const result = /** @type {Root} */ (raw$1(tree, file, options));
	    return result
	  }
	}

	var convert_1 = convert$2;

	function convert$2(test) {
	  if (typeof test === 'string') {
	    return typeFactory(test)
	  }

	  if (test === null || test === undefined) {
	    return ok
	  }

	  if (typeof test === 'object') {
	    return ('length' in test ? anyFactory$1 : matchesFactory)(test)
	  }

	  if (typeof test === 'function') {
	    return test
	  }

	  throw new Error('Expected function, string, or object as test')
	}

	function convertAll(tests) {
	  var results = [];
	  var length = tests.length;
	  var index = -1;

	  while (++index < length) {
	    results[index] = convert$2(tests[index]);
	  }

	  return results
	}

	// Utility assert each property in `test` is represented in `node`, and each
	// values are strictly equal.
	function matchesFactory(test) {
	  return matches

	  function matches(node) {
	    var key;

	    for (key in test) {
	      if (node[key] !== test[key]) {
	        return false
	      }
	    }

	    return true
	  }
	}

	function anyFactory$1(tests) {
	  var checks = convertAll(tests);
	  var length = checks.length;

	  return matches

	  function matches() {
	    var index = -1;

	    while (++index < length) {
	      if (checks[index].apply(this, arguments)) {
	        return true
	      }
	    }

	    return false
	  }
	}

	// Utility to convert a string into a function which checks a given node’s type
	// for said string.
	function typeFactory(test) {
	  return type

	  function type(node) {
	    return Boolean(node && node.type === test)
	  }
	}

	// Utility to return true.
	function ok() {
	  return true
	}

	var convert$3 = /*@__PURE__*/getDefaultExportFromCjs(convert_1);

	var convert_ = /*#__PURE__*/Object.freeze({
		__proto__: null,
		default: convert$3
	});

	var require$$0 = /*@__PURE__*/getAugmentedNamespace(convert_);

	var unistUtilVisitParents = visitParents$1;

	var convert$1 = require$$0;

	var CONTINUE$1 = true;
	var SKIP$1 = 'skip';
	var EXIT$1 = false;

	visitParents$1.CONTINUE = CONTINUE$1;
	visitParents$1.SKIP = SKIP$1;
	visitParents$1.EXIT = EXIT$1;

	function visitParents$1(tree, test, visitor, reverse) {
	  var is;

	  if (typeof test === 'function' && typeof visitor !== 'function') {
	    reverse = visitor;
	    visitor = test;
	    test = null;
	  }

	  is = convert$1(test);

	  one(tree, null, []);

	  // Visit a single node.
	  function one(node, index, parents) {
	    var result = [];
	    var subresult;

	    if (!test || is(node, index, parents[parents.length - 1] || null)) {
	      result = toResult(visitor(node, parents));

	      if (result[0] === EXIT$1) {
	        return result
	      }
	    }

	    if (node.children && result[0] !== SKIP$1) {
	      subresult = toResult(all(node.children, parents.concat(node)));
	      return subresult[0] === EXIT$1 ? subresult : result
	    }

	    return result
	  }

	  // Visit children in `parent`.
	  function all(children, parents) {
	    var min = -1;
	    var step = reverse ? -1 : 1;
	    var index = (reverse ? children.length : min) + step;
	    var result;

	    while (index > min && index < children.length) {
	      result = one(children[index], index, parents);

	      if (result[0] === EXIT$1) {
	        return result
	      }

	      index = typeof result[1] === 'number' ? result[1] : index + step;
	    }
	  }
	}

	function toResult(value) {
	  if (value !== null && typeof value === 'object' && 'length' in value) {
	    return value
	  }

	  if (typeof value === 'number') {
	    return [CONTINUE$1, value]
	  }

	  return [value]
	}

	var unistUtilVisit = visit$1;

	var visitParents = unistUtilVisitParents;

	var CONTINUE = visitParents.CONTINUE;
	var SKIP = visitParents.SKIP;
	var EXIT = visitParents.EXIT;

	visit$1.CONTINUE = CONTINUE;
	visit$1.SKIP = SKIP;
	visit$1.EXIT = EXIT;

	function visit$1(tree, test, visitor, reverse) {
	  if (typeof test === 'function' && typeof visitor !== 'function') {
	    reverse = visitor;
	    visitor = test;
	    test = null;
	  }

	  visitParents(tree, test, overload, reverse);

	  function overload(node, parents) {
	    var parent = parents[parents.length - 1];
	    var index = parent ? parent.children.indexOf(node) : null;
	    return visitor(node, index, parent)
	  }
	}

	var visit = unistUtilVisit;

	var hasOwnProperty$2 = Object.prototype.hasOwnProperty;
	var hastCssPropertyMap = {
	  align: 'text-align',
	  valign: 'vertical-align',
	  height: 'height',
	  width: 'width',
	};

	var hastUtilTableCellStyle = function tableCellStyle(node) {
	  visit(node, 'element', visitor);
	  return node;
	};

	function visitor(node) {
	  if (node.tagName !== 'tr' && node.tagName !== 'td' && node.tagName !== 'th') {
	    return;
	  }

	  var hastName;
	  var cssName;
	  for (hastName in hastCssPropertyMap) {
	    if (
	      !hasOwnProperty$2.call(hastCssPropertyMap, hastName) ||
	      node.properties[hastName] === undefined
	    ) {
	      continue;
	    }
	    cssName = hastCssPropertyMap[hastName];
	    appendStyle(node, cssName, node.properties[hastName]);
	    delete node.properties[hastName];
	  }
	}

	function appendStyle(node, property, value) {
	  var prevStyle = (node.properties.style || '').trim();
	  if (prevStyle && !/;\s*/.test(prevStyle)) {
	    prevStyle += ';';
	  }
	  if (prevStyle) {
	    prevStyle += ' ';
	  }
	  var nextStyle = prevStyle + property + ': ' + value + ';';
	  node.properties.style = nextStyle;
	}

	var tableCellStyle = /*@__PURE__*/getDefaultExportFromCjs(hastUtilTableCellStyle);

	/**
	 * @param {unknown} thing
	 * @returns {boolean}
	 */
	function whitespace(thing) {
	  /** @type {string} */
	  var value =
	    // @ts-ignore looks like a node.
	    thing && typeof thing === 'object' && thing.type === 'text'
	      ? // @ts-ignore looks like a text.
	        thing.value || ''
	      : thing;

	  // HTML whitespace expression.
	  // See <https://html.spec.whatwg.org/#space-character>.
	  return typeof value === 'string' && value.replace(/[ \t\n\f\r]/g, '') === ''
	}

	/**
	 * @typedef {import('hast').Root} Root
	 * @typedef {import('hast').Element} Element
	 * @typedef {import('react').ReactNode} ReactNode
	 * @typedef {import('react').ReactElement<unknown>} ReactElement
	 *
	 * @callback CreateElementLike
	 * @param {any} name
	 * @param {any} props
	 * @param {...ReactNode} children
	 * @returns {ReactNode}
	 *
	 * @typedef SharedOptions
	 * @property {CreateElementLike} createElement
	 *   How to create elements or components.
	 *   You should typically pass `React.createElement`.
	 * @property {((props: any) => ReactNode)|undefined} [Fragment]
	 *   Create fragments instead of an outer `<div>` if available.
	 *   You should typically pass `React.Fragment`.
	 * @property {string|undefined} [prefix='h-']
	 *   React key prefix
	 *
	 * @typedef {SharedOptions & (import("./complex-types").ComponentsWithNodeOptions|import("./complex-types").ComponentsWithoutNodeOptions)} Options
	 */


	const own$9 = {}.hasOwnProperty;
	const tableElements = new Set([
	  'table',
	  'thead',
	  'tbody',
	  'tfoot',
	  'tr',
	  'th',
	  'td'
	]);

	/**
	 * @type {import('unified').Plugin<[Options], Root, ReactElement>}
	 */
	function rehypeReact(options) {
	  if (!options || typeof options.createElement !== 'function') {
	    throw new TypeError('createElement is not a function')
	  }

	  const createElement = options.createElement;

	  Object.assign(this, {Compiler: compiler});

	  /** @type {import('unified').CompilerFunction<Root, ReactNode>} */
	  function compiler(node) {
	    /** @type {ReactNode} */
	    // @ts-expect-error: assume `name` is a known element.
	    let result = toH(h, tableCellStyle(node), options.prefix);

	    if (node.type === 'root') {
	      // Invert <https://github.com/syntax-tree/hast-to-hyperscript/blob/d227372/index.js#L46-L56>.
	      result =
	        result &&
	        typeof result === 'object' &&
	        'type' in result &&
	        'props' in result &&
	        result.type === 'div' &&
	        (node.children.length !== 1 || node.children[0].type !== 'element')
	          ? // `children` does exist.
	            // type-coverage:ignore-next-line
	            result.props.children
	          : [result];

	      return createElement(options.Fragment || 'div', {}, result)
	    }

	    return result
	  }

	  /**
	   * @param {keyof JSX.IntrinsicElements} name
	   * @param {Record<string, unknown>} props
	   * @param {Array<ReactNode>} [children]
	   * @returns {ReactNode}
	   */
	  function h(name, props, children) {
	    // Currently, a warning is triggered by react for *any* white space in
	    // tables.
	    // So we remove the pretty lines for now.
	    // See: <https://github.com/facebook/react/pull/7081>.
	    // See: <https://github.com/facebook/react/pull/7515>.
	    // See: <https://github.com/remarkjs/remark-react/issues/64>.
	    if (children && tableElements.has(name)) {
	      children = children.filter((child) => !whitespace(child));
	    }

	    if (options.components && own$9.call(options.components, name)) {
	      const component = options.components[name];

	      if (options.passNode && typeof component === 'function') {
	        // @ts-expect-error: `toH` passes the current node.
	        // type-coverage:ignore-next-line
	        props = Object.assign({node: this}, props);
	      }

	      return createElement(component, props, children)
	    }

	    return createElement(name, props, children)
	  }
	}

	/**
	 * @typedef {import('unist').Node} Node
	 * @typedef {import('unist').Parent} Parent
	 * @typedef {import('hast').Element} Element
	 *
	 * @typedef {string} TagName
	 * @typedef {null|undefined|TagName|TestFunctionAnything|Array.<TagName|TestFunctionAnything>} Test
	 */

	/**
	 * @template {Element} T
	 * @typedef {null|undefined|T['tagName']|TestFunctionPredicate<T>|Array.<T['tagName']|TestFunctionPredicate<T>>} PredicateTest
	 */

	/**
	 * Check if an element passes a test
	 *
	 * @callback TestFunctionAnything
	 * @param {Element} element
	 * @param {number|null|undefined} [index]
	 * @param {Parent|null|undefined} [parent]
	 * @returns {boolean|void}
	 */

	/**
	 * Check if an element passes a certain node test
	 *
	 * @template {Element} X
	 * @callback TestFunctionPredicate
	 * @param {Element} element
	 * @param {number|null|undefined} [index]
	 * @param {Parent|null|undefined} [parent]
	 * @returns {element is X}
	 */

	/**
	 * Check if a node is an element and passes a certain node test
	 *
	 * @callback AssertAnything
	 * @param {unknown} [node]
	 * @param {number|null|undefined} [index]
	 * @param {Parent|null|undefined} [parent]
	 * @returns {boolean}
	 */

	/**
	 * Check if a node is an element and passes a certain node test
	 *
	 * @template {Element} Y
	 * @callback AssertPredicate
	 * @param {unknown} [node]
	 * @param {number|null|undefined} [index]
	 * @param {Parent|null|undefined} [parent]
	 * @returns {node is Y}
	 */

	// Check if `node` is an `element` and whether it passes the given test.
	const isElement =
	  /**
	   * Check if a node is an element and passes a test.
	   * When a `parent` node is known the `index` of node should also be given.
	   *
	   * @type {(
	   *   (() => false) &
	   *   (<T extends Element = Element>(node: unknown, test?: PredicateTest<T>, index?: number, parent?: Parent, context?: unknown) => node is T) &
	   *   ((node: unknown, test: Test, index?: number, parent?: Parent, context?: unknown) => boolean)
	   * )}
	   */
	  (
	    /**
	     * Check if a node passes a test.
	     * When a `parent` node is known the `index` of node should also be given.
	     *
	     * @param {unknown} [node] Node to check
	     * @param {Test} [test] When nullish, checks if `node` is a `Node`.
	     * When `string`, works like passing `function (node) {return node.type === test}`.
	     * When `function` checks if function passed the node is true.
	     * When `array`, checks any one of the subtests pass.
	     * @param {number} [index] Position of `node` in `parent`
	     * @param {Parent} [parent] Parent of `node`
	     * @param {unknown} [context] Context object to invoke `test` with
	     * @returns {boolean} Whether test passed and `node` is an `Element` (object with `type` set to `element` and `tagName` set to a non-empty string).
	     */
	    // eslint-disable-next-line max-params
	    function (node, test, index, parent, context) {
	      const check = convertElement(test);

	      // @ts-expect-error Looks like a node.
	      if (!node || !node.type || typeof node.type !== 'string') {
	        return false
	      }

	      return check.call(context, node, index, parent)
	    }
	  );

	const convertElement =
	  /**
	   * @type {(
	   *   (<T extends Element>(test: T['tagName']|TestFunctionPredicate<T>) => AssertPredicate<T>) &
	   *   ((test?: Test) => AssertAnything)
	   * )}
	   */
	  (
	    /**
	     * Generate an assertion from a check.
	     * @param {Test} [test]
	     * When nullish, checks if `node` is a `Node`.
	     * When `string`, works like passing `function (node) {return node.type === test}`.
	     * When `function` checks if function passed the node is true.
	     * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.
	     * When `array`, checks any one of the subtests pass.
	     * @returns {AssertAnything}
	     */
	    function (test) {
	      if (test === undefined || test === null) {
	        return element$2
	      }

	      if (typeof test === 'string') {
	        return tagNameFactory(test)
	      }

	      if (typeof test === 'object') {
	        return anyFactory(test)
	      }

	      if (typeof test === 'function') {
	        return castFactory(test)
	      }

	      throw new Error('Expected function, string, or array as test')
	    }
	  );

	/**
	 * @param {Array.<TagName|TestFunctionAnything>} tests
	 * @returns {AssertAnything}
	 */
	function anyFactory(tests) {
	  /** @type {Array.<AssertAnything>} */
	  const checks = [];
	  let index = -1;

	  while (++index < tests.length) {
	    checks[index] = convertElement(tests[index]);
	  }

	  return castFactory(any)

	  /**
	   * @this {unknown}
	   * @param {unknown[]} parameters
	   * @returns {boolean}
	   */
	  function any(...parameters) {
	    let index = -1;

	    while (++index < checks.length) {
	      if (checks[index].call(this, ...parameters)) {
	        return true
	      }
	    }

	    return false
	  }
	}

	/**
	 * Utility to convert a string into a function which checks a given node’s tag
	 * name for said string.
	 *
	 * @param {TagName} check
	 * @returns {AssertAnything}
	 */
	function tagNameFactory(check) {
	  return tagName

	  /**
	   * @param {unknown} node
	   * @returns {boolean}
	   */
	  function tagName(node) {
	    return element$2(node) && node.tagName === check
	  }
	}

	/**
	 * @param {TestFunctionAnything} check
	 * @returns {AssertAnything}
	 */
	function castFactory(check) {
	  return assertion

	  /**
	   * @this {unknown}
	   * @param {unknown} node
	   * @param {Array.<unknown>} parameters
	   * @returns {boolean}
	   */
	  function assertion(node, ...parameters) {
	    // @ts-expect-error: fine.
	    return element$2(node) && Boolean(check.call(this, node, ...parameters))
	  }
	}

	/**
	 * Utility to return true if this is an element.
	 * @param {unknown} node
	 * @returns {node is Element}
	 */
	function element$2(node) {
	  return Boolean(
	    node &&
	      typeof node === 'object' &&
	      // @ts-expect-error Looks like a node.
	      node.type === 'element' &&
	      // @ts-expect-error Looks like an element.
	      typeof node.tagName === 'string'
	  )
	}

	/**
	 * @typedef {import('../../types.js').Comment} Comment
	 */


	/** @type {import('unist-util-is').AssertPredicate<Comment>} */
	// @ts-ignore
	const comment$1 = convert$5('comment');

	/**
	 * @typedef {import('../../types.js').Parent} Parent
	 * @typedef {import('../../types.js').Child} Child
	 */


	const siblingAfter = siblings(1);
	const siblingBefore = siblings(-1);

	/**
	 * Factory to check siblings in a direction.
	 *
	 * @param {number} increment
	 */
	function siblings(increment) {
	  return sibling

	  /**
	   * Find applicable siblings in a direction.
	   *
	   * @param {Parent} parent
	   * @param {number} index
	   * @param {boolean} [includeWhitespace=false]
	   * @returns {Child}
	   */
	  function sibling(parent, index, includeWhitespace) {
	    const siblings = parent && parent.children;
	    let offset = index + increment;
	    let next = siblings && siblings[offset];

	    if (!includeWhitespace) {
	      while (next && whitespace(next)) {
	        offset += increment;
	        next = siblings[offset];
	      }
	    }

	    return next
	  }
	}

	/**
	 * @typedef {import('../../types.js').Node} Node
	 * @typedef {import('../../types.js').Text} Text
	 */


	/** @type {import('unist-util-is').AssertPredicate<Text>} */
	// @ts-ignore
	const isText = convert$5('text');

	/**
	 * Check if `node` starts with whitespace.
	 *
	 * @param {Node} node
	 * @returns {boolean}
	 */
	function whitespaceStart(node) {
	  return isText(node) && whitespace(node.value.charAt(0))
	}

	/**
	 * @typedef {import('../types.js').OmitHandle} OmitHandle
	 */

	const own$8 = {}.hasOwnProperty;

	/**
	 * Factory to check if a given node can have a tag omitted.
	 *
	 * @param {Object.<string, OmitHandle>} handlers
	 * @returns {OmitHandle}
	 */
	function omission$1(handlers) {
	  return omit

	  /**
	   * Check if a given node can have a tag omitted.
	   *
	   * @type {OmitHandle}
	   */
	  function omit(node, index, parent) {
	    return (
	      own$8.call(handlers, node.tagName) &&
	      handlers[node.tagName](node, index, parent)
	    )
	  }
	}

	/**
	 * @typedef {import('../types.js').OmitHandle} OmitHandle
	 */


	const closing = omission$1({
	  html: html$2,
	  head: headOrColgroupOrCaption,
	  body: body$1,
	  p,
	  li,
	  dt: dt$1,
	  dd,
	  rt: rubyElement,
	  rp: rubyElement,
	  optgroup,
	  option,
	  menuitem,
	  colgroup: headOrColgroupOrCaption,
	  caption: headOrColgroupOrCaption,
	  thead,
	  tbody: tbody$1,
	  tfoot,
	  tr: tr$1,
	  td: cells,
	  th: cells
	});

	/**
	 * Macro for `</head>`, `</colgroup>`, and `</caption>`.
	 *
	 * @type {OmitHandle}
	 */
	function headOrColgroupOrCaption(_, index, parent) {
	  const next = siblingAfter(parent, index, true);
	  return !next || (!comment$1(next) && !whitespaceStart(next))
	}

	/**
	 * Whether to omit `</html>`.
	 *
	 * @type {OmitHandle}
	 */
	function html$2(_, index, parent) {
	  const next = siblingAfter(parent, index);
	  return !next || !comment$1(next)
	}

	/**
	 * Whether to omit `</body>`.
	 *
	 * @type {OmitHandle}
	 */
	function body$1(_, index, parent) {
	  const next = siblingAfter(parent, index);
	  return !next || !comment$1(next)
	}

	/**
	 * Whether to omit `</p>`.
	 *
	 * @type {OmitHandle}
	 */
	function p(_, index, parent) {
	  const next = siblingAfter(parent, index);
	  return next
	    ? isElement(next, [
	        'address',
	        'article',
	        'aside',
	        'blockquote',
	        'details',
	        'div',
	        'dl',
	        'fieldset',
	        'figcaption',
	        'figure',
	        'footer',
	        'form',
	        'h1',
	        'h2',
	        'h3',
	        'h4',
	        'h5',
	        'h6',
	        'header',
	        'hgroup',
	        'hr',
	        'main',
	        'menu',
	        'nav',
	        'ol',
	        'p',
	        'pre',
	        'section',
	        'table',
	        'ul'
	      ])
	    : !parent ||
	        // Confusing parent.
	        !isElement(parent, [
	          'a',
	          'audio',
	          'del',
	          'ins',
	          'map',
	          'noscript',
	          'video'
	        ])
	}

	/**
	 * Whether to omit `</li>`.
	 *
	 * @type {OmitHandle}
	 */
	function li(_, index, parent) {
	  const next = siblingAfter(parent, index);
	  return !next || isElement(next, 'li')
	}

	/**
	 * Whether to omit `</dt>`.
	 *
	 * @type {OmitHandle}
	 */
	function dt$1(_, index, parent) {
	  const next = siblingAfter(parent, index);
	  return next && isElement(next, ['dt', 'dd'])
	}

	/**
	 * Whether to omit `</dd>`.
	 *
	 * @type {OmitHandle}
	 */
	function dd(_, index, parent) {
	  const next = siblingAfter(parent, index);
	  return !next || isElement(next, ['dt', 'dd'])
	}

	/**
	 * Whether to omit `</rt>` or `</rp>`.
	 *
	 * @type {OmitHandle}
	 */
	function rubyElement(_, index, parent) {
	  const next = siblingAfter(parent, index);
	  return !next || isElement(next, ['rp', 'rt'])
	}

	/**
	 * Whether to omit `</optgroup>`.
	 *
	 * @type {OmitHandle}
	 */
	function optgroup(_, index, parent) {
	  const next = siblingAfter(parent, index);
	  return !next || isElement(next, 'optgroup')
	}

	/**
	 * Whether to omit `</option>`.
	 *
	 * @type {OmitHandle}
	 */
	function option(_, index, parent) {
	  const next = siblingAfter(parent, index);
	  return !next || isElement(next, ['option', 'optgroup'])
	}

	/**
	 * Whether to omit `</menuitem>`.
	 *
	 * @type {OmitHandle}
	 */
	function menuitem(_, index, parent) {
	  const next = siblingAfter(parent, index);
	  return !next || isElement(next, ['menuitem', 'hr', 'menu'])
	}

	/**
	 * Whether to omit `</thead>`.
	 *
	 * @type {OmitHandle}
	 */
	function thead(_, index, parent) {
	  const next = siblingAfter(parent, index);
	  return next && isElement(next, ['tbody', 'tfoot'])
	}

	/**
	 * Whether to omit `</tbody>`.
	 *
	 * @type {OmitHandle}
	 */
	function tbody$1(_, index, parent) {
	  const next = siblingAfter(parent, index);
	  return !next || isElement(next, ['tbody', 'tfoot'])
	}

	/**
	 * Whether to omit `</tfoot>`.
	 *
	 * @type {OmitHandle}
	 */
	function tfoot(_, index, parent) {
	  return !siblingAfter(parent, index)
	}

	/**
	 * Whether to omit `</tr>`.
	 *
	 * @type {OmitHandle}
	 */
	function tr$1(_, index, parent) {
	  const next = siblingAfter(parent, index);
	  return !next || isElement(next, 'tr')
	}

	/**
	 * Whether to omit `</td>` or `</th>`.
	 *
	 * @type {OmitHandle}
	 */
	function cells(_, index, parent) {
	  const next = siblingAfter(parent, index);
	  return !next || isElement(next, ['td', 'th'])
	}

	/**
	 * @typedef {import('../types.js').OmitHandle} OmitHandle
	 * @typedef {import('../types.js').Child} Child
	 */


	const opening = omission$1({
	  html: html$1,
	  head,
	  body,
	  colgroup,
	  tbody
	});

	/**
	 * Whether to omit `<html>`.
	 *
	 * @type {OmitHandle}
	 */
	function html$1(node) {
	  const head = siblingAfter(node, -1);
	  return !head || !comment$1(head)
	}

	/**
	 * Whether to omit `<head>`.
	 *
	 * @type {OmitHandle}
	 */
	function head(node) {
	  const children = node.children;
	  /** @type {Array.<string>} */
	  const seen = [];
	  let index = -1;
	  /** @type {Child} */
	  let child;

	  while (++index < children.length) {
	    child = children[index];
	    if (isElement(child, ['title', 'base'])) {
	      if (seen.includes(child.tagName)) return false
	      seen.push(child.tagName);
	    }
	  }

	  return children.length > 0
	}

	/**
	 * Whether to omit `<body>`.
	 *
	 * @type {OmitHandle}
	 */
	function body(node) {
	  const head = siblingAfter(node, -1, true);

	  return (
	    !head ||
	    (!comment$1(head) &&
	      !whitespaceStart(head) &&
	      !isElement(head, ['meta', 'link', 'script', 'style', 'template']))
	  )
	}

	/**
	 * Whether to omit `<colgroup>`.
	 * The spec describes some logic for the opening tag, but it’s easier to
	 * implement in the closing tag, to the same effect, so we handle it there
	 * instead.
	 *
	 * @type {OmitHandle}
	 */
	function colgroup(node, index, parent) {
	  const previous = siblingBefore(parent, index);
	  const head = siblingAfter(node, -1, true);

	  // Previous colgroup was already omitted.
	  if (
	    isElement(previous, 'colgroup') &&
	    closing(previous, parent.children.indexOf(previous), parent)
	  ) {
	    return false
	  }

	  return head && isElement(head, 'col')
	}

	/**
	 * Whether to omit `<tbody>`.
	 *
	 * @type {OmitHandle}
	 */
	function tbody(node, index, parent) {
	  const previous = siblingBefore(parent, index);
	  const head = siblingAfter(node, -1);

	  // Previous table section was already omitted.
	  if (
	    isElement(previous, ['thead', 'tbody']) &&
	    closing(previous, parent.children.indexOf(previous), parent)
	  ) {
	    return false
	  }

	  return head && isElement(head, 'tr')
	}

	/**
	 * @typedef {import('../types.js').Omission} Omission
	 */


	/** @type {Omission} */
	const omission = {opening, closing};

	/**
	 * @typedef {Object} CoreOptions
	 * @property {string[]} [subset=[]]
	 *   Whether to only escape the given subset of characters.
	 * @property {boolean} [escapeOnly=false]
	 *   Whether to only escape possibly dangerous characters.
	 *   Those characters are `"`, `&`, `'`, `<`, `>`, and `` ` ``.
	 *
	 * @typedef {Object} FormatOptions
	 * @property {(code: number, next: number, options: CoreWithFormatOptions) => string} format
	 *   Format strategy.
	 *
	 * @typedef {CoreOptions & FormatOptions & import('./util/format-smart.js').FormatSmartOptions} CoreWithFormatOptions
	 */

	/**
	 * Encode certain characters in `value`.
	 *
	 * @param {string} value
	 * @param {CoreWithFormatOptions} options
	 * @returns {string}
	 */
	function core(value, options) {
	  value = value.replace(
	    options.subset ? charactersToExpression(options.subset) : /["&'<>`]/g,
	    basic
	  );

	  if (options.subset || options.escapeOnly) {
	    return value
	  }

	  return (
	    value
	      // Surrogate pairs.
	      .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, surrogate)
	      // BMP control characters (C0 except for LF, CR, SP; DEL; and some more
	      // non-ASCII ones).
	      .replace(
	        // eslint-disable-next-line no-control-regex, unicorn/no-hex-escape
	        /[\x01-\t\v\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g,
	        basic
	      )
	  )

	  /**
	   * @param {string} pair
	   * @param {number} index
	   * @param {string} all
	   */
	  function surrogate(pair, index, all) {
	    return options.format(
	      (pair.charCodeAt(0) - 0xd800) * 0x400 +
	        pair.charCodeAt(1) -
	        0xdc00 +
	        0x10000,
	      all.charCodeAt(index + 2),
	      options
	    )
	  }

	  /**
	   * @param {string} character
	   * @param {number} index
	   * @param {string} all
	   */
	  function basic(character, index, all) {
	    return options.format(
	      character.charCodeAt(0),
	      all.charCodeAt(index + 1),
	      options
	    )
	  }
	}

	/**
	 * @param {string[]} subset
	 * @returns {RegExp}
	 */
	function charactersToExpression(subset) {
	  /** @type {string[]} */
	  const groups = [];
	  let index = -1;

	  while (++index < subset.length) {
	    groups.push(subset[index].replace(/[|\\{}()[\]^$+*?.]/g, '\\$&'));
	  }

	  return new RegExp('(?:' + groups.join('|') + ')', 'g')
	}

	/**
	 * Configurable ways to encode characters as hexadecimal references.
	 *
	 * @param {number} code
	 * @param {number} next
	 * @param {boolean|undefined} omit
	 * @returns {string}
	 */
	function toHexadecimal(code, next, omit) {
	  const value = '&#x' + code.toString(16).toUpperCase();
	  return omit && next && !/[\dA-Fa-f]/.test(String.fromCharCode(next))
	    ? value
	    : value + ';'
	}

	/**
	 * Configurable ways to encode characters as decimal references.
	 *
	 * @param {number} code
	 * @param {number} next
	 * @param {boolean|undefined} omit
	 * @returns {string}
	 */
	function toDecimal(code, next, omit) {
	  const value = '&#' + String(code);
	  return omit && next && !/\d/.test(String.fromCharCode(next))
	    ? value
	    : value + ';'
	}

	/**
	 * List of legacy HTML named character references that don’t need a trailing semicolon.
	 *
	 * @type {Array<string>}
	 */
	const characterEntitiesLegacy = [
	  'AElig',
	  'AMP',
	  'Aacute',
	  'Acirc',
	  'Agrave',
	  'Aring',
	  'Atilde',
	  'Auml',
	  'COPY',
	  'Ccedil',
	  'ETH',
	  'Eacute',
	  'Ecirc',
	  'Egrave',
	  'Euml',
	  'GT',
	  'Iacute',
	  'Icirc',
	  'Igrave',
	  'Iuml',
	  'LT',
	  'Ntilde',
	  'Oacute',
	  'Ocirc',
	  'Ograve',
	  'Oslash',
	  'Otilde',
	  'Ouml',
	  'QUOT',
	  'REG',
	  'THORN',
	  'Uacute',
	  'Ucirc',
	  'Ugrave',
	  'Uuml',
	  'Yacute',
	  'aacute',
	  'acirc',
	  'acute',
	  'aelig',
	  'agrave',
	  'amp',
	  'aring',
	  'atilde',
	  'auml',
	  'brvbar',
	  'ccedil',
	  'cedil',
	  'cent',
	  'copy',
	  'curren',
	  'deg',
	  'divide',
	  'eacute',
	  'ecirc',
	  'egrave',
	  'eth',
	  'euml',
	  'frac12',
	  'frac14',
	  'frac34',
	  'gt',
	  'iacute',
	  'icirc',
	  'iexcl',
	  'igrave',
	  'iquest',
	  'iuml',
	  'laquo',
	  'lt',
	  'macr',
	  'micro',
	  'middot',
	  'nbsp',
	  'not',
	  'ntilde',
	  'oacute',
	  'ocirc',
	  'ograve',
	  'ordf',
	  'ordm',
	  'oslash',
	  'otilde',
	  'ouml',
	  'para',
	  'plusmn',
	  'pound',
	  'quot',
	  'raquo',
	  'reg',
	  'sect',
	  'shy',
	  'sup1',
	  'sup2',
	  'sup3',
	  'szlig',
	  'thorn',
	  'times',
	  'uacute',
	  'ucirc',
	  'ugrave',
	  'uml',
	  'uuml',
	  'yacute',
	  'yen',
	  'yuml'
	];

	/**
	 * Map of named character references from HTML 4.
	 *
	 * @type {Record<string, string>}
	 */
	const characterEntitiesHtml4 = {
	  nbsp: ' ',
	  iexcl: '¡',
	  cent: '¢',
	  pound: '£',
	  curren: '¤',
	  yen: '¥',
	  brvbar: '¦',
	  sect: '§',
	  uml: '¨',
	  copy: '©',
	  ordf: 'ª',
	  laquo: '«',
	  not: '¬',
	  shy: '­',
	  reg: '®',
	  macr: '¯',
	  deg: '°',
	  plusmn: '±',
	  sup2: '²',
	  sup3: '³',
	  acute: '´',
	  micro: 'µ',
	  para: '¶',
	  middot: '·',
	  cedil: '¸',
	  sup1: '¹',
	  ordm: 'º',
	  raquo: '»',
	  frac14: '¼',
	  frac12: '½',
	  frac34: '¾',
	  iquest: '¿',
	  Agrave: 'À',
	  Aacute: 'Á',
	  Acirc: 'Â',
	  Atilde: 'Ã',
	  Auml: 'Ä',
	  Aring: 'Å',
	  AElig: 'Æ',
	  Ccedil: 'Ç',
	  Egrave: 'È',
	  Eacute: 'É',
	  Ecirc: 'Ê',
	  Euml: 'Ë',
	  Igrave: 'Ì',
	  Iacute: 'Í',
	  Icirc: 'Î',
	  Iuml: 'Ï',
	  ETH: 'Ð',
	  Ntilde: 'Ñ',
	  Ograve: 'Ò',
	  Oacute: 'Ó',
	  Ocirc: 'Ô',
	  Otilde: 'Õ',
	  Ouml: 'Ö',
	  times: '×',
	  Oslash: 'Ø',
	  Ugrave: 'Ù',
	  Uacute: 'Ú',
	  Ucirc: 'Û',
	  Uuml: 'Ü',
	  Yacute: 'Ý',
	  THORN: 'Þ',
	  szlig: 'ß',
	  agrave: 'à',
	  aacute: 'á',
	  acirc: 'â',
	  atilde: 'ã',
	  auml: 'ä',
	  aring: 'å',
	  aelig: 'æ',
	  ccedil: 'ç',
	  egrave: 'è',
	  eacute: 'é',
	  ecirc: 'ê',
	  euml: 'ë',
	  igrave: 'ì',
	  iacute: 'í',
	  icirc: 'î',
	  iuml: 'ï',
	  eth: 'ð',
	  ntilde: 'ñ',
	  ograve: 'ò',
	  oacute: 'ó',
	  ocirc: 'ô',
	  otilde: 'õ',
	  ouml: 'ö',
	  divide: '÷',
	  oslash: 'ø',
	  ugrave: 'ù',
	  uacute: 'ú',
	  ucirc: 'û',
	  uuml: 'ü',
	  yacute: 'ý',
	  thorn: 'þ',
	  yuml: 'ÿ',
	  fnof: 'ƒ',
	  Alpha: 'Α',
	  Beta: 'Β',
	  Gamma: 'Γ',
	  Delta: 'Δ',
	  Epsilon: 'Ε',
	  Zeta: 'Ζ',
	  Eta: 'Η',
	  Theta: 'Θ',
	  Iota: 'Ι',
	  Kappa: 'Κ',
	  Lambda: 'Λ',
	  Mu: 'Μ',
	  Nu: 'Ν',
	  Xi: 'Ξ',
	  Omicron: 'Ο',
	  Pi: 'Π',
	  Rho: 'Ρ',
	  Sigma: 'Σ',
	  Tau: 'Τ',
	  Upsilon: 'Υ',
	  Phi: 'Φ',
	  Chi: 'Χ',
	  Psi: 'Ψ',
	  Omega: 'Ω',
	  alpha: 'α',
	  beta: 'β',
	  gamma: 'γ',
	  delta: 'δ',
	  epsilon: 'ε',
	  zeta: 'ζ',
	  eta: 'η',
	  theta: 'θ',
	  iota: 'ι',
	  kappa: 'κ',
	  lambda: 'λ',
	  mu: 'μ',
	  nu: 'ν',
	  xi: 'ξ',
	  omicron: 'ο',
	  pi: 'π',
	  rho: 'ρ',
	  sigmaf: 'ς',
	  sigma: 'σ',
	  tau: 'τ',
	  upsilon: 'υ',
	  phi: 'φ',
	  chi: 'χ',
	  psi: 'ψ',
	  omega: 'ω',
	  thetasym: 'ϑ',
	  upsih: 'ϒ',
	  piv: 'ϖ',
	  bull: '•',
	  hellip: '…',
	  prime: '′',
	  Prime: '″',
	  oline: '‾',
	  frasl: '⁄',
	  weierp: '℘',
	  image: 'ℑ',
	  real: 'ℜ',
	  trade: '™',
	  alefsym: 'ℵ',
	  larr: '←',
	  uarr: '↑',
	  rarr: '→',
	  darr: '↓',
	  harr: '↔',
	  crarr: '↵',
	  lArr: '⇐',
	  uArr: '⇑',
	  rArr: '⇒',
	  dArr: '⇓',
	  hArr: '⇔',
	  forall: '∀',
	  part: '∂',
	  exist: '∃',
	  empty: '∅',
	  nabla: '∇',
	  isin: '∈',
	  notin: '∉',
	  ni: '∋',
	  prod: '∏',
	  sum: '∑',
	  minus: '−',
	  lowast: '∗',
	  radic: '√',
	  prop: '∝',
	  infin: '∞',
	  ang: '∠',
	  and: '∧',
	  or: '∨',
	  cap: '∩',
	  cup: '∪',
	  int: '∫',
	  there4: '∴',
	  sim: '∼',
	  cong: '≅',
	  asymp: '≈',
	  ne: '≠',
	  equiv: '≡',
	  le: '≤',
	  ge: '≥',
	  sub: '⊂',
	  sup: '⊃',
	  nsub: '⊄',
	  sube: '⊆',
	  supe: '⊇',
	  oplus: '⊕',
	  otimes: '⊗',
	  perp: '⊥',
	  sdot: '⋅',
	  lceil: '⌈',
	  rceil: '⌉',
	  lfloor: '⌊',
	  rfloor: '⌋',
	  lang: '〈',
	  rang: '〉',
	  loz: '◊',
	  spades: '♠',
	  clubs: '♣',
	  hearts: '♥',
	  diams: '♦',
	  quot: '"',
	  amp: '&',
	  lt: '<',
	  gt: '>',
	  OElig: 'Œ',
	  oelig: 'œ',
	  Scaron: 'Š',
	  scaron: 'š',
	  Yuml: 'Ÿ',
	  circ: 'ˆ',
	  tilde: '˜',
	  ensp: ' ',
	  emsp: ' ',
	  thinsp: ' ',
	  zwnj: '‌',
	  zwj: '‍',
	  lrm: '‎',
	  rlm: '‏',
	  ndash: '–',
	  mdash: '—',
	  lsquo: '‘',
	  rsquo: '’',
	  sbquo: '‚',
	  ldquo: '“',
	  rdquo: '”',
	  bdquo: '„',
	  dagger: '†',
	  Dagger: '‡',
	  permil: '‰',
	  lsaquo: '‹',
	  rsaquo: '›',
	  euro: '€'
	};

	/**
	 * List of legacy (that don’t need a trailing `;`) named references which could,
	 * depending on what follows them, turn into a different meaning
	 *
	 * @type {Array.<string>}
	 */
	const dangerous = [
	  'cent',
	  'copy',
	  'divide',
	  'gt',
	  'lt',
	  'not',
	  'para',
	  'times'
	];

	const own$7 = {}.hasOwnProperty;

	/**
	 * `characterEntitiesHtml4` but inverted.
	 *
	 * @type {Object.<string, string>}
	 */
	const characters = {};

	/** @type {string} */
	let key;

	for (key in characterEntitiesHtml4) {
	  if (own$7.call(characterEntitiesHtml4, key)) {
	    characters[characterEntitiesHtml4[key]] = key;
	  }
	}

	/**
	 * Configurable ways to encode characters as named references.
	 *
	 * @param {number} code
	 * @param {number} next
	 * @param {boolean|undefined} omit
	 * @param {boolean|undefined} attribute
	 * @returns {string}
	 */
	function toNamed(code, next, omit, attribute) {
	  const character = String.fromCharCode(code);

	  if (own$7.call(characters, character)) {
	    const name = characters[character];
	    const value = '&' + name;

	    if (
	      omit &&
	      characterEntitiesLegacy.includes(name) &&
	      !dangerous.includes(name) &&
	      (!attribute ||
	        (next &&
	          next !== 61 /* `=` */ &&
	          /[^\da-z]/i.test(String.fromCharCode(next))))
	    ) {
	      return value
	    }

	    return value + ';'
	  }

	  return ''
	}

	/**
	 * @typedef {Object} FormatSmartOptions
	 * @property {boolean} [useNamedReferences=false]
	 *   Prefer named character references (`&amp;`) where possible.
	 * @property {boolean} [useShortestReferences=false]
	 *   Prefer the shortest possible reference, if that results in less bytes.
	 *   **Note**: `useNamedReferences` can be omitted when using `useShortestReferences`.
	 * @property {boolean} [omitOptionalSemicolons=false]
	 *   Whether to omit semicolons when possible.
	 *   **Note**: This creates what HTML calls “parse errors” but is otherwise still valid HTML — don’t use this except when building a minifier.
	 *   Omitting semicolons is possible for certain named and numeric references in some cases.
	 * @property {boolean} [attribute=false]
	 *   Create character references which don’t fail in attributes.
	 *   **Note**: `attribute` only applies when operating dangerously with
	 *   `omitOptionalSemicolons: true`.
	 */


	/**
	 * Configurable ways to encode a character yielding pretty or small results.
	 *
	 * @param {number} code
	 * @param {number} next
	 * @param {FormatSmartOptions} options
	 * @returns {string}
	 */
	function formatSmart(code, next, options) {
	  let numeric = toHexadecimal(code, next, options.omitOptionalSemicolons);
	  /** @type {string|undefined} */
	  let named;

	  if (options.useNamedReferences || options.useShortestReferences) {
	    named = toNamed(
	      code,
	      next,
	      options.omitOptionalSemicolons,
	      options.attribute
	    );
	  }

	  // Use the shortest numeric reference when requested.
	  // A simple algorithm would use decimal for all code points under 100, as
	  // those are shorter than hexadecimal:
	  //
	  // * `&#99;` vs `&#x63;` (decimal shorter)
	  // * `&#100;` vs `&#x64;` (equal)
	  //
	  // However, because we take `next` into consideration when `omit` is used,
	  // And it would be possible that decimals are shorter on bigger values as
	  // well if `next` is hexadecimal but not decimal, we instead compare both.
	  if (
	    (options.useShortestReferences || !named) &&
	    options.useShortestReferences
	  ) {
	    const decimal = toDecimal(code, next, options.omitOptionalSemicolons);

	    if (decimal.length < numeric.length) {
	      numeric = decimal;
	    }
	  }

	  return named &&
	    (!options.useShortestReferences || named.length < numeric.length)
	    ? named
	    : numeric
	}

	/**
	 * @typedef {import('./core.js').CoreOptions & import('./util/format-smart.js').FormatSmartOptions} Options
	 * @typedef {import('./core.js').CoreOptions} LightOptions
	 */


	/**
	 * Encode special characters in `value`.
	 *
	 * @param {string} value
	 *   Value to encode.
	 * @param {Options} [options]
	 *   Configuration.
	 * @returns {string}
	 *   Encoded value.
	 */
	function stringifyEntities(value, options) {
	  return core(value, Object.assign({format: formatSmart}, options))
	}

	/**
	 * Count how often a character (or substring) is used in a string.
	 *
	 * @param {string} value
	 *   Value to search in.
	 * @param {string} character
	 *   Character (or substring) to look for.
	 * @return {number}
	 *   Number of times `character` occurred in `value`.
	 */
	function ccount(value, character) {
	  const source = String(value);

	  if (typeof character !== 'string') {
	    throw new TypeError('Expected character')
	  }

	  let count = 0;
	  let index = source.indexOf(character);

	  while (index !== -1) {
	    count++;
	    index = source.indexOf(character, index + character.length);
	  }

	  return count
	}

	// Maps of subsets.
	// Each value is a matrix of tuples.
	// The first value causes parse errors, the second is valid.
	// Of both values, the first value is unsafe, and the second is safe.
	const constants = {
	  // See: <https://html.spec.whatwg.org/#attribute-name-state>.
	  name: [
	    ['\t\n\f\r &/=>'.split(''), '\t\n\f\r "&\'/=>`'.split('')],
	    ['\0\t\n\f\r "&\'/<=>'.split(''), '\0\t\n\f\r "&\'/<=>`'.split('')]
	  ],
	  // See: <https://html.spec.whatwg.org/#attribute-value-(unquoted)-state>.
	  unquoted: [
	    ['\t\n\f\r &>'.split(''), '\0\t\n\f\r "&\'<=>`'.split('')],
	    ['\0\t\n\f\r "&\'<=>`'.split(''), '\0\t\n\f\r "&\'<=>`'.split('')]
	  ],
	  // See: <https://html.spec.whatwg.org/#attribute-value-(single-quoted)-state>.
	  single: [
	    ["&'".split(''), '"&\'`'.split('')],
	    ["\0&'".split(''), '\0"&\'`'.split('')]
	  ],
	  // See: <https://html.spec.whatwg.org/#attribute-value-(double-quoted)-state>.
	  double: [
	    ['"&'.split(''), '"&\'`'.split('')],
	    ['\0"&'.split(''), '\0"&\'`'.split('')]
	  ]
	};

	/**
	 * @typedef {import('./types.js').Handle} Handle
	 * @typedef {import('./types.js').Comment} Comment
	 */


	/**
	 * @type {Handle}
	 * @param {Comment} node
	 */
	function comment(ctx, node) {
	  // See: <https://html.spec.whatwg.org/multipage/syntax.html#comments>
	  return ctx.bogusComments
	    ? '<?' +
	        stringifyEntities(
	          node.value,
	          Object.assign({}, ctx.entities, {subset: ['>']})
	        ) +
	        '>'
	    : '<!--' + node.value.replace(/^>|^->|<!--|-->|--!>|<!-$/g, encode) + '-->'

	  /**
	   * @param {string} $0
	   */
	  function encode($0) {
	    return stringifyEntities(
	      $0,
	      Object.assign({}, ctx.entities, {subset: ['<', '>']})
	    )
	  }
	}

	/**
	 * @typedef {import('./types.js').Handle} Handle
	 */

	/**
	 * @type {Handle}
	 */
	function doctype(ctx) {
	  return (
	    '<!' +
	    (ctx.upperDoctype ? 'DOCTYPE' : 'doctype') +
	    (ctx.tightDoctype ? '' : ' ') +
	    'html>'
	  )
	}

	/**
	 * @typedef {import('./types.js').Handle} Handle
	 * @typedef {import('./types.js').Text} Text
	 */


	/**
	 * @type {Handle}
	 * @param {Text} node
	 */
	function text$4(ctx, node, _, parent) {
	  // Check if content of `node` should be escaped.
	  return parent &&
	    parent.type === 'element' &&
	    // @ts-expect-error: hush.
	    (parent.tagName === 'script' || parent.tagName === 'style')
	    ? node.value
	    : stringifyEntities(
	        node.value,
	        Object.assign({}, ctx.entities, {subset: ['<', '&']})
	      )
	}

	/**
	 * @typedef {import('./types.js').Handle} Handle
	 * @typedef {import('./types.js').Raw} Raw
	 */


	/**
	 * @type {Handle}
	 * @param {Raw} node
	 */
	function raw(ctx, node, index, parent) {
	  // @ts-ignore Hush.
	  return ctx.dangerous ? node.value : text$4(ctx, node, index, parent)
	}

	/**
	 * @typedef {import('./types.js').Handle} Handle
	 * @typedef {import('./types.js').Element} Element
	 * @typedef {import('./types.js').Context} Context
	 * @typedef {import('./types.js').Properties} Properties
	 * @typedef {import('./types.js').PropertyValue} PropertyValue
	 * @typedef {import('./types.js').Parent} Parent
	 */


	/**
	 * @type {Object.<string, Handle>}
	 */
	const handlers$1 = {
	  comment,
	  doctype,
	  element: element$1,
	  // @ts-ignore `raw` is nonstandard
	  raw,
	  // @ts-ignore `root` is a parent.
	  root: all$2,
	  text: text$4
	};

	const own$6 = {}.hasOwnProperty;

	/**
	 * @type {Handle}
	 */
	function one$2(ctx, node, index, parent) {
	  if (!node || !node.type) {
	    throw new Error('Expected node, not `' + node + '`')
	  }

	  if (!own$6.call(handlers$1, node.type)) {
	    throw new Error('Cannot compile unknown node `' + node.type + '`')
	  }

	  return handlers$1[node.type](ctx, node, index, parent)
	}

	/**
	 * Serialize all children of `parent`.
	 *
	 * @type {Handle}
	 * @param {Parent} parent
	 */
	function all$2(ctx, parent) {
	  /** @type {Array.<string>} */
	  const results = [];
	  const children = (parent && parent.children) || [];
	  let index = -1;

	  while (++index < children.length) {
	    results[index] = one$2(ctx, children[index], index, parent);
	  }

	  return results.join('')
	}

	/**
	 * @type {Handle}
	 * @param {Element} node
	 */
	// eslint-disable-next-line complexity
	function element$1(ctx, node, index, parent) {
	  const schema = ctx.schema;
	  const omit = schema.space === 'svg' ? undefined : ctx.omit;
	  let selfClosing =
	    schema.space === 'svg'
	      ? ctx.closeEmpty
	      : ctx.voids.includes(node.tagName.toLowerCase());
	  /** @type {Array.<string>} */
	  const parts = [];
	  /** @type {string} */
	  let last;

	  if (schema.space === 'html' && node.tagName === 'svg') {
	    ctx.schema = svg;
	  }

	  const attrs = serializeAttributes(ctx, node.properties);

	  const content = all$2(
	    ctx,
	    schema.space === 'html' && node.tagName === 'template' ? node.content : node
	  );

	  ctx.schema = schema;

	  // If the node is categorised as void, but it has children, remove the
	  // categorisation.
	  // This enables for example `menuitem`s, which are void in W3C HTML but not
	  // void in WHATWG HTML, to be stringified properly.
	  if (content) selfClosing = false;

	  if (attrs || !omit || !omit.opening(node, index, parent)) {
	    parts.push('<', node.tagName, attrs ? ' ' + attrs : '');

	    if (selfClosing && (schema.space === 'svg' || ctx.close)) {
	      last = attrs.charAt(attrs.length - 1);
	      if (
	        !ctx.tightClose ||
	        last === '/' ||
	        (last && last !== '"' && last !== "'")
	      ) {
	        parts.push(' ');
	      }

	      parts.push('/');
	    }

	    parts.push('>');
	  }

	  parts.push(content);

	  if (!selfClosing && (!omit || !omit.closing(node, index, parent))) {
	    parts.push('</' + node.tagName + '>');
	  }

	  return parts.join('')
	}

	/**
	 * @param {Context} ctx
	 * @param {Properties} props
	 * @returns {string}
	 */
	function serializeAttributes(ctx, props) {
	  /** @type {Array.<string>} */
	  const values = [];
	  let index = -1;
	  /** @type {string} */
	  let key;
	  /** @type {string} */
	  let value;
	  /** @type {string} */
	  let last;

	  for (key in props) {
	    if (props[key] !== undefined && props[key] !== null) {
	      value = serializeAttribute(ctx, key, props[key]);
	      if (value) values.push(value);
	    }
	  }

	  while (++index < values.length) {
	    last = ctx.tight ? values[index].charAt(values[index].length - 1) : null;

	    // In tight mode, don’t add a space after quoted attributes.
	    if (index !== values.length - 1 && last !== '"' && last !== "'") {
	      values[index] += ' ';
	    }
	  }

	  return values.join('')
	}

	/**
	 * @param {Context} ctx
	 * @param {string} key
	 * @param {PropertyValue} value
	 * @returns {string}
	 */
	// eslint-disable-next-line complexity
	function serializeAttribute(ctx, key, value) {
	  const info = find$1(ctx.schema, key);
	  let quote = ctx.quote;
	  /** @type {string} */
	  let result;

	  if (info.overloadedBoolean && (value === info.attribute || value === '')) {
	    value = true;
	  } else if (
	    info.boolean ||
	    (info.overloadedBoolean && typeof value !== 'string')
	  ) {
	    value = Boolean(value);
	  }

	  if (
	    value === undefined ||
	    value === null ||
	    value === false ||
	    (typeof value === 'number' && Number.isNaN(value))
	  ) {
	    return ''
	  }

	  const name = stringifyEntities(
	    info.attribute,
	    Object.assign({}, ctx.entities, {
	      // Always encode without parse errors in non-HTML.
	      subset:
	        constants.name[ctx.schema.space === 'html' ? ctx.valid : 1][ctx.safe]
	    })
	  );

	  // No value.
	  // There is currently only one boolean property in SVG: `[download]` on
	  // `<a>`.
	  // This property does not seem to work in browsers (FF, Sa, Ch), so I can’t
	  // test if dropping the value works.
	  // But I assume that it should:
	  //
	  // ```html
	  // <!doctype html>
	  // <svg viewBox="0 0 100 100">
	  //   <a href=https://example.com download>
	  //     <circle cx=50 cy=40 r=35 />
	  //   </a>
	  // </svg>
	  // ```
	  //
	  // See: <https://github.com/wooorm/property-information/blob/main/lib/svg.js>
	  if (value === true) return name

	  value =
	    typeof value === 'object' && 'length' in value
	      ? // `spaces` doesn’t accept a second argument, but it’s given here just to
	        // keep the code cleaner.
	        (info.commaSeparated ? stringify : stringify$1)(value, {
	          padLeft: !ctx.tightLists
	        })
	      : String(value);

	  if (ctx.collapseEmpty && !value) return name

	  // Check unquoted value.
	  if (ctx.unquoted) {
	    result = stringifyEntities(
	      value,
	      Object.assign({}, ctx.entities, {
	        subset: constants.unquoted[ctx.valid][ctx.safe],
	        attribute: true
	      })
	    );
	  }

	  // If we don’t want unquoted, or if `value` contains character references when
	  // unquoted…
	  if (result !== value) {
	    // If the alternative is less common than `quote`, switch.
	    if (ctx.smart && ccount(value, quote) > ccount(value, ctx.alternative)) {
	      quote = ctx.alternative;
	    }

	    result =
	      quote +
	      stringifyEntities(
	        value,
	        Object.assign({}, ctx.entities, {
	          // Always encode without parse errors in non-HTML.
	          subset: (quote === "'" ? constants.single : constants.double)[
	            ctx.schema.space === 'html' ? ctx.valid : 1
	          ][ctx.safe],
	          attribute: true
	        })
	      ) +
	      quote;
	  }

	  // Don’t add a `=` for unquoted empties.
	  return name + (result ? '=' + result : result)
	}

	/**
	 * @typedef {import('./types.js').Node} Node
	 * @typedef {import('./types.js').Options} Options
	 * @typedef {import('./types.js').Context} Context
	 * @typedef {import('./types.js').Quote} Quote
	 */


	/**
	 * @param {Node|Array.<Node>} node
	 * @param {Options} [options]
	 * @returns {string}
	 */
	function toHtml(node, options = {}) {
	  const quote = options.quote || '"';
	  /** @type {Quote} */
	  const alternative = quote === '"' ? "'" : '"';

	  if (quote !== '"' && quote !== "'") {
	    throw new Error('Invalid quote `' + quote + '`, expected `\'` or `"`')
	  }

	  /** @type {Context} */
	  const context = {
	    valid: options.allowParseErrors ? 0 : 1,
	    safe: options.allowDangerousCharacters ? 0 : 1,
	    schema: options.space === 'svg' ? svg : html$3,
	    omit: options.omitOptionalTags ? omission : undefined,
	    quote,
	    alternative,
	    smart: options.quoteSmart,
	    unquoted: options.preferUnquoted,
	    tight: options.tightAttributes,
	    upperDoctype: options.upperDoctype,
	    tightDoctype: options.tightDoctype,
	    bogusComments: options.bogusComments,
	    tightLists: options.tightCommaSeparatedLists,
	    tightClose: options.tightSelfClosing,
	    collapseEmpty: options.collapseEmptyAttributes,
	    dangerous: options.allowDangerousHtml,
	    voids: options.voids || htmlVoidElements.concat(),
	    entities: options.entities || {},
	    close: options.closeSelfClosing,
	    closeEmpty: options.closeEmptyElements
	  };

	  return one$2(
	    context,
	    // @ts-ignore Assume `node` does not contain a root.
	    Array.isArray(node) ? {type: 'root', children: node} : node,
	    null,
	    null
	  )
	}

	/**
	 * @typedef {import('hast').Root} Root
	 * @typedef {Root|Root['children'][number]} Node
	 * @typedef {import('hast-util-to-html').Options} Options
	 */


	/** @type {import('unified').Plugin<[Options?]|Array<void>, Node, string>} */
	function rehypeStringify(config) {
	  const processorSettings = /** @type {Options} */ (this.data('settings'));
	  const settings = Object.assign({}, processorSettings, config);

	  Object.assign(this, {Compiler: compiler});

	  /**
	   * @type {import('unified').CompilerFunction<Node, string>}
	   */
	  function compiler(tree) {
	    return toHtml(tree, settings)
	  }
	}

	function escapeStringRegexp(string) {
		if (typeof string !== 'string') {
			throw new TypeError('Expected a string');
		}

		// Escape characters with special meaning either inside or outside character sets.
		// Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
		return string
			.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&')
			.replace(/-/g, '\\x2d');
	}

	/**
	 * @typedef {import('mdast').Parent} MdastParent
	 * @typedef {import('mdast').Root} Root
	 * @typedef {import('mdast').Content} Content
	 * @typedef {import('mdast').PhrasingContent} PhrasingContent
	 * @typedef {import('mdast').Text} Text
	 * @typedef {import('unist-util-visit-parents').Test} Test
	 * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult
	 */


	const own$5 = {}.hasOwnProperty;

	/**
	 * Find patterns in a tree and replace them.
	 *
	 * The algorithm searches the tree in *preorder* for complete values in `Text`
	 * nodes.
	 * Partial matches are not supported.
	 *
	 * @param tree
	 *   Tree to change.
	 * @param find
	 *   Patterns to find.
	 * @param replace
	 *   Things to replace with (when `find` is `Find`) or configuration.
	 * @param options
	 *   Configuration (when `find` is not `Find`).
	 * @returns
	 *   Given, modified, tree.
	 */
	// To do: next major: remove `find` & `replace` combo, remove schema.
	const findAndReplace =
	  /**
	   * @type {(
	   *   (<Tree extends Node>(tree: Tree, find: Find, replace?: Replace | null | undefined, options?: Options | null | undefined) => Tree) &
	   *   (<Tree extends Node>(tree: Tree, schema: FindAndReplaceSchema | FindAndReplaceList, options?: Options | null | undefined) => Tree)
	   * )}
	   **/
	  (
	    /**
	     * @template {Node} Tree
	     * @param {Tree} tree
	     * @param {Find | FindAndReplaceSchema | FindAndReplaceList} find
	     * @param {Replace | Options | null | undefined} [replace]
	     * @param {Options | null | undefined} [options]
	     * @returns {Tree}
	     */
	    function (tree, find, replace, options) {
	      /** @type {Options | null | undefined} */
	      let settings;
	      /** @type {FindAndReplaceSchema|FindAndReplaceList} */
	      let schema;

	      if (typeof find === 'string' || find instanceof RegExp) {
	        // @ts-expect-error don’t expect options twice.
	        schema = [[find, replace]];
	        settings = options;
	      } else {
	        schema = find;
	        // @ts-expect-error don’t expect replace twice.
	        settings = replace;
	      }

	      if (!settings) {
	        settings = {};
	      }

	      const ignored = convert$5(settings.ignore || []);
	      const pairs = toPairs(schema);
	      let pairIndex = -1;

	      while (++pairIndex < pairs.length) {
	        visitParents$2(tree, 'text', visitor);
	      }

	      // To do next major: don’t return the given tree.
	      return tree

	      /** @type {import('unist-util-visit-parents/complex-types.js').BuildVisitor<Root, 'text'>} */
	      function visitor(node, parents) {
	        let index = -1;
	        /** @type {Parent | undefined} */
	        let grandparent;

	        while (++index < parents.length) {
	          const parent = parents[index];

	          if (
	            ignored(
	              parent,
	              // @ts-expect-error: TS doesn’t understand but it’s perfect.
	              grandparent ? grandparent.children.indexOf(parent) : undefined,
	              grandparent
	            )
	          ) {
	            return
	          }

	          grandparent = parent;
	        }

	        if (grandparent) {
	          return handler(node, parents)
	        }
	      }

	      /**
	       * Handle a text node which is not in an ignored parent.
	       *
	       * @param {Text} node
	       *   Text node.
	       * @param {Array<Parent>} parents
	       *   Parents.
	       * @returns {VisitorResult}
	       *   Result.
	       */
	      function handler(node, parents) {
	        const parent = parents[parents.length - 1];
	        const find = pairs[pairIndex][0];
	        const replace = pairs[pairIndex][1];
	        let start = 0;
	        // @ts-expect-error: TS is wrong, some of these children can be text.
	        const index = parent.children.indexOf(node);
	        let change = false;
	        /** @type {Array<PhrasingContent>} */
	        let nodes = [];

	        find.lastIndex = 0;

	        let match = find.exec(node.value);

	        while (match) {
	          const position = match.index;
	          /** @type {RegExpMatchObject} */
	          const matchObject = {
	            index: match.index,
	            input: match.input,
	            // @ts-expect-error: stack is fine.
	            stack: [...parents, node]
	          };
	          let value = replace(...match, matchObject);

	          if (typeof value === 'string') {
	            value = value.length > 0 ? {type: 'text', value} : undefined;
	          }

	          // It wasn’t a match after all.
	          if (value !== false) {
	            if (start !== position) {
	              nodes.push({
	                type: 'text',
	                value: node.value.slice(start, position)
	              });
	            }

	            if (Array.isArray(value)) {
	              nodes.push(...value);
	            } else if (value) {
	              nodes.push(value);
	            }

	            start = position + match[0].length;
	            change = true;
	          }

	          if (!find.global) {
	            break
	          }

	          match = find.exec(node.value);
	        }

	        if (change) {
	          if (start < node.value.length) {
	            nodes.push({type: 'text', value: node.value.slice(start)});
	          }

	          parent.children.splice(index, 1, ...nodes);
	        } else {
	          nodes = [node];
	        }

	        return index + nodes.length
	      }
	    }
	  );

	/**
	 * Turn a schema into pairs.
	 *
	 * @param {FindAndReplaceSchema | FindAndReplaceList} schema
	 *   Schema.
	 * @returns {Pairs}
	 *   Clean pairs.
	 */
	function toPairs(schema) {
	  /** @type {Pairs} */
	  const result = [];

	  if (typeof schema !== 'object') {
	    throw new TypeError('Expected array or object as schema')
	  }

	  if (Array.isArray(schema)) {
	    let index = -1;

	    while (++index < schema.length) {
	      result.push([
	        toExpression(schema[index][0]),
	        toFunction(schema[index][1])
	      ]);
	    }
	  } else {
	    /** @type {string} */
	    let key;

	    for (key in schema) {
	      if (own$5.call(schema, key)) {
	        result.push([toExpression(key), toFunction(schema[key])]);
	      }
	    }
	  }

	  return result
	}

	/**
	 * Turn a find into an expression.
	 *
	 * @param {Find} find
	 *   Find.
	 * @returns {RegExp}
	 *   Expression.
	 */
	function toExpression(find) {
	  return typeof find === 'string' ? new RegExp(escapeStringRegexp(find), 'g') : find
	}

	/**
	 * Turn a replace into a function.
	 *
	 * @param {Replace} replace
	 *   Replace.
	 * @returns {ReplaceFunction}
	 *   Function.
	 */
	function toFunction(replace) {
	  return typeof replace === 'function' ? replace : () => replace
	}

	/**
	 * @typedef {import('mdast').Content} Content
	 * @typedef {import('mdast').Root} Root
	 * @typedef {import('mdast-util-find-and-replace').ReplaceFunction} ReplaceFunction
	 */


	/**
	 * Turn normal line endings into hard breaks.
	 *
	 * @param {Node} tree
	 *   Tree to change.
	 * @returns {void}
	 *   Nothing.
	 */
	function newlineToBreak(tree) {
	  findAndReplace(tree, /\r?\n|\r/g, replace$1);
	}

	/**
	 * Replace line endings.
	 *
	 * @type {ReplaceFunction}
	 */
	function replace$1() {
	  return {type: 'break'}
	}

	/**
	 * @typedef {import('mdast').Root} Root
	 */


	/**
	 * Plugin to support hard breaks without needing spaces or escapes (turns enters
	 * into `<br>`s).
	 *
	 * @type {import('unified').Plugin<void[], Root>}
	 */
	function remarkBreaks() {
	  return newlineToBreak
	}

	/**
	 * Like `Array#splice`, but smarter for giant arrays.
	 *
	 * `Array#splice` takes all items to be inserted as individual argument which
	 * causes a stack overflow in V8 when trying to insert 100k items for instance.
	 *
	 * Otherwise, this does not return the removed items, and takes `items` as an
	 * array instead of rest parameters.
	 *
	 * @template {unknown} T
	 * @param {T[]} list
	 * @param {number} start
	 * @param {number} remove
	 * @param {T[]} items
	 * @returns {void}
	 */
	function splice(list, start, remove, items) {
	  const end = list.length;
	  let chunkStart = 0;
	  /** @type {unknown[]} */

	  let parameters; // Make start between zero and `end` (included).

	  if (start < 0) {
	    start = -start > end ? 0 : end + start;
	  } else {
	    start = start > end ? end : start;
	  }

	  remove = remove > 0 ? remove : 0; // No need to chunk the items if there’s only a couple (10k) items.

	  if (items.length < 10000) {
	    parameters = Array.from(items);
	    parameters.unshift(start, remove) // @ts-expect-error Hush, it’s fine.
	    ;[].splice.apply(list, parameters);
	  } else {
	    // Delete `remove` items starting from `start`
	    if (remove) [].splice.apply(list, [start, remove]); // Insert the items in chunks to not cause stack overflows.

	    while (chunkStart < items.length) {
	      parameters = items.slice(chunkStart, chunkStart + 10000);
	      parameters.unshift(start, 0) // @ts-expect-error Hush, it’s fine.
	      ;[].splice.apply(list, parameters);
	      chunkStart += 10000;
	      start += 10000;
	    }
	  }
	}
	/**
	 * Append `items` (an array) at the end of `list` (another array).
	 * When `list` was empty, returns `items` instead.
	 *
	 * This prevents a potentially expensive operation when `list` is empty,
	 * and adds items in batches to prevent V8 from hanging.
	 *
	 * @template {unknown} T
	 * @param {T[]} list
	 * @param {T[]} items
	 * @returns {T[]}
	 */

	function push(list, items) {
	  if (list.length > 0) {
	    splice(list, list.length, 0, items);
	    return list
	  }

	  return items
	}

	/**
	 * @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension
	 * @typedef {import('micromark-util-types').Extension} Extension
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
	 */


	const hasOwnProperty$1 = {}.hasOwnProperty;

	/**
	 * Combine several syntax extensions into one.
	 *
	 * @param {Extension[]} extensions List of syntax extensions.
	 * @returns {NormalizedExtension} A single combined extension.
	 */
	function combineExtensions(extensions) {
	  /** @type {NormalizedExtension} */
	  const all = {};
	  let index = -1;

	  while (++index < extensions.length) {
	    syntaxExtension(all, extensions[index]);
	  }

	  return all
	}

	/**
	 * Merge `extension` into `all`.
	 *
	 * @param {NormalizedExtension} all Extension to merge into.
	 * @param {Extension} extension Extension to merge.
	 * @returns {void}
	 */
	function syntaxExtension(all, extension) {
	  /** @type {string} */
	  let hook;

	  for (hook in extension) {
	    const maybe = hasOwnProperty$1.call(all, hook) ? all[hook] : undefined;
	    const left = maybe || (all[hook] = {});
	    const right = extension[hook];
	    /** @type {string} */
	    let code;

	    for (code in right) {
	      if (!hasOwnProperty$1.call(left, code)) left[code] = [];
	      const value = right[code];
	      constructs(
	        // @ts-expect-error Looks like a list.
	        left[code],
	        Array.isArray(value) ? value : value ? [value] : []
	      );
	    }
	  }
	}

	/**
	 * Merge `list` into `existing` (both lists of constructs).
	 * Mutates `existing`.
	 *
	 * @param {unknown[]} existing
	 * @param {unknown[]} list
	 * @returns {void}
	 */
	function constructs(existing, list) {
	  let index = -1;
	  /** @type {unknown[]} */
	  const before = [];

	  while (++index < list.length) {
	(list[index].add === 'after' ? existing : before).push(list[index]);
	  }

	  splice(existing, 0, 0, before);
	}

	// This module is generated by `script/`.
	//
	// CommonMark handles attention (emphasis, strong) markers based on what comes
	// before or after them.
	// One such difference is if those characters are Unicode punctuation.
	// This script is generated from the Unicode data.

	/**
	 * Regular expression that matches a unicode punctuation character.
	 */
	const unicodePunctuationRegex =
	  /[!-\/:-@\[-`\{-~\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061D-\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1B7D\u1B7E\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52-\u2E5D\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]/;

	/**
	 * @typedef {import('micromark-util-types').Code} Code
	 */


	/**
	 * Check whether the character code represents an ASCII alpha (`a` through `z`,
	 * case insensitive).
	 *
	 * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.
	 *
	 * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)
	 * to U+005A (`Z`).
	 *
	 * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)
	 * to U+007A (`z`).
	 *
	 * @param code
	 *   Code.
	 * @returns
	 *   Whether it matches.
	 */
	const asciiAlpha = regexCheck(/[A-Za-z]/);

	/**
	 * Check whether the character code represents an ASCII alphanumeric (`a`
	 * through `z`, case insensitive, or `0` through `9`).
	 *
	 * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha
	 * (see `asciiAlpha`).
	 *
	 * @param code
	 *   Code.
	 * @returns
	 *   Whether it matches.
	 */
	const asciiAlphanumeric = regexCheck(/[\dA-Za-z]/);

	/**
	 * Check whether the character code represents an ASCII atext.
	 *
	 * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in
	 * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),
	 * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F
	 * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E
	 * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE
	 * (`{`) to U+007E TILDE (`~`).
	 *
	 * See:
	 * **\[RFC5322]**:
	 * [Internet Message Format](https://tools.ietf.org/html/rfc5322).
	 * P. Resnick.
	 * IETF.
	 *
	 * @param code
	 *   Code.
	 * @returns
	 *   Whether it matches.
	 */
	const asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/);

	/**
	 * Check whether a character code is an ASCII control character.
	 *
	 * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)
	 * to U+001F (US), or U+007F (DEL).
	 *
	 * @param {Code} code
	 *   Code.
	 * @returns {boolean}
	 *   Whether it matches.
	 */
	function asciiControl(code) {
	  return (
	    // Special whitespace codes (which have negative values), C0 and Control
	    // character DEL
	    code !== null && (code < 32 || code === 127)
	  )
	}

	/**
	 * Check whether the character code represents an ASCII digit (`0` through `9`).
	 *
	 * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to
	 * U+0039 (`9`).
	 *
	 * @param code
	 *   Code.
	 * @returns
	 *   Whether it matches.
	 */
	const asciiDigit = regexCheck(/\d/);

	/**
	 * Check whether the character code represents an ASCII hex digit (`a` through
	 * `f`, case insensitive, or `0` through `9`).
	 *
	 * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex
	 * digit, or an ASCII lower hex digit.
	 *
	 * An **ASCII upper hex digit** is a character in the inclusive range U+0041
	 * (`A`) to U+0046 (`F`).
	 *
	 * An **ASCII lower hex digit** is a character in the inclusive range U+0061
	 * (`a`) to U+0066 (`f`).
	 *
	 * @param code
	 *   Code.
	 * @returns
	 *   Whether it matches.
	 */
	const asciiHexDigit = regexCheck(/[\dA-Fa-f]/);

	/**
	 * Check whether the character code represents ASCII punctuation.
	 *
	 * An **ASCII punctuation** is a character in the inclusive ranges U+0021
	 * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT
	 * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT
	 * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).
	 *
	 * @param code
	 *   Code.
	 * @returns
	 *   Whether it matches.
	 */
	const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);

	/**
	 * Check whether a character code is a markdown line ending.
	 *
	 * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN
	 * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).
	 *
	 * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE
	 * RETURN (CR) are replaced by these virtual characters depending on whether
	 * they occurred together.
	 *
	 * @param {Code} code
	 *   Code.
	 * @returns {boolean}
	 *   Whether it matches.
	 */
	function markdownLineEnding(code) {
	  return code !== null && code < -2
	}

	/**
	 * Check whether a character code is a markdown line ending (see
	 * `markdownLineEnding`) or markdown space (see `markdownSpace`).
	 *
	 * @param {Code} code
	 *   Code.
	 * @returns {boolean}
	 *   Whether it matches.
	 */
	function markdownLineEndingOrSpace(code) {
	  return code !== null && (code < 0 || code === 32)
	}

	/**
	 * Check whether a character code is a markdown space.
	 *
	 * A **markdown space** is the concrete character U+0020 SPACE (SP) and the
	 * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).
	 *
	 * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is
	 * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL
	 * SPACE (VS) characters, depending on the column at which the tab occurred.
	 *
	 * @param {Code} code
	 *   Code.
	 * @returns {boolean}
	 *   Whether it matches.
	 */
	function markdownSpace(code) {
	  return code === -2 || code === -1 || code === 32
	}

	// Size note: removing ASCII from the regex and using `asciiPunctuation` here
	// In fact adds to the bundle size.
	/**
	 * Check whether the character code represents Unicode punctuation.
	 *
	 * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,
	 * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`
	 * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`
	 * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII
	 * punctuation (see `asciiPunctuation`).
	 *
	 * See:
	 * **\[UNICODE]**:
	 * [The Unicode Standard](https://www.unicode.org/versions/).
	 * Unicode Consortium.
	 *
	 * @param code
	 *   Code.
	 * @returns
	 *   Whether it matches.
	 */
	const unicodePunctuation = regexCheck(unicodePunctuationRegex);

	/**
	 * Check whether the character code represents Unicode whitespace.
	 *
	 * Note that this does handle micromark specific markdown whitespace characters.
	 * See `markdownLineEndingOrSpace` to check that.
	 *
	 * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,
	 * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),
	 * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\[UNICODE]**).
	 *
	 * See:
	 * **\[UNICODE]**:
	 * [The Unicode Standard](https://www.unicode.org/versions/).
	 * Unicode Consortium.
	 *
	 * @param code
	 *   Code.
	 * @returns
	 *   Whether it matches.
	 */
	const unicodeWhitespace = regexCheck(/\s/);

	/**
	 * Create a code check from a regex.
	 *
	 * @param {RegExp} regex
	 * @returns {(code: Code) => boolean}
	 */
	function regexCheck(regex) {
	  return check

	  /**
	   * Check whether a code matches the bound regex.
	   *
	   * @param {Code} code
	   *   Character code.
	   * @returns {boolean}
	   *   Whether the character code matches the bound regex.
	   */
	  function check(code) {
	    return code !== null && regex.test(String.fromCharCode(code))
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Extension} Extension
	 * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').Previous} Previous
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Event} Event
	 * @typedef {import('micromark-util-types').Code} Code
	 */
	const www = {
	  tokenize: tokenizeWww,
	  partial: true
	};
	const domain = {
	  tokenize: tokenizeDomain,
	  partial: true
	};
	const path$1 = {
	  tokenize: tokenizePath,
	  partial: true
	};
	const punctuation = {
	  tokenize: tokenizePunctuation,
	  partial: true
	};
	const namedCharacterReference = {
	  tokenize: tokenizeNamedCharacterReference,
	  partial: true
	};
	const wwwAutolink = {
	  tokenize: tokenizeWwwAutolink,
	  previous: previousWww
	};
	const httpAutolink = {
	  tokenize: tokenizeHttpAutolink,
	  previous: previousHttp
	};
	const emailAutolink = {
	  tokenize: tokenizeEmailAutolink,
	  previous: previousEmail
	};
	/** @type {ConstructRecord} */

	const text$3 = {};
	/** @type {Extension} */

	const gfmAutolinkLiteral = {
	  text: text$3
	};
	let code$1 = 48; // Add alphanumerics.

	while (code$1 < 123) {
	  text$3[code$1] = emailAutolink;
	  code$1++;
	  if (code$1 === 58) code$1 = 65;
	  else if (code$1 === 91) code$1 = 97;
	}

	text$3[43] = emailAutolink;
	text$3[45] = emailAutolink;
	text$3[46] = emailAutolink;
	text$3[95] = emailAutolink;
	text$3[72] = [emailAutolink, httpAutolink];
	text$3[104] = [emailAutolink, httpAutolink];
	text$3[87] = [emailAutolink, wwwAutolink];
	text$3[119] = [emailAutolink, wwwAutolink];
	/** @type {Tokenizer} */

	function tokenizeEmailAutolink(effects, ok, nok) {
	  const self = this;
	  /** @type {boolean} */

	  let hasDot;
	  /** @type {boolean|undefined} */

	  let hasDigitInLastSegment;
	  return start
	  /** @type {State} */

	  function start(code) {
	    if (
	      !gfmAtext(code) ||
	      !previousEmail(self.previous) ||
	      previousUnbalanced(self.events)
	    ) {
	      return nok(code)
	    }

	    effects.enter('literalAutolink');
	    effects.enter('literalAutolinkEmail');
	    return atext(code)
	  }
	  /** @type {State} */

	  function atext(code) {
	    if (gfmAtext(code)) {
	      effects.consume(code);
	      return atext
	    }

	    if (code === 64) {
	      effects.consume(code);
	      return label
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function label(code) {
	    if (code === 46) {
	      return effects.check(punctuation, done, dotContinuation)(code)
	    }

	    if (code === 45 || code === 95) {
	      return effects.check(punctuation, nok, dashOrUnderscoreContinuation)(code)
	    }

	    if (asciiAlphanumeric(code)) {
	      if (!hasDigitInLastSegment && asciiDigit(code)) {
	        hasDigitInLastSegment = true;
	      }

	      effects.consume(code);
	      return label
	    }

	    return done(code)
	  }
	  /** @type {State} */

	  function dotContinuation(code) {
	    effects.consume(code);
	    hasDot = true;
	    hasDigitInLastSegment = undefined;
	    return label
	  }
	  /** @type {State} */

	  function dashOrUnderscoreContinuation(code) {
	    effects.consume(code);
	    return afterDashOrUnderscore
	  }
	  /** @type {State} */

	  function afterDashOrUnderscore(code) {
	    if (code === 46) {
	      return effects.check(punctuation, nok, dotContinuation)(code)
	    }

	    return label(code)
	  }
	  /** @type {State} */

	  function done(code) {
	    if (hasDot && !hasDigitInLastSegment) {
	      effects.exit('literalAutolinkEmail');
	      effects.exit('literalAutolink');
	      return ok(code)
	    }

	    return nok(code)
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeWwwAutolink(effects, ok, nok) {
	  const self = this;
	  return start
	  /** @type {State} */

	  function start(code) {
	    if (
	      (code !== 87 && code !== 119) ||
	      !previousWww(self.previous) ||
	      previousUnbalanced(self.events)
	    ) {
	      return nok(code)
	    }

	    effects.enter('literalAutolink');
	    effects.enter('literalAutolinkWww'); // For `www.` we check instead of attempt, because when it matches, GH
	    // treats it as part of a domain (yes, it says a valid domain must come
	    // after `www.`, but that’s not how it’s implemented by them).

	    return effects.check(
	      www,
	      effects.attempt(domain, effects.attempt(path$1, done), nok),
	      nok
	    )(code)
	  }
	  /** @type {State} */

	  function done(code) {
	    effects.exit('literalAutolinkWww');
	    effects.exit('literalAutolink');
	    return ok(code)
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeHttpAutolink(effects, ok, nok) {
	  const self = this;
	  return start
	  /** @type {State} */

	  function start(code) {
	    if (
	      (code !== 72 && code !== 104) ||
	      !previousHttp(self.previous) ||
	      previousUnbalanced(self.events)
	    ) {
	      return nok(code)
	    }

	    effects.enter('literalAutolink');
	    effects.enter('literalAutolinkHttp');
	    effects.consume(code);
	    return t1
	  }
	  /** @type {State} */

	  function t1(code) {
	    if (code === 84 || code === 116) {
	      effects.consume(code);
	      return t2
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function t2(code) {
	    if (code === 84 || code === 116) {
	      effects.consume(code);
	      return p
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function p(code) {
	    if (code === 80 || code === 112) {
	      effects.consume(code);
	      return s
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function s(code) {
	    if (code === 83 || code === 115) {
	      effects.consume(code);
	      return colon
	    }

	    return colon(code)
	  }
	  /** @type {State} */

	  function colon(code) {
	    if (code === 58) {
	      effects.consume(code);
	      return slash1
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function slash1(code) {
	    if (code === 47) {
	      effects.consume(code);
	      return slash2
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function slash2(code) {
	    if (code === 47) {
	      effects.consume(code);
	      return after
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function after(code) {
	    return code === null ||
	      asciiControl(code) ||
	      unicodeWhitespace(code) ||
	      unicodePunctuation(code)
	      ? nok(code)
	      : effects.attempt(domain, effects.attempt(path$1, done), nok)(code)
	  }
	  /** @type {State} */

	  function done(code) {
	    effects.exit('literalAutolinkHttp');
	    effects.exit('literalAutolink');
	    return ok(code)
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeWww(effects, ok, nok) {
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.consume(code);
	    return w2
	  }
	  /** @type {State} */

	  function w2(code) {
	    if (code === 87 || code === 119) {
	      effects.consume(code);
	      return w3
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function w3(code) {
	    if (code === 87 || code === 119) {
	      effects.consume(code);
	      return dot
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function dot(code) {
	    if (code === 46) {
	      effects.consume(code);
	      return after
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function after(code) {
	    return code === null || markdownLineEnding(code) ? nok(code) : ok(code)
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeDomain(effects, ok, nok) {
	  /** @type {boolean|undefined} */
	  let hasUnderscoreInLastSegment;
	  /** @type {boolean|undefined} */

	  let hasUnderscoreInLastLastSegment;
	  return domain
	  /** @type {State} */

	  function domain(code) {
	    if (code === 38) {
	      return effects.check(
	        namedCharacterReference,
	        done,
	        punctuationContinuation
	      )(code)
	    }

	    if (code === 46 || code === 95) {
	      return effects.check(punctuation, done, punctuationContinuation)(code)
	    } // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can
	    // occur, which sounds like ASCII only, but they also support `www.點看.com`,
	    // so that’s Unicode.
	    // Instead of some new production for Unicode alphanumerics, markdown
	    // already has that for Unicode punctuation and whitespace, so use those.

	    if (
	      code === null ||
	      asciiControl(code) ||
	      unicodeWhitespace(code) ||
	      (code !== 45 && unicodePunctuation(code))
	    ) {
	      return done(code)
	    }

	    effects.consume(code);
	    return domain
	  }
	  /** @type {State} */

	  function punctuationContinuation(code) {
	    if (code === 46) {
	      hasUnderscoreInLastLastSegment = hasUnderscoreInLastSegment;
	      hasUnderscoreInLastSegment = undefined;
	      effects.consume(code);
	      return domain
	    }

	    if (code === 95) hasUnderscoreInLastSegment = true;
	    effects.consume(code);
	    return domain
	  }
	  /** @type {State} */

	  function done(code) {
	    if (!hasUnderscoreInLastLastSegment && !hasUnderscoreInLastSegment) {
	      return ok(code)
	    }

	    return nok(code)
	  }
	}
	/** @type {Tokenizer} */

	function tokenizePath(effects, ok) {
	  let balance = 0;
	  return inPath
	  /** @type {State} */

	  function inPath(code) {
	    if (code === 38) {
	      return effects.check(
	        namedCharacterReference,
	        ok,
	        continuedPunctuation
	      )(code)
	    }

	    if (code === 40) {
	      balance++;
	    }

	    if (code === 41) {
	      return effects.check(
	        punctuation,
	        parenAtPathEnd,
	        continuedPunctuation
	      )(code)
	    }

	    if (pathEnd(code)) {
	      return ok(code)
	    }

	    if (trailingPunctuation(code)) {
	      return effects.check(punctuation, ok, continuedPunctuation)(code)
	    }

	    effects.consume(code);
	    return inPath
	  }
	  /** @type {State} */

	  function continuedPunctuation(code) {
	    effects.consume(code);
	    return inPath
	  }
	  /** @type {State} */

	  function parenAtPathEnd(code) {
	    balance--;
	    return balance < 0 ? ok(code) : continuedPunctuation(code)
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeNamedCharacterReference(effects, ok, nok) {
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.consume(code);
	    return inside
	  }
	  /** @type {State} */

	  function inside(code) {
	    if (asciiAlpha(code)) {
	      effects.consume(code);
	      return inside
	    }

	    if (code === 59) {
	      effects.consume(code);
	      return after
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function after(code) {
	    // If the named character reference is followed by the end of the path, it’s
	    // not continued punctuation.
	    return pathEnd(code) ? ok(code) : nok(code)
	  }
	}
	/** @type {Tokenizer} */

	function tokenizePunctuation(effects, ok, nok) {
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.consume(code);
	    return after
	  }
	  /** @type {State} */

	  function after(code) {
	    // Check the next.
	    if (trailingPunctuation(code)) {
	      effects.consume(code);
	      return after
	    } // If the punctuation marker is followed by the end of the path, it’s not
	    // continued punctuation.

	    return pathEnd(code) ? ok(code) : nok(code)
	  }
	}
	/**
	 * @param {Code} code
	 * @returns {boolean}
	 */

	function trailingPunctuation(code) {
	  return (
	    code === 33 ||
	    code === 34 ||
	    code === 39 ||
	    code === 41 ||
	    code === 42 ||
	    code === 44 ||
	    code === 46 ||
	    code === 58 ||
	    code === 59 ||
	    code === 60 ||
	    code === 63 ||
	    code === 95 ||
	    code === 126
	  )
	}
	/**
	 * @param {Code} code
	 * @returns {boolean}
	 */

	function pathEnd(code) {
	  return code === null || code === 60 || markdownLineEndingOrSpace(code)
	}
	/**
	 * @param {Code} code
	 * @returns {boolean}
	 */

	function gfmAtext(code) {
	  return (
	    code === 43 ||
	    code === 45 ||
	    code === 46 ||
	    code === 95 ||
	    asciiAlphanumeric(code)
	  )
	}
	/** @type {Previous} */

	function previousWww(code) {
	  return (
	    code === null ||
	    code === 40 ||
	    code === 42 ||
	    code === 95 ||
	    code === 126 ||
	    markdownLineEndingOrSpace(code)
	  )
	}
	/** @type {Previous} */

	function previousHttp(code) {
	  return code === null || !asciiAlpha(code)
	}
	/** @type {Previous} */

	function previousEmail(code) {
	  return code !== 47 && previousHttp(code)
	}
	/**
	 * @param {Array<Event>} events
	 * @returns {boolean}
	 */

	function previousUnbalanced(events) {
	  let index = events.length;
	  let result = false;

	  while (index--) {
	    const token = events[index][1];

	    if (
	      (token.type === 'labelLink' || token.type === 'labelImage') &&
	      !token._balanced
	    ) {
	      result = true;
	      break
	    } // @ts-expect-error If we’ve seen this token, and it was marked as not
	    // having any unbalanced bracket before it, we can exit.

	    if (token._gfmAutolinkLiteralWalkedInto) {
	      result = false;
	      break
	    }
	  }

	  if (events.length > 0 && !result) {
	    // @ts-expect-error Mark the last token as “walked into” w/o finding
	    // anything.
	    events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true;
	  }

	  return result
	}

	/**
	 * @typedef {import('micromark-util-types').Code} Code
	 */

	/**
	 * Classify whether a character code represents whitespace, punctuation, or
	 * something else.
	 *
	 * Used for attention (emphasis, strong), whose sequences can open or close
	 * based on the class of surrounding characters.
	 *
	 * Note that eof (`null`) is seen as whitespace.
	 *
	 * @param {Code} code
	 * @returns {number|undefined}
	 */
	function classifyCharacter(code) {
	  if (
	    code === null ||
	    markdownLineEndingOrSpace(code) ||
	    unicodeWhitespace(code)
	  ) {
	    return 1
	  }

	  if (unicodePunctuation(code)) {
	    return 2
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
	 * @typedef {import('micromark-util-types').Event} Event
	 * @typedef {import('micromark-util-types').Resolver} Resolver
	 */

	/**
	 * Call all `resolveAll`s.
	 *
	 * @param {{resolveAll?: Resolver}[]} constructs
	 * @param {Event[]} events
	 * @param {TokenizeContext} context
	 * @returns {Event[]}
	 */
	function resolveAll(constructs, events, context) {
	  /** @type {Resolver[]} */
	  const called = [];
	  let index = -1;

	  while (++index < constructs.length) {
	    const resolve = constructs[index].resolveAll;

	    if (resolve && !called.includes(resolve)) {
	      events = resolve(events, context);
	      called.push(resolve);
	    }
	  }

	  return events
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').Resolver} Resolver
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Token} Token
	 * @typedef {import('micromark-util-types').Event} Event
	 * @typedef {import('micromark-util-types').Code} Code
	 * @typedef {import('micromark-util-types').Point} Point
	 */

	/** @type {Construct} */
	const attention = {
	  name: 'attention',
	  tokenize: tokenizeAttention,
	  resolveAll: resolveAllAttention
	};
	/**
	 * Take all events and resolve attention to emphasis or strong.
	 *
	 * @type {Resolver}
	 */

	function resolveAllAttention(events, context) {
	  let index = -1;
	  /** @type {number} */

	  let open;
	  /** @type {Token} */

	  let group;
	  /** @type {Token} */

	  let text;
	  /** @type {Token} */

	  let openingSequence;
	  /** @type {Token} */

	  let closingSequence;
	  /** @type {number} */

	  let use;
	  /** @type {Event[]} */

	  let nextEvents;
	  /** @type {number} */

	  let offset; // Walk through all events.
	  //
	  // Note: performance of this is fine on an mb of normal markdown, but it’s
	  // a bottleneck for malicious stuff.

	  while (++index < events.length) {
	    // Find a token that can close.
	    if (
	      events[index][0] === 'enter' &&
	      events[index][1].type === 'attentionSequence' &&
	      events[index][1]._close
	    ) {
	      open = index; // Now walk back to find an opener.

	      while (open--) {
	        // Find a token that can open the closer.
	        if (
	          events[open][0] === 'exit' &&
	          events[open][1].type === 'attentionSequence' &&
	          events[open][1]._open && // If the markers are the same:
	          context.sliceSerialize(events[open][1]).charCodeAt(0) ===
	            context.sliceSerialize(events[index][1]).charCodeAt(0)
	        ) {
	          // If the opening can close or the closing can open,
	          // and the close size *is not* a multiple of three,
	          // but the sum of the opening and closing size *is* multiple of three,
	          // then don’t match.
	          if (
	            (events[open][1]._close || events[index][1]._open) &&
	            (events[index][1].end.offset - events[index][1].start.offset) % 3 &&
	            !(
	              (events[open][1].end.offset -
	                events[open][1].start.offset +
	                events[index][1].end.offset -
	                events[index][1].start.offset) %
	              3
	            )
	          ) {
	            continue
	          } // Number of markers to use from the sequence.

	          use =
	            events[open][1].end.offset - events[open][1].start.offset > 1 &&
	            events[index][1].end.offset - events[index][1].start.offset > 1
	              ? 2
	              : 1;
	          const start = Object.assign({}, events[open][1].end);
	          const end = Object.assign({}, events[index][1].start);
	          movePoint(start, -use);
	          movePoint(end, use);
	          openingSequence = {
	            type: use > 1 ? 'strongSequence' : 'emphasisSequence',
	            start,
	            end: Object.assign({}, events[open][1].end)
	          };
	          closingSequence = {
	            type: use > 1 ? 'strongSequence' : 'emphasisSequence',
	            start: Object.assign({}, events[index][1].start),
	            end
	          };
	          text = {
	            type: use > 1 ? 'strongText' : 'emphasisText',
	            start: Object.assign({}, events[open][1].end),
	            end: Object.assign({}, events[index][1].start)
	          };
	          group = {
	            type: use > 1 ? 'strong' : 'emphasis',
	            start: Object.assign({}, openingSequence.start),
	            end: Object.assign({}, closingSequence.end)
	          };
	          events[open][1].end = Object.assign({}, openingSequence.start);
	          events[index][1].start = Object.assign({}, closingSequence.end);
	          nextEvents = []; // If there are more markers in the opening, add them before.

	          if (events[open][1].end.offset - events[open][1].start.offset) {
	            nextEvents = push(nextEvents, [
	              ['enter', events[open][1], context],
	              ['exit', events[open][1], context]
	            ]);
	          } // Opening.

	          nextEvents = push(nextEvents, [
	            ['enter', group, context],
	            ['enter', openingSequence, context],
	            ['exit', openingSequence, context],
	            ['enter', text, context]
	          ]); // Between.

	          nextEvents = push(
	            nextEvents,
	            resolveAll(
	              context.parser.constructs.insideSpan.null,
	              events.slice(open + 1, index),
	              context
	            )
	          ); // Closing.

	          nextEvents = push(nextEvents, [
	            ['exit', text, context],
	            ['enter', closingSequence, context],
	            ['exit', closingSequence, context],
	            ['exit', group, context]
	          ]); // If there are more markers in the closing, add them after.

	          if (events[index][1].end.offset - events[index][1].start.offset) {
	            offset = 2;
	            nextEvents = push(nextEvents, [
	              ['enter', events[index][1], context],
	              ['exit', events[index][1], context]
	            ]);
	          } else {
	            offset = 0;
	          }

	          splice(events, open - 1, index - open + 3, nextEvents);
	          index = open + nextEvents.length - offset - 2;
	          break
	        }
	      }
	    }
	  } // Remove remaining sequences.

	  index = -1;

	  while (++index < events.length) {
	    if (events[index][1].type === 'attentionSequence') {
	      events[index][1].type = 'data';
	    }
	  }

	  return events
	}
	/** @type {Tokenizer} */

	function tokenizeAttention(effects, ok) {
	  const attentionMarkers = this.parser.constructs.attentionMarkers.null;
	  const previous = this.previous;
	  const before = classifyCharacter(previous);
	  /** @type {NonNullable<Code>} */

	  let marker;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('attentionSequence');
	    marker = code;
	    return sequence(code)
	  }
	  /** @type {State} */

	  function sequence(code) {
	    if (code === marker) {
	      effects.consume(code);
	      return sequence
	    }

	    const token = effects.exit('attentionSequence');
	    const after = classifyCharacter(code);
	    const open =
	      !after || (after === 2 && before) || attentionMarkers.includes(code);
	    const close =
	      !before || (before === 2 && after) || attentionMarkers.includes(previous);
	    token._open = Boolean(marker === 42 ? open : open && (before || !close));
	    token._close = Boolean(marker === 42 ? close : close && (after || !open));
	    return ok(code)
	  }
	}
	/**
	 * Move a point a bit.
	 *
	 * Note: `move` only works inside lines! It’s not possible to move past other
	 * chunks (replacement characters, tabs, or line endings).
	 *
	 * @param {Point} point
	 * @param {number} offset
	 * @returns {void}
	 */

	function movePoint(point, offset) {
	  point.column += offset;
	  point.offset += offset;
	  point._bufferIndex += offset;
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 */

	/** @type {Construct} */
	const autolink = {
	  name: 'autolink',
	  tokenize: tokenizeAutolink
	};
	/** @type {Tokenizer} */

	function tokenizeAutolink(effects, ok, nok) {
	  let size = 1;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('autolink');
	    effects.enter('autolinkMarker');
	    effects.consume(code);
	    effects.exit('autolinkMarker');
	    effects.enter('autolinkProtocol');
	    return open
	  }
	  /** @type {State} */

	  function open(code) {
	    if (asciiAlpha(code)) {
	      effects.consume(code);
	      return schemeOrEmailAtext
	    }

	    return asciiAtext(code) ? emailAtext(code) : nok(code)
	  }
	  /** @type {State} */

	  function schemeOrEmailAtext(code) {
	    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)
	      ? schemeInsideOrEmailAtext(code)
	      : emailAtext(code)
	  }
	  /** @type {State} */

	  function schemeInsideOrEmailAtext(code) {
	    if (code === 58) {
	      effects.consume(code);
	      return urlInside
	    }

	    if (
	      (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) &&
	      size++ < 32
	    ) {
	      effects.consume(code);
	      return schemeInsideOrEmailAtext
	    }

	    return emailAtext(code)
	  }
	  /** @type {State} */

	  function urlInside(code) {
	    if (code === 62) {
	      effects.exit('autolinkProtocol');
	      return end(code)
	    }

	    if (code === null || code === 32 || code === 60 || asciiControl(code)) {
	      return nok(code)
	    }

	    effects.consume(code);
	    return urlInside
	  }
	  /** @type {State} */

	  function emailAtext(code) {
	    if (code === 64) {
	      effects.consume(code);
	      size = 0;
	      return emailAtSignOrDot
	    }

	    if (asciiAtext(code)) {
	      effects.consume(code);
	      return emailAtext
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function emailAtSignOrDot(code) {
	    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code)
	  }
	  /** @type {State} */

	  function emailLabel(code) {
	    if (code === 46) {
	      effects.consume(code);
	      size = 0;
	      return emailAtSignOrDot
	    }

	    if (code === 62) {
	      // Exit, then change the type.
	      effects.exit('autolinkProtocol').type = 'autolinkEmail';
	      return end(code)
	    }

	    return emailValue(code)
	  }
	  /** @type {State} */

	  function emailValue(code) {
	    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {
	      effects.consume(code);
	      return code === 45 ? emailValue : emailLabel
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function end(code) {
	    effects.enter('autolinkMarker');
	    effects.consume(code);
	    effects.exit('autolinkMarker');
	    effects.exit('autolink');
	    return ok
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Effects} Effects
	 * @typedef {import('micromark-util-types').State} State
	 */
	/**
	 * @param {Effects} effects
	 * @param {State} ok
	 * @param {string} type
	 * @param {number} [max=Infinity]
	 * @returns {State}
	 */

	function factorySpace(effects, ok, type, max) {
	  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;
	  let size = 0;
	  return start
	  /** @type {State} */

	  function start(code) {
	    if (markdownSpace(code)) {
	      effects.enter(type);
	      return prefix(code)
	    }

	    return ok(code)
	  }
	  /** @type {State} */

	  function prefix(code) {
	    if (markdownSpace(code) && size++ < limit) {
	      effects.consume(code);
	      return prefix
	    }

	    effects.exit(type);
	    return ok(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 */

	/** @type {Construct} */
	const blankLine = {
	  tokenize: tokenizeBlankLine,
	  partial: true
	};
	/** @type {Tokenizer} */

	function tokenizeBlankLine(effects, ok, nok) {
	  return factorySpace(effects, afterWhitespace, 'linePrefix')
	  /** @type {State} */

	  function afterWhitespace(code) {
	    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').Exiter} Exiter
	 * @typedef {import('micromark-util-types').State} State
	 */

	/** @type {Construct} */
	const blockQuote = {
	  name: 'blockQuote',
	  tokenize: tokenizeBlockQuoteStart,
	  continuation: {
	    tokenize: tokenizeBlockQuoteContinuation
	  },
	  exit: exit$1
	};
	/** @type {Tokenizer} */

	function tokenizeBlockQuoteStart(effects, ok, nok) {
	  const self = this;
	  return start
	  /** @type {State} */

	  function start(code) {
	    if (code === 62) {
	      const state = self.containerState;

	      if (!state.open) {
	        effects.enter('blockQuote', {
	          _container: true
	        });
	        state.open = true;
	      }

	      effects.enter('blockQuotePrefix');
	      effects.enter('blockQuoteMarker');
	      effects.consume(code);
	      effects.exit('blockQuoteMarker');
	      return after
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function after(code) {
	    if (markdownSpace(code)) {
	      effects.enter('blockQuotePrefixWhitespace');
	      effects.consume(code);
	      effects.exit('blockQuotePrefixWhitespace');
	      effects.exit('blockQuotePrefix');
	      return ok
	    }

	    effects.exit('blockQuotePrefix');
	    return ok(code)
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeBlockQuoteContinuation(effects, ok, nok) {
	  return factorySpace(
	    effects,
	    effects.attempt(blockQuote, ok, nok),
	    'linePrefix',
	    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4
	  )
	}
	/** @type {Exiter} */

	function exit$1(effects) {
	  effects.exit('blockQuote');
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 */

	/** @type {Construct} */
	const characterEscape = {
	  name: 'characterEscape',
	  tokenize: tokenizeCharacterEscape
	};
	/** @type {Tokenizer} */

	function tokenizeCharacterEscape(effects, ok, nok) {
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('characterEscape');
	    effects.enter('escapeMarker');
	    effects.consume(code);
	    effects.exit('escapeMarker');
	    return open
	  }
	  /** @type {State} */

	  function open(code) {
	    if (asciiPunctuation(code)) {
	      effects.enter('characterEscapeValue');
	      effects.consume(code);
	      effects.exit('characterEscapeValue');
	      effects.exit('characterEscape');
	      return ok
	    }

	    return nok(code)
	  }
	}

	/// <reference lib="dom" />

	/* eslint-env browser */

	const element = document.createElement('i');

	/**
	 * @param {string} value
	 * @returns {string|false}
	 */
	function decodeNamedCharacterReference(value) {
	  const characterReference = '&' + value + ';';
	  element.innerHTML = characterReference;
	  const char = element.textContent;

	  // Some named character references do not require the closing semicolon
	  // (`&not`, for instance), which leads to situations where parsing the assumed
	  // named reference of `&notit;` will result in the string `¬it;`.
	  // When we encounter a trailing semicolon after parsing, and the character
	  // reference to decode was not a semicolon (`&semi;`), we can assume that the
	  // matching was not complete.
	  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can
	  // yield `null`.
	  if (char.charCodeAt(char.length - 1) === 59 /* `;` */ && value !== 'semi') {
	    return false
	  }

	  // If the decoded string is equal to the input, the character reference was
	  // not valid.
	  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can
	  // yield `null`.
	  return char === characterReference ? false : char
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').Token} Token
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Code} Code
	 */

	/** @type {Construct} */
	const characterReference = {
	  name: 'characterReference',
	  tokenize: tokenizeCharacterReference
	};
	/** @type {Tokenizer} */

	function tokenizeCharacterReference(effects, ok, nok) {
	  const self = this;
	  let size = 0;
	  /** @type {number} */

	  let max;
	  /** @type {(code: Code) => code is number} */

	  let test;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('characterReference');
	    effects.enter('characterReferenceMarker');
	    effects.consume(code);
	    effects.exit('characterReferenceMarker');
	    return open
	  }
	  /** @type {State} */

	  function open(code) {
	    if (code === 35) {
	      effects.enter('characterReferenceMarkerNumeric');
	      effects.consume(code);
	      effects.exit('characterReferenceMarkerNumeric');
	      return numeric
	    }

	    effects.enter('characterReferenceValue');
	    max = 31;
	    test = asciiAlphanumeric;
	    return value(code)
	  }
	  /** @type {State} */

	  function numeric(code) {
	    if (code === 88 || code === 120) {
	      effects.enter('characterReferenceMarkerHexadecimal');
	      effects.consume(code);
	      effects.exit('characterReferenceMarkerHexadecimal');
	      effects.enter('characterReferenceValue');
	      max = 6;
	      test = asciiHexDigit;
	      return value
	    }

	    effects.enter('characterReferenceValue');
	    max = 7;
	    test = asciiDigit;
	    return value(code)
	  }
	  /** @type {State} */

	  function value(code) {
	    /** @type {Token} */
	    let token;

	    if (code === 59 && size) {
	      token = effects.exit('characterReferenceValue');

	      if (
	        test === asciiAlphanumeric &&
	        !decodeNamedCharacterReference(self.sliceSerialize(token))
	      ) {
	        return nok(code)
	      }

	      effects.enter('characterReferenceMarker');
	      effects.consume(code);
	      effects.exit('characterReferenceMarker');
	      effects.exit('characterReference');
	      return ok
	    }

	    if (test(code) && size++ < max) {
	      effects.consume(code);
	      return value
	    }

	    return nok(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Code} Code
	 */

	/** @type {Construct} */
	const codeFenced = {
	  name: 'codeFenced',
	  tokenize: tokenizeCodeFenced,
	  concrete: true
	};
	/** @type {Tokenizer} */

	function tokenizeCodeFenced(effects, ok, nok) {
	  const self = this;
	  /** @type {Construct} */

	  const closingFenceConstruct = {
	    tokenize: tokenizeClosingFence,
	    partial: true
	  };
	  /** @type {Construct} */

	  const nonLazyLine = {
	    tokenize: tokenizeNonLazyLine,
	    partial: true
	  };
	  const tail = this.events[this.events.length - 1];
	  const initialPrefix =
	    tail && tail[1].type === 'linePrefix'
	      ? tail[2].sliceSerialize(tail[1], true).length
	      : 0;
	  let sizeOpen = 0;
	  /** @type {NonNullable<Code>} */

	  let marker;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('codeFenced');
	    effects.enter('codeFencedFence');
	    effects.enter('codeFencedFenceSequence');
	    marker = code;
	    return sequenceOpen(code)
	  }
	  /** @type {State} */

	  function sequenceOpen(code) {
	    if (code === marker) {
	      effects.consume(code);
	      sizeOpen++;
	      return sequenceOpen
	    }

	    effects.exit('codeFencedFenceSequence');
	    return sizeOpen < 3
	      ? nok(code)
	      : factorySpace(effects, infoOpen, 'whitespace')(code)
	  }
	  /** @type {State} */

	  function infoOpen(code) {
	    if (code === null || markdownLineEnding(code)) {
	      return openAfter(code)
	    }

	    effects.enter('codeFencedFenceInfo');
	    effects.enter('chunkString', {
	      contentType: 'string'
	    });
	    return info(code)
	  }
	  /** @type {State} */

	  function info(code) {
	    if (code === null || markdownLineEndingOrSpace(code)) {
	      effects.exit('chunkString');
	      effects.exit('codeFencedFenceInfo');
	      return factorySpace(effects, infoAfter, 'whitespace')(code)
	    }

	    if (code === 96 && code === marker) return nok(code)
	    effects.consume(code);
	    return info
	  }
	  /** @type {State} */

	  function infoAfter(code) {
	    if (code === null || markdownLineEnding(code)) {
	      return openAfter(code)
	    }

	    effects.enter('codeFencedFenceMeta');
	    effects.enter('chunkString', {
	      contentType: 'string'
	    });
	    return meta(code)
	  }
	  /** @type {State} */

	  function meta(code) {
	    if (code === null || markdownLineEnding(code)) {
	      effects.exit('chunkString');
	      effects.exit('codeFencedFenceMeta');
	      return openAfter(code)
	    }

	    if (code === 96 && code === marker) return nok(code)
	    effects.consume(code);
	    return meta
	  }
	  /** @type {State} */

	  function openAfter(code) {
	    effects.exit('codeFencedFence');
	    return self.interrupt ? ok(code) : contentStart(code)
	  }
	  /** @type {State} */

	  function contentStart(code) {
	    if (code === null) {
	      return after(code)
	    }

	    if (markdownLineEnding(code)) {
	      return effects.attempt(
	        nonLazyLine,
	        effects.attempt(
	          closingFenceConstruct,
	          after,
	          initialPrefix
	            ? factorySpace(
	                effects,
	                contentStart,
	                'linePrefix',
	                initialPrefix + 1
	              )
	            : contentStart
	        ),
	        after
	      )(code)
	    }

	    effects.enter('codeFlowValue');
	    return contentContinue(code)
	  }
	  /** @type {State} */

	  function contentContinue(code) {
	    if (code === null || markdownLineEnding(code)) {
	      effects.exit('codeFlowValue');
	      return contentStart(code)
	    }

	    effects.consume(code);
	    return contentContinue
	  }
	  /** @type {State} */

	  function after(code) {
	    effects.exit('codeFenced');
	    return ok(code)
	  }
	  /** @type {Tokenizer} */

	  function tokenizeNonLazyLine(effects, ok, nok) {
	    const self = this;
	    return start
	    /** @type {State} */

	    function start(code) {
	      effects.enter('lineEnding');
	      effects.consume(code);
	      effects.exit('lineEnding');
	      return lineStart
	    }
	    /** @type {State} */

	    function lineStart(code) {
	      return self.parser.lazy[self.now().line] ? nok(code) : ok(code)
	    }
	  }
	  /** @type {Tokenizer} */

	  function tokenizeClosingFence(effects, ok, nok) {
	    let size = 0;
	    return factorySpace(
	      effects,
	      closingSequenceStart,
	      'linePrefix',
	      this.parser.constructs.disable.null.includes('codeIndented')
	        ? undefined
	        : 4
	    )
	    /** @type {State} */

	    function closingSequenceStart(code) {
	      effects.enter('codeFencedFence');
	      effects.enter('codeFencedFenceSequence');
	      return closingSequence(code)
	    }
	    /** @type {State} */

	    function closingSequence(code) {
	      if (code === marker) {
	        effects.consume(code);
	        size++;
	        return closingSequence
	      }

	      if (size < sizeOpen) return nok(code)
	      effects.exit('codeFencedFenceSequence');
	      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code)
	    }
	    /** @type {State} */

	    function closingSequenceEnd(code) {
	      if (code === null || markdownLineEnding(code)) {
	        effects.exit('codeFencedFence');
	        return ok(code)
	      }

	      return nok(code)
	    }
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').Resolver} Resolver
	 * @typedef {import('micromark-util-types').Token} Token
	 * @typedef {import('micromark-util-types').State} State
	 */

	/** @type {Construct} */
	const codeIndented = {
	  name: 'codeIndented',
	  tokenize: tokenizeCodeIndented
	};
	/** @type {Construct} */

	const indentedContent = {
	  tokenize: tokenizeIndentedContent,
	  partial: true
	};
	/** @type {Tokenizer} */

	function tokenizeCodeIndented(effects, ok, nok) {
	  const self = this;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('codeIndented');
	    return factorySpace(effects, afterStartPrefix, 'linePrefix', 4 + 1)(code)
	  }
	  /** @type {State} */

	  function afterStartPrefix(code) {
	    const tail = self.events[self.events.length - 1];
	    return tail &&
	      tail[1].type === 'linePrefix' &&
	      tail[2].sliceSerialize(tail[1], true).length >= 4
	      ? afterPrefix(code)
	      : nok(code)
	  }
	  /** @type {State} */

	  function afterPrefix(code) {
	    if (code === null) {
	      return after(code)
	    }

	    if (markdownLineEnding(code)) {
	      return effects.attempt(indentedContent, afterPrefix, after)(code)
	    }

	    effects.enter('codeFlowValue');
	    return content(code)
	  }
	  /** @type {State} */

	  function content(code) {
	    if (code === null || markdownLineEnding(code)) {
	      effects.exit('codeFlowValue');
	      return afterPrefix(code)
	    }

	    effects.consume(code);
	    return content
	  }
	  /** @type {State} */

	  function after(code) {
	    effects.exit('codeIndented');
	    return ok(code)
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeIndentedContent(effects, ok, nok) {
	  const self = this;
	  return start
	  /** @type {State} */

	  function start(code) {
	    // If this is a lazy line, it can’t be code.
	    if (self.parser.lazy[self.now().line]) {
	      return nok(code)
	    }

	    if (markdownLineEnding(code)) {
	      effects.enter('lineEnding');
	      effects.consume(code);
	      effects.exit('lineEnding');
	      return start
	    }

	    return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code)
	  }
	  /** @type {State} */

	  function afterPrefix(code) {
	    const tail = self.events[self.events.length - 1];
	    return tail &&
	      tail[1].type === 'linePrefix' &&
	      tail[2].sliceSerialize(tail[1], true).length >= 4
	      ? ok(code)
	      : markdownLineEnding(code)
	      ? start(code)
	      : nok(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Resolver} Resolver
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').Previous} Previous
	 * @typedef {import('micromark-util-types').Token} Token
	 * @typedef {import('micromark-util-types').State} State
	 */

	/** @type {Construct} */
	const codeText = {
	  name: 'codeText',
	  tokenize: tokenizeCodeText,
	  resolve: resolveCodeText,
	  previous
	};
	/** @type {Resolver} */

	function resolveCodeText(events) {
	  let tailExitIndex = events.length - 4;
	  let headEnterIndex = 3;
	  /** @type {number} */

	  let index;
	  /** @type {number|undefined} */

	  let enter; // If we start and end with an EOL or a space.

	  if (
	    (events[headEnterIndex][1].type === 'lineEnding' ||
	      events[headEnterIndex][1].type === 'space') &&
	    (events[tailExitIndex][1].type === 'lineEnding' ||
	      events[tailExitIndex][1].type === 'space')
	  ) {
	    index = headEnterIndex; // And we have data.

	    while (++index < tailExitIndex) {
	      if (events[index][1].type === 'codeTextData') {
	        // Then we have padding.
	        events[headEnterIndex][1].type = 'codeTextPadding';
	        events[tailExitIndex][1].type = 'codeTextPadding';
	        headEnterIndex += 2;
	        tailExitIndex -= 2;
	        break
	      }
	    }
	  } // Merge adjacent spaces and data.

	  index = headEnterIndex - 1;
	  tailExitIndex++;

	  while (++index <= tailExitIndex) {
	    if (enter === undefined) {
	      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {
	        enter = index;
	      }
	    } else if (
	      index === tailExitIndex ||
	      events[index][1].type === 'lineEnding'
	    ) {
	      events[enter][1].type = 'codeTextData';

	      if (index !== enter + 2) {
	        events[enter][1].end = events[index - 1][1].end;
	        events.splice(enter + 2, index - enter - 2);
	        tailExitIndex -= index - enter - 2;
	        index = enter + 2;
	      }

	      enter = undefined;
	    }
	  }

	  return events
	}
	/** @type {Previous} */

	function previous(code) {
	  // If there is a previous code, there will always be a tail.
	  return (
	    code !== 96 ||
	    this.events[this.events.length - 1][1].type === 'characterEscape'
	  )
	}
	/** @type {Tokenizer} */

	function tokenizeCodeText(effects, ok, nok) {
	  let sizeOpen = 0;
	  /** @type {number} */

	  let size;
	  /** @type {Token} */

	  let token;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('codeText');
	    effects.enter('codeTextSequence');
	    return openingSequence(code)
	  }
	  /** @type {State} */

	  function openingSequence(code) {
	    if (code === 96) {
	      effects.consume(code);
	      sizeOpen++;
	      return openingSequence
	    }

	    effects.exit('codeTextSequence');
	    return gap(code)
	  }
	  /** @type {State} */

	  function gap(code) {
	    // EOF.
	    if (code === null) {
	      return nok(code)
	    } // Closing fence?
	    // Could also be data.

	    if (code === 96) {
	      token = effects.enter('codeTextSequence');
	      size = 0;
	      return closingSequence(code)
	    } // Tabs don’t work, and virtual spaces don’t make sense.

	    if (code === 32) {
	      effects.enter('space');
	      effects.consume(code);
	      effects.exit('space');
	      return gap
	    }

	    if (markdownLineEnding(code)) {
	      effects.enter('lineEnding');
	      effects.consume(code);
	      effects.exit('lineEnding');
	      return gap
	    } // Data.

	    effects.enter('codeTextData');
	    return data(code)
	  } // In code.

	  /** @type {State} */

	  function data(code) {
	    if (
	      code === null ||
	      code === 32 ||
	      code === 96 ||
	      markdownLineEnding(code)
	    ) {
	      effects.exit('codeTextData');
	      return gap(code)
	    }

	    effects.consume(code);
	    return data
	  } // Closing fence.

	  /** @type {State} */

	  function closingSequence(code) {
	    // More.
	    if (code === 96) {
	      effects.consume(code);
	      size++;
	      return closingSequence
	    } // Done!

	    if (size === sizeOpen) {
	      effects.exit('codeTextSequence');
	      effects.exit('codeText');
	      return ok(code)
	    } // More or less accents: mark as data.

	    token.type = 'codeTextData';
	    return data(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Token} Token
	 * @typedef {import('micromark-util-types').Chunk} Chunk
	 * @typedef {import('micromark-util-types').Event} Event
	 */

	/**
	 * Tokenize subcontent.
	 *
	 * @param {Event[]} events
	 * @returns {boolean}
	 */
	function subtokenize(events) {
	  /** @type {Record<string, number>} */
	  const jumps = {};
	  let index = -1;
	  /** @type {Event} */

	  let event;
	  /** @type {number|undefined} */

	  let lineIndex;
	  /** @type {number} */

	  let otherIndex;
	  /** @type {Event} */

	  let otherEvent;
	  /** @type {Event[]} */

	  let parameters;
	  /** @type {Event[]} */

	  let subevents;
	  /** @type {boolean|undefined} */

	  let more;

	  while (++index < events.length) {
	    while (index in jumps) {
	      index = jumps[index];
	    }

	    event = events[index]; // Add a hook for the GFM tasklist extension, which needs to know if text
	    // is in the first content of a list item.

	    if (
	      index &&
	      event[1].type === 'chunkFlow' &&
	      events[index - 1][1].type === 'listItemPrefix'
	    ) {
	      subevents = event[1]._tokenizer.events;
	      otherIndex = 0;

	      if (
	        otherIndex < subevents.length &&
	        subevents[otherIndex][1].type === 'lineEndingBlank'
	      ) {
	        otherIndex += 2;
	      }

	      if (
	        otherIndex < subevents.length &&
	        subevents[otherIndex][1].type === 'content'
	      ) {
	        while (++otherIndex < subevents.length) {
	          if (subevents[otherIndex][1].type === 'content') {
	            break
	          }

	          if (subevents[otherIndex][1].type === 'chunkText') {
	            subevents[otherIndex][1]._isInFirstContentOfListItem = true;
	            otherIndex++;
	          }
	        }
	      }
	    } // Enter.

	    if (event[0] === 'enter') {
	      if (event[1].contentType) {
	        Object.assign(jumps, subcontent(events, index));
	        index = jumps[index];
	        more = true;
	      }
	    } // Exit.
	    else if (event[1]._container) {
	      otherIndex = index;
	      lineIndex = undefined;

	      while (otherIndex--) {
	        otherEvent = events[otherIndex];

	        if (
	          otherEvent[1].type === 'lineEnding' ||
	          otherEvent[1].type === 'lineEndingBlank'
	        ) {
	          if (otherEvent[0] === 'enter') {
	            if (lineIndex) {
	              events[lineIndex][1].type = 'lineEndingBlank';
	            }

	            otherEvent[1].type = 'lineEnding';
	            lineIndex = otherIndex;
	          }
	        } else {
	          break
	        }
	      }

	      if (lineIndex) {
	        // Fix position.
	        event[1].end = Object.assign({}, events[lineIndex][1].start); // Switch container exit w/ line endings.

	        parameters = events.slice(lineIndex, index);
	        parameters.unshift(event);
	        splice(events, lineIndex, index - lineIndex + 1, parameters);
	      }
	    }
	  }

	  return !more
	}
	/**
	 * Tokenize embedded tokens.
	 *
	 * @param {Event[]} events
	 * @param {number} eventIndex
	 * @returns {Record<string, number>}
	 */

	function subcontent(events, eventIndex) {
	  const token = events[eventIndex][1];
	  const context = events[eventIndex][2];
	  let startPosition = eventIndex - 1;
	  /** @type {number[]} */

	  const startPositions = [];
	  const tokenizer =
	    token._tokenizer || context.parser[token.contentType](token.start);
	  const childEvents = tokenizer.events;
	  /** @type {[number, number][]} */

	  const jumps = [];
	  /** @type {Record<string, number>} */

	  const gaps = {};
	  /** @type {Chunk[]} */

	  let stream;
	  /** @type {Token|undefined} */

	  let previous;
	  let index = -1;
	  /** @type {Token|undefined} */

	  let current = token;
	  let adjust = 0;
	  let start = 0;
	  const breaks = [start]; // Loop forward through the linked tokens to pass them in order to the
	  // subtokenizer.

	  while (current) {
	    // Find the position of the event for this token.
	    while (events[++startPosition][1] !== current) {
	      // Empty.
	    }

	    startPositions.push(startPosition);

	    if (!current._tokenizer) {
	      stream = context.sliceStream(current);

	      if (!current.next) {
	        stream.push(null);
	      }

	      if (previous) {
	        tokenizer.defineSkip(current.start);
	      }

	      if (current._isInFirstContentOfListItem) {
	        tokenizer._gfmTasklistFirstContentOfListItem = true;
	      }

	      tokenizer.write(stream);

	      if (current._isInFirstContentOfListItem) {
	        tokenizer._gfmTasklistFirstContentOfListItem = undefined;
	      }
	    } // Unravel the next token.

	    previous = current;
	    current = current.next;
	  } // Now, loop back through all events (and linked tokens), to figure out which
	  // parts belong where.

	  current = token;

	  while (++index < childEvents.length) {
	    if (
	      // Find a void token that includes a break.
	      childEvents[index][0] === 'exit' &&
	      childEvents[index - 1][0] === 'enter' &&
	      childEvents[index][1].type === childEvents[index - 1][1].type &&
	      childEvents[index][1].start.line !== childEvents[index][1].end.line
	    ) {
	      start = index + 1;
	      breaks.push(start); // Help GC.

	      current._tokenizer = undefined;
	      current.previous = undefined;
	      current = current.next;
	    }
	  } // Help GC.

	  tokenizer.events = []; // If there’s one more token (which is the cases for lines that end in an
	  // EOF), that’s perfect: the last point we found starts it.
	  // If there isn’t then make sure any remaining content is added to it.

	  if (current) {
	    // Help GC.
	    current._tokenizer = undefined;
	    current.previous = undefined;
	  } else {
	    breaks.pop();
	  } // Now splice the events from the subtokenizer into the current events,
	  // moving back to front so that splice indices aren’t affected.

	  index = breaks.length;

	  while (index--) {
	    const slice = childEvents.slice(breaks[index], breaks[index + 1]);
	    const start = startPositions.pop();
	    jumps.unshift([start, start + slice.length - 1]);
	    splice(events, start, 2, slice);
	  }

	  index = -1;

	  while (++index < jumps.length) {
	    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];
	    adjust += jumps[index][1] - jumps[index][0] - 1;
	  }

	  return gaps
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Resolver} Resolver
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').Token} Token
	 * @typedef {import('micromark-util-types').State} State
	 */

	/**
	 * No name because it must not be turned off.
	 * @type {Construct}
	 */
	const content$1 = {
	  tokenize: tokenizeContent,
	  resolve: resolveContent
	};
	/** @type {Construct} */

	const continuationConstruct = {
	  tokenize: tokenizeContinuation,
	  partial: true
	};
	/**
	 * Content is transparent: it’s parsed right now. That way, definitions are also
	 * parsed right now: before text in paragraphs (specifically, media) are parsed.
	 *
	 * @type {Resolver}
	 */

	function resolveContent(events) {
	  subtokenize(events);
	  return events
	}
	/** @type {Tokenizer} */

	function tokenizeContent(effects, ok) {
	  /** @type {Token} */
	  let previous;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('content');
	    previous = effects.enter('chunkContent', {
	      contentType: 'content'
	    });
	    return data(code)
	  }
	  /** @type {State} */

	  function data(code) {
	    if (code === null) {
	      return contentEnd(code)
	    }

	    if (markdownLineEnding(code)) {
	      return effects.check(
	        continuationConstruct,
	        contentContinue,
	        contentEnd
	      )(code)
	    } // Data.

	    effects.consume(code);
	    return data
	  }
	  /** @type {State} */

	  function contentEnd(code) {
	    effects.exit('chunkContent');
	    effects.exit('content');
	    return ok(code)
	  }
	  /** @type {State} */

	  function contentContinue(code) {
	    effects.consume(code);
	    effects.exit('chunkContent');
	    previous.next = effects.enter('chunkContent', {
	      contentType: 'content',
	      previous
	    });
	    previous = previous.next;
	    return data
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeContinuation(effects, ok, nok) {
	  const self = this;
	  return startLookahead
	  /** @type {State} */

	  function startLookahead(code) {
	    effects.exit('chunkContent');
	    effects.enter('lineEnding');
	    effects.consume(code);
	    effects.exit('lineEnding');
	    return factorySpace(effects, prefixed, 'linePrefix')
	  }
	  /** @type {State} */

	  function prefixed(code) {
	    if (code === null || markdownLineEnding(code)) {
	      return nok(code)
	    }

	    const tail = self.events[self.events.length - 1];

	    if (
	      !self.parser.constructs.disable.null.includes('codeIndented') &&
	      tail &&
	      tail[1].type === 'linePrefix' &&
	      tail[2].sliceSerialize(tail[1], true).length >= 4
	    ) {
	      return ok(code)
	    }

	    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Effects} Effects
	 * @typedef {import('micromark-util-types').State} State
	 */

	/**
	 * @param {Effects} effects
	 * @param {State} ok
	 * @param {State} nok
	 * @param {string} type
	 * @param {string} literalType
	 * @param {string} literalMarkerType
	 * @param {string} rawType
	 * @param {string} stringType
	 * @param {number} [max=Infinity]
	 * @returns {State}
	 */
	// eslint-disable-next-line max-params
	function factoryDestination(
	  effects,
	  ok,
	  nok,
	  type,
	  literalType,
	  literalMarkerType,
	  rawType,
	  stringType,
	  max
	) {
	  const limit = max || Number.POSITIVE_INFINITY;
	  let balance = 0;
	  return start
	  /** @type {State} */

	  function start(code) {
	    if (code === 60) {
	      effects.enter(type);
	      effects.enter(literalType);
	      effects.enter(literalMarkerType);
	      effects.consume(code);
	      effects.exit(literalMarkerType);
	      return destinationEnclosedBefore
	    }

	    if (code === null || code === 41 || asciiControl(code)) {
	      return nok(code)
	    }

	    effects.enter(type);
	    effects.enter(rawType);
	    effects.enter(stringType);
	    effects.enter('chunkString', {
	      contentType: 'string'
	    });
	    return destinationRaw(code)
	  }
	  /** @type {State} */

	  function destinationEnclosedBefore(code) {
	    if (code === 62) {
	      effects.enter(literalMarkerType);
	      effects.consume(code);
	      effects.exit(literalMarkerType);
	      effects.exit(literalType);
	      effects.exit(type);
	      return ok
	    }

	    effects.enter(stringType);
	    effects.enter('chunkString', {
	      contentType: 'string'
	    });
	    return destinationEnclosed(code)
	  }
	  /** @type {State} */

	  function destinationEnclosed(code) {
	    if (code === 62) {
	      effects.exit('chunkString');
	      effects.exit(stringType);
	      return destinationEnclosedBefore(code)
	    }

	    if (code === null || code === 60 || markdownLineEnding(code)) {
	      return nok(code)
	    }

	    effects.consume(code);
	    return code === 92 ? destinationEnclosedEscape : destinationEnclosed
	  }
	  /** @type {State} */

	  function destinationEnclosedEscape(code) {
	    if (code === 60 || code === 62 || code === 92) {
	      effects.consume(code);
	      return destinationEnclosed
	    }

	    return destinationEnclosed(code)
	  }
	  /** @type {State} */

	  function destinationRaw(code) {
	    if (code === 40) {
	      if (++balance > limit) return nok(code)
	      effects.consume(code);
	      return destinationRaw
	    }

	    if (code === 41) {
	      if (!balance--) {
	        effects.exit('chunkString');
	        effects.exit(stringType);
	        effects.exit(rawType);
	        effects.exit(type);
	        return ok(code)
	      }

	      effects.consume(code);
	      return destinationRaw
	    }

	    if (code === null || markdownLineEndingOrSpace(code)) {
	      if (balance) return nok(code)
	      effects.exit('chunkString');
	      effects.exit(stringType);
	      effects.exit(rawType);
	      effects.exit(type);
	      return ok(code)
	    }

	    if (asciiControl(code)) return nok(code)
	    effects.consume(code);
	    return code === 92 ? destinationRawEscape : destinationRaw
	  }
	  /** @type {State} */

	  function destinationRawEscape(code) {
	    if (code === 40 || code === 41 || code === 92) {
	      effects.consume(code);
	      return destinationRaw
	    }

	    return destinationRaw(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Effects} Effects
	 * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
	 * @typedef {import('micromark-util-types').State} State
	 */

	/**
	 * @this {TokenizeContext}
	 * @param {Effects} effects
	 * @param {State} ok
	 * @param {State} nok
	 * @param {string} type
	 * @param {string} markerType
	 * @param {string} stringType
	 * @returns {State}
	 */
	// eslint-disable-next-line max-params
	function factoryLabel(effects, ok, nok, type, markerType, stringType) {
	  const self = this;
	  let size = 0;
	  /** @type {boolean} */

	  let data;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter(type);
	    effects.enter(markerType);
	    effects.consume(code);
	    effects.exit(markerType);
	    effects.enter(stringType);
	    return atBreak
	  }
	  /** @type {State} */

	  function atBreak(code) {
	    if (
	      code === null ||
	      code === 91 ||
	      (code === 93 && !data) ||
	      /* To do: remove in the future once we’ve switched from
	       * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,
	       * which doesn’t need this */

	      /* Hidden footnotes hook */

	      /* c8 ignore next 3 */
	      (code === 94 &&
	        !size &&
	        '_hiddenFootnoteSupport' in self.parser.constructs) ||
	      size > 999
	    ) {
	      return nok(code)
	    }

	    if (code === 93) {
	      effects.exit(stringType);
	      effects.enter(markerType);
	      effects.consume(code);
	      effects.exit(markerType);
	      effects.exit(type);
	      return ok
	    }

	    if (markdownLineEnding(code)) {
	      effects.enter('lineEnding');
	      effects.consume(code);
	      effects.exit('lineEnding');
	      return atBreak
	    }

	    effects.enter('chunkString', {
	      contentType: 'string'
	    });
	    return label(code)
	  }
	  /** @type {State} */

	  function label(code) {
	    if (
	      code === null ||
	      code === 91 ||
	      code === 93 ||
	      markdownLineEnding(code) ||
	      size++ > 999
	    ) {
	      effects.exit('chunkString');
	      return atBreak(code)
	    }

	    effects.consume(code);
	    data = data || !markdownSpace(code);
	    return code === 92 ? labelEscape : label
	  }
	  /** @type {State} */

	  function labelEscape(code) {
	    if (code === 91 || code === 92 || code === 93) {
	      effects.consume(code);
	      size++;
	      return label
	    }

	    return label(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Effects} Effects
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Code} Code
	 */

	/**
	 * @param {Effects} effects
	 * @param {State} ok
	 * @param {State} nok
	 * @param {string} type
	 * @param {string} markerType
	 * @param {string} stringType
	 * @returns {State}
	 */
	// eslint-disable-next-line max-params
	function factoryTitle(effects, ok, nok, type, markerType, stringType) {
	  /** @type {NonNullable<Code>} */
	  let marker;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter(type);
	    effects.enter(markerType);
	    effects.consume(code);
	    effects.exit(markerType);
	    marker = code === 40 ? 41 : code;
	    return atFirstTitleBreak
	  }
	  /** @type {State} */

	  function atFirstTitleBreak(code) {
	    if (code === marker) {
	      effects.enter(markerType);
	      effects.consume(code);
	      effects.exit(markerType);
	      effects.exit(type);
	      return ok
	    }

	    effects.enter(stringType);
	    return atTitleBreak(code)
	  }
	  /** @type {State} */

	  function atTitleBreak(code) {
	    if (code === marker) {
	      effects.exit(stringType);
	      return atFirstTitleBreak(marker)
	    }

	    if (code === null) {
	      return nok(code)
	    } // Note: blank lines can’t exist in content.

	    if (markdownLineEnding(code)) {
	      effects.enter('lineEnding');
	      effects.consume(code);
	      effects.exit('lineEnding');
	      return factorySpace(effects, atTitleBreak, 'linePrefix')
	    }

	    effects.enter('chunkString', {
	      contentType: 'string'
	    });
	    return title(code)
	  }
	  /** @type {State} */

	  function title(code) {
	    if (code === marker || code === null || markdownLineEnding(code)) {
	      effects.exit('chunkString');
	      return atTitleBreak(code)
	    }

	    effects.consume(code);
	    return code === 92 ? titleEscape : title
	  }
	  /** @type {State} */

	  function titleEscape(code) {
	    if (code === marker || code === 92) {
	      effects.consume(code);
	      return title
	    }

	    return title(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Effects} Effects
	 * @typedef {import('micromark-util-types').State} State
	 */

	/**
	 * @param {Effects} effects
	 * @param {State} ok
	 */
	function factoryWhitespace(effects, ok) {
	  /** @type {boolean} */
	  let seen;
	  return start
	  /** @type {State} */

	  function start(code) {
	    if (markdownLineEnding(code)) {
	      effects.enter('lineEnding');
	      effects.consume(code);
	      effects.exit('lineEnding');
	      seen = true;
	      return start
	    }

	    if (markdownSpace(code)) {
	      return factorySpace(
	        effects,
	        start,
	        seen ? 'linePrefix' : 'lineSuffix'
	      )(code)
	    }

	    return ok(code)
	  }
	}

	/**
	 * Normalize an identifier (such as used in definitions).
	 *
	 * @param {string} value
	 * @returns {string}
	 */
	function normalizeIdentifier(value) {
	  return (
	    value // Collapse Markdown whitespace.
	      .replace(/[\t\n\r ]+/g, ' ') // Trim.
	      .replace(/^ | $/g, '') // Some characters are considered “uppercase”, but if their lowercase
	      // counterpart is uppercased will result in a different uppercase
	      // character.
	      // Hence, to get that form, we perform both lower- and uppercase.
	      // Upper case makes sure keys will not interact with default prototypal
	      // methods: no method is uppercase.
	      .toLowerCase()
	      .toUpperCase()
	  )
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 */

	/** @type {Construct} */
	const definition = {
	  name: 'definition',
	  tokenize: tokenizeDefinition
	};
	/** @type {Construct} */

	const titleConstruct = {
	  tokenize: tokenizeTitle,
	  partial: true
	};
	/** @type {Tokenizer} */

	function tokenizeDefinition(effects, ok, nok) {
	  const self = this;
	  /** @type {string} */

	  let identifier;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('definition');
	    return factoryLabel.call(
	      self,
	      effects,
	      labelAfter,
	      nok,
	      'definitionLabel',
	      'definitionLabelMarker',
	      'definitionLabelString'
	    )(code)
	  }
	  /** @type {State} */

	  function labelAfter(code) {
	    identifier = normalizeIdentifier(
	      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)
	    );

	    if (code === 58) {
	      effects.enter('definitionMarker');
	      effects.consume(code);
	      effects.exit('definitionMarker'); // Note: blank lines can’t exist in content.

	      return factoryWhitespace(
	        effects,
	        factoryDestination(
	          effects,
	          effects.attempt(
	            titleConstruct,
	            factorySpace(effects, after, 'whitespace'),
	            factorySpace(effects, after, 'whitespace')
	          ),
	          nok,
	          'definitionDestination',
	          'definitionDestinationLiteral',
	          'definitionDestinationLiteralMarker',
	          'definitionDestinationRaw',
	          'definitionDestinationString'
	        )
	      )
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function after(code) {
	    if (code === null || markdownLineEnding(code)) {
	      effects.exit('definition');

	      if (!self.parser.defined.includes(identifier)) {
	        self.parser.defined.push(identifier);
	      }

	      return ok(code)
	    }

	    return nok(code)
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeTitle(effects, ok, nok) {
	  return start
	  /** @type {State} */

	  function start(code) {
	    return markdownLineEndingOrSpace(code)
	      ? factoryWhitespace(effects, before)(code)
	      : nok(code)
	  }
	  /** @type {State} */

	  function before(code) {
	    if (code === 34 || code === 39 || code === 40) {
	      return factoryTitle(
	        effects,
	        factorySpace(effects, after, 'whitespace'),
	        nok,
	        'definitionTitle',
	        'definitionTitleMarker',
	        'definitionTitleString'
	      )(code)
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function after(code) {
	    return code === null || markdownLineEnding(code) ? ok(code) : nok(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 */

	/** @type {Construct} */
	const hardBreakEscape = {
	  name: 'hardBreakEscape',
	  tokenize: tokenizeHardBreakEscape
	};
	/** @type {Tokenizer} */

	function tokenizeHardBreakEscape(effects, ok, nok) {
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('hardBreakEscape');
	    effects.enter('escapeMarker');
	    effects.consume(code);
	    return open
	  }
	  /** @type {State} */

	  function open(code) {
	    if (markdownLineEnding(code)) {
	      effects.exit('escapeMarker');
	      effects.exit('hardBreakEscape');
	      return ok(code)
	    }

	    return nok(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Resolver} Resolver
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').Token} Token
	 * @typedef {import('micromark-util-types').State} State
	 */

	/** @type {Construct} */
	const headingAtx = {
	  name: 'headingAtx',
	  tokenize: tokenizeHeadingAtx,
	  resolve: resolveHeadingAtx
	};
	/** @type {Resolver} */

	function resolveHeadingAtx(events, context) {
	  let contentEnd = events.length - 2;
	  let contentStart = 3;
	  /** @type {Token} */

	  let content;
	  /** @type {Token} */

	  let text; // Prefix whitespace, part of the opening.

	  if (events[contentStart][1].type === 'whitespace') {
	    contentStart += 2;
	  } // Suffix whitespace, part of the closing.

	  if (
	    contentEnd - 2 > contentStart &&
	    events[contentEnd][1].type === 'whitespace'
	  ) {
	    contentEnd -= 2;
	  }

	  if (
	    events[contentEnd][1].type === 'atxHeadingSequence' &&
	    (contentStart === contentEnd - 1 ||
	      (contentEnd - 4 > contentStart &&
	        events[contentEnd - 2][1].type === 'whitespace'))
	  ) {
	    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;
	  }

	  if (contentEnd > contentStart) {
	    content = {
	      type: 'atxHeadingText',
	      start: events[contentStart][1].start,
	      end: events[contentEnd][1].end
	    };
	    text = {
	      type: 'chunkText',
	      start: events[contentStart][1].start,
	      end: events[contentEnd][1].end,
	      // @ts-expect-error Constants are fine to assign.
	      contentType: 'text'
	    };
	    splice(events, contentStart, contentEnd - contentStart + 1, [
	      ['enter', content, context],
	      ['enter', text, context],
	      ['exit', text, context],
	      ['exit', content, context]
	    ]);
	  }

	  return events
	}
	/** @type {Tokenizer} */

	function tokenizeHeadingAtx(effects, ok, nok) {
	  const self = this;
	  let size = 0;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('atxHeading');
	    effects.enter('atxHeadingSequence');
	    return fenceOpenInside(code)
	  }
	  /** @type {State} */

	  function fenceOpenInside(code) {
	    if (code === 35 && size++ < 6) {
	      effects.consume(code);
	      return fenceOpenInside
	    }

	    if (code === null || markdownLineEndingOrSpace(code)) {
	      effects.exit('atxHeadingSequence');
	      return self.interrupt ? ok(code) : headingBreak(code)
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function headingBreak(code) {
	    if (code === 35) {
	      effects.enter('atxHeadingSequence');
	      return sequence(code)
	    }

	    if (code === null || markdownLineEnding(code)) {
	      effects.exit('atxHeading');
	      return ok(code)
	    }

	    if (markdownSpace(code)) {
	      return factorySpace(effects, headingBreak, 'whitespace')(code)
	    }

	    effects.enter('atxHeadingText');
	    return data(code)
	  }
	  /** @type {State} */

	  function sequence(code) {
	    if (code === 35) {
	      effects.consume(code);
	      return sequence
	    }

	    effects.exit('atxHeadingSequence');
	    return headingBreak(code)
	  }
	  /** @type {State} */

	  function data(code) {
	    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {
	      effects.exit('atxHeadingText');
	      return headingBreak(code)
	    }

	    effects.consume(code);
	    return data
	  }
	}

	/**
	 * List of lowercase HTML tag names which when parsing HTML (flow), result
	 * in more relaxed rules (condition 6): because they are known blocks, the
	 * HTML-like syntax doesn’t have to be strictly parsed.
	 * For tag names not in this list, a more strict algorithm (condition 7) is used
	 * to detect whether the HTML-like syntax is seen as HTML (flow) or not.
	 *
	 * This is copied from:
	 * <https://spec.commonmark.org/0.29/#html-blocks>.
	 */
	const htmlBlockNames = [
	  'address',
	  'article',
	  'aside',
	  'base',
	  'basefont',
	  'blockquote',
	  'body',
	  'caption',
	  'center',
	  'col',
	  'colgroup',
	  'dd',
	  'details',
	  'dialog',
	  'dir',
	  'div',
	  'dl',
	  'dt',
	  'fieldset',
	  'figcaption',
	  'figure',
	  'footer',
	  'form',
	  'frame',
	  'frameset',
	  'h1',
	  'h2',
	  'h3',
	  'h4',
	  'h5',
	  'h6',
	  'head',
	  'header',
	  'hr',
	  'html',
	  'iframe',
	  'legend',
	  'li',
	  'link',
	  'main',
	  'menu',
	  'menuitem',
	  'nav',
	  'noframes',
	  'ol',
	  'optgroup',
	  'option',
	  'p',
	  'param',
	  'section',
	  'source',
	  'summary',
	  'table',
	  'tbody',
	  'td',
	  'tfoot',
	  'th',
	  'thead',
	  'title',
	  'tr',
	  'track',
	  'ul'
	];

	/**
	 * List of lowercase HTML tag names which when parsing HTML (flow), result in
	 * HTML that can include lines w/o exiting, until a closing tag also in this
	 * list is found (condition 1).
	 *
	 * This module is copied from:
	 * <https://spec.commonmark.org/0.29/#html-blocks>.
	 *
	 * Note that `textarea` is not available in `CommonMark@0.29` but has been
	 * merged to the primary branch and is slated to be released in the next release
	 * of CommonMark.
	 */
	const htmlRawNames = ['pre', 'script', 'style', 'textarea'];

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Resolver} Resolver
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Code} Code
	 */
	/** @type {Construct} */

	const htmlFlow = {
	  name: 'htmlFlow',
	  tokenize: tokenizeHtmlFlow,
	  resolveTo: resolveToHtmlFlow,
	  concrete: true
	};
	/** @type {Construct} */

	const nextBlankConstruct = {
	  tokenize: tokenizeNextBlank,
	  partial: true
	};
	/** @type {Resolver} */

	function resolveToHtmlFlow(events) {
	  let index = events.length;

	  while (index--) {
	    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {
	      break
	    }
	  }

	  if (index > 1 && events[index - 2][1].type === 'linePrefix') {
	    // Add the prefix start to the HTML token.
	    events[index][1].start = events[index - 2][1].start; // Add the prefix start to the HTML line token.

	    events[index + 1][1].start = events[index - 2][1].start; // Remove the line prefix.

	    events.splice(index - 2, 2);
	  }

	  return events
	}
	/** @type {Tokenizer} */

	function tokenizeHtmlFlow(effects, ok, nok) {
	  const self = this;
	  /** @type {number} */

	  let kind;
	  /** @type {boolean} */

	  let startTag;
	  /** @type {string} */

	  let buffer;
	  /** @type {number} */

	  let index;
	  /** @type {Code} */

	  let marker;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('htmlFlow');
	    effects.enter('htmlFlowData');
	    effects.consume(code);
	    return open
	  }
	  /** @type {State} */

	  function open(code) {
	    if (code === 33) {
	      effects.consume(code);
	      return declarationStart
	    }

	    if (code === 47) {
	      effects.consume(code);
	      return tagCloseStart
	    }

	    if (code === 63) {
	      effects.consume(code);
	      kind = 3; // While we’re in an instruction instead of a declaration, we’re on a `?`
	      // right now, so we do need to search for `>`, similar to declarations.

	      return self.interrupt ? ok : continuationDeclarationInside
	    }

	    if (asciiAlpha(code)) {
	      effects.consume(code);
	      buffer = String.fromCharCode(code);
	      startTag = true;
	      return tagName
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function declarationStart(code) {
	    if (code === 45) {
	      effects.consume(code);
	      kind = 2;
	      return commentOpenInside
	    }

	    if (code === 91) {
	      effects.consume(code);
	      kind = 5;
	      buffer = 'CDATA[';
	      index = 0;
	      return cdataOpenInside
	    }

	    if (asciiAlpha(code)) {
	      effects.consume(code);
	      kind = 4;
	      return self.interrupt ? ok : continuationDeclarationInside
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function commentOpenInside(code) {
	    if (code === 45) {
	      effects.consume(code);
	      return self.interrupt ? ok : continuationDeclarationInside
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function cdataOpenInside(code) {
	    if (code === buffer.charCodeAt(index++)) {
	      effects.consume(code);
	      return index === buffer.length
	        ? self.interrupt
	          ? ok
	          : continuation
	        : cdataOpenInside
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function tagCloseStart(code) {
	    if (asciiAlpha(code)) {
	      effects.consume(code);
	      buffer = String.fromCharCode(code);
	      return tagName
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function tagName(code) {
	    if (
	      code === null ||
	      code === 47 ||
	      code === 62 ||
	      markdownLineEndingOrSpace(code)
	    ) {
	      if (
	        code !== 47 &&
	        startTag &&
	        htmlRawNames.includes(buffer.toLowerCase())
	      ) {
	        kind = 1;
	        return self.interrupt ? ok(code) : continuation(code)
	      }

	      if (htmlBlockNames.includes(buffer.toLowerCase())) {
	        kind = 6;

	        if (code === 47) {
	          effects.consume(code);
	          return basicSelfClosing
	        }

	        return self.interrupt ? ok(code) : continuation(code)
	      }

	      kind = 7; // Do not support complete HTML when interrupting

	      return self.interrupt && !self.parser.lazy[self.now().line]
	        ? nok(code)
	        : startTag
	        ? completeAttributeNameBefore(code)
	        : completeClosingTagAfter(code)
	    }

	    if (code === 45 || asciiAlphanumeric(code)) {
	      effects.consume(code);
	      buffer += String.fromCharCode(code);
	      return tagName
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function basicSelfClosing(code) {
	    if (code === 62) {
	      effects.consume(code);
	      return self.interrupt ? ok : continuation
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function completeClosingTagAfter(code) {
	    if (markdownSpace(code)) {
	      effects.consume(code);
	      return completeClosingTagAfter
	    }

	    return completeEnd(code)
	  }
	  /** @type {State} */

	  function completeAttributeNameBefore(code) {
	    if (code === 47) {
	      effects.consume(code);
	      return completeEnd
	    }

	    if (code === 58 || code === 95 || asciiAlpha(code)) {
	      effects.consume(code);
	      return completeAttributeName
	    }

	    if (markdownSpace(code)) {
	      effects.consume(code);
	      return completeAttributeNameBefore
	    }

	    return completeEnd(code)
	  }
	  /** @type {State} */

	  function completeAttributeName(code) {
	    if (
	      code === 45 ||
	      code === 46 ||
	      code === 58 ||
	      code === 95 ||
	      asciiAlphanumeric(code)
	    ) {
	      effects.consume(code);
	      return completeAttributeName
	    }

	    return completeAttributeNameAfter(code)
	  }
	  /** @type {State} */

	  function completeAttributeNameAfter(code) {
	    if (code === 61) {
	      effects.consume(code);
	      return completeAttributeValueBefore
	    }

	    if (markdownSpace(code)) {
	      effects.consume(code);
	      return completeAttributeNameAfter
	    }

	    return completeAttributeNameBefore(code)
	  }
	  /** @type {State} */

	  function completeAttributeValueBefore(code) {
	    if (
	      code === null ||
	      code === 60 ||
	      code === 61 ||
	      code === 62 ||
	      code === 96
	    ) {
	      return nok(code)
	    }

	    if (code === 34 || code === 39) {
	      effects.consume(code);
	      marker = code;
	      return completeAttributeValueQuoted
	    }

	    if (markdownSpace(code)) {
	      effects.consume(code);
	      return completeAttributeValueBefore
	    }

	    marker = null;
	    return completeAttributeValueUnquoted(code)
	  }
	  /** @type {State} */

	  function completeAttributeValueQuoted(code) {
	    if (code === null || markdownLineEnding(code)) {
	      return nok(code)
	    }

	    if (code === marker) {
	      effects.consume(code);
	      return completeAttributeValueQuotedAfter
	    }

	    effects.consume(code);
	    return completeAttributeValueQuoted
	  }
	  /** @type {State} */

	  function completeAttributeValueUnquoted(code) {
	    if (
	      code === null ||
	      code === 34 ||
	      code === 39 ||
	      code === 60 ||
	      code === 61 ||
	      code === 62 ||
	      code === 96 ||
	      markdownLineEndingOrSpace(code)
	    ) {
	      return completeAttributeNameAfter(code)
	    }

	    effects.consume(code);
	    return completeAttributeValueUnquoted
	  }
	  /** @type {State} */

	  function completeAttributeValueQuotedAfter(code) {
	    if (code === 47 || code === 62 || markdownSpace(code)) {
	      return completeAttributeNameBefore(code)
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function completeEnd(code) {
	    if (code === 62) {
	      effects.consume(code);
	      return completeAfter
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function completeAfter(code) {
	    if (markdownSpace(code)) {
	      effects.consume(code);
	      return completeAfter
	    }

	    return code === null || markdownLineEnding(code)
	      ? continuation(code)
	      : nok(code)
	  }
	  /** @type {State} */

	  function continuation(code) {
	    if (code === 45 && kind === 2) {
	      effects.consume(code);
	      return continuationCommentInside
	    }

	    if (code === 60 && kind === 1) {
	      effects.consume(code);
	      return continuationRawTagOpen
	    }

	    if (code === 62 && kind === 4) {
	      effects.consume(code);
	      return continuationClose
	    }

	    if (code === 63 && kind === 3) {
	      effects.consume(code);
	      return continuationDeclarationInside
	    }

	    if (code === 93 && kind === 5) {
	      effects.consume(code);
	      return continuationCharacterDataInside
	    }

	    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {
	      return effects.check(
	        nextBlankConstruct,
	        continuationClose,
	        continuationAtLineEnding
	      )(code)
	    }

	    if (code === null || markdownLineEnding(code)) {
	      return continuationAtLineEnding(code)
	    }

	    effects.consume(code);
	    return continuation
	  }
	  /** @type {State} */

	  function continuationAtLineEnding(code) {
	    effects.exit('htmlFlowData');
	    return htmlContinueStart(code)
	  }
	  /** @type {State} */

	  function htmlContinueStart(code) {
	    if (code === null) {
	      return done(code)
	    }

	    if (markdownLineEnding(code)) {
	      return effects.attempt(
	        {
	          tokenize: htmlLineEnd,
	          partial: true
	        },
	        htmlContinueStart,
	        done
	      )(code)
	    }

	    effects.enter('htmlFlowData');
	    return continuation(code)
	  }
	  /** @type {Tokenizer} */

	  function htmlLineEnd(effects, ok, nok) {
	    return start
	    /** @type {State} */

	    function start(code) {
	      effects.enter('lineEnding');
	      effects.consume(code);
	      effects.exit('lineEnding');
	      return lineStart
	    }
	    /** @type {State} */

	    function lineStart(code) {
	      return self.parser.lazy[self.now().line] ? nok(code) : ok(code)
	    }
	  }
	  /** @type {State} */

	  function continuationCommentInside(code) {
	    if (code === 45) {
	      effects.consume(code);
	      return continuationDeclarationInside
	    }

	    return continuation(code)
	  }
	  /** @type {State} */

	  function continuationRawTagOpen(code) {
	    if (code === 47) {
	      effects.consume(code);
	      buffer = '';
	      return continuationRawEndTag
	    }

	    return continuation(code)
	  }
	  /** @type {State} */

	  function continuationRawEndTag(code) {
	    if (code === 62 && htmlRawNames.includes(buffer.toLowerCase())) {
	      effects.consume(code);
	      return continuationClose
	    }

	    if (asciiAlpha(code) && buffer.length < 8) {
	      effects.consume(code);
	      buffer += String.fromCharCode(code);
	      return continuationRawEndTag
	    }

	    return continuation(code)
	  }
	  /** @type {State} */

	  function continuationCharacterDataInside(code) {
	    if (code === 93) {
	      effects.consume(code);
	      return continuationDeclarationInside
	    }

	    return continuation(code)
	  }
	  /** @type {State} */

	  function continuationDeclarationInside(code) {
	    if (code === 62) {
	      effects.consume(code);
	      return continuationClose
	    } // More dashes.

	    if (code === 45 && kind === 2) {
	      effects.consume(code);
	      return continuationDeclarationInside
	    }

	    return continuation(code)
	  }
	  /** @type {State} */

	  function continuationClose(code) {
	    if (code === null || markdownLineEnding(code)) {
	      effects.exit('htmlFlowData');
	      return done(code)
	    }

	    effects.consume(code);
	    return continuationClose
	  }
	  /** @type {State} */

	  function done(code) {
	    effects.exit('htmlFlow');
	    return ok(code)
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeNextBlank(effects, ok, nok) {
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.exit('htmlFlowData');
	    effects.enter('lineEndingBlank');
	    effects.consume(code);
	    effects.exit('lineEndingBlank');
	    return effects.attempt(blankLine, ok, nok)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Code} Code
	 */

	/** @type {Construct} */
	const htmlText = {
	  name: 'htmlText',
	  tokenize: tokenizeHtmlText
	};
	/** @type {Tokenizer} */

	function tokenizeHtmlText(effects, ok, nok) {
	  const self = this;
	  /** @type {NonNullable<Code>|undefined} */

	  let marker;
	  /** @type {string} */

	  let buffer;
	  /** @type {number} */

	  let index;
	  /** @type {State} */

	  let returnState;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('htmlText');
	    effects.enter('htmlTextData');
	    effects.consume(code);
	    return open
	  }
	  /** @type {State} */

	  function open(code) {
	    if (code === 33) {
	      effects.consume(code);
	      return declarationOpen
	    }

	    if (code === 47) {
	      effects.consume(code);
	      return tagCloseStart
	    }

	    if (code === 63) {
	      effects.consume(code);
	      return instruction
	    }

	    if (asciiAlpha(code)) {
	      effects.consume(code);
	      return tagOpen
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function declarationOpen(code) {
	    if (code === 45) {
	      effects.consume(code);
	      return commentOpen
	    }

	    if (code === 91) {
	      effects.consume(code);
	      buffer = 'CDATA[';
	      index = 0;
	      return cdataOpen
	    }

	    if (asciiAlpha(code)) {
	      effects.consume(code);
	      return declaration
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function commentOpen(code) {
	    if (code === 45) {
	      effects.consume(code);
	      return commentStart
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function commentStart(code) {
	    if (code === null || code === 62) {
	      return nok(code)
	    }

	    if (code === 45) {
	      effects.consume(code);
	      return commentStartDash
	    }

	    return comment(code)
	  }
	  /** @type {State} */

	  function commentStartDash(code) {
	    if (code === null || code === 62) {
	      return nok(code)
	    }

	    return comment(code)
	  }
	  /** @type {State} */

	  function comment(code) {
	    if (code === null) {
	      return nok(code)
	    }

	    if (code === 45) {
	      effects.consume(code);
	      return commentClose
	    }

	    if (markdownLineEnding(code)) {
	      returnState = comment;
	      return atLineEnding(code)
	    }

	    effects.consume(code);
	    return comment
	  }
	  /** @type {State} */

	  function commentClose(code) {
	    if (code === 45) {
	      effects.consume(code);
	      return end
	    }

	    return comment(code)
	  }
	  /** @type {State} */

	  function cdataOpen(code) {
	    if (code === buffer.charCodeAt(index++)) {
	      effects.consume(code);
	      return index === buffer.length ? cdata : cdataOpen
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function cdata(code) {
	    if (code === null) {
	      return nok(code)
	    }

	    if (code === 93) {
	      effects.consume(code);
	      return cdataClose
	    }

	    if (markdownLineEnding(code)) {
	      returnState = cdata;
	      return atLineEnding(code)
	    }

	    effects.consume(code);
	    return cdata
	  }
	  /** @type {State} */

	  function cdataClose(code) {
	    if (code === 93) {
	      effects.consume(code);
	      return cdataEnd
	    }

	    return cdata(code)
	  }
	  /** @type {State} */

	  function cdataEnd(code) {
	    if (code === 62) {
	      return end(code)
	    }

	    if (code === 93) {
	      effects.consume(code);
	      return cdataEnd
	    }

	    return cdata(code)
	  }
	  /** @type {State} */

	  function declaration(code) {
	    if (code === null || code === 62) {
	      return end(code)
	    }

	    if (markdownLineEnding(code)) {
	      returnState = declaration;
	      return atLineEnding(code)
	    }

	    effects.consume(code);
	    return declaration
	  }
	  /** @type {State} */

	  function instruction(code) {
	    if (code === null) {
	      return nok(code)
	    }

	    if (code === 63) {
	      effects.consume(code);
	      return instructionClose
	    }

	    if (markdownLineEnding(code)) {
	      returnState = instruction;
	      return atLineEnding(code)
	    }

	    effects.consume(code);
	    return instruction
	  }
	  /** @type {State} */

	  function instructionClose(code) {
	    return code === 62 ? end(code) : instruction(code)
	  }
	  /** @type {State} */

	  function tagCloseStart(code) {
	    if (asciiAlpha(code)) {
	      effects.consume(code);
	      return tagClose
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function tagClose(code) {
	    if (code === 45 || asciiAlphanumeric(code)) {
	      effects.consume(code);
	      return tagClose
	    }

	    return tagCloseBetween(code)
	  }
	  /** @type {State} */

	  function tagCloseBetween(code) {
	    if (markdownLineEnding(code)) {
	      returnState = tagCloseBetween;
	      return atLineEnding(code)
	    }

	    if (markdownSpace(code)) {
	      effects.consume(code);
	      return tagCloseBetween
	    }

	    return end(code)
	  }
	  /** @type {State} */

	  function tagOpen(code) {
	    if (code === 45 || asciiAlphanumeric(code)) {
	      effects.consume(code);
	      return tagOpen
	    }

	    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {
	      return tagOpenBetween(code)
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function tagOpenBetween(code) {
	    if (code === 47) {
	      effects.consume(code);
	      return end
	    }

	    if (code === 58 || code === 95 || asciiAlpha(code)) {
	      effects.consume(code);
	      return tagOpenAttributeName
	    }

	    if (markdownLineEnding(code)) {
	      returnState = tagOpenBetween;
	      return atLineEnding(code)
	    }

	    if (markdownSpace(code)) {
	      effects.consume(code);
	      return tagOpenBetween
	    }

	    return end(code)
	  }
	  /** @type {State} */

	  function tagOpenAttributeName(code) {
	    if (
	      code === 45 ||
	      code === 46 ||
	      code === 58 ||
	      code === 95 ||
	      asciiAlphanumeric(code)
	    ) {
	      effects.consume(code);
	      return tagOpenAttributeName
	    }

	    return tagOpenAttributeNameAfter(code)
	  }
	  /** @type {State} */

	  function tagOpenAttributeNameAfter(code) {
	    if (code === 61) {
	      effects.consume(code);
	      return tagOpenAttributeValueBefore
	    }

	    if (markdownLineEnding(code)) {
	      returnState = tagOpenAttributeNameAfter;
	      return atLineEnding(code)
	    }

	    if (markdownSpace(code)) {
	      effects.consume(code);
	      return tagOpenAttributeNameAfter
	    }

	    return tagOpenBetween(code)
	  }
	  /** @type {State} */

	  function tagOpenAttributeValueBefore(code) {
	    if (
	      code === null ||
	      code === 60 ||
	      code === 61 ||
	      code === 62 ||
	      code === 96
	    ) {
	      return nok(code)
	    }

	    if (code === 34 || code === 39) {
	      effects.consume(code);
	      marker = code;
	      return tagOpenAttributeValueQuoted
	    }

	    if (markdownLineEnding(code)) {
	      returnState = tagOpenAttributeValueBefore;
	      return atLineEnding(code)
	    }

	    if (markdownSpace(code)) {
	      effects.consume(code);
	      return tagOpenAttributeValueBefore
	    }

	    effects.consume(code);
	    marker = undefined;
	    return tagOpenAttributeValueUnquoted
	  }
	  /** @type {State} */

	  function tagOpenAttributeValueQuoted(code) {
	    if (code === marker) {
	      effects.consume(code);
	      return tagOpenAttributeValueQuotedAfter
	    }

	    if (code === null) {
	      return nok(code)
	    }

	    if (markdownLineEnding(code)) {
	      returnState = tagOpenAttributeValueQuoted;
	      return atLineEnding(code)
	    }

	    effects.consume(code);
	    return tagOpenAttributeValueQuoted
	  }
	  /** @type {State} */

	  function tagOpenAttributeValueQuotedAfter(code) {
	    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {
	      return tagOpenBetween(code)
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function tagOpenAttributeValueUnquoted(code) {
	    if (
	      code === null ||
	      code === 34 ||
	      code === 39 ||
	      code === 60 ||
	      code === 61 ||
	      code === 96
	    ) {
	      return nok(code)
	    }

	    if (code === 62 || markdownLineEndingOrSpace(code)) {
	      return tagOpenBetween(code)
	    }

	    effects.consume(code);
	    return tagOpenAttributeValueUnquoted
	  } // We can’t have blank lines in content, so no need to worry about empty
	  // tokens.

	  /** @type {State} */

	  function atLineEnding(code) {
	    effects.exit('htmlTextData');
	    effects.enter('lineEnding');
	    effects.consume(code);
	    effects.exit('lineEnding');
	    return factorySpace(
	      effects,
	      afterPrefix,
	      'linePrefix',
	      self.parser.constructs.disable.null.includes('codeIndented')
	        ? undefined
	        : 4
	    )
	  }
	  /** @type {State} */

	  function afterPrefix(code) {
	    effects.enter('htmlTextData');
	    return returnState(code)
	  }
	  /** @type {State} */

	  function end(code) {
	    if (code === 62) {
	      effects.consume(code);
	      effects.exit('htmlTextData');
	      effects.exit('htmlText');
	      return ok
	    }

	    return nok(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Resolver} Resolver
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').Event} Event
	 * @typedef {import('micromark-util-types').Token} Token
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Code} Code
	 */

	/** @type {Construct} */
	const labelEnd = {
	  name: 'labelEnd',
	  tokenize: tokenizeLabelEnd,
	  resolveTo: resolveToLabelEnd,
	  resolveAll: resolveAllLabelEnd
	};
	/** @type {Construct} */

	const resourceConstruct = {
	  tokenize: tokenizeResource
	};
	/** @type {Construct} */

	const fullReferenceConstruct = {
	  tokenize: tokenizeFullReference
	};
	/** @type {Construct} */

	const collapsedReferenceConstruct = {
	  tokenize: tokenizeCollapsedReference
	};
	/** @type {Resolver} */

	function resolveAllLabelEnd(events) {
	  let index = -1;
	  /** @type {Token} */

	  let token;

	  while (++index < events.length) {
	    token = events[index][1];

	    if (
	      token.type === 'labelImage' ||
	      token.type === 'labelLink' ||
	      token.type === 'labelEnd'
	    ) {
	      // Remove the marker.
	      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2);
	      token.type = 'data';
	      index++;
	    }
	  }

	  return events
	}
	/** @type {Resolver} */

	function resolveToLabelEnd(events, context) {
	  let index = events.length;
	  let offset = 0;
	  /** @type {Token} */

	  let token;
	  /** @type {number|undefined} */

	  let open;
	  /** @type {number|undefined} */

	  let close;
	  /** @type {Event[]} */

	  let media; // Find an opening.

	  while (index--) {
	    token = events[index][1];

	    if (open) {
	      // If we see another link, or inactive link label, we’ve been here before.
	      if (
	        token.type === 'link' ||
	        (token.type === 'labelLink' && token._inactive)
	      ) {
	        break
	      } // Mark other link openings as inactive, as we can’t have links in
	      // links.

	      if (events[index][0] === 'enter' && token.type === 'labelLink') {
	        token._inactive = true;
	      }
	    } else if (close) {
	      if (
	        events[index][0] === 'enter' &&
	        (token.type === 'labelImage' || token.type === 'labelLink') &&
	        !token._balanced
	      ) {
	        open = index;

	        if (token.type !== 'labelLink') {
	          offset = 2;
	          break
	        }
	      }
	    } else if (token.type === 'labelEnd') {
	      close = index;
	    }
	  }

	  const group = {
	    type: events[open][1].type === 'labelLink' ? 'link' : 'image',
	    start: Object.assign({}, events[open][1].start),
	    end: Object.assign({}, events[events.length - 1][1].end)
	  };
	  const label = {
	    type: 'label',
	    start: Object.assign({}, events[open][1].start),
	    end: Object.assign({}, events[close][1].end)
	  };
	  const text = {
	    type: 'labelText',
	    start: Object.assign({}, events[open + offset + 2][1].end),
	    end: Object.assign({}, events[close - 2][1].start)
	  };
	  media = [
	    ['enter', group, context],
	    ['enter', label, context]
	  ]; // Opening marker.

	  media = push(media, events.slice(open + 1, open + offset + 3)); // Text open.

	  media = push(media, [['enter', text, context]]); // Between.

	  media = push(
	    media,
	    resolveAll(
	      context.parser.constructs.insideSpan.null,
	      events.slice(open + offset + 4, close - 3),
	      context
	    )
	  ); // Text close, marker close, label close.

	  media = push(media, [
	    ['exit', text, context],
	    events[close - 2],
	    events[close - 1],
	    ['exit', label, context]
	  ]); // Reference, resource, or so.

	  media = push(media, events.slice(close + 1)); // Media close.

	  media = push(media, [['exit', group, context]]);
	  splice(events, open, events.length, media);
	  return events
	}
	/** @type {Tokenizer} */

	function tokenizeLabelEnd(effects, ok, nok) {
	  const self = this;
	  let index = self.events.length;
	  /** @type {Token} */

	  let labelStart;
	  /** @type {boolean} */

	  let defined; // Find an opening.

	  while (index--) {
	    if (
	      (self.events[index][1].type === 'labelImage' ||
	        self.events[index][1].type === 'labelLink') &&
	      !self.events[index][1]._balanced
	    ) {
	      labelStart = self.events[index][1];
	      break
	    }
	  }

	  return start
	  /** @type {State} */

	  function start(code) {
	    if (!labelStart) {
	      return nok(code)
	    } // It’s a balanced bracket, but contains a link.

	    if (labelStart._inactive) return balanced(code)
	    defined = self.parser.defined.includes(
	      normalizeIdentifier(
	        self.sliceSerialize({
	          start: labelStart.end,
	          end: self.now()
	        })
	      )
	    );
	    effects.enter('labelEnd');
	    effects.enter('labelMarker');
	    effects.consume(code);
	    effects.exit('labelMarker');
	    effects.exit('labelEnd');
	    return afterLabelEnd
	  }
	  /** @type {State} */

	  function afterLabelEnd(code) {
	    // Resource: `[asd](fgh)`.
	    if (code === 40) {
	      return effects.attempt(
	        resourceConstruct,
	        ok,
	        defined ? ok : balanced
	      )(code)
	    } // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?

	    if (code === 91) {
	      return effects.attempt(
	        fullReferenceConstruct,
	        ok,
	        defined
	          ? effects.attempt(collapsedReferenceConstruct, ok, balanced)
	          : balanced
	      )(code)
	    } // Shortcut reference: `[asd]`?

	    return defined ? ok(code) : balanced(code)
	  }
	  /** @type {State} */

	  function balanced(code) {
	    labelStart._balanced = true;
	    return nok(code)
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeResource(effects, ok, nok) {
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('resource');
	    effects.enter('resourceMarker');
	    effects.consume(code);
	    effects.exit('resourceMarker');
	    return factoryWhitespace(effects, open)
	  }
	  /** @type {State} */

	  function open(code) {
	    if (code === 41) {
	      return end(code)
	    }

	    return factoryDestination(
	      effects,
	      destinationAfter,
	      nok,
	      'resourceDestination',
	      'resourceDestinationLiteral',
	      'resourceDestinationLiteralMarker',
	      'resourceDestinationRaw',
	      'resourceDestinationString',
	      32
	    )(code)
	  }
	  /** @type {State} */

	  function destinationAfter(code) {
	    return markdownLineEndingOrSpace(code)
	      ? factoryWhitespace(effects, between)(code)
	      : end(code)
	  }
	  /** @type {State} */

	  function between(code) {
	    if (code === 34 || code === 39 || code === 40) {
	      return factoryTitle(
	        effects,
	        factoryWhitespace(effects, end),
	        nok,
	        'resourceTitle',
	        'resourceTitleMarker',
	        'resourceTitleString'
	      )(code)
	    }

	    return end(code)
	  }
	  /** @type {State} */

	  function end(code) {
	    if (code === 41) {
	      effects.enter('resourceMarker');
	      effects.consume(code);
	      effects.exit('resourceMarker');
	      effects.exit('resource');
	      return ok
	    }

	    return nok(code)
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeFullReference(effects, ok, nok) {
	  const self = this;
	  return start
	  /** @type {State} */

	  function start(code) {
	    return factoryLabel.call(
	      self,
	      effects,
	      afterLabel,
	      nok,
	      'reference',
	      'referenceMarker',
	      'referenceString'
	    )(code)
	  }
	  /** @type {State} */

	  function afterLabel(code) {
	    return self.parser.defined.includes(
	      normalizeIdentifier(
	        self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)
	      )
	    )
	      ? ok(code)
	      : nok(code)
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeCollapsedReference(effects, ok, nok) {
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('reference');
	    effects.enter('referenceMarker');
	    effects.consume(code);
	    effects.exit('referenceMarker');
	    return open
	  }
	  /** @type {State} */

	  function open(code) {
	    if (code === 93) {
	      effects.enter('referenceMarker');
	      effects.consume(code);
	      effects.exit('referenceMarker');
	      effects.exit('reference');
	      return ok
	    }

	    return nok(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 */
	/** @type {Construct} */

	const labelStartImage = {
	  name: 'labelStartImage',
	  tokenize: tokenizeLabelStartImage,
	  resolveAll: labelEnd.resolveAll
	};
	/** @type {Tokenizer} */

	function tokenizeLabelStartImage(effects, ok, nok) {
	  const self = this;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('labelImage');
	    effects.enter('labelImageMarker');
	    effects.consume(code);
	    effects.exit('labelImageMarker');
	    return open
	  }
	  /** @type {State} */

	  function open(code) {
	    if (code === 91) {
	      effects.enter('labelMarker');
	      effects.consume(code);
	      effects.exit('labelMarker');
	      effects.exit('labelImage');
	      return after
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function after(code) {
	    /* To do: remove in the future once we’ve switched from
	     * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,
	     * which doesn’t need this */

	    /* Hidden footnotes hook */

	    /* c8 ignore next 3 */
	    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs
	      ? nok(code)
	      : ok(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 */
	/** @type {Construct} */

	const labelStartLink = {
	  name: 'labelStartLink',
	  tokenize: tokenizeLabelStartLink,
	  resolveAll: labelEnd.resolveAll
	};
	/** @type {Tokenizer} */

	function tokenizeLabelStartLink(effects, ok, nok) {
	  const self = this;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('labelLink');
	    effects.enter('labelMarker');
	    effects.consume(code);
	    effects.exit('labelMarker');
	    effects.exit('labelLink');
	    return after
	  }
	  /** @type {State} */

	  function after(code) {
	    /* To do: remove in the future once we’ve switched from
	     * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,
	     * which doesn’t need this */

	    /* Hidden footnotes hook. */

	    /* c8 ignore next 3 */
	    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs
	      ? nok(code)
	      : ok(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 */


	/** @type {Construct} */
	const lineEnding = {
	  name: 'lineEnding',
	  tokenize: tokenizeLineEnding
	};
	/** @type {Tokenizer} */

	function tokenizeLineEnding(effects, ok) {
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('lineEnding');
	    effects.consume(code);
	    effects.exit('lineEnding');
	    return factorySpace(effects, ok, 'linePrefix')
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Code} Code
	 */

	/** @type {Construct} */
	const thematicBreak$1 = {
	  name: 'thematicBreak',
	  tokenize: tokenizeThematicBreak
	};
	/** @type {Tokenizer} */

	function tokenizeThematicBreak(effects, ok, nok) {
	  let size = 0;
	  /** @type {NonNullable<Code>} */

	  let marker;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('thematicBreak');
	    marker = code;
	    return atBreak(code)
	  }
	  /** @type {State} */

	  function atBreak(code) {
	    if (code === marker) {
	      effects.enter('thematicBreakSequence');
	      return sequence(code)
	    }

	    if (markdownSpace(code)) {
	      return factorySpace(effects, atBreak, 'whitespace')(code)
	    }

	    if (size < 3 || (code !== null && !markdownLineEnding(code))) {
	      return nok(code)
	    }

	    effects.exit('thematicBreak');
	    return ok(code)
	  }
	  /** @type {State} */

	  function sequence(code) {
	    if (code === marker) {
	      effects.consume(code);
	      size++;
	      return sequence
	    }

	    effects.exit('thematicBreakSequence');
	    return atBreak(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
	 * @typedef {import('micromark-util-types').Exiter} Exiter
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Code} Code
	 */

	/** @type {Construct} */

	const list$1 = {
	  name: 'list',
	  tokenize: tokenizeListStart,
	  continuation: {
	    tokenize: tokenizeListContinuation
	  },
	  exit: tokenizeListEnd
	};
	/** @type {Construct} */

	const listItemPrefixWhitespaceConstruct = {
	  tokenize: tokenizeListItemPrefixWhitespace,
	  partial: true
	};
	/** @type {Construct} */

	const indentConstruct = {
	  tokenize: tokenizeIndent$1,
	  partial: true
	};
	/**
	 * @type {Tokenizer}
	 * @this {TokenizeContextWithState}
	 */

	function tokenizeListStart(effects, ok, nok) {
	  const self = this;
	  const tail = self.events[self.events.length - 1];
	  let initialSize =
	    tail && tail[1].type === 'linePrefix'
	      ? tail[2].sliceSerialize(tail[1], true).length
	      : 0;
	  let size = 0;
	  return start
	  /** @type {State} */

	  function start(code) {
	    const kind =
	      self.containerState.type ||
	      (code === 42 || code === 43 || code === 45
	        ? 'listUnordered'
	        : 'listOrdered');

	    if (
	      kind === 'listUnordered'
	        ? !self.containerState.marker || code === self.containerState.marker
	        : asciiDigit(code)
	    ) {
	      if (!self.containerState.type) {
	        self.containerState.type = kind;
	        effects.enter(kind, {
	          _container: true
	        });
	      }

	      if (kind === 'listUnordered') {
	        effects.enter('listItemPrefix');
	        return code === 42 || code === 45
	          ? effects.check(thematicBreak$1, nok, atMarker)(code)
	          : atMarker(code)
	      }

	      if (!self.interrupt || code === 49) {
	        effects.enter('listItemPrefix');
	        effects.enter('listItemValue');
	        return inside(code)
	      }
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function inside(code) {
	    if (asciiDigit(code) && ++size < 10) {
	      effects.consume(code);
	      return inside
	    }

	    if (
	      (!self.interrupt || size < 2) &&
	      (self.containerState.marker
	        ? code === self.containerState.marker
	        : code === 41 || code === 46)
	    ) {
	      effects.exit('listItemValue');
	      return atMarker(code)
	    }

	    return nok(code)
	  }
	  /**
	   * @type {State}
	   **/

	  function atMarker(code) {
	    effects.enter('listItemMarker');
	    effects.consume(code);
	    effects.exit('listItemMarker');
	    self.containerState.marker = self.containerState.marker || code;
	    return effects.check(
	      blankLine, // Can’t be empty when interrupting.
	      self.interrupt ? nok : onBlank,
	      effects.attempt(
	        listItemPrefixWhitespaceConstruct,
	        endOfPrefix,
	        otherPrefix
	      )
	    )
	  }
	  /** @type {State} */

	  function onBlank(code) {
	    self.containerState.initialBlankLine = true;
	    initialSize++;
	    return endOfPrefix(code)
	  }
	  /** @type {State} */

	  function otherPrefix(code) {
	    if (markdownSpace(code)) {
	      effects.enter('listItemPrefixWhitespace');
	      effects.consume(code);
	      effects.exit('listItemPrefixWhitespace');
	      return endOfPrefix
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function endOfPrefix(code) {
	    self.containerState.size =
	      initialSize +
	      self.sliceSerialize(effects.exit('listItemPrefix'), true).length;
	    return ok(code)
	  }
	}
	/**
	 * @type {Tokenizer}
	 * @this {TokenizeContextWithState}
	 */

	function tokenizeListContinuation(effects, ok, nok) {
	  const self = this;
	  self.containerState._closeFlow = undefined;
	  return effects.check(blankLine, onBlank, notBlank)
	  /** @type {State} */

	  function onBlank(code) {
	    self.containerState.furtherBlankLines =
	      self.containerState.furtherBlankLines ||
	      self.containerState.initialBlankLine; // We have a blank line.
	    // Still, try to consume at most the items size.

	    return factorySpace(
	      effects,
	      ok,
	      'listItemIndent',
	      self.containerState.size + 1
	    )(code)
	  }
	  /** @type {State} */

	  function notBlank(code) {
	    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {
	      self.containerState.furtherBlankLines = undefined;
	      self.containerState.initialBlankLine = undefined;
	      return notInCurrentItem(code)
	    }

	    self.containerState.furtherBlankLines = undefined;
	    self.containerState.initialBlankLine = undefined;
	    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)
	  }
	  /** @type {State} */

	  function notInCurrentItem(code) {
	    // While we do continue, we signal that the flow should be closed.
	    self.containerState._closeFlow = true; // As we’re closing flow, we’re no longer interrupting.

	    self.interrupt = undefined;
	    return factorySpace(
	      effects,
	      effects.attempt(list$1, ok, nok),
	      'linePrefix',
	      self.parser.constructs.disable.null.includes('codeIndented')
	        ? undefined
	        : 4
	    )(code)
	  }
	}
	/**
	 * @type {Tokenizer}
	 * @this {TokenizeContextWithState}
	 */

	function tokenizeIndent$1(effects, ok, nok) {
	  const self = this;
	  return factorySpace(
	    effects,
	    afterPrefix,
	    'listItemIndent',
	    self.containerState.size + 1
	  )
	  /** @type {State} */

	  function afterPrefix(code) {
	    const tail = self.events[self.events.length - 1];
	    return tail &&
	      tail[1].type === 'listItemIndent' &&
	      tail[2].sliceSerialize(tail[1], true).length === self.containerState.size
	      ? ok(code)
	      : nok(code)
	  }
	}
	/**
	 * @type {Exiter}
	 * @this {TokenizeContextWithState}
	 */

	function tokenizeListEnd(effects) {
	  effects.exit(this.containerState.type);
	}
	/**
	 * @type {Tokenizer}
	 * @this {TokenizeContextWithState}
	 */

	function tokenizeListItemPrefixWhitespace(effects, ok, nok) {
	  const self = this;
	  return factorySpace(
	    effects,
	    afterPrefix,
	    'listItemPrefixWhitespace',
	    self.parser.constructs.disable.null.includes('codeIndented')
	      ? undefined
	      : 4 + 1
	  )
	  /** @type {State} */

	  function afterPrefix(code) {
	    const tail = self.events[self.events.length - 1];
	    return !markdownSpace(code) &&
	      tail &&
	      tail[1].type === 'listItemPrefixWhitespace'
	      ? ok(code)
	      : nok(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').Resolver} Resolver
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Code} Code
	 */

	/** @type {Construct} */
	const setextUnderline = {
	  name: 'setextUnderline',
	  tokenize: tokenizeSetextUnderline,
	  resolveTo: resolveToSetextUnderline
	};
	/** @type {Resolver} */

	function resolveToSetextUnderline(events, context) {
	  let index = events.length;
	  /** @type {number|undefined} */

	  let content;
	  /** @type {number|undefined} */

	  let text;
	  /** @type {number|undefined} */

	  let definition; // Find the opening of the content.
	  // It’ll always exist: we don’t tokenize if it isn’t there.

	  while (index--) {
	    if (events[index][0] === 'enter') {
	      if (events[index][1].type === 'content') {
	        content = index;
	        break
	      }

	      if (events[index][1].type === 'paragraph') {
	        text = index;
	      }
	    } // Exit
	    else {
	      if (events[index][1].type === 'content') {
	        // Remove the content end (if needed we’ll add it later)
	        events.splice(index, 1);
	      }

	      if (!definition && events[index][1].type === 'definition') {
	        definition = index;
	      }
	    }
	  }

	  const heading = {
	    type: 'setextHeading',
	    start: Object.assign({}, events[text][1].start),
	    end: Object.assign({}, events[events.length - 1][1].end)
	  }; // Change the paragraph to setext heading text.

	  events[text][1].type = 'setextHeadingText'; // If we have definitions in the content, we’ll keep on having content,
	  // but we need move it.

	  if (definition) {
	    events.splice(text, 0, ['enter', heading, context]);
	    events.splice(definition + 1, 0, ['exit', events[content][1], context]);
	    events[content][1].end = Object.assign({}, events[definition][1].end);
	  } else {
	    events[content][1] = heading;
	  } // Add the heading exit at the end.

	  events.push(['exit', heading, context]);
	  return events
	}
	/** @type {Tokenizer} */

	function tokenizeSetextUnderline(effects, ok, nok) {
	  const self = this;
	  let index = self.events.length;
	  /** @type {NonNullable<Code>} */

	  let marker;
	  /** @type {boolean} */

	  let paragraph; // Find an opening.

	  while (index--) {
	    // Skip enter/exit of line ending, line prefix, and content.
	    // We can now either have a definition or a paragraph.
	    if (
	      self.events[index][1].type !== 'lineEnding' &&
	      self.events[index][1].type !== 'linePrefix' &&
	      self.events[index][1].type !== 'content'
	    ) {
	      paragraph = self.events[index][1].type === 'paragraph';
	      break
	    }
	  }

	  return start
	  /** @type {State} */

	  function start(code) {
	    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {
	      effects.enter('setextHeadingLine');
	      effects.enter('setextHeadingLineSequence');
	      marker = code;
	      return closingSequence(code)
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function closingSequence(code) {
	    if (code === marker) {
	      effects.consume(code);
	      return closingSequence
	    }

	    effects.exit('setextHeadingLineSequence');
	    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code)
	  }
	  /** @type {State} */

	  function closingSequenceEnd(code) {
	    if (code === null || markdownLineEnding(code)) {
	      effects.exit('setextHeadingLine');
	      return ok(code)
	    }

	    return nok(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Extension} Extension
	 * @typedef {import('micromark-util-types').Resolver} Resolver
	 * @typedef {import('micromark-util-types').Token} Token
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').Exiter} Exiter
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Event} Event
	 */
	const indent = {
	  tokenize: tokenizeIndent,
	  partial: true
	};
	/**
	 * @returns {Extension}
	 */

	function gfmFootnote() {
	  /** @type {Extension} */
	  return {
	    document: {
	      [91]: {
	        tokenize: tokenizeDefinitionStart,
	        continuation: {
	          tokenize: tokenizeDefinitionContinuation
	        },
	        exit: gfmFootnoteDefinitionEnd
	      }
	    },
	    text: {
	      [91]: {
	        tokenize: tokenizeGfmFootnoteCall
	      },
	      [93]: {
	        add: 'after',
	        tokenize: tokenizePotentialGfmFootnoteCall,
	        resolveTo: resolveToPotentialGfmFootnoteCall
	      }
	    }
	  }
	}
	/** @type {Tokenizer} */

	function tokenizePotentialGfmFootnoteCall(effects, ok, nok) {
	  const self = this;
	  let index = self.events.length;
	  /** @type {Array<string>} */
	  // @ts-expect-error It’s fine!

	  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
	  /** @type {Token} */

	  let labelStart; // Find an opening.

	  while (index--) {
	    const token = self.events[index][1];

	    if (token.type === 'labelImage') {
	      labelStart = token;
	      break
	    } // Exit if we’ve walked far enough.

	    if (
	      token.type === 'gfmFootnoteCall' ||
	      token.type === 'labelLink' ||
	      token.type === 'label' ||
	      token.type === 'image' ||
	      token.type === 'link'
	    ) {
	      break
	    }
	  }

	  return start
	  /** @type {State} */

	  function start(code) {
	    if (!labelStart || !labelStart._balanced) {
	      return nok(code)
	    }

	    const id = normalizeIdentifier(
	      self.sliceSerialize({
	        start: labelStart.end,
	        end: self.now()
	      })
	    );

	    if (id.charCodeAt(0) !== 94 || !defined.includes(id.slice(1))) {
	      return nok(code)
	    }

	    effects.enter('gfmFootnoteCallLabelMarker');
	    effects.consume(code);
	    effects.exit('gfmFootnoteCallLabelMarker');
	    return ok(code)
	  }
	}
	/** @type {Resolver} */

	function resolveToPotentialGfmFootnoteCall(events, context) {
	  let index = events.length;

	  while (index--) {
	    if (
	      events[index][1].type === 'labelImage' &&
	      events[index][0] === 'enter'
	    ) {
	      events[index][1];
	      break
	    }
	  }

	  // Change the `labelImageMarker` to a `data`.
	  events[index + 1][1].type = 'data';
	  events[index + 3][1].type = 'gfmFootnoteCallLabelMarker'; // The whole (without `!`):

	  const call = {
	    type: 'gfmFootnoteCall',
	    start: Object.assign({}, events[index + 3][1].start),
	    end: Object.assign({}, events[events.length - 1][1].end)
	  }; // The `^` marker

	  const marker = {
	    type: 'gfmFootnoteCallMarker',
	    start: Object.assign({}, events[index + 3][1].end),
	    end: Object.assign({}, events[index + 3][1].end)
	  }; // Increment the end 1 character.

	  marker.end.column++;
	  marker.end.offset++;
	  marker.end._bufferIndex++;
	  const string = {
	    type: 'gfmFootnoteCallString',
	    start: Object.assign({}, marker.end),
	    end: Object.assign({}, events[events.length - 1][1].start)
	  };
	  const chunk = {
	    type: 'chunkString',
	    contentType: 'string',
	    start: Object.assign({}, string.start),
	    end: Object.assign({}, string.end)
	  };
	  /** @type {Array<Event>} */

	  const replacement = [
	    // Take the `labelImageMarker` (now `data`, the `!`)
	    events[index + 1],
	    events[index + 2],
	    ['enter', call, context], // The `[`
	    events[index + 3],
	    events[index + 4], // The `^`.
	    ['enter', marker, context],
	    ['exit', marker, context], // Everything in between.
	    ['enter', string, context],
	    ['enter', chunk, context],
	    ['exit', chunk, context],
	    ['exit', string, context], // The ending (`]`, properly parsed and labelled).
	    events[events.length - 2],
	    events[events.length - 1],
	    ['exit', call, context]
	  ];
	  events.splice(index, events.length - index + 1, ...replacement);
	  return events
	}
	/** @type {Tokenizer} */

	function tokenizeGfmFootnoteCall(effects, ok, nok) {
	  const self = this;
	  /** @type {Array<string>} */
	  // @ts-expect-error It’s fine!

	  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
	  let size = 0;
	  /** @type {boolean} */

	  let data;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('gfmFootnoteCall');
	    effects.enter('gfmFootnoteCallLabelMarker');
	    effects.consume(code);
	    effects.exit('gfmFootnoteCallLabelMarker');
	    return callStart
	  }
	  /** @type {State} */

	  function callStart(code) {
	    if (code !== 94) return nok(code)
	    effects.enter('gfmFootnoteCallMarker');
	    effects.consume(code);
	    effects.exit('gfmFootnoteCallMarker');
	    effects.enter('gfmFootnoteCallString');
	    effects.enter('chunkString').contentType = 'string';
	    return callData
	  }
	  /** @type {State} */

	  function callData(code) {
	    /** @type {Token} */
	    let token;

	    if (code === null || code === 91 || size++ > 999) {
	      return nok(code)
	    }

	    if (code === 93) {
	      if (!data) {
	        return nok(code)
	      }

	      effects.exit('chunkString');
	      token = effects.exit('gfmFootnoteCallString');
	      return defined.includes(normalizeIdentifier(self.sliceSerialize(token)))
	        ? end(code)
	        : nok(code)
	    }

	    effects.consume(code);

	    if (!markdownLineEndingOrSpace(code)) {
	      data = true;
	    }

	    return code === 92 ? callEscape : callData
	  }
	  /** @type {State} */

	  function callEscape(code) {
	    if (code === 91 || code === 92 || code === 93) {
	      effects.consume(code);
	      size++;
	      return callData
	    }

	    return callData(code)
	  }
	  /** @type {State} */

	  function end(code) {
	    effects.enter('gfmFootnoteCallLabelMarker');
	    effects.consume(code);
	    effects.exit('gfmFootnoteCallLabelMarker');
	    effects.exit('gfmFootnoteCall');
	    return ok
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeDefinitionStart(effects, ok, nok) {
	  const self = this;
	  /** @type {Array<string>} */
	  // @ts-expect-error It’s fine!

	  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);
	  /** @type {string} */

	  let identifier;
	  let size = 0;
	  /** @type {boolean|undefined} */

	  let data;
	  return start
	  /** @type {State} */

	  function start(code) {
	    effects.enter('gfmFootnoteDefinition')._container = true;
	    effects.enter('gfmFootnoteDefinitionLabel');
	    effects.enter('gfmFootnoteDefinitionLabelMarker');
	    effects.consume(code);
	    effects.exit('gfmFootnoteDefinitionLabelMarker');
	    return labelStart
	  }
	  /** @type {State} */

	  function labelStart(code) {
	    if (code === 94) {
	      effects.enter('gfmFootnoteDefinitionMarker');
	      effects.consume(code);
	      effects.exit('gfmFootnoteDefinitionMarker');
	      effects.enter('gfmFootnoteDefinitionLabelString');
	      return atBreak
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function atBreak(code) {
	    /** @type {Token} */
	    let token;

	    if (code === null || code === 91 || size > 999) {
	      return nok(code)
	    }

	    if (code === 93) {
	      if (!data) {
	        return nok(code)
	      }

	      token = effects.exit('gfmFootnoteDefinitionLabelString');
	      identifier = normalizeIdentifier(self.sliceSerialize(token));
	      effects.enter('gfmFootnoteDefinitionLabelMarker');
	      effects.consume(code);
	      effects.exit('gfmFootnoteDefinitionLabelMarker');
	      effects.exit('gfmFootnoteDefinitionLabel');
	      return labelAfter
	    }

	    if (markdownLineEnding(code)) {
	      effects.enter('lineEnding');
	      effects.consume(code);
	      effects.exit('lineEnding');
	      size++;
	      return atBreak
	    }

	    effects.enter('chunkString').contentType = 'string';
	    return label(code)
	  }
	  /** @type {State} */

	  function label(code) {
	    if (
	      code === null ||
	      markdownLineEnding(code) ||
	      code === 91 ||
	      code === 93 ||
	      size > 999
	    ) {
	      effects.exit('chunkString');
	      return atBreak(code)
	    }

	    if (!markdownLineEndingOrSpace(code)) {
	      data = true;
	    }

	    size++;
	    effects.consume(code);
	    return code === 92 ? labelEscape : label
	  }
	  /** @type {State} */

	  function labelEscape(code) {
	    if (code === 91 || code === 92 || code === 93) {
	      effects.consume(code);
	      size++;
	      return label
	    }

	    return label(code)
	  }
	  /** @type {State} */

	  function labelAfter(code) {
	    if (code === 58) {
	      effects.enter('definitionMarker');
	      effects.consume(code);
	      effects.exit('definitionMarker'); // Any whitespace after the marker is eaten, forming indented code
	      // is not possible.
	      // No space is also fine, just like a block quote marker.

	      return factorySpace(effects, done, 'gfmFootnoteDefinitionWhitespace')
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function done(code) {
	    if (!defined.includes(identifier)) {
	      defined.push(identifier);
	    }

	    return ok(code)
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeDefinitionContinuation(effects, ok, nok) {
	  // Either a blank line, which is okay, or an indented thing.
	  return effects.check(blankLine, ok, effects.attempt(indent, ok, nok))
	}
	/** @type {Exiter} */

	function gfmFootnoteDefinitionEnd(effects) {
	  effects.exit('gfmFootnoteDefinition');
	}
	/** @type {Tokenizer} */

	function tokenizeIndent(effects, ok, nok) {
	  const self = this;
	  return factorySpace(
	    effects,
	    afterPrefix,
	    'gfmFootnoteDefinitionIndent',
	    4 + 1
	  )
	  /** @type {State} */

	  function afterPrefix(code) {
	    const tail = self.events[self.events.length - 1];
	    return tail &&
	      tail[1].type === 'gfmFootnoteDefinitionIndent' &&
	      tail[2].sliceSerialize(tail[1], true).length === 4
	      ? ok(code)
	      : nok(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Extension} Extension
	 * @typedef {import('micromark-util-types').Resolver} Resolver
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Token} Token
	 * @typedef {import('micromark-util-types').Event} Event
	 */


	/**
	 * @param {Options} [options]
	 * @returns {Extension}
	 */
	function gfmStrikethrough(options = {}) {
	  let single = options.singleTilde;
	  const tokenizer = {
	    tokenize: tokenizeStrikethrough,
	    resolveAll: resolveAllStrikethrough
	  };

	  if (single === null || single === undefined) {
	    single = true;
	  }

	  return {
	    text: {
	      [126]: tokenizer
	    },
	    insideSpan: {
	      null: [tokenizer]
	    },
	    attentionMarkers: {
	      null: [126]
	    }
	  }
	  /**
	   * Take events and resolve strikethrough.
	   *
	   * @type {Resolver}
	   */

	  function resolveAllStrikethrough(events, context) {
	    let index = -1; // Walk through all events.

	    while (++index < events.length) {
	      // Find a token that can close.
	      if (
	        events[index][0] === 'enter' &&
	        events[index][1].type === 'strikethroughSequenceTemporary' &&
	        events[index][1]._close
	      ) {
	        let open = index; // Now walk back to find an opener.

	        while (open--) {
	          // Find a token that can open the closer.
	          if (
	            events[open][0] === 'exit' &&
	            events[open][1].type === 'strikethroughSequenceTemporary' &&
	            events[open][1]._open && // If the sizes are the same:
	            events[index][1].end.offset - events[index][1].start.offset ===
	              events[open][1].end.offset - events[open][1].start.offset
	          ) {
	            events[index][1].type = 'strikethroughSequence';
	            events[open][1].type = 'strikethroughSequence';
	            const strikethrough = {
	              type: 'strikethrough',
	              start: Object.assign({}, events[open][1].start),
	              end: Object.assign({}, events[index][1].end)
	            };
	            const text = {
	              type: 'strikethroughText',
	              start: Object.assign({}, events[open][1].end),
	              end: Object.assign({}, events[index][1].start)
	            }; // Opening.

	            const nextEvents = [
	              ['enter', strikethrough, context],
	              ['enter', events[open][1], context],
	              ['exit', events[open][1], context],
	              ['enter', text, context]
	            ]; // Between.

	            splice(
	              nextEvents,
	              nextEvents.length,
	              0,
	              resolveAll(
	                context.parser.constructs.insideSpan.null,
	                events.slice(open + 1, index),
	                context
	              )
	            ); // Closing.

	            splice(nextEvents, nextEvents.length, 0, [
	              ['exit', text, context],
	              ['enter', events[index][1], context],
	              ['exit', events[index][1], context],
	              ['exit', strikethrough, context]
	            ]);
	            splice(events, open - 1, index - open + 3, nextEvents);
	            index = open + nextEvents.length - 2;
	            break
	          }
	        }
	      }
	    }

	    index = -1;

	    while (++index < events.length) {
	      if (events[index][1].type === 'strikethroughSequenceTemporary') {
	        events[index][1].type = 'data';
	      }
	    }

	    return events
	  }
	  /** @type {Tokenizer} */

	  function tokenizeStrikethrough(effects, ok, nok) {
	    const previous = this.previous;
	    const events = this.events;
	    let size = 0;
	    return start
	    /** @type {State} */

	    function start(code) {
	      if (
	        previous === 126 &&
	        events[events.length - 1][1].type !== 'characterEscape'
	      ) {
	        return nok(code)
	      }

	      effects.enter('strikethroughSequenceTemporary');
	      return more(code)
	    }
	    /** @type {State} */

	    function more(code) {
	      const before = classifyCharacter(previous);

	      if (code === 126) {
	        // If this is the third marker, exit.
	        if (size > 1) return nok(code)
	        effects.consume(code);
	        size++;
	        return more
	      }

	      if (size < 2 && !single) return nok(code)
	      const token = effects.exit('strikethroughSequenceTemporary');
	      const after = classifyCharacter(code);
	      token._open = !after || (after === 2 && Boolean(before));
	      token._close = !before || (before === 2 && Boolean(after));
	      return ok(code)
	    }
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Extension} Extension
	 * @typedef {import('micromark-util-types').Resolver} Resolver
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Token} Token
	 */


	/** @type {Extension} */
	const gfmTable = {
	  flow: {
	    null: {
	      tokenize: tokenizeTable,
	      resolve: resolveTable
	    }
	  }
	};
	const nextPrefixedOrBlank = {
	  tokenize: tokenizeNextPrefixedOrBlank,
	  partial: true
	};
	/** @type {Resolver} */

	function resolveTable(events, context) {
	  let index = -1;
	  /** @type {boolean|undefined} */

	  let inHead;
	  /** @type {boolean|undefined} */

	  let inDelimiterRow;
	  /** @type {boolean|undefined} */

	  let inRow;
	  /** @type {number|undefined} */

	  let contentStart;
	  /** @type {number|undefined} */

	  let contentEnd;
	  /** @type {number|undefined} */

	  let cellStart;
	  /** @type {boolean|undefined} */

	  let seenCellInRow;

	  while (++index < events.length) {
	    const token = events[index][1];

	    if (inRow) {
	      if (token.type === 'temporaryTableCellContent') {
	        contentStart = contentStart || index;
	        contentEnd = index;
	      }

	      if (
	        // Combine separate content parts into one.
	        (token.type === 'tableCellDivider' || token.type === 'tableRow') &&
	        contentEnd
	      ) {
	        const content = {
	          type: 'tableContent',
	          start: events[contentStart][1].start,
	          end: events[contentEnd][1].end
	        };
	        /** @type {Token} */

	        const text = {
	          type: 'chunkText',
	          start: content.start,
	          end: content.end,
	          // @ts-expect-error It’s fine.
	          contentType: 'text'
	        };
	        events.splice(
	          contentStart,
	          contentEnd - contentStart + 1,
	          ['enter', content, context],
	          ['enter', text, context],
	          ['exit', text, context],
	          ['exit', content, context]
	        );
	        index -= contentEnd - contentStart - 3;
	        contentStart = undefined;
	        contentEnd = undefined;
	      }
	    }

	    if (
	      events[index][0] === 'exit' &&
	      cellStart !== undefined &&
	      cellStart + (seenCellInRow ? 0 : 1) < index &&
	      (token.type === 'tableCellDivider' ||
	        (token.type === 'tableRow' &&
	          (cellStart + 3 < index ||
	            events[cellStart][1].type !== 'whitespace')))
	    ) {
	      const cell = {
	        type: inDelimiterRow
	          ? 'tableDelimiter'
	          : inHead
	          ? 'tableHeader'
	          : 'tableData',
	        start: events[cellStart][1].start,
	        end: events[index][1].end
	      };
	      events.splice(index + (token.type === 'tableCellDivider' ? 1 : 0), 0, [
	        'exit',
	        cell,
	        context
	      ]);
	      events.splice(cellStart, 0, ['enter', cell, context]);
	      index += 2;
	      cellStart = index + 1;
	      seenCellInRow = true;
	    }

	    if (token.type === 'tableRow') {
	      inRow = events[index][0] === 'enter';

	      if (inRow) {
	        cellStart = index + 1;
	        seenCellInRow = false;
	      }
	    }

	    if (token.type === 'tableDelimiterRow') {
	      inDelimiterRow = events[index][0] === 'enter';

	      if (inDelimiterRow) {
	        cellStart = index + 1;
	        seenCellInRow = false;
	      }
	    }

	    if (token.type === 'tableHead') {
	      inHead = events[index][0] === 'enter';
	    }
	  }

	  return events
	}
	/** @type {Tokenizer} */

	function tokenizeTable(effects, ok, nok) {
	  const self = this;
	  /** @type {Array<Align>} */

	  const align = [];
	  let tableHeaderCount = 0;
	  /** @type {boolean|undefined} */

	  let seenDelimiter;
	  /** @type {boolean|undefined} */

	  let hasDash;
	  return start
	  /** @type {State} */

	  function start(code) {
	    // @ts-expect-error Custom.
	    effects.enter('table')._align = align;
	    effects.enter('tableHead');
	    effects.enter('tableRow'); // If we start with a pipe, we open a cell marker.

	    if (code === 124) {
	      return cellDividerHead(code)
	    }

	    tableHeaderCount++;
	    effects.enter('temporaryTableCellContent'); // Can’t be space or eols at the start of a construct, so we’re in a cell.

	    return inCellContentHead(code)
	  }
	  /** @type {State} */

	  function cellDividerHead(code) {
	    effects.enter('tableCellDivider');
	    effects.consume(code);
	    effects.exit('tableCellDivider');
	    seenDelimiter = true;
	    return cellBreakHead
	  }
	  /** @type {State} */

	  function cellBreakHead(code) {
	    if (code === null || markdownLineEnding(code)) {
	      return atRowEndHead(code)
	    }

	    if (markdownSpace(code)) {
	      effects.enter('whitespace');
	      effects.consume(code);
	      return inWhitespaceHead
	    }

	    if (seenDelimiter) {
	      seenDelimiter = undefined;
	      tableHeaderCount++;
	    }

	    if (code === 124) {
	      return cellDividerHead(code)
	    } // Anything else is cell content.

	    effects.enter('temporaryTableCellContent');
	    return inCellContentHead(code)
	  }
	  /** @type {State} */

	  function inWhitespaceHead(code) {
	    if (markdownSpace(code)) {
	      effects.consume(code);
	      return inWhitespaceHead
	    }

	    effects.exit('whitespace');
	    return cellBreakHead(code)
	  }
	  /** @type {State} */

	  function inCellContentHead(code) {
	    // EOF, whitespace, pipe
	    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {
	      effects.exit('temporaryTableCellContent');
	      return cellBreakHead(code)
	    }

	    effects.consume(code);
	    return code === 92 ? inCellContentEscapeHead : inCellContentHead
	  }
	  /** @type {State} */

	  function inCellContentEscapeHead(code) {
	    if (code === 92 || code === 124) {
	      effects.consume(code);
	      return inCellContentHead
	    } // Anything else.

	    return inCellContentHead(code)
	  }
	  /** @type {State} */

	  function atRowEndHead(code) {
	    if (code === null) {
	      return nok(code)
	    }

	    effects.exit('tableRow');
	    effects.exit('tableHead');
	    const originalInterrupt = self.interrupt;
	    self.interrupt = true;
	    return effects.attempt(
	      {
	        tokenize: tokenizeRowEnd,
	        partial: true
	      },
	      function (code) {
	        self.interrupt = originalInterrupt;
	        effects.enter('tableDelimiterRow');
	        return atDelimiterRowBreak(code)
	      },
	      function (code) {
	        self.interrupt = originalInterrupt;
	        return nok(code)
	      }
	    )(code)
	  }
	  /** @type {State} */

	  function atDelimiterRowBreak(code) {
	    if (code === null || markdownLineEnding(code)) {
	      return rowEndDelimiter(code)
	    }

	    if (markdownSpace(code)) {
	      effects.enter('whitespace');
	      effects.consume(code);
	      return inWhitespaceDelimiter
	    }

	    if (code === 45) {
	      effects.enter('tableDelimiterFiller');
	      effects.consume(code);
	      hasDash = true;
	      align.push('none');
	      return inFillerDelimiter
	    }

	    if (code === 58) {
	      effects.enter('tableDelimiterAlignment');
	      effects.consume(code);
	      effects.exit('tableDelimiterAlignment');
	      align.push('left');
	      return afterLeftAlignment
	    } // If we start with a pipe, we open a cell marker.

	    if (code === 124) {
	      effects.enter('tableCellDivider');
	      effects.consume(code);
	      effects.exit('tableCellDivider');
	      return atDelimiterRowBreak
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function inWhitespaceDelimiter(code) {
	    if (markdownSpace(code)) {
	      effects.consume(code);
	      return inWhitespaceDelimiter
	    }

	    effects.exit('whitespace');
	    return atDelimiterRowBreak(code)
	  }
	  /** @type {State} */

	  function inFillerDelimiter(code) {
	    if (code === 45) {
	      effects.consume(code);
	      return inFillerDelimiter
	    }

	    effects.exit('tableDelimiterFiller');

	    if (code === 58) {
	      effects.enter('tableDelimiterAlignment');
	      effects.consume(code);
	      effects.exit('tableDelimiterAlignment');
	      align[align.length - 1] =
	        align[align.length - 1] === 'left' ? 'center' : 'right';
	      return afterRightAlignment
	    }

	    return atDelimiterRowBreak(code)
	  }
	  /** @type {State} */

	  function afterLeftAlignment(code) {
	    if (code === 45) {
	      effects.enter('tableDelimiterFiller');
	      effects.consume(code);
	      hasDash = true;
	      return inFillerDelimiter
	    } // Anything else is not ok.

	    return nok(code)
	  }
	  /** @type {State} */

	  function afterRightAlignment(code) {
	    if (code === null || markdownLineEnding(code)) {
	      return rowEndDelimiter(code)
	    }

	    if (markdownSpace(code)) {
	      effects.enter('whitespace');
	      effects.consume(code);
	      return inWhitespaceDelimiter
	    } // `|`

	    if (code === 124) {
	      effects.enter('tableCellDivider');
	      effects.consume(code);
	      effects.exit('tableCellDivider');
	      return atDelimiterRowBreak
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function rowEndDelimiter(code) {
	    effects.exit('tableDelimiterRow'); // Exit if there was no dash at all, or if the header cell count is not the
	    // delimiter cell count.

	    if (!hasDash || tableHeaderCount !== align.length) {
	      return nok(code)
	    }

	    if (code === null) {
	      return tableClose(code)
	    }

	    return effects.check(
	      nextPrefixedOrBlank,
	      tableClose,
	      effects.attempt(
	        {
	          tokenize: tokenizeRowEnd,
	          partial: true
	        },
	        factorySpace(effects, bodyStart, 'linePrefix', 4),
	        tableClose
	      )
	    )(code)
	  }
	  /** @type {State} */

	  function tableClose(code) {
	    effects.exit('table');
	    return ok(code)
	  }
	  /** @type {State} */

	  function bodyStart(code) {
	    effects.enter('tableBody');
	    return rowStartBody(code)
	  }
	  /** @type {State} */

	  function rowStartBody(code) {
	    effects.enter('tableRow'); // If we start with a pipe, we open a cell marker.

	    if (code === 124) {
	      return cellDividerBody(code)
	    }

	    effects.enter('temporaryTableCellContent'); // Can’t be space or eols at the start of a construct, so we’re in a cell.

	    return inCellContentBody(code)
	  }
	  /** @type {State} */

	  function cellDividerBody(code) {
	    effects.enter('tableCellDivider');
	    effects.consume(code);
	    effects.exit('tableCellDivider');
	    return cellBreakBody
	  }
	  /** @type {State} */

	  function cellBreakBody(code) {
	    if (code === null || markdownLineEnding(code)) {
	      return atRowEndBody(code)
	    }

	    if (markdownSpace(code)) {
	      effects.enter('whitespace');
	      effects.consume(code);
	      return inWhitespaceBody
	    } // `|`

	    if (code === 124) {
	      return cellDividerBody(code)
	    } // Anything else is cell content.

	    effects.enter('temporaryTableCellContent');
	    return inCellContentBody(code)
	  }
	  /** @type {State} */

	  function inWhitespaceBody(code) {
	    if (markdownSpace(code)) {
	      effects.consume(code);
	      return inWhitespaceBody
	    }

	    effects.exit('whitespace');
	    return cellBreakBody(code)
	  }
	  /** @type {State} */

	  function inCellContentBody(code) {
	    // EOF, whitespace, pipe
	    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {
	      effects.exit('temporaryTableCellContent');
	      return cellBreakBody(code)
	    }

	    effects.consume(code);
	    return code === 92 ? inCellContentEscapeBody : inCellContentBody
	  }
	  /** @type {State} */

	  function inCellContentEscapeBody(code) {
	    if (code === 92 || code === 124) {
	      effects.consume(code);
	      return inCellContentBody
	    } // Anything else.

	    return inCellContentBody(code)
	  }
	  /** @type {State} */

	  function atRowEndBody(code) {
	    effects.exit('tableRow');

	    if (code === null) {
	      return tableBodyClose(code)
	    }

	    return effects.check(
	      nextPrefixedOrBlank,
	      tableBodyClose,
	      effects.attempt(
	        {
	          tokenize: tokenizeRowEnd,
	          partial: true
	        },
	        factorySpace(effects, rowStartBody, 'linePrefix', 4),
	        tableBodyClose
	      )
	    )(code)
	  }
	  /** @type {State} */

	  function tableBodyClose(code) {
	    effects.exit('tableBody');
	    return tableClose(code)
	  }
	  /** @type {Tokenizer} */

	  function tokenizeRowEnd(effects, ok, nok) {
	    return start
	    /** @type {State} */

	    function start(code) {
	      effects.enter('lineEnding');
	      effects.consume(code);
	      effects.exit('lineEnding');
	      return factorySpace(effects, prefixed, 'linePrefix')
	    }
	    /** @type {State} */

	    function prefixed(code) {
	      // Blank or interrupting line.
	      if (
	        self.parser.lazy[self.now().line] ||
	        code === null ||
	        markdownLineEnding(code)
	      ) {
	        return nok(code)
	      }

	      const tail = self.events[self.events.length - 1]; // Indented code can interrupt delimiter and body rows.

	      if (
	        !self.parser.constructs.disable.null.includes('codeIndented') &&
	        tail &&
	        tail[1].type === 'linePrefix' &&
	        tail[2].sliceSerialize(tail[1], true).length >= 4
	      ) {
	        return nok(code)
	      }

	      self._gfmTableDynamicInterruptHack = true;
	      return effects.check(
	        self.parser.constructs.flow,
	        function (code) {
	          self._gfmTableDynamicInterruptHack = false;
	          return nok(code)
	        },
	        function (code) {
	          self._gfmTableDynamicInterruptHack = false;
	          return ok(code)
	        }
	      )(code)
	    }
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeNextPrefixedOrBlank(effects, ok, nok) {
	  let size = 0;
	  return start
	  /** @type {State} */

	  function start(code) {
	    // This is a check, so we don’t care about tokens, but we open a bogus one
	    // so we’re valid.
	    effects.enter('check'); // EOL.

	    effects.consume(code);
	    return whitespace
	  }
	  /** @type {State} */

	  function whitespace(code) {
	    if (code === -1 || code === 32) {
	      effects.consume(code);
	      size++;
	      return size === 4 ? ok : whitespace
	    } // EOF or whitespace

	    if (code === null || markdownLineEndingOrSpace(code)) {
	      return ok(code)
	    } // Anything else.

	    return nok(code)
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Extension} Extension
	 * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').Previous} Previous
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Event} Event
	 * @typedef {import('micromark-util-types').Code} Code
	 */
	const tasklistCheck = {
	  tokenize: tokenizeTasklistCheck
	};
	const gfmTaskListItem = {
	  text: {
	    [91]: tasklistCheck
	  }
	};
	/** @type {Tokenizer} */

	function tokenizeTasklistCheck(effects, ok, nok) {
	  const self = this;
	  return open
	  /** @type {State} */

	  function open(code) {
	    if (
	      // Exit if there’s stuff before.
	      self.previous !== null || // Exit if not in the first content that is the first child of a list
	      // item.
	      !self._gfmTasklistFirstContentOfListItem
	    ) {
	      return nok(code)
	    }

	    effects.enter('taskListCheck');
	    effects.enter('taskListCheckMarker');
	    effects.consume(code);
	    effects.exit('taskListCheckMarker');
	    return inside
	  }
	  /** @type {State} */

	  function inside(code) {
	    // To match how GH works in comments, use `markdownSpace` (`[ \t]`) instead
	    // of `markdownLineEndingOrSpace` (`[ \t\r\n]`).
	    if (markdownLineEndingOrSpace(code)) {
	      effects.enter('taskListCheckValueUnchecked');
	      effects.consume(code);
	      effects.exit('taskListCheckValueUnchecked');
	      return close
	    }

	    if (code === 88 || code === 120) {
	      effects.enter('taskListCheckValueChecked');
	      effects.consume(code);
	      effects.exit('taskListCheckValueChecked');
	      return close
	    }

	    return nok(code)
	  }
	  /** @type {State} */

	  function close(code) {
	    if (code === 93) {
	      effects.enter('taskListCheckMarker');
	      effects.consume(code);
	      effects.exit('taskListCheckMarker');
	      effects.exit('taskListCheck');
	      return effects.check(
	        {
	          tokenize: spaceThenNonSpace
	        },
	        ok,
	        nok
	      )
	    }

	    return nok(code)
	  }
	}
	/** @type {Tokenizer} */

	function spaceThenNonSpace(effects, ok, nok) {
	  const self = this;
	  return factorySpace(effects, after, 'whitespace')
	  /** @type {State} */

	  function after(code) {
	    const tail = self.events[self.events.length - 1];
	    return (
	      // We either found spaces…
	      ((tail && tail[1].type === 'whitespace') || // …or it was followed by a line ending, in which case, there has to be
	        // non-whitespace after that line ending, because otherwise we’d get an
	        // EOF as the content is closed with blank lines.
	        markdownLineEnding(code)) &&
	        code !== null
	        ? ok(code)
	        : nok(code)
	    )
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Extension} Extension
	 * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
	 * @typedef {import('micromark-extension-gfm-strikethrough').Options} Options
	 * @typedef {import('micromark-extension-gfm-footnote').HtmlOptions} HtmlOptions
	 */


	/**
	 * Support GFM or markdown on github.com.
	 *
	 * @param {Options} [options]
	 * @returns {Extension}
	 */
	function gfm(options) {
	  return combineExtensions([
	    gfmAutolinkLiteral,
	    gfmFootnote(),
	    gfmStrikethrough(options),
	    gfmTable,
	    gfmTaskListItem
	  ])
	}

	function gfmAutolinkLiteralFromMarkdown() { return {} }
	function gfmAutolinkLiteralToMarkdown() { return {} }

	/**
	 * Turn the number (in string form as either hexa- or plain decimal) coming from
	 * a numeric character reference into a character.
	 *
	 * @param {string} value
	 *   Value to decode.
	 * @param {number} base
	 *   Numeric base.
	 * @returns {string}
	 */
	function decodeNumericCharacterReference(value, base) {
	  const code = Number.parseInt(value, base);

	  if (
	    // C0 except for HT, LF, FF, CR, space
	    code < 9 ||
	    code === 11 ||
	    (code > 13 && code < 32) || // Control character (DEL) of the basic block and C1 controls.
	    (code > 126 && code < 160) || // Lone high surrogates and low surrogates.
	    (code > 55295 && code < 57344) || // Noncharacters.
	    (code > 64975 && code < 65008) ||
	    (code & 65535) === 65535 ||
	    (code & 65535) === 65534 || // Out of range
	    code > 1114111
	  ) {
	    return '\uFFFD'
	  }

	  return String.fromCharCode(code)
	}

	const characterEscapeOrReference =
	  /\\([!-/:-@[-`{-~])|&(#(?:\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/gi;
	/**
	 * Utility to decode markdown strings (which occur in places such as fenced
	 * code info strings, destinations, labels, and titles).
	 * The “string” content type allows character escapes and -references.
	 * This decodes those.
	 *
	 * @param {string} value
	 * @returns {string}
	 */

	function decodeString(value) {
	  return value.replace(characterEscapeOrReference, decode)
	}
	/**
	 * @param {string} $0
	 * @param {string} $1
	 * @param {string} $2
	 * @returns {string}
	 */

	function decode($0, $1, $2) {
	  if ($1) {
	    // Escape.
	    return $1
	  } // Reference.

	  const head = $2.charCodeAt(0);

	  if (head === 35) {
	    const head = $2.charCodeAt(1);
	    const hex = head === 120 || head === 88;
	    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10)
	  }

	  return decodeNamedCharacterReference($2) || $0
	}

	/**
	 * @typedef {import('mdast').Association} Association
	 */


	/**
	 * The `label` of an association is the string value: character escapes and
	 * references work, and casing is intact.
	 * The `identifier` is used to match one association to another: controversially,
	 * character escapes and references don’t work in this matching: `&copy;` does
	 * not match `©`, and `\+` does not match `+`.
	 * But casing is ignored (and whitespace) is trimmed and collapsed: ` A\nb`
	 * matches `a b`.
	 * So, we do prefer the label when figuring out how we’re going to serialize:
	 * it has whitespace, casing, and we can ignore most useless character escapes
	 * and all character references.
	 *
	 * @param {Association} node
	 * @returns {string}
	 */
	function association(node) {
	  if (node.label || !node.identifier) {
	    return node.label || ''
	  }

	  return decodeString(node.identifier)
	}

	/**
	 * @typedef {import('unist').Point} Point
	 * @typedef {import('../types.js').TrackFields} TrackFields
	 */

	/**
	 * Functions to track output positions.
	 * This info isn’t used yet but suchs functionality allows line wrapping,
	 * and theoretically source maps (though, is there practical use in that?).
	 *
	 * @param {TrackFields} options_
	 */
	function track(options_) {
	  // Defaults are used to prevent crashes when older utilities somehow activate
	  // this code.
	  /* c8 ignore next 5 */
	  const options = options_ || {};
	  const now = options.now || {};
	  let lineShift = options.lineShift || 0;
	  let line = now.line || 1;
	  let column = now.column || 1;

	  return {move, current, shift}

	  /**
	   * Get the current tracked info.
	   *
	   * @returns {{now: Point, lineShift: number}}
	   */
	  function current() {
	    return {now: {line, column}, lineShift}
	  }

	  /**
	   * Define an increased line shift (the typical indent for lines).
	   *
	   * @param {number} value
	   */
	  function shift(value) {
	    lineShift += value;
	  }

	  /**
	   * Move past a string.
	   *
	   * @param {string} value
	   * @returns {string}
	   */
	  function move(value = '') {
	    const chunks = value.split(/\r?\n|\r/g);
	    const tail = chunks[chunks.length - 1];
	    line += chunks.length - 1;
	    column =
	      chunks.length === 1 ? column + tail.length : 1 + tail.length + lineShift;
	    return value
	  }
	}

	/**
	 * @typedef {import('../types.js').Node} Node
	 * @typedef {import('../types.js').Parent} Parent
	 * @typedef {import('../types.js').Join} Join
	 * @typedef {import('../types.js').Context} Context
	 * @typedef {import('../types.js').TrackFields} TrackFields
	 */


	/**
	 * @param {Parent} parent
	 * @param {Context} context
	 * @param {TrackFields} safeOptions
	 * @returns {string}
	 */
	function containerFlow(parent, context, safeOptions) {
	  const indexStack = context.indexStack;
	  const children = parent.children || [];
	  const tracker = track(safeOptions);
	  /** @type {Array<string>} */
	  const results = [];
	  let index = -1;

	  indexStack.push(-1);

	  while (++index < children.length) {
	    const child = children[index];

	    indexStack[indexStack.length - 1] = index;

	    results.push(
	      tracker.move(
	        context.handle(child, parent, context, {
	          before: '\n',
	          after: '\n',
	          ...tracker.current()
	        })
	      )
	    );

	    if (child.type !== 'list') {
	      context.bulletLastUsed = undefined;
	    }

	    if (index < children.length - 1) {
	      results.push(tracker.move(between(child, children[index + 1])));
	    }
	  }

	  indexStack.pop();

	  return results.join('')

	  /**
	   * @param {Node} left
	   * @param {Node} right
	   * @returns {string}
	   */
	  function between(left, right) {
	    let index = context.join.length;

	    while (index--) {
	      const result = context.join[index](left, right, parent, context);

	      if (result === true || result === 1) {
	        break
	      }

	      if (typeof result === 'number') {
	        return '\n'.repeat(1 + result)
	      }

	      if (result === false) {
	        return '\n\n<!---->\n\n'
	      }
	    }

	    return '\n\n'
	  }
	}

	/**
	 * @callback Map
	 * @param {string} value
	 * @param {number} line
	 * @param {boolean} blank
	 * @returns {string}
	 */

	const eol = /\r?\n|\r/g;

	/**
	 * @param {string} value
	 * @param {Map} map
	 * @returns {string}
	 */
	function indentLines(value, map) {
	  /** @type {Array<string>} */
	  const result = [];
	  let start = 0;
	  let line = 0;
	  /** @type {RegExpExecArray|null} */
	  let match;

	  while ((match = eol.exec(value))) {
	    one(value.slice(start, match.index));
	    result.push(match[0]);
	    start = match.index + match[0].length;
	    line++;
	  }

	  one(value.slice(start));

	  return result.join('')

	  /**
	   * @param {string} value
	   */
	  function one(value) {
	    result.push(map(value, line, !value));
	  }
	}

	/**
	 * @typedef {import('../types.js').Unsafe} Unsafe
	 */

	/**
	 * @param {Unsafe} pattern
	 * @returns {RegExp}
	 */
	function patternCompile(pattern) {
	  if (!pattern._compiled) {
	    const before =
	      (pattern.atBreak ? '[\\r\\n][\\t ]*' : '') +
	      (pattern.before ? '(?:' + pattern.before + ')' : '');

	    pattern._compiled = new RegExp(
	      (before ? '(' + before + ')' : '') +
	        (/[|\\{}()[\]^$+*?.-]/.test(pattern.character) ? '\\' : '') +
	        pattern.character +
	        (pattern.after ? '(?:' + pattern.after + ')' : ''),
	      'g'
	    );
	  }

	  return pattern._compiled
	}

	/**
	 * @typedef {import('../types.js').Unsafe} Unsafe
	 */

	/**
	 * @param {Array<string>} stack
	 * @param {Unsafe} pattern
	 * @returns {boolean}
	 */
	function patternInScope(stack, pattern) {
	  return (
	    listInScope(stack, pattern.inConstruct, true) &&
	    !listInScope(stack, pattern.notInConstruct, false)
	  )
	}

	/**
	 * @param {Array<string>} stack
	 * @param {Unsafe['inConstruct']} list
	 * @param {boolean} none
	 * @returns {boolean}
	 */
	function listInScope(stack, list, none) {
	  if (!list) {
	    return none
	  }

	  if (typeof list === 'string') {
	    list = [list];
	  }

	  let index = -1;

	  while (++index < list.length) {
	    if (stack.includes(list[index])) {
	      return true
	    }
	  }

	  return false
	}

	/**
	 * @typedef {import('../types.js').Context} Context
	 * @typedef {import('../types.js').SafeOptions} SafeOptions
	 */


	/**
	 * @param {Context} context
	 * @param {string|null|undefined} input
	 * @param {SafeOptions & {encode?: Array<string>}} config
	 * @returns {string}
	 */
	function safe(context, input, config) {
	  const value = (config.before || '') + (input || '') + (config.after || '');
	  /** @type {Array<number>} */
	  const positions = [];
	  /** @type {Array<string>} */
	  const result = [];
	  /** @type {Record<number, {before: boolean, after: boolean}>} */
	  const infos = {};
	  let index = -1;

	  while (++index < context.unsafe.length) {
	    const pattern = context.unsafe[index];

	    if (!patternInScope(context.stack, pattern)) {
	      continue
	    }

	    const expression = patternCompile(pattern);
	    /** @type {RegExpExecArray|null} */
	    let match;

	    while ((match = expression.exec(value))) {
	      const before = 'before' in pattern || Boolean(pattern.atBreak);
	      const after = 'after' in pattern;
	      const position = match.index + (before ? match[1].length : 0);

	      if (positions.includes(position)) {
	        if (infos[position].before && !before) {
	          infos[position].before = false;
	        }

	        if (infos[position].after && !after) {
	          infos[position].after = false;
	        }
	      } else {
	        positions.push(position);
	        infos[position] = {before, after};
	      }
	    }
	  }

	  positions.sort(numerical);

	  let start = config.before ? config.before.length : 0;
	  const end = value.length - (config.after ? config.after.length : 0);
	  index = -1;

	  while (++index < positions.length) {
	    const position = positions[index];

	    // Character before or after matched:
	    if (position < start || position >= end) {
	      continue
	    }

	    // If this character is supposed to be escaped because it has a condition on
	    // the next character, and the next character is definitly being escaped,
	    // then skip this escape.
	    if (
	      (position + 1 < end &&
	        positions[index + 1] === position + 1 &&
	        infos[position].after &&
	        !infos[position + 1].before &&
	        !infos[position + 1].after) ||
	      (positions[index - 1] === position - 1 &&
	        infos[position].before &&
	        !infos[position - 1].before &&
	        !infos[position - 1].after)
	    ) {
	      continue
	    }

	    if (start !== position) {
	      // If we have to use a character reference, an ampersand would be more
	      // correct, but as backslashes only care about punctuation, either will
	      // do the trick
	      result.push(escapeBackslashes(value.slice(start, position), '\\'));
	    }

	    start = position;

	    if (
	      /[!-/:-@[-`{-~]/.test(value.charAt(position)) &&
	      (!config.encode || !config.encode.includes(value.charAt(position)))
	    ) {
	      // Character escape.
	      result.push('\\');
	    } else {
	      // Character reference.
	      result.push(
	        '&#x' + value.charCodeAt(position).toString(16).toUpperCase() + ';'
	      );
	      start++;
	    }
	  }

	  result.push(escapeBackslashes(value.slice(start, end), config.after));

	  return result.join('')
	}

	/**
	 * @param {number} a
	 * @param {number} b
	 * @returns {number}
	 */
	function numerical(a, b) {
	  return a - b
	}

	/**
	 * @param {string} value
	 * @param {string} after
	 * @returns {string}
	 */
	function escapeBackslashes(value, after) {
	  const expression = /\\(?=[!-/:-@[-`{-~])/g;
	  /** @type {Array<number>} */
	  const positions = [];
	  /** @type {Array<string>} */
	  const results = [];
	  const whole = value + after;
	  let index = -1;
	  let start = 0;
	  /** @type {RegExpExecArray|null} */
	  let match;

	  while ((match = expression.exec(whole))) {
	    positions.push(match.index);
	  }

	  while (++index < positions.length) {
	    if (start !== positions[index]) {
	      results.push(value.slice(start, positions[index]));
	    }

	    results.push('\\');
	    start = positions[index];
	  }

	  results.push(value.slice(start));

	  return results.join('')
	}

	/**
	 * @typedef {import('mdast').FootnoteReference} FootnoteReference
	 * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition
	 * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
	 * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
	 * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
	 * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
	 * @typedef {import('mdast-util-to-markdown').Map} Map
	 */


	/**
	 * @returns {FromMarkdownExtension}
	 */
	function gfmFootnoteFromMarkdown() {
	  return {
	    enter: {
	      gfmFootnoteDefinition: enterFootnoteDefinition,
	      gfmFootnoteDefinitionLabelString: enterFootnoteDefinitionLabelString,
	      gfmFootnoteCall: enterFootnoteCall,
	      gfmFootnoteCallString: enterFootnoteCallString
	    },
	    exit: {
	      gfmFootnoteDefinition: exitFootnoteDefinition,
	      gfmFootnoteDefinitionLabelString: exitFootnoteDefinitionLabelString,
	      gfmFootnoteCall: exitFootnoteCall,
	      gfmFootnoteCallString: exitFootnoteCallString
	    }
	  }

	  /** @type {FromMarkdownHandle} */
	  function enterFootnoteDefinition(token) {
	    this.enter(
	      {type: 'footnoteDefinition', identifier: '', label: '', children: []},
	      token
	    );
	  }

	  /** @type {FromMarkdownHandle} */
	  function enterFootnoteDefinitionLabelString() {
	    this.buffer();
	  }

	  /** @type {FromMarkdownHandle} */
	  function exitFootnoteDefinitionLabelString(token) {
	    const label = this.resume();
	    const node = /** @type {FootnoteDefinition} */ (
	      this.stack[this.stack.length - 1]
	    );
	    node.label = label;
	    node.identifier = normalizeIdentifier(
	      this.sliceSerialize(token)
	    ).toLowerCase();
	  }

	  /** @type {FromMarkdownHandle} */
	  function exitFootnoteDefinition(token) {
	    this.exit(token);
	  }

	  /** @type {FromMarkdownHandle} */
	  function enterFootnoteCall(token) {
	    this.enter({type: 'footnoteReference', identifier: '', label: ''}, token);
	  }

	  /** @type {FromMarkdownHandle} */
	  function enterFootnoteCallString() {
	    this.buffer();
	  }

	  /** @type {FromMarkdownHandle} */
	  function exitFootnoteCallString(token) {
	    const label = this.resume();
	    const node = /** @type {FootnoteDefinition} */ (
	      this.stack[this.stack.length - 1]
	    );
	    node.label = label;
	    node.identifier = normalizeIdentifier(
	      this.sliceSerialize(token)
	    ).toLowerCase();
	  }

	  /** @type {FromMarkdownHandle} */
	  function exitFootnoteCall(token) {
	    this.exit(token);
	  }
	}

	/**
	 * @returns {ToMarkdownExtension}
	 */
	function gfmFootnoteToMarkdown() {
	  footnoteReference.peek = footnoteReferencePeek;

	  return {
	    // This is on by default already.
	    unsafe: [{character: '[', inConstruct: ['phrasing', 'label', 'reference']}],
	    handlers: {footnoteDefinition, footnoteReference}
	  }

	  /**
	   * @type {ToMarkdownHandle}
	   * @param {FootnoteReference} node
	   */
	  function footnoteReference(node, _, context, safeOptions) {
	    const tracker = track(safeOptions);
	    let value = tracker.move('[^');
	    const exit = context.enter('footnoteReference');
	    const subexit = context.enter('reference');
	    value += tracker.move(
	      safe(context, association(node), {
	        ...tracker.current(),
	        before: value,
	        after: ']'
	      })
	    );
	    subexit();
	    exit();
	    value += tracker.move(']');
	    return value
	  }

	  /** @type {ToMarkdownHandle} */
	  function footnoteReferencePeek() {
	    return '['
	  }

	  /**
	   * @type {ToMarkdownHandle}
	   * @param {FootnoteDefinition} node
	   */
	  function footnoteDefinition(node, _, context, safeOptions) {
	    const tracker = track(safeOptions);
	    let value = tracker.move('[^');
	    const exit = context.enter('footnoteDefinition');
	    const subexit = context.enter('label');
	    value += tracker.move(
	      safe(context, association(node), {
	        ...tracker.current(),
	        before: value,
	        after: ']'
	      })
	    );
	    subexit();
	    value += tracker.move(
	      ']:' + (node.children && node.children.length > 0 ? ' ' : '')
	    );
	    tracker.shift(4);
	    value += tracker.move(
	      indentLines(containerFlow(node, context, tracker.current()), map)
	    );
	    exit();

	    return value

	    /** @type {Map} */
	    function map(line, index, blank) {
	      if (index) {
	        return (blank ? '' : '    ') + line
	      }

	      return line
	    }
	  }
	}

	/**
	 * @typedef {import('../types.js').Node} Node
	 * @typedef {import('../types.js').Parent} Parent
	 * @typedef {import('../types.js').SafeOptions} SafeOptions
	 * @typedef {import('../types.js').Context} Context
	 */


	/**
	 * @param {Parent} parent
	 * @param {Context} context
	 * @param {SafeOptions} safeOptions
	 * @returns {string}
	 */
	function containerPhrasing(parent, context, safeOptions) {
	  const indexStack = context.indexStack;
	  const children = parent.children || [];
	  /** @type {Array<string>} */
	  const results = [];
	  let index = -1;
	  let before = safeOptions.before;

	  indexStack.push(-1);
	  let tracker = track(safeOptions);

	  while (++index < children.length) {
	    const child = children[index];
	    /** @type {string} */
	    let after;

	    indexStack[indexStack.length - 1] = index;

	    if (index + 1 < children.length) {
	      // @ts-expect-error: hush, it’s actually a `zwitch`.
	      let handle = context.handle.handlers[children[index + 1].type];
	      if (handle && handle.peek) handle = handle.peek;
	      after = handle
	        ? handle(children[index + 1], parent, context, {
	            before: '',
	            after: '',
	            ...tracker.current()
	          }).charAt(0)
	        : '';
	    } else {
	      after = safeOptions.after;
	    }

	    // In some cases, html (text) can be found in phrasing right after an eol.
	    // When we’d serialize that, in most cases that would be seen as html
	    // (flow).
	    // As we can’t escape or so to prevent it from happening, we take a somewhat
	    // reasonable approach: replace that eol with a space.
	    // See: <https://github.com/syntax-tree/mdast-util-to-markdown/issues/15>
	    if (
	      results.length > 0 &&
	      (before === '\r' || before === '\n') &&
	      child.type === 'html'
	    ) {
	      results[results.length - 1] = results[results.length - 1].replace(
	        /(\r?\n|\r)$/,
	        ' '
	      );
	      before = ' ';

	      // To do: does this work to reset tracker?
	      tracker = track(safeOptions);
	      tracker.move(results.join(''));
	    }

	    results.push(
	      tracker.move(
	        context.handle(child, parent, context, {
	          ...tracker.current(),
	          before,
	          after
	        })
	      )
	    );

	    before = results[results.length - 1].slice(-1);
	  }

	  indexStack.pop();

	  return results.join('')
	}

	/**
	 * @typedef {import('mdast').Delete} Delete
	 * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
	 * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
	 * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
	 * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
	 */


	/** @type {FromMarkdownExtension} */
	const gfmStrikethroughFromMarkdown = {
	  canContainEols: ['delete'],
	  enter: {strikethrough: enterStrikethrough},
	  exit: {strikethrough: exitStrikethrough}
	};

	/** @type {ToMarkdownExtension} */
	const gfmStrikethroughToMarkdown = {
	  unsafe: [{character: '~', inConstruct: 'phrasing'}],
	  handlers: {delete: handleDelete}
	};

	handleDelete.peek = peekDelete;

	/** @type {FromMarkdownHandle} */
	function enterStrikethrough(token) {
	  this.enter({type: 'delete', children: []}, token);
	}

	/** @type {FromMarkdownHandle} */
	function exitStrikethrough(token) {
	  this.exit(token);
	}

	/**
	 * @type {ToMarkdownHandle}
	 * @param {Delete} node
	 */
	function handleDelete(node, _, context, safeOptions) {
	  const tracker = track(safeOptions);
	  const exit = context.enter('emphasis');
	  let value = tracker.move('~~');
	  value += containerPhrasing(node, context, {
	    ...tracker.current(),
	    before: value,
	    after: '~'
	  });
	  value += tracker.move('~~');
	  exit();
	  return value
	}

	/** @type {ToMarkdownHandle} */
	function peekDelete() {
	  return '~'
	}

	/**
	 * @typedef {import('mdast').InlineCode} InlineCode
	 * @typedef {import('../types.js').Handle} Handle
	 */


	inlineCode$1.peek = inlineCodePeek;

	/**
	 * @type {Handle}
	 * @param {InlineCode} node
	 */
	function inlineCode$1(node, _, context) {
	  let value = node.value || '';
	  let sequence = '`';
	  let index = -1;

	  // If there is a single grave accent on its own in the code, use a fence of
	  // two.
	  // If there are two in a row, use one.
	  while (new RegExp('(^|[^`])' + sequence + '([^`]|$)').test(value)) {
	    sequence += '`';
	  }

	  // If this is not just spaces or eols (tabs don’t count), and either the
	  // first or last character are a space, eol, or tick, then pad with spaces.
	  if (
	    /[^ \r\n]/.test(value) &&
	    ((/^[ \r\n]/.test(value) && /[ \r\n]$/.test(value)) || /^`|`$/.test(value))
	  ) {
	    value = ' ' + value + ' ';
	  }

	  // We have a potential problem: certain characters after eols could result in
	  // blocks being seen.
	  // For example, if someone injected the string `'\n# b'`, then that would
	  // result in an ATX heading.
	  // We can’t escape characters in `inlineCode`, but because eols are
	  // transformed to spaces when going from markdown to HTML anyway, we can swap
	  // them out.
	  while (++index < context.unsafe.length) {
	    const pattern = context.unsafe[index];
	    const expression = patternCompile(pattern);
	    /** @type {RegExpExecArray|null} */
	    let match;

	    // Only look for `atBreak`s.
	    // Btw: note that `atBreak` patterns will always start the regex at LF or
	    // CR.
	    if (!pattern.atBreak) continue

	    while ((match = expression.exec(value))) {
	      let position = match.index;

	      // Support CRLF (patterns only look for one of the characters).
	      if (
	        value.charCodeAt(position) === 10 /* `\n` */ &&
	        value.charCodeAt(position - 1) === 13 /* `\r` */
	      ) {
	        position--;
	      }

	      value = value.slice(0, position) + ' ' + value.slice(match.index + 1);
	    }
	  }

	  return sequence + value + sequence
	}

	/**
	 * @type {Handle}
	 */
	function inlineCodePeek() {
	  return '`'
	}

	/**
	 * @typedef Options
	 *   Configuration (optional).
	 * @property {string|null|Array<string|null|undefined>} [align]
	 *   One style for all columns, or styles for their respective columns.
	 *   Each style is either `'l'` (left), `'r'` (right), or `'c'` (center).
	 *   Other values are treated as `''`, which doesn’t place the colon in the
	 *   alignment row but does align left.
	 *   *Only the lowercased first character is used, so `Right` is fine.*
	 * @property {boolean} [padding=true]
	 *   Whether to add a space of padding between delimiters and cells.
	 *
	 *   When `true`, there is padding:
	 *
	 *   ```markdown
	 *   | Alpha | B     |
	 *   | ----- | ----- |
	 *   | C     | Delta |
	 *   ```
	 *
	 *   When `false`, there is no padding:
	 *
	 *   ```markdown
	 *   |Alpha|B    |
	 *   |-----|-----|
	 *   |C    |Delta|
	 *   ```
	 * @property {boolean} [delimiterStart=true]
	 *   Whether to begin each row with the delimiter.
	 *
	 *   > 👉 **Note**: please don’t use this: it could create fragile structures
	 *   > that aren’t understandable to some markdown parsers.
	 *
	 *   When `true`, there are starting delimiters:
	 *
	 *   ```markdown
	 *   | Alpha | B     |
	 *   | ----- | ----- |
	 *   | C     | Delta |
	 *   ```
	 *
	 *   When `false`, there are no starting delimiters:
	 *
	 *   ```markdown
	 *   Alpha | B     |
	 *   ----- | ----- |
	 *   C     | Delta |
	 *   ```
	 * @property {boolean} [delimiterEnd=true]
	 *   Whether to end each row with the delimiter.
	 *
	 *   > 👉 **Note**: please don’t use this: it could create fragile structures
	 *   > that aren’t understandable to some markdown parsers.
	 *
	 *   When `true`, there are ending delimiters:
	 *
	 *   ```markdown
	 *   | Alpha | B     |
	 *   | ----- | ----- |
	 *   | C     | Delta |
	 *   ```
	 *
	 *   When `false`, there are no ending delimiters:
	 *
	 *   ```markdown
	 *   | Alpha | B
	 *   | ----- | -----
	 *   | C     | Delta
	 *   ```
	 * @property {boolean} [alignDelimiters=true]
	 *   Whether to align the delimiters.
	 *   By default, they are aligned:
	 *
	 *   ```markdown
	 *   | Alpha | B     |
	 *   | ----- | ----- |
	 *   | C     | Delta |
	 *   ```
	 *
	 *   Pass `false` to make them staggered:
	 *
	 *   ```markdown
	 *   | Alpha | B |
	 *   | - | - |
	 *   | C | Delta |
	 *   ```
	 * @property {(value: string) => number} [stringLength]
	 *   Function to detect the length of table cell content.
	 *   This is used when aligning the delimiters (`|`) between table cells.
	 *   Full-width characters and emoji mess up delimiter alignment when viewing
	 *   the markdown source.
	 *   To fix this, you can pass this function, which receives the cell content
	 *   and returns its “visible” size.
	 *   Note that what is and isn’t visible depends on where the text is displayed.
	 *
	 *   Without such a function, the following:
	 *
	 *   ```js
	 *   markdownTable([
	 *     ['Alpha', 'Bravo'],
	 *     ['中文', 'Charlie'],
	 *     ['👩‍❤️‍👩', 'Delta']
	 *   ])
	 *   ```
	 *
	 *   Yields:
	 *
	 *   ```markdown
	 *   | Alpha | Bravo |
	 *   | - | - |
	 *   | 中文 | Charlie |
	 *   | 👩‍❤️‍👩 | Delta |
	 *   ```
	 *
	 *   With [`string-width`](https://github.com/sindresorhus/string-width):
	 *
	 *   ```js
	 *   import stringWidth from 'string-width'
	 *
	 *   markdownTable(
	 *     [
	 *       ['Alpha', 'Bravo'],
	 *       ['中文', 'Charlie'],
	 *       ['👩‍❤️‍👩', 'Delta']
	 *     ],
	 *     {stringLength: stringWidth}
	 *   )
	 *   ```
	 *
	 *   Yields:
	 *
	 *   ```markdown
	 *   | Alpha | Bravo   |
	 *   | ----- | ------- |
	 *   | 中文  | Charlie |
	 *   | 👩‍❤️‍👩    | Delta   |
	 *   ```
	 */

	/**
	 * @typedef {Options} MarkdownTableOptions
	 * @todo
	 *   Remove next major.
	 */

	/**
	 * Generate a markdown ([GFM](https://docs.github.com/en/github/writing-on-github/working-with-advanced-formatting/organizing-information-with-tables)) table..
	 *
	 * @param {Array<Array<string|null|undefined>>} table
	 *   Table data (matrix of strings).
	 * @param {Options} [options]
	 *   Configuration (optional).
	 * @returns {string}
	 */
	function markdownTable(table, options = {}) {
	  const align = (options.align || []).concat();
	  const stringLength = options.stringLength || defaultStringLength;
	  /** @type {Array<number>} Character codes as symbols for alignment per column. */
	  const alignments = [];
	  /** @type {Array<Array<string>>} Cells per row. */
	  const cellMatrix = [];
	  /** @type {Array<Array<number>>} Sizes of each cell per row. */
	  const sizeMatrix = [];
	  /** @type {Array<number>} */
	  const longestCellByColumn = [];
	  let mostCellsPerRow = 0;
	  let rowIndex = -1;

	  // This is a superfluous loop if we don’t align delimiters, but otherwise we’d
	  // do superfluous work when aligning, so optimize for aligning.
	  while (++rowIndex < table.length) {
	    /** @type {Array<string>} */
	    const row = [];
	    /** @type {Array<number>} */
	    const sizes = [];
	    let columnIndex = -1;

	    if (table[rowIndex].length > mostCellsPerRow) {
	      mostCellsPerRow = table[rowIndex].length;
	    }

	    while (++columnIndex < table[rowIndex].length) {
	      const cell = serialize(table[rowIndex][columnIndex]);

	      if (options.alignDelimiters !== false) {
	        const size = stringLength(cell);
	        sizes[columnIndex] = size;

	        if (
	          longestCellByColumn[columnIndex] === undefined ||
	          size > longestCellByColumn[columnIndex]
	        ) {
	          longestCellByColumn[columnIndex] = size;
	        }
	      }

	      row.push(cell);
	    }

	    cellMatrix[rowIndex] = row;
	    sizeMatrix[rowIndex] = sizes;
	  }

	  // Figure out which alignments to use.
	  let columnIndex = -1;

	  if (typeof align === 'object' && 'length' in align) {
	    while (++columnIndex < mostCellsPerRow) {
	      alignments[columnIndex] = toAlignment(align[columnIndex]);
	    }
	  } else {
	    const code = toAlignment(align);

	    while (++columnIndex < mostCellsPerRow) {
	      alignments[columnIndex] = code;
	    }
	  }

	  // Inject the alignment row.
	  columnIndex = -1;
	  /** @type {Array<string>} */
	  const row = [];
	  /** @type {Array<number>} */
	  const sizes = [];

	  while (++columnIndex < mostCellsPerRow) {
	    const code = alignments[columnIndex];
	    let before = '';
	    let after = '';

	    if (code === 99 /* `c` */) {
	      before = ':';
	      after = ':';
	    } else if (code === 108 /* `l` */) {
	      before = ':';
	    } else if (code === 114 /* `r` */) {
	      after = ':';
	    }

	    // There *must* be at least one hyphen-minus in each alignment cell.
	    let size =
	      options.alignDelimiters === false
	        ? 1
	        : Math.max(
	            1,
	            longestCellByColumn[columnIndex] - before.length - after.length
	          );

	    const cell = before + '-'.repeat(size) + after;

	    if (options.alignDelimiters !== false) {
	      size = before.length + size + after.length;

	      if (size > longestCellByColumn[columnIndex]) {
	        longestCellByColumn[columnIndex] = size;
	      }

	      sizes[columnIndex] = size;
	    }

	    row[columnIndex] = cell;
	  }

	  // Inject the alignment row.
	  cellMatrix.splice(1, 0, row);
	  sizeMatrix.splice(1, 0, sizes);

	  rowIndex = -1;
	  /** @type {Array<string>} */
	  const lines = [];

	  while (++rowIndex < cellMatrix.length) {
	    const row = cellMatrix[rowIndex];
	    const sizes = sizeMatrix[rowIndex];
	    columnIndex = -1;
	    /** @type {Array<string>} */
	    const line = [];

	    while (++columnIndex < mostCellsPerRow) {
	      const cell = row[columnIndex] || '';
	      let before = '';
	      let after = '';

	      if (options.alignDelimiters !== false) {
	        const size =
	          longestCellByColumn[columnIndex] - (sizes[columnIndex] || 0);
	        const code = alignments[columnIndex];

	        if (code === 114 /* `r` */) {
	          before = ' '.repeat(size);
	        } else if (code === 99 /* `c` */) {
	          if (size % 2) {
	            before = ' '.repeat(size / 2 + 0.5);
	            after = ' '.repeat(size / 2 - 0.5);
	          } else {
	            before = ' '.repeat(size / 2);
	            after = before;
	          }
	        } else {
	          after = ' '.repeat(size);
	        }
	      }

	      if (options.delimiterStart !== false && !columnIndex) {
	        line.push('|');
	      }

	      if (
	        options.padding !== false &&
	        // Don’t add the opening space if we’re not aligning and the cell is
	        // empty: there will be a closing space.
	        !(options.alignDelimiters === false && cell === '') &&
	        (options.delimiterStart !== false || columnIndex)
	      ) {
	        line.push(' ');
	      }

	      if (options.alignDelimiters !== false) {
	        line.push(before);
	      }

	      line.push(cell);

	      if (options.alignDelimiters !== false) {
	        line.push(after);
	      }

	      if (options.padding !== false) {
	        line.push(' ');
	      }

	      if (
	        options.delimiterEnd !== false ||
	        columnIndex !== mostCellsPerRow - 1
	      ) {
	        line.push('|');
	      }
	    }

	    lines.push(
	      options.delimiterEnd === false
	        ? line.join('').replace(/ +$/, '')
	        : line.join('')
	    );
	  }

	  return lines.join('\n')
	}

	/**
	 * @param {string|null|undefined} [value]
	 * @returns {string}
	 */
	function serialize(value) {
	  return value === null || value === undefined ? '' : String(value)
	}

	/**
	 * @param {string} value
	 * @returns {number}
	 */
	function defaultStringLength(value) {
	  return value.length
	}

	/**
	 * @param {string|null|undefined} value
	 * @returns {number}
	 */
	function toAlignment(value) {
	  const code = typeof value === 'string' ? value.codePointAt(0) : 0;

	  return code === 67 /* `C` */ || code === 99 /* `c` */
	    ? 99 /* `c` */
	    : code === 76 /* `L` */ || code === 108 /* `l` */
	    ? 108 /* `l` */
	    : code === 82 /* `R` */ || code === 114 /* `r` */
	    ? 114 /* `r` */
	    : 0
	}

	/**
	 * @typedef {import('mdast').AlignType} AlignType
	 * @typedef {import('mdast').Table} Table
	 * @typedef {import('mdast').TableRow} TableRow
	 * @typedef {import('mdast').TableCell} TableCell
	 * @typedef {import('mdast').InlineCode} InlineCode
	 * @typedef {import('markdown-table').MarkdownTableOptions} MarkdownTableOptions
	 * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
	 * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
	 * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
	 * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
	 * @typedef {import('mdast-util-to-markdown').Context} ToMarkdownContext
	 * @typedef {import('mdast-util-to-markdown').SafeOptions} SafeOptions
	 *
	 * @typedef Options
	 * @property {boolean} [tableCellPadding=true]
	 * @property {boolean} [tablePipeAlign=true]
	 * @property {MarkdownTableOptions['stringLength']} [stringLength]
	 */


	/** @type {FromMarkdownExtension} */
	const gfmTableFromMarkdown = {
	  enter: {
	    table: enterTable,
	    tableData: enterCell,
	    tableHeader: enterCell,
	    tableRow: enterRow
	  },
	  exit: {
	    codeText: exitCodeText,
	    table: exitTable,
	    tableData: exit,
	    tableHeader: exit,
	    tableRow: exit
	  }
	};

	/** @type {FromMarkdownHandle} */
	function enterTable(token) {
	  /** @type {Array<'left'|'right'|'center'|'none'>} */
	  // @ts-expect-error: `align` is custom.
	  const align = token._align;
	  this.enter(
	    {
	      type: 'table',
	      align: align.map((d) => (d === 'none' ? null : d)),
	      children: []
	    },
	    token
	  );
	  this.setData('inTable', true);
	}

	/** @type {FromMarkdownHandle} */
	function exitTable(token) {
	  this.exit(token);
	  this.setData('inTable');
	}

	/** @type {FromMarkdownHandle} */
	function enterRow(token) {
	  this.enter({type: 'tableRow', children: []}, token);
	}

	/** @type {FromMarkdownHandle} */
	function exit(token) {
	  this.exit(token);
	}

	/** @type {FromMarkdownHandle} */
	function enterCell(token) {
	  this.enter({type: 'tableCell', children: []}, token);
	}

	// Overwrite the default code text data handler to unescape escaped pipes when
	// they are in tables.
	/** @type {FromMarkdownHandle} */
	function exitCodeText(token) {
	  let value = this.resume();

	  if (this.getData('inTable')) {
	    value = value.replace(/\\([\\|])/g, replace);
	  }

	  const node = /** @type {InlineCode} */ (this.stack[this.stack.length - 1]);
	  node.value = value;
	  this.exit(token);
	}

	/**
	 * @param {string} $0
	 * @param {string} $1
	 * @returns {string}
	 */
	function replace($0, $1) {
	  // Pipes work, backslashes don’t (but can’t escape pipes).
	  return $1 === '|' ? $1 : $0
	}

	/**
	 * @param {Options} [options]
	 * @returns {ToMarkdownExtension}
	 */
	function gfmTableToMarkdown(options) {
	  const settings = options || {};
	  const padding = settings.tableCellPadding;
	  const alignDelimiters = settings.tablePipeAlign;
	  const stringLength = settings.stringLength;
	  const around = padding ? ' ' : '|';

	  return {
	    unsafe: [
	      {character: '\r', inConstruct: 'tableCell'},
	      {character: '\n', inConstruct: 'tableCell'},
	      // A pipe, when followed by a tab or space (padding), or a dash or colon
	      // (unpadded delimiter row), could result in a table.
	      {atBreak: true, character: '|', after: '[\t :-]'},
	      // A pipe in a cell must be encoded.
	      {character: '|', inConstruct: 'tableCell'},
	      // A colon must be followed by a dash, in which case it could start a
	      // delimiter row.
	      {atBreak: true, character: ':', after: '-'},
	      // A delimiter row can also start with a dash, when followed by more
	      // dashes, a colon, or a pipe.
	      // This is a stricter version than the built in check for lists, thematic
	      // breaks, and setex heading underlines though:
	      // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/51a2038/lib/unsafe.js#L57>
	      {atBreak: true, character: '-', after: '[:|-]'}
	    ],
	    handlers: {
	      table: handleTable,
	      tableRow: handleTableRow,
	      tableCell: handleTableCell,
	      inlineCode: inlineCodeWithTable
	    }
	  }

	  /**
	   * @type {ToMarkdownHandle}
	   * @param {Table} node
	   */
	  function handleTable(node, _, context, safeOptions) {
	    return serializeData(
	      handleTableAsData(node, context, safeOptions),
	      // @ts-expect-error: fixed in `markdown-table@3.0.1`.
	      node.align
	    )
	  }

	  /**
	   * This function isn’t really used normally, because we handle rows at the
	   * table level.
	   * But, if someone passes in a table row, this ensures we make somewhat sense.
	   *
	   * @type {ToMarkdownHandle}
	   * @param {TableRow} node
	   */
	  function handleTableRow(node, _, context, safeOptions) {
	    const row = handleTableRowAsData(node, context, safeOptions);
	    // `markdown-table` will always add an align row
	    const value = serializeData([row]);
	    return value.slice(0, value.indexOf('\n'))
	  }

	  /**
	   * @type {ToMarkdownHandle}
	   * @param {TableCell} node
	   */
	  function handleTableCell(node, _, context, safeOptions) {
	    const exit = context.enter('tableCell');
	    const subexit = context.enter('phrasing');
	    const value = containerPhrasing(node, context, {
	      ...safeOptions,
	      before: around,
	      after: around
	    });
	    subexit();
	    exit();
	    return value
	  }

	  /**
	   * @param {Array<Array<string>>} matrix
	   * @param {Array<string>} [align]
	   */
	  function serializeData(matrix, align) {
	    return markdownTable(matrix, {
	      align,
	      alignDelimiters,
	      padding,
	      stringLength
	    })
	  }

	  /**
	   * @param {Table} node
	   * @param {ToMarkdownContext} context
	   * @param {SafeOptions} safeOptions
	   */
	  function handleTableAsData(node, context, safeOptions) {
	    const children = node.children;
	    let index = -1;
	    /** @type {Array<Array<string>>} */
	    const result = [];
	    const subexit = context.enter('table');

	    while (++index < children.length) {
	      result[index] = handleTableRowAsData(
	        children[index],
	        context,
	        safeOptions
	      );
	    }

	    subexit();

	    return result
	  }

	  /**
	   * @param {TableRow} node
	   * @param {ToMarkdownContext} context
	   * @param {SafeOptions} safeOptions
	   */
	  function handleTableRowAsData(node, context, safeOptions) {
	    const children = node.children;
	    let index = -1;
	    /** @type {Array<string>} */
	    const result = [];
	    const subexit = context.enter('tableRow');

	    while (++index < children.length) {
	      // Note: the positional info as used here is incorrect.
	      // Making it correct would be impossible due to aligning cells?
	      // And it would need copy/pasting `markdown-table` into this project.
	      result[index] = handleTableCell(
	        children[index],
	        node,
	        context,
	        safeOptions
	      );
	    }

	    subexit();

	    return result
	  }

	  /**
	   * @type {ToMarkdownHandle}
	   * @param {InlineCode} node
	   */
	  function inlineCodeWithTable(node, parent, context) {
	    let value = inlineCode$1(node, parent, context);

	    if (context.stack.includes('tableCell')) {
	      value = value.replace(/\|/g, '\\$&');
	    }

	    return value
	  }
	}

	/**
	 * @typedef {import('../types.js').Context} Context
	 * @typedef {import('../types.js').Options} Options
	 */

	/**
	 * @param {Context} context
	 * @returns {Exclude<Options['bullet'], undefined>}
	 */
	function checkBullet(context) {
	  const marker = context.options.bullet || '*';

	  if (marker !== '*' && marker !== '+' && marker !== '-') {
	    throw new Error(
	      'Cannot serialize items with `' +
	        marker +
	        '` for `options.bullet`, expected `*`, `+`, or `-`'
	    )
	  }

	  return marker
	}

	/**
	 * @typedef {import('../types.js').Context} Context
	 * @typedef {import('../types.js').Options} Options
	 */

	/**
	 * @param {Context} context
	 * @returns {Exclude<Options['listItemIndent'], undefined>}
	 */
	function checkListItemIndent(context) {
	  const style = context.options.listItemIndent || 'tab';

	  // To do: remove in a major.
	  // @ts-expect-error: deprecated.
	  if (style === 1 || style === '1') {
	    return 'one'
	  }

	  if (style !== 'tab' && style !== 'one' && style !== 'mixed') {
	    throw new Error(
	      'Cannot serialize items with `' +
	        style +
	        '` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`'
	    )
	  }

	  return style
	}

	/**
	 * @typedef {import('mdast').ListItem} ListItem
	 * @typedef {import('mdast').List} List
	 * @typedef {import('../util/indent-lines.js').Map} Map
	 * @typedef {import('../types.js').Options} Options
	 * @typedef {import('../types.js').Handle} Handle
	 */


	/**
	 * @type {Handle}
	 * @param {ListItem} node
	 */
	function listItem$1(node, parent, context, safeOptions) {
	  const listItemIndent = checkListItemIndent(context);
	  let bullet = context.bulletCurrent || checkBullet(context);

	  // Add the marker value for ordered lists.
	  if (parent && parent.type === 'list' && parent.ordered) {
	    bullet =
	      (typeof parent.start === 'number' && parent.start > -1
	        ? parent.start
	        : 1) +
	      (context.options.incrementListMarker === false
	        ? 0
	        : parent.children.indexOf(node)) +
	      bullet;
	  }

	  let size = bullet.length + 1;

	  if (
	    listItemIndent === 'tab' ||
	    (listItemIndent === 'mixed' &&
	      ((parent && parent.type === 'list' && parent.spread) || node.spread))
	  ) {
	    size = Math.ceil(size / 4) * 4;
	  }

	  const tracker = track(safeOptions);
	  tracker.move(bullet + ' '.repeat(size - bullet.length));
	  tracker.shift(size);
	  const exit = context.enter('listItem');
	  const value = indentLines(
	    containerFlow(node, context, tracker.current()),
	    map
	  );
	  exit();

	  return value

	  /** @type {Map} */
	  function map(line, index, blank) {
	    if (index) {
	      return (blank ? '' : ' '.repeat(size)) + line
	    }

	    return (blank ? bullet : bullet + ' '.repeat(size - bullet.length)) + line
	  }
	}

	/**
	 * @typedef {Extract<import('mdast').Root|import('mdast').Content, import('unist').Parent>} Parent
	 * @typedef {import('mdast').ListItem} ListItem
	 * @typedef {import('mdast').Paragraph} Paragraph
	 * @typedef {import('mdast').BlockContent} BlockContent
	 * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
	 * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle
	 * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
	 * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle
	 */


	/** @type {FromMarkdownExtension} */
	const gfmTaskListItemFromMarkdown = {
	  exit: {
	    taskListCheckValueChecked: exitCheck,
	    taskListCheckValueUnchecked: exitCheck,
	    paragraph: exitParagraphWithTaskListItem
	  }
	};

	/** @type {ToMarkdownExtension} */
	const gfmTaskListItemToMarkdown = {
	  unsafe: [{atBreak: true, character: '-', after: '[:|-]'}],
	  handlers: {listItem: listItemWithTaskListItem}
	};

	/** @type {FromMarkdownHandle} */
	function exitCheck(token) {
	  const node = /** @type {ListItem} */ (this.stack[this.stack.length - 2]);
	  // We’re always in a paragraph, in a list item.
	  node.checked = token.type === 'taskListCheckValueChecked';
	}

	/** @type {FromMarkdownHandle} */
	function exitParagraphWithTaskListItem(token) {
	  const parent = /** @type {Parent} */ (this.stack[this.stack.length - 2]);
	  const node = /** @type {Paragraph} */ (this.stack[this.stack.length - 1]);
	  const siblings = parent.children;
	  const head = node.children[0];
	  let index = -1;
	  /** @type {Paragraph|undefined} */
	  let firstParaghraph;

	  if (
	    parent &&
	    parent.type === 'listItem' &&
	    typeof parent.checked === 'boolean' &&
	    head &&
	    head.type === 'text'
	  ) {
	    while (++index < siblings.length) {
	      const sibling = siblings[index];
	      if (sibling.type === 'paragraph') {
	        firstParaghraph = sibling;
	        break
	      }
	    }

	    if (firstParaghraph === node) {
	      // Must start with a space or a tab.
	      head.value = head.value.slice(1);

	      if (head.value.length === 0) {
	        node.children.shift();
	      } else if (
	        node.position &&
	        head.position &&
	        typeof head.position.start.offset === 'number'
	      ) {
	        head.position.start.column++;
	        head.position.start.offset++;
	        node.position.start = Object.assign({}, head.position.start);
	      }
	    }
	  }

	  this.exit(token);
	}

	/**
	 * @type {ToMarkdownHandle}
	 * @param {ListItem} node
	 */
	function listItemWithTaskListItem(node, parent, context, safeOptions) {
	  const head = node.children[0];
	  const checkable =
	    typeof node.checked === 'boolean' && head && head.type === 'paragraph';
	  const checkbox = '[' + (node.checked ? 'x' : ' ') + '] ';
	  const tracker = track(safeOptions);

	  if (checkable) {
	    tracker.move(checkbox);
	  }

	  let value = listItem$1(node, parent, context, {
	    ...safeOptions,
	    ...tracker.current()
	  });

	  if (checkable) {
	    value = value.replace(/^(?:[*+-]|\d+\.)([\r\n]| {1,3})/, check);
	  }

	  return value

	  /**
	   * @param {string} $0
	   * @returns {string}
	   */
	  function check($0) {
	    return $0 + checkbox
	  }
	}

	/**
	 * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension
	 * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension
	 *
	 * @typedef {import('mdast-util-gfm-table').Options} Options
	 */


	/**
	 * @returns {Array<FromMarkdownExtension>}
	 */
	function gfmFromMarkdown() {
	  return [
	    gfmAutolinkLiteralFromMarkdown,
	    gfmFootnoteFromMarkdown(),
	    gfmStrikethroughFromMarkdown,
	    gfmTableFromMarkdown,
	    gfmTaskListItemFromMarkdown
	  ]
	}

	/**
	 * @param {Options} [options]
	 * @returns {ToMarkdownExtension}
	 */
	function gfmToMarkdown(options) {
	  return {
	    extensions: [
	      gfmAutolinkLiteralToMarkdown,
	      gfmFootnoteToMarkdown(),
	      gfmStrikethroughToMarkdown,
	      gfmTableToMarkdown(options),
	      gfmTaskListItemToMarkdown
	    ]
	  }
	}

	/**
	 * @typedef {import('mdast').Root} Root
	 * @typedef {import('micromark-extension-gfm').Options & import('mdast-util-gfm').Options} Options
	 */


	/**
	 * Plugin to support GFM (autolink literals, footnotes, strikethrough, tables, tasklists).
	 *
	 * @type {import('unified').Plugin<[Options?]|void[], Root>}
	 */
	function remarkGfm(options = {}) {
	  const data = this.data();

	  add('micromarkExtensions', gfm(options));
	  add('fromMarkdownExtensions', gfmFromMarkdown());
	  add('toMarkdownExtensions', gfmToMarkdown(options));

	  /**
	   * @param {string} field
	   * @param {unknown} value
	   */
	  function add(field, value) {
	    const list = /** @type {unknown[]} */ (
	      // Other extensions
	      /* c8 ignore next 2 */
	      data[field] ? data[field] : (data[field] = [])
	    );

	    list.push(value);
	  }
	}

	/**
	 * @typedef Options
	 * @property {boolean} [includeImageAlt=true]
	 */

	/**
	 * Get the text content of a node.
	 * Prefer the node’s plain-text fields, otherwise serialize its children,
	 * and if the given value is an array, serialize the nodes in it.
	 *
	 * @param {unknown} node
	 * @param {Options} [options]
	 * @returns {string}
	 */
	function toString(node, options) {
	  var {includeImageAlt = true} = {};
	  return one$1(node, includeImageAlt)
	}

	/**
	 * @param {unknown} node
	 * @param {boolean} includeImageAlt
	 * @returns {string}
	 */
	function one$1(node, includeImageAlt) {
	  return (
	    (node &&
	      typeof node === 'object' &&
	      // @ts-ignore looks like a literal.
	      (node.value ||
	        // @ts-ignore looks like an image.
	        (includeImageAlt ? node.alt : '') ||
	        // @ts-ignore looks like a parent.
	        ('children' in node && all$1(node.children, includeImageAlt)) ||
	        (Array.isArray(node) && all$1(node, includeImageAlt)))) ||
	    ''
	  )
	}

	/**
	 * @param {Array.<unknown>} values
	 * @param {boolean} includeImageAlt
	 * @returns {string}
	 */
	function all$1(values, includeImageAlt) {
	  /** @type {Array.<string>} */
	  var result = [];
	  var index = -1;

	  while (++index < values.length) {
	    result[index] = one$1(values[index], includeImageAlt);
	  }

	  return result.join('')
	}

	/**
	 * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
	 * @typedef {import('micromark-util-types').Initializer} Initializer
	 * @typedef {import('micromark-util-types').Token} Token
	 * @typedef {import('micromark-util-types').State} State
	 */

	/** @type {InitialConstruct} */
	const content = {
	  tokenize: initializeContent
	};
	/** @type {Initializer} */

	function initializeContent(effects) {
	  const contentStart = effects.attempt(
	    this.parser.constructs.contentInitial,
	    afterContentStartConstruct,
	    paragraphInitial
	  );
	  /** @type {Token} */

	  let previous;
	  return contentStart
	  /** @type {State} */

	  function afterContentStartConstruct(code) {
	    if (code === null) {
	      effects.consume(code);
	      return
	    }

	    effects.enter('lineEnding');
	    effects.consume(code);
	    effects.exit('lineEnding');
	    return factorySpace(effects, contentStart, 'linePrefix')
	  }
	  /** @type {State} */

	  function paragraphInitial(code) {
	    effects.enter('paragraph');
	    return lineStart(code)
	  }
	  /** @type {State} */

	  function lineStart(code) {
	    const token = effects.enter('chunkText', {
	      contentType: 'text',
	      previous
	    });

	    if (previous) {
	      previous.next = token;
	    }

	    previous = token;
	    return data(code)
	  }
	  /** @type {State} */

	  function data(code) {
	    if (code === null) {
	      effects.exit('chunkText');
	      effects.exit('paragraph');
	      effects.consume(code);
	      return
	    }

	    if (markdownLineEnding(code)) {
	      effects.consume(code);
	      effects.exit('chunkText');
	      return lineStart
	    } // Data.

	    effects.consume(code);
	    return data
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
	 * @typedef {import('micromark-util-types').Initializer} Initializer
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
	 * @typedef {import('micromark-util-types').Tokenizer} Tokenizer
	 * @typedef {import('micromark-util-types').Token} Token
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Point} Point
	 */

	/** @type {InitialConstruct} */

	const document$2 = {
	  tokenize: initializeDocument
	};
	/** @type {Construct} */

	const containerConstruct = {
	  tokenize: tokenizeContainer
	};
	/** @type {Initializer} */

	function initializeDocument(effects) {
	  const self = this;
	  /** @type {StackItem[]} */

	  const stack = [];
	  let continued = 0;
	  /** @type {TokenizeContext|undefined} */

	  let childFlow;
	  /** @type {Token|undefined} */

	  let childToken;
	  /** @type {number} */

	  let lineStartOffset;
	  return start
	  /** @type {State} */

	  function start(code) {
	    // First we iterate through the open blocks, starting with the root
	    // document, and descending through last children down to the last open
	    // block.
	    // Each block imposes a condition that the line must satisfy if the block is
	    // to remain open.
	    // For example, a block quote requires a `>` character.
	    // A paragraph requires a non-blank line.
	    // In this phase we may match all or just some of the open blocks.
	    // But we cannot close unmatched blocks yet, because we may have a lazy
	    // continuation line.
	    if (continued < stack.length) {
	      const item = stack[continued];
	      self.containerState = item[1];
	      return effects.attempt(
	        item[0].continuation,
	        documentContinue,
	        checkNewContainers
	      )(code)
	    } // Done.

	    return checkNewContainers(code)
	  }
	  /** @type {State} */

	  function documentContinue(code) {
	    continued++; // Note: this field is called `_closeFlow` but it also closes containers.
	    // Perhaps a good idea to rename it but it’s already used in the wild by
	    // extensions.

	    if (self.containerState._closeFlow) {
	      self.containerState._closeFlow = undefined;

	      if (childFlow) {
	        closeFlow();
	      } // Note: this algorithm for moving events around is similar to the
	      // algorithm when dealing with lazy lines in `writeToChild`.

	      const indexBeforeExits = self.events.length;
	      let indexBeforeFlow = indexBeforeExits;
	      /** @type {Point|undefined} */

	      let point; // Find the flow chunk.

	      while (indexBeforeFlow--) {
	        if (
	          self.events[indexBeforeFlow][0] === 'exit' &&
	          self.events[indexBeforeFlow][1].type === 'chunkFlow'
	        ) {
	          point = self.events[indexBeforeFlow][1].end;
	          break
	        }
	      }

	      exitContainers(continued); // Fix positions.

	      let index = indexBeforeExits;

	      while (index < self.events.length) {
	        self.events[index][1].end = Object.assign({}, point);
	        index++;
	      } // Inject the exits earlier (they’re still also at the end).

	      splice(
	        self.events,
	        indexBeforeFlow + 1,
	        0,
	        self.events.slice(indexBeforeExits)
	      ); // Discard the duplicate exits.

	      self.events.length = index;
	      return checkNewContainers(code)
	    }

	    return start(code)
	  }
	  /** @type {State} */

	  function checkNewContainers(code) {
	    // Next, after consuming the continuation markers for existing blocks, we
	    // look for new block starts (e.g. `>` for a block quote).
	    // If we encounter a new block start, we close any blocks unmatched in
	    // step 1 before creating the new block as a child of the last matched
	    // block.
	    if (continued === stack.length) {
	      // No need to `check` whether there’s a container, of `exitContainers`
	      // would be moot.
	      // We can instead immediately `attempt` to parse one.
	      if (!childFlow) {
	        return documentContinued(code)
	      } // If we have concrete content, such as block HTML or fenced code,
	      // we can’t have containers “pierce” into them, so we can immediately
	      // start.

	      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {
	        return flowStart(code)
	      } // If we do have flow, it could still be a blank line,
	      // but we’d be interrupting it w/ a new container if there’s a current
	      // construct.

	      self.interrupt = Boolean(
	        childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack
	      );
	    } // Check if there is a new container.

	    self.containerState = {};
	    return effects.check(
	      containerConstruct,
	      thereIsANewContainer,
	      thereIsNoNewContainer
	    )(code)
	  }
	  /** @type {State} */

	  function thereIsANewContainer(code) {
	    if (childFlow) closeFlow();
	    exitContainers(continued);
	    return documentContinued(code)
	  }
	  /** @type {State} */

	  function thereIsNoNewContainer(code) {
	    self.parser.lazy[self.now().line] = continued !== stack.length;
	    lineStartOffset = self.now().offset;
	    return flowStart(code)
	  }
	  /** @type {State} */

	  function documentContinued(code) {
	    // Try new containers.
	    self.containerState = {};
	    return effects.attempt(
	      containerConstruct,
	      containerContinue,
	      flowStart
	    )(code)
	  }
	  /** @type {State} */

	  function containerContinue(code) {
	    continued++;
	    stack.push([self.currentConstruct, self.containerState]); // Try another.

	    return documentContinued(code)
	  }
	  /** @type {State} */

	  function flowStart(code) {
	    if (code === null) {
	      if (childFlow) closeFlow();
	      exitContainers(0);
	      effects.consume(code);
	      return
	    }

	    childFlow = childFlow || self.parser.flow(self.now());
	    effects.enter('chunkFlow', {
	      contentType: 'flow',
	      previous: childToken,
	      _tokenizer: childFlow
	    });
	    return flowContinue(code)
	  }
	  /** @type {State} */

	  function flowContinue(code) {
	    if (code === null) {
	      writeToChild(effects.exit('chunkFlow'), true);
	      exitContainers(0);
	      effects.consume(code);
	      return
	    }

	    if (markdownLineEnding(code)) {
	      effects.consume(code);
	      writeToChild(effects.exit('chunkFlow')); // Get ready for the next line.

	      continued = 0;
	      self.interrupt = undefined;
	      return start
	    }

	    effects.consume(code);
	    return flowContinue
	  }
	  /**
	   * @param {Token} token
	   * @param {boolean} [eof]
	   * @returns {void}
	   */

	  function writeToChild(token, eof) {
	    const stream = self.sliceStream(token);
	    if (eof) stream.push(null);
	    token.previous = childToken;
	    if (childToken) childToken.next = token;
	    childToken = token;
	    childFlow.defineSkip(token.start);
	    childFlow.write(stream); // Alright, so we just added a lazy line:
	    //
	    // ```markdown
	    // > a
	    // b.
	    //
	    // Or:
	    //
	    // > ~~~c
	    // d
	    //
	    // Or:
	    //
	    // > | e |
	    // f
	    // ```
	    //
	    // The construct in the second example (fenced code) does not accept lazy
	    // lines, so it marked itself as done at the end of its first line, and
	    // then the content construct parses `d`.
	    // Most constructs in markdown match on the first line: if the first line
	    // forms a construct, a non-lazy line can’t “unmake” it.
	    //
	    // The construct in the third example is potentially a GFM table, and
	    // those are *weird*.
	    // It *could* be a table, from the first line, if the following line
	    // matches a condition.
	    // In this case, that second line is lazy, which “unmakes” the first line
	    // and turns the whole into one content block.
	    //
	    // We’ve now parsed the non-lazy and the lazy line, and can figure out
	    // whether the lazy line started a new flow block.
	    // If it did, we exit the current containers between the two flow blocks.

	    if (self.parser.lazy[token.start.line]) {
	      let index = childFlow.events.length;

	      while (index--) {
	        if (
	          // The token starts before the line ending…
	          childFlow.events[index][1].start.offset < lineStartOffset && // …and either is not ended yet…
	          (!childFlow.events[index][1].end || // …or ends after it.
	            childFlow.events[index][1].end.offset > lineStartOffset)
	        ) {
	          // Exit: there’s still something open, which means it’s a lazy line
	          // part of something.
	          return
	        }
	      } // Note: this algorithm for moving events around is similar to the
	      // algorithm when closing flow in `documentContinue`.

	      const indexBeforeExits = self.events.length;
	      let indexBeforeFlow = indexBeforeExits;
	      /** @type {boolean|undefined} */

	      let seen;
	      /** @type {Point|undefined} */

	      let point; // Find the previous chunk (the one before the lazy line).

	      while (indexBeforeFlow--) {
	        if (
	          self.events[indexBeforeFlow][0] === 'exit' &&
	          self.events[indexBeforeFlow][1].type === 'chunkFlow'
	        ) {
	          if (seen) {
	            point = self.events[indexBeforeFlow][1].end;
	            break
	          }

	          seen = true;
	        }
	      }

	      exitContainers(continued); // Fix positions.

	      index = indexBeforeExits;

	      while (index < self.events.length) {
	        self.events[index][1].end = Object.assign({}, point);
	        index++;
	      } // Inject the exits earlier (they’re still also at the end).

	      splice(
	        self.events,
	        indexBeforeFlow + 1,
	        0,
	        self.events.slice(indexBeforeExits)
	      ); // Discard the duplicate exits.

	      self.events.length = index;
	    }
	  }
	  /**
	   * @param {number} size
	   * @returns {void}
	   */

	  function exitContainers(size) {
	    let index = stack.length; // Exit open containers.

	    while (index-- > size) {
	      const entry = stack[index];
	      self.containerState = entry[1];
	      entry[0].exit.call(self, effects);
	    }

	    stack.length = size;
	  }

	  function closeFlow() {
	    childFlow.write([null]);
	    childToken = undefined;
	    childFlow = undefined;
	    self.containerState._closeFlow = undefined;
	  }
	}
	/** @type {Tokenizer} */

	function tokenizeContainer(effects, ok, nok) {
	  return factorySpace(
	    effects,
	    effects.attempt(this.parser.constructs.document, ok, nok),
	    'linePrefix',
	    this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4
	  )
	}

	/**
	 * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
	 * @typedef {import('micromark-util-types').Initializer} Initializer
	 * @typedef {import('micromark-util-types').State} State
	 */


	/** @type {InitialConstruct} */
	const flow$1 = {
	  tokenize: initializeFlow
	};
	/** @type {Initializer} */

	function initializeFlow(effects) {
	  const self = this;
	  const initial = effects.attempt(
	    // Try to parse a blank line.
	    blankLine,
	    atBlankEnding, // Try to parse initial flow (essentially, only code).
	    effects.attempt(
	      this.parser.constructs.flowInitial,
	      afterConstruct,
	      factorySpace(
	        effects,
	        effects.attempt(
	          this.parser.constructs.flow,
	          afterConstruct,
	          effects.attempt(content$1, afterConstruct)
	        ),
	        'linePrefix'
	      )
	    )
	  );
	  return initial
	  /** @type {State} */

	  function atBlankEnding(code) {
	    if (code === null) {
	      effects.consume(code);
	      return
	    }

	    effects.enter('lineEndingBlank');
	    effects.consume(code);
	    effects.exit('lineEndingBlank');
	    self.currentConstruct = undefined;
	    return initial
	  }
	  /** @type {State} */

	  function afterConstruct(code) {
	    if (code === null) {
	      effects.consume(code);
	      return
	    }

	    effects.enter('lineEnding');
	    effects.consume(code);
	    effects.exit('lineEnding');
	    self.currentConstruct = undefined;
	    return initial
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Resolver} Resolver
	 * @typedef {import('micromark-util-types').Initializer} Initializer
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Code} Code
	 */
	const resolver = {
	  resolveAll: createResolver()
	};
	const string$1 = initializeFactory('string');
	const text$2 = initializeFactory('text');
	/**
	 * @param {'string'|'text'} field
	 * @returns {InitialConstruct}
	 */

	function initializeFactory(field) {
	  return {
	    tokenize: initializeText,
	    resolveAll: createResolver(
	      field === 'text' ? resolveAllLineSuffixes : undefined
	    )
	  }
	  /** @type {Initializer} */

	  function initializeText(effects) {
	    const self = this;
	    const constructs = this.parser.constructs[field];
	    const text = effects.attempt(constructs, start, notText);
	    return start
	    /** @type {State} */

	    function start(code) {
	      return atBreak(code) ? text(code) : notText(code)
	    }
	    /** @type {State} */

	    function notText(code) {
	      if (code === null) {
	        effects.consume(code);
	        return
	      }

	      effects.enter('data');
	      effects.consume(code);
	      return data
	    }
	    /** @type {State} */

	    function data(code) {
	      if (atBreak(code)) {
	        effects.exit('data');
	        return text(code)
	      } // Data.

	      effects.consume(code);
	      return data
	    }
	    /**
	     * @param {Code} code
	     * @returns {boolean}
	     */

	    function atBreak(code) {
	      if (code === null) {
	        return true
	      }

	      const list = constructs[code];
	      let index = -1;

	      if (list) {
	        while (++index < list.length) {
	          const item = list[index];

	          if (!item.previous || item.previous.call(self, self.previous)) {
	            return true
	          }
	        }
	      }

	      return false
	    }
	  }
	}
	/**
	 * @param {Resolver} [extraResolver]
	 * @returns {Resolver}
	 */

	function createResolver(extraResolver) {
	  return resolveAllText
	  /** @type {Resolver} */

	  function resolveAllText(events, context) {
	    let index = -1;
	    /** @type {number|undefined} */

	    let enter; // A rather boring computation (to merge adjacent `data` events) which
	    // improves mm performance by 29%.

	    while (++index <= events.length) {
	      if (enter === undefined) {
	        if (events[index] && events[index][1].type === 'data') {
	          enter = index;
	          index++;
	        }
	      } else if (!events[index] || events[index][1].type !== 'data') {
	        // Don’t do anything if there is one data token.
	        if (index !== enter + 2) {
	          events[enter][1].end = events[index - 1][1].end;
	          events.splice(enter + 2, index - enter - 2);
	          index = enter + 2;
	        }

	        enter = undefined;
	      }
	    }

	    return extraResolver ? extraResolver(events, context) : events
	  }
	}
	/**
	 * A rather ugly set of instructions which again looks at chunks in the input
	 * stream.
	 * The reason to do this here is that it is *much* faster to parse in reverse.
	 * And that we can’t hook into `null` to split the line suffix before an EOF.
	 * To do: figure out if we can make this into a clean utility, or even in core.
	 * As it will be useful for GFMs literal autolink extension (and maybe even
	 * tables?)
	 *
	 * @type {Resolver}
	 */

	function resolveAllLineSuffixes(events, context) {
	  let eventIndex = 0; // Skip first.

	  while (++eventIndex <= events.length) {
	    if (
	      (eventIndex === events.length ||
	        events[eventIndex][1].type === 'lineEnding') &&
	      events[eventIndex - 1][1].type === 'data'
	    ) {
	      const data = events[eventIndex - 1][1];
	      const chunks = context.sliceStream(data);
	      let index = chunks.length;
	      let bufferIndex = -1;
	      let size = 0;
	      /** @type {boolean|undefined} */

	      let tabs;

	      while (index--) {
	        const chunk = chunks[index];

	        if (typeof chunk === 'string') {
	          bufferIndex = chunk.length;

	          while (chunk.charCodeAt(bufferIndex - 1) === 32) {
	            size++;
	            bufferIndex--;
	          }

	          if (bufferIndex) break
	          bufferIndex = -1;
	        } // Number
	        else if (chunk === -2) {
	          tabs = true;
	          size++;
	        } else if (chunk === -1) ; else {
	          // Replacement character, exit.
	          index++;
	          break
	        }
	      }

	      if (size) {
	        const token = {
	          type:
	            eventIndex === events.length || tabs || size < 2
	              ? 'lineSuffix'
	              : 'hardBreakTrailing',
	          start: {
	            line: data.end.line,
	            column: data.end.column - size,
	            offset: data.end.offset - size,
	            _index: data.start._index + index,
	            _bufferIndex: index
	              ? bufferIndex
	              : data.start._bufferIndex + bufferIndex
	          },
	          end: Object.assign({}, data.end)
	        };
	        data.end = Object.assign({}, token.start);

	        if (data.start.offset === data.end.offset) {
	          Object.assign(data, token);
	        } else {
	          events.splice(
	            eventIndex,
	            0,
	            ['enter', token, context],
	            ['exit', token, context]
	          );
	          eventIndex += 2;
	        }
	      }

	      eventIndex++;
	    }
	  }

	  return events
	}

	/**
	 * @typedef {import('micromark-util-types').Code} Code
	 * @typedef {import('micromark-util-types').Chunk} Chunk
	 * @typedef {import('micromark-util-types').Point} Point
	 * @typedef {import('micromark-util-types').Token} Token
	 * @typedef {import('micromark-util-types').Effects} Effects
	 * @typedef {import('micromark-util-types').State} State
	 * @typedef {import('micromark-util-types').Construct} Construct
	 * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
	 * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord
	 * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
	 * @typedef {import('micromark-util-types').ParseContext} ParseContext
	 */


	/**
	 * Create a tokenizer.
	 * Tokenizers deal with one type of data (e.g., containers, flow, text).
	 * The parser is the object dealing with it all.
	 * `initialize` works like other constructs, except that only its `tokenize`
	 * function is used, in which case it doesn’t receive an `ok` or `nok`.
	 * `from` can be given to set the point before the first character, although
	 * when further lines are indented, they must be set with `defineSkip`.
	 *
	 * @param {ParseContext} parser
	 * @param {InitialConstruct} initialize
	 * @param {Omit<Point, '_index'|'_bufferIndex'>} [from]
	 * @returns {TokenizeContext}
	 */
	function createTokenizer(parser, initialize, from) {
	  /** @type {Point} */
	  let point = Object.assign(
	    from
	      ? Object.assign({}, from)
	      : {
	          line: 1,
	          column: 1,
	          offset: 0
	        },
	    {
	      _index: 0,
	      _bufferIndex: -1
	    }
	  );
	  /** @type {Record<string, number>} */

	  const columnStart = {};
	  /** @type {Construct[]} */

	  const resolveAllConstructs = [];
	  /** @type {Chunk[]} */

	  let chunks = [];
	  /** @type {Token[]} */

	  let stack = [];
	  /**
	   * Tools used for tokenizing.
	   *
	   * @type {Effects}
	   */

	  const effects = {
	    consume,
	    enter,
	    exit,
	    attempt: constructFactory(onsuccessfulconstruct),
	    check: constructFactory(onsuccessfulcheck),
	    interrupt: constructFactory(onsuccessfulcheck, {
	      interrupt: true
	    })
	  };
	  /**
	   * State and tools for resolving and serializing.
	   *
	   * @type {TokenizeContext}
	   */

	  const context = {
	    previous: null,
	    code: null,
	    containerState: {},
	    events: [],
	    parser,
	    sliceStream,
	    sliceSerialize,
	    now,
	    defineSkip,
	    write
	  };
	  /**
	   * The state function.
	   *
	   * @type {State|void}
	   */

	  let state = initialize.tokenize.call(context, effects);

	  if (initialize.resolveAll) {
	    resolveAllConstructs.push(initialize);
	  }

	  return context
	  /** @type {TokenizeContext['write']} */

	  function write(slice) {
	    chunks = push(chunks, slice);
	    main(); // Exit if we’re not done, resolve might change stuff.

	    if (chunks[chunks.length - 1] !== null) {
	      return []
	    }

	    addResult(initialize, 0); // Otherwise, resolve, and exit.

	    context.events = resolveAll(resolveAllConstructs, context.events, context);
	    return context.events
	  } //
	  // Tools.
	  //

	  /** @type {TokenizeContext['sliceSerialize']} */

	  function sliceSerialize(token, expandTabs) {
	    return serializeChunks(sliceStream(token), expandTabs)
	  }
	  /** @type {TokenizeContext['sliceStream']} */

	  function sliceStream(token) {
	    return sliceChunks(chunks, token)
	  }
	  /** @type {TokenizeContext['now']} */

	  function now() {
	    return Object.assign({}, point)
	  }
	  /** @type {TokenizeContext['defineSkip']} */

	  function defineSkip(value) {
	    columnStart[value.line] = value.column;
	    accountForPotentialSkip();
	  } //
	  // State management.
	  //

	  /**
	   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by
	   * `consume`).
	   * Here is where we walk through the chunks, which either include strings of
	   * several characters, or numerical character codes.
	   * The reason to do this in a loop instead of a call is so the stack can
	   * drain.
	   *
	   * @returns {void}
	   */

	  function main() {
	    /** @type {number} */
	    let chunkIndex;

	    while (point._index < chunks.length) {
	      const chunk = chunks[point._index]; // If we’re in a buffer chunk, loop through it.

	      if (typeof chunk === 'string') {
	        chunkIndex = point._index;

	        if (point._bufferIndex < 0) {
	          point._bufferIndex = 0;
	        }

	        while (
	          point._index === chunkIndex &&
	          point._bufferIndex < chunk.length
	        ) {
	          go(chunk.charCodeAt(point._bufferIndex));
	        }
	      } else {
	        go(chunk);
	      }
	    }
	  }
	  /**
	   * Deal with one code.
	   *
	   * @param {Code} code
	   * @returns {void}
	   */

	  function go(code) {
	    state = state(code);
	  }
	  /** @type {Effects['consume']} */

	  function consume(code) {
	    if (markdownLineEnding(code)) {
	      point.line++;
	      point.column = 1;
	      point.offset += code === -3 ? 2 : 1;
	      accountForPotentialSkip();
	    } else if (code !== -1) {
	      point.column++;
	      point.offset++;
	    } // Not in a string chunk.

	    if (point._bufferIndex < 0) {
	      point._index++;
	    } else {
	      point._bufferIndex++; // At end of string chunk.
	      // @ts-expect-error Points w/ non-negative `_bufferIndex` reference
	      // strings.

	      if (point._bufferIndex === chunks[point._index].length) {
	        point._bufferIndex = -1;
	        point._index++;
	      }
	    } // Expose the previous character.

	    context.previous = code; // Mark as consumed.
	  }
	  /** @type {Effects['enter']} */

	  function enter(type, fields) {
	    /** @type {Token} */
	    // @ts-expect-error Patch instead of assign required fields to help GC.
	    const token = fields || {};
	    token.type = type;
	    token.start = now();
	    context.events.push(['enter', token, context]);
	    stack.push(token);
	    return token
	  }
	  /** @type {Effects['exit']} */

	  function exit(type) {
	    const token = stack.pop();
	    token.end = now();
	    context.events.push(['exit', token, context]);
	    return token
	  }
	  /**
	   * Use results.
	   *
	   * @type {ReturnHandle}
	   */

	  function onsuccessfulconstruct(construct, info) {
	    addResult(construct, info.from);
	  }
	  /**
	   * Discard results.
	   *
	   * @type {ReturnHandle}
	   */

	  function onsuccessfulcheck(_, info) {
	    info.restore();
	  }
	  /**
	   * Factory to attempt/check/interrupt.
	   *
	   * @param {ReturnHandle} onreturn
	   * @param {Record<string, unknown>} [fields]
	   */

	  function constructFactory(onreturn, fields) {
	    return hook
	    /**
	     * Handle either an object mapping codes to constructs, a list of
	     * constructs, or a single construct.
	     *
	     * @param {Construct|Construct[]|ConstructRecord} constructs
	     * @param {State} returnState
	     * @param {State} [bogusState]
	     * @returns {State}
	     */

	    function hook(constructs, returnState, bogusState) {
	      /** @type {Construct[]} */
	      let listOfConstructs;
	      /** @type {number} */

	      let constructIndex;
	      /** @type {Construct} */

	      let currentConstruct;
	      /** @type {Info} */

	      let info;
	      return Array.isArray(constructs)
	        ? /* c8 ignore next 1 */
	          handleListOfConstructs(constructs)
	        : 'tokenize' in constructs // @ts-expect-error Looks like a construct.
	        ? handleListOfConstructs([constructs])
	        : handleMapOfConstructs(constructs)
	      /**
	       * Handle a list of construct.
	       *
	       * @param {ConstructRecord} map
	       * @returns {State}
	       */

	      function handleMapOfConstructs(map) {
	        return start
	        /** @type {State} */

	        function start(code) {
	          const def = code !== null && map[code];
	          const all = code !== null && map.null;
	          const list = [
	            // To do: add more extension tests.

	            /* c8 ignore next 2 */
	            ...(Array.isArray(def) ? def : def ? [def] : []),
	            ...(Array.isArray(all) ? all : all ? [all] : [])
	          ];
	          return handleListOfConstructs(list)(code)
	        }
	      }
	      /**
	       * Handle a list of construct.
	       *
	       * @param {Construct[]} list
	       * @returns {State}
	       */

	      function handleListOfConstructs(list) {
	        listOfConstructs = list;
	        constructIndex = 0;

	        if (list.length === 0) {
	          return bogusState
	        }

	        return handleConstruct(list[constructIndex])
	      }
	      /**
	       * Handle a single construct.
	       *
	       * @param {Construct} construct
	       * @returns {State}
	       */

	      function handleConstruct(construct) {
	        return start
	        /** @type {State} */

	        function start(code) {
	          // To do: not needed to store if there is no bogus state, probably?
	          // Currently doesn’t work because `inspect` in document does a check
	          // w/o a bogus, which doesn’t make sense. But it does seem to help perf
	          // by not storing.
	          info = store();
	          currentConstruct = construct;

	          if (!construct.partial) {
	            context.currentConstruct = construct;
	          }

	          if (
	            construct.name &&
	            context.parser.constructs.disable.null.includes(construct.name)
	          ) {
	            return nok()
	          }

	          return construct.tokenize.call(
	            // If we do have fields, create an object w/ `context` as its
	            // prototype.
	            // This allows a “live binding”, which is needed for `interrupt`.
	            fields ? Object.assign(Object.create(context), fields) : context,
	            effects,
	            ok,
	            nok
	          )(code)
	        }
	      }
	      /** @type {State} */

	      function ok(code) {
	        onreturn(currentConstruct, info);
	        return returnState
	      }
	      /** @type {State} */

	      function nok(code) {
	        info.restore();

	        if (++constructIndex < listOfConstructs.length) {
	          return handleConstruct(listOfConstructs[constructIndex])
	        }

	        return bogusState
	      }
	    }
	  }
	  /**
	   * @param {Construct} construct
	   * @param {number} from
	   * @returns {void}
	   */

	  function addResult(construct, from) {
	    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {
	      resolveAllConstructs.push(construct);
	    }

	    if (construct.resolve) {
	      splice(
	        context.events,
	        from,
	        context.events.length - from,
	        construct.resolve(context.events.slice(from), context)
	      );
	    }

	    if (construct.resolveTo) {
	      context.events = construct.resolveTo(context.events, context);
	    }
	  }
	  /**
	   * Store state.
	   *
	   * @returns {Info}
	   */

	  function store() {
	    const startPoint = now();
	    const startPrevious = context.previous;
	    const startCurrentConstruct = context.currentConstruct;
	    const startEventsIndex = context.events.length;
	    const startStack = Array.from(stack);
	    return {
	      restore,
	      from: startEventsIndex
	    }
	    /**
	     * Restore state.
	     *
	     * @returns {void}
	     */

	    function restore() {
	      point = startPoint;
	      context.previous = startPrevious;
	      context.currentConstruct = startCurrentConstruct;
	      context.events.length = startEventsIndex;
	      stack = startStack;
	      accountForPotentialSkip();
	    }
	  }
	  /**
	   * Move the current point a bit forward in the line when it’s on a column
	   * skip.
	   *
	   * @returns {void}
	   */

	  function accountForPotentialSkip() {
	    if (point.line in columnStart && point.column < 2) {
	      point.column = columnStart[point.line];
	      point.offset += columnStart[point.line] - 1;
	    }
	  }
	}
	/**
	 * Get the chunks from a slice of chunks in the range of a token.
	 *
	 * @param {Chunk[]} chunks
	 * @param {Pick<Token, 'start'|'end'>} token
	 * @returns {Chunk[]}
	 */

	function sliceChunks(chunks, token) {
	  const startIndex = token.start._index;
	  const startBufferIndex = token.start._bufferIndex;
	  const endIndex = token.end._index;
	  const endBufferIndex = token.end._bufferIndex;
	  /** @type {Chunk[]} */

	  let view;

	  if (startIndex === endIndex) {
	    // @ts-expect-error `_bufferIndex` is used on string chunks.
	    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];
	  } else {
	    view = chunks.slice(startIndex, endIndex);

	    if (startBufferIndex > -1) {
	      // @ts-expect-error `_bufferIndex` is used on string chunks.
	      view[0] = view[0].slice(startBufferIndex);
	    }

	    if (endBufferIndex > 0) {
	      // @ts-expect-error `_bufferIndex` is used on string chunks.
	      view.push(chunks[endIndex].slice(0, endBufferIndex));
	    }
	  }

	  return view
	}
	/**
	 * Get the string value of a slice of chunks.
	 *
	 * @param {Chunk[]} chunks
	 * @param {boolean} [expandTabs=false]
	 * @returns {string}
	 */

	function serializeChunks(chunks, expandTabs) {
	  let index = -1;
	  /** @type {string[]} */

	  const result = [];
	  /** @type {boolean|undefined} */

	  let atTab;

	  while (++index < chunks.length) {
	    const chunk = chunks[index];
	    /** @type {string} */

	    let value;

	    if (typeof chunk === 'string') {
	      value = chunk;
	    } else
	      switch (chunk) {
	        case -5: {
	          value = '\r';
	          break
	        }

	        case -4: {
	          value = '\n';
	          break
	        }

	        case -3: {
	          value = '\r' + '\n';
	          break
	        }

	        case -2: {
	          value = expandTabs ? ' ' : '\t';
	          break
	        }

	        case -1: {
	          if (!expandTabs && atTab) continue
	          value = ' ';
	          break
	        }

	        default: {
	          // Currently only replacement character.
	          value = String.fromCharCode(chunk);
	        }
	      }

	    atTab = chunk === -2;
	    result.push(value);
	  }

	  return result.join('')
	}

	/**
	 * @typedef {import('micromark-util-types').Extension} Extension
	 */
	/** @type {Extension['document']} */

	const document$1 = {
	  [42]: list$1,
	  [43]: list$1,
	  [45]: list$1,
	  [48]: list$1,
	  [49]: list$1,
	  [50]: list$1,
	  [51]: list$1,
	  [52]: list$1,
	  [53]: list$1,
	  [54]: list$1,
	  [55]: list$1,
	  [56]: list$1,
	  [57]: list$1,
	  [62]: blockQuote
	};
	/** @type {Extension['contentInitial']} */

	const contentInitial = {
	  [91]: definition
	};
	/** @type {Extension['flowInitial']} */

	const flowInitial = {
	  [-2]: codeIndented,
	  [-1]: codeIndented,
	  [32]: codeIndented
	};
	/** @type {Extension['flow']} */

	const flow = {
	  [35]: headingAtx,
	  [42]: thematicBreak$1,
	  [45]: [setextUnderline, thematicBreak$1],
	  [60]: htmlFlow,
	  [61]: setextUnderline,
	  [95]: thematicBreak$1,
	  [96]: codeFenced,
	  [126]: codeFenced
	};
	/** @type {Extension['string']} */

	const string = {
	  [38]: characterReference,
	  [92]: characterEscape
	};
	/** @type {Extension['text']} */

	const text$1 = {
	  [-5]: lineEnding,
	  [-4]: lineEnding,
	  [-3]: lineEnding,
	  [33]: labelStartImage,
	  [38]: characterReference,
	  [42]: attention,
	  [60]: [autolink, htmlText],
	  [91]: labelStartLink,
	  [92]: [hardBreakEscape, characterEscape],
	  [93]: labelEnd,
	  [95]: attention,
	  [96]: codeText
	};
	/** @type {Extension['insideSpan']} */

	const insideSpan = {
	  null: [attention, resolver]
	};
	/** @type {Extension['attentionMarkers']} */

	const attentionMarkers = {
	  null: [42, 95]
	};
	/** @type {Extension['disable']} */

	const disable = {
	  null: []
	};

	var defaultConstructs = /*#__PURE__*/Object.freeze({
		__proto__: null,
		attentionMarkers: attentionMarkers,
		contentInitial: contentInitial,
		disable: disable,
		document: document$1,
		flow: flow,
		flowInitial: flowInitial,
		insideSpan: insideSpan,
		string: string,
		text: text$1
	});

	/**
	 * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct
	 * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension
	 * @typedef {import('micromark-util-types').ParseOptions} ParseOptions
	 * @typedef {import('micromark-util-types').ParseContext} ParseContext
	 * @typedef {import('micromark-util-types').Create} Create
	 */
	/**
	 * @param {ParseOptions} [options]
	 * @returns {ParseContext}
	 */

	function parse(options = {}) {
	  /** @type {FullNormalizedExtension} */
	  // @ts-expect-error `defaultConstructs` is full, so the result will be too.
	  const constructs = combineExtensions(
	    // @ts-expect-error Same as above.
	    [defaultConstructs].concat(options.extensions || [])
	  );
	  /** @type {ParseContext} */

	  const parser = {
	    defined: [],
	    lazy: {},
	    constructs,
	    content: create(content),
	    document: create(document$2),
	    flow: create(flow$1),
	    string: create(string$1),
	    text: create(text$2)
	  };
	  return parser
	  /**
	   * @param {InitialConstruct} initial
	   */

	  function create(initial) {
	    return creator
	    /** @type {Create} */

	    function creator(from) {
	      return createTokenizer(parser, initial, from)
	    }
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Encoding} Encoding
	 * @typedef {import('micromark-util-types').Value} Value
	 * @typedef {import('micromark-util-types').Chunk} Chunk
	 * @typedef {import('micromark-util-types').Code} Code
	 */

	/**
	 * @callback Preprocessor
	 * @param {Value} value
	 * @param {Encoding} [encoding]
	 * @param {boolean} [end=false]
	 * @returns {Chunk[]}
	 */
	const search = /[\0\t\n\r]/g;
	/**
	 * @returns {Preprocessor}
	 */

	function preprocess() {
	  let column = 1;
	  let buffer = '';
	  /** @type {boolean|undefined} */

	  let start = true;
	  /** @type {boolean|undefined} */

	  let atCarriageReturn;
	  return preprocessor
	  /** @type {Preprocessor} */

	  function preprocessor(value, encoding, end) {
	    /** @type {Chunk[]} */
	    const chunks = [];
	    /** @type {RegExpMatchArray|null} */

	    let match;
	    /** @type {number} */

	    let next;
	    /** @type {number} */

	    let startPosition;
	    /** @type {number} */

	    let endPosition;
	    /** @type {Code} */

	    let code; // @ts-expect-error `Buffer` does allow an encoding.

	    value = buffer + value.toString(encoding);
	    startPosition = 0;
	    buffer = '';

	    if (start) {
	      if (value.charCodeAt(0) === 65279) {
	        startPosition++;
	      }

	      start = undefined;
	    }

	    while (startPosition < value.length) {
	      search.lastIndex = startPosition;
	      match = search.exec(value);
	      endPosition =
	        match && match.index !== undefined ? match.index : value.length;
	      code = value.charCodeAt(endPosition);

	      if (!match) {
	        buffer = value.slice(startPosition);
	        break
	      }

	      if (code === 10 && startPosition === endPosition && atCarriageReturn) {
	        chunks.push(-3);
	        atCarriageReturn = undefined;
	      } else {
	        if (atCarriageReturn) {
	          chunks.push(-5);
	          atCarriageReturn = undefined;
	        }

	        if (startPosition < endPosition) {
	          chunks.push(value.slice(startPosition, endPosition));
	          column += endPosition - startPosition;
	        }

	        switch (code) {
	          case 0: {
	            chunks.push(65533);
	            column++;
	            break
	          }

	          case 9: {
	            next = Math.ceil(column / 4) * 4;
	            chunks.push(-2);

	            while (column++ < next) chunks.push(-1);

	            break
	          }

	          case 10: {
	            chunks.push(-4);
	            column = 1;
	            break
	          }

	          default: {
	            atCarriageReturn = true;
	            column = 1;
	          }
	        }
	      }

	      startPosition = endPosition + 1;
	    }

	    if (end) {
	      if (atCarriageReturn) chunks.push(-5);
	      if (buffer) chunks.push(buffer);
	      chunks.push(null);
	    }

	    return chunks
	  }
	}

	/**
	 * @typedef {import('micromark-util-types').Event} Event
	 */
	/**
	 * @param {Event[]} events
	 * @returns {Event[]}
	 */

	function postprocess(events) {
	  while (!subtokenize(events)) {
	    // Empty
	  }

	  return events
	}

	/**
	 * @typedef {import('unist').Point} Point
	 * @typedef {import('unist').Node} Node
	 * @typedef {import('unist').Position} Position
	 * @typedef {object & {type: string, position?: Position|undefined}} NodeLike
	 */

	/**
	 * Stringify one point, a position (start and end points), or a node’s
	 * positional information.
	 *
	 * @param {Node|NodeLike|Position|Point|null} [value]
	 * @returns {string}
	 */
	function stringifyPosition(value) {
	  // Nothing.
	  if (!value || typeof value !== 'object') {
	    return ''
	  }

	  // Node.
	  if ('position' in value || 'type' in value) {
	    return position(value.position)
	  }

	  // Position.
	  if ('start' in value || 'end' in value) {
	    return position(value)
	  }

	  // Point.
	  if ('line' in value || 'column' in value) {
	    return point(value)
	  }

	  // ?
	  return ''
	}

	/**
	 * @param {Point|undefined} point
	 * @returns {string}
	 */
	function point(point) {
	  return index(point && point.line) + ':' + index(point && point.column)
	}

	/**
	 * @param {Position|undefined} pos
	 * @returns {string}
	 */
	function position(pos) {
	  return point(pos && pos.start) + '-' + point(pos && pos.end)
	}

	/**
	 * @param {number|undefined} value
	 * @returns {number}
	 */
	function index(value) {
	  return value && typeof value === 'number' ? value : 1
	}

	/**
	 * @typedef {import('micromark-util-types').Encoding} Encoding
	 * @typedef {import('micromark-util-types').Event} Event
	 * @typedef {import('micromark-util-types').ParseOptions} ParseOptions
	 * @typedef {import('micromark-util-types').Token} Token
	 * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext
	 * @typedef {import('micromark-util-types').Value} Value
	 * @typedef {import('unist').Parent} UnistParent
	 * @typedef {import('unist').Point} Point
	 * @typedef {import('mdast').PhrasingContent} PhrasingContent
	 * @typedef {import('mdast').Content} Content
	 * @typedef {Root|Content} Node
	 * @typedef {Extract<Node, UnistParent>} Parent
	 * @typedef {import('mdast').Break} Break
	 * @typedef {import('mdast').Blockquote} Blockquote
	 * @typedef {import('mdast').Code} Code
	 * @typedef {import('mdast').Definition} Definition
	 * @typedef {import('mdast').Emphasis} Emphasis
	 * @typedef {import('mdast').Heading} Heading
	 * @typedef {import('mdast').HTML} HTML
	 * @typedef {import('mdast').Image} Image
	 * @typedef {import('mdast').ImageReference} ImageReference
	 * @typedef {import('mdast').InlineCode} InlineCode
	 * @typedef {import('mdast').Link} Link
	 * @typedef {import('mdast').LinkReference} LinkReference
	 * @typedef {import('mdast').List} List
	 * @typedef {import('mdast').ListItem} ListItem
	 * @typedef {import('mdast').Paragraph} Paragraph
	 * @typedef {import('mdast').Root} Root
	 * @typedef {import('mdast').Strong} Strong
	 * @typedef {import('mdast').Text} Text
	 * @typedef {import('mdast').ThematicBreak} ThematicBreak
	 *
	 * @typedef {UnistParent & {type: 'fragment', children: Array<PhrasingContent>}} Fragment
	 */

	const own$4 = {}.hasOwnProperty;
	/**
	 * @param value Markdown to parse (`string` or `Buffer`).
	 * @param [encoding] Character encoding to understand `value` as when it’s a `Buffer` (`string`, default: `'utf8'`).
	 * @param [options] Configuration
	 */

	const fromMarkdown =
	  /**
	   * @type {(
	   *   ((value: Value, encoding: Encoding, options?: Options) => Root) &
	   *   ((value: Value, options?: Options) => Root)
	   * )}
	   */

	  /**
	   * @param {Value} value
	   * @param {Encoding} [encoding]
	   * @param {Options} [options]
	   * @returns {Root}
	   */
	  function (value, encoding, options) {
	    if (typeof encoding !== 'string') {
	      options = encoding;
	      encoding = undefined;
	    }

	    return compiler(options)(
	      postprocess(
	        parse(options).document().write(preprocess()(value, encoding, true))
	      )
	    )
	  };
	/**
	 * Note this compiler only understand complete buffering, not streaming.
	 *
	 * @param {Options} [options]
	 */

	function compiler(options = {}) {
	  /** @type {NormalizedExtension} */
	  // @ts-expect-error: our base has all required fields, so the result will too.
	  const config = configure(
	    {
	      transforms: [],
	      canContainEols: [
	        'emphasis',
	        'fragment',
	        'heading',
	        'paragraph',
	        'strong'
	      ],
	      enter: {
	        autolink: opener(link),
	        autolinkProtocol: onenterdata,
	        autolinkEmail: onenterdata,
	        atxHeading: opener(heading),
	        blockQuote: opener(blockQuote),
	        characterEscape: onenterdata,
	        characterReference: onenterdata,
	        codeFenced: opener(codeFlow),
	        codeFencedFenceInfo: buffer,
	        codeFencedFenceMeta: buffer,
	        codeIndented: opener(codeFlow, buffer),
	        codeText: opener(codeText, buffer),
	        codeTextData: onenterdata,
	        data: onenterdata,
	        codeFlowValue: onenterdata,
	        definition: opener(definition),
	        definitionDestinationString: buffer,
	        definitionLabelString: buffer,
	        definitionTitleString: buffer,
	        emphasis: opener(emphasis),
	        hardBreakEscape: opener(hardBreak),
	        hardBreakTrailing: opener(hardBreak),
	        htmlFlow: opener(html, buffer),
	        htmlFlowData: onenterdata,
	        htmlText: opener(html, buffer),
	        htmlTextData: onenterdata,
	        image: opener(image),
	        label: buffer,
	        link: opener(link),
	        listItem: opener(listItem),
	        listItemValue: onenterlistitemvalue,
	        listOrdered: opener(list, onenterlistordered),
	        listUnordered: opener(list),
	        paragraph: opener(paragraph),
	        reference: onenterreference,
	        referenceString: buffer,
	        resourceDestinationString: buffer,
	        resourceTitleString: buffer,
	        setextHeading: opener(heading),
	        strong: opener(strong),
	        thematicBreak: opener(thematicBreak)
	      },
	      exit: {
	        atxHeading: closer(),
	        atxHeadingSequence: onexitatxheadingsequence,
	        autolink: closer(),
	        autolinkEmail: onexitautolinkemail,
	        autolinkProtocol: onexitautolinkprotocol,
	        blockQuote: closer(),
	        characterEscapeValue: onexitdata,
	        characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,
	        characterReferenceMarkerNumeric: onexitcharacterreferencemarker,
	        characterReferenceValue: onexitcharacterreferencevalue,
	        codeFenced: closer(onexitcodefenced),
	        codeFencedFence: onexitcodefencedfence,
	        codeFencedFenceInfo: onexitcodefencedfenceinfo,
	        codeFencedFenceMeta: onexitcodefencedfencemeta,
	        codeFlowValue: onexitdata,
	        codeIndented: closer(onexitcodeindented),
	        codeText: closer(onexitcodetext),
	        codeTextData: onexitdata,
	        data: onexitdata,
	        definition: closer(),
	        definitionDestinationString: onexitdefinitiondestinationstring,
	        definitionLabelString: onexitdefinitionlabelstring,
	        definitionTitleString: onexitdefinitiontitlestring,
	        emphasis: closer(),
	        hardBreakEscape: closer(onexithardbreak),
	        hardBreakTrailing: closer(onexithardbreak),
	        htmlFlow: closer(onexithtmlflow),
	        htmlFlowData: onexitdata,
	        htmlText: closer(onexithtmltext),
	        htmlTextData: onexitdata,
	        image: closer(onexitimage),
	        label: onexitlabel,
	        labelText: onexitlabeltext,
	        lineEnding: onexitlineending,
	        link: closer(onexitlink),
	        listItem: closer(),
	        listOrdered: closer(),
	        listUnordered: closer(),
	        paragraph: closer(),
	        referenceString: onexitreferencestring,
	        resourceDestinationString: onexitresourcedestinationstring,
	        resourceTitleString: onexitresourcetitlestring,
	        resource: onexitresource,
	        setextHeading: closer(onexitsetextheading),
	        setextHeadingLineSequence: onexitsetextheadinglinesequence,
	        setextHeadingText: onexitsetextheadingtext,
	        strong: closer(),
	        thematicBreak: closer()
	      }
	    },
	    options.mdastExtensions || []
	  );
	  /** @type {CompileData} */

	  const data = {};
	  return compile
	  /**
	   * @param {Array<Event>} events
	   * @returns {Root}
	   */

	  function compile(events) {
	    /** @type {Root} */
	    let tree = {
	      type: 'root',
	      children: []
	    };
	    /** @type {CompileContext['stack']} */

	    const stack = [tree];
	    /** @type {CompileContext['tokenStack']} */

	    const tokenStack = [];
	    /** @type {Array<number>} */

	    const listStack = [];
	    /** @type {Omit<CompileContext, 'sliceSerialize'>} */

	    const context = {
	      stack,
	      tokenStack,
	      config,
	      enter,
	      exit,
	      buffer,
	      resume,
	      setData,
	      getData
	    };
	    let index = -1;

	    while (++index < events.length) {
	      // We preprocess lists to add `listItem` tokens, and to infer whether
	      // items the list itself are spread out.
	      if (
	        events[index][1].type === 'listOrdered' ||
	        events[index][1].type === 'listUnordered'
	      ) {
	        if (events[index][0] === 'enter') {
	          listStack.push(index);
	        } else {
	          const tail = listStack.pop();
	          index = prepareList(events, tail, index);
	        }
	      }
	    }

	    index = -1;

	    while (++index < events.length) {
	      const handler = config[events[index][0]];

	      if (own$4.call(handler, events[index][1].type)) {
	        handler[events[index][1].type].call(
	          Object.assign(
	            {
	              sliceSerialize: events[index][2].sliceSerialize
	            },
	            context
	          ),
	          events[index][1]
	        );
	      }
	    }

	    if (tokenStack.length > 0) {
	      const tail = tokenStack[tokenStack.length - 1];
	      const handler = tail[1] || defaultOnError;
	      handler.call(context, undefined, tail[0]);
	    } // Figure out `root` position.

	    tree.position = {
	      start: point(
	        events.length > 0
	          ? events[0][1].start
	          : {
	              line: 1,
	              column: 1,
	              offset: 0
	            }
	      ),
	      end: point(
	        events.length > 0
	          ? events[events.length - 2][1].end
	          : {
	              line: 1,
	              column: 1,
	              offset: 0
	            }
	      )
	    };
	    index = -1;

	    while (++index < config.transforms.length) {
	      tree = config.transforms[index](tree) || tree;
	    }

	    return tree
	  }
	  /**
	   * @param {Array<Event>} events
	   * @param {number} start
	   * @param {number} length
	   * @returns {number}
	   */

	  function prepareList(events, start, length) {
	    let index = start - 1;
	    let containerBalance = -1;
	    let listSpread = false;
	    /** @type {Token|undefined} */

	    let listItem;
	    /** @type {number|undefined} */

	    let lineIndex;
	    /** @type {number|undefined} */

	    let firstBlankLineIndex;
	    /** @type {boolean|undefined} */

	    let atMarker;

	    while (++index <= length) {
	      const event = events[index];

	      if (
	        event[1].type === 'listUnordered' ||
	        event[1].type === 'listOrdered' ||
	        event[1].type === 'blockQuote'
	      ) {
	        if (event[0] === 'enter') {
	          containerBalance++;
	        } else {
	          containerBalance--;
	        }

	        atMarker = undefined;
	      } else if (event[1].type === 'lineEndingBlank') {
	        if (event[0] === 'enter') {
	          if (
	            listItem &&
	            !atMarker &&
	            !containerBalance &&
	            !firstBlankLineIndex
	          ) {
	            firstBlankLineIndex = index;
	          }

	          atMarker = undefined;
	        }
	      } else if (
	        event[1].type === 'linePrefix' ||
	        event[1].type === 'listItemValue' ||
	        event[1].type === 'listItemMarker' ||
	        event[1].type === 'listItemPrefix' ||
	        event[1].type === 'listItemPrefixWhitespace'
	      ) ; else {
	        atMarker = undefined;
	      }

	      if (
	        (!containerBalance &&
	          event[0] === 'enter' &&
	          event[1].type === 'listItemPrefix') ||
	        (containerBalance === -1 &&
	          event[0] === 'exit' &&
	          (event[1].type === 'listUnordered' ||
	            event[1].type === 'listOrdered'))
	      ) {
	        if (listItem) {
	          let tailIndex = index;
	          lineIndex = undefined;

	          while (tailIndex--) {
	            const tailEvent = events[tailIndex];

	            if (
	              tailEvent[1].type === 'lineEnding' ||
	              tailEvent[1].type === 'lineEndingBlank'
	            ) {
	              if (tailEvent[0] === 'exit') continue

	              if (lineIndex) {
	                events[lineIndex][1].type = 'lineEndingBlank';
	                listSpread = true;
	              }

	              tailEvent[1].type = 'lineEnding';
	              lineIndex = tailIndex;
	            } else if (
	              tailEvent[1].type === 'linePrefix' ||
	              tailEvent[1].type === 'blockQuotePrefix' ||
	              tailEvent[1].type === 'blockQuotePrefixWhitespace' ||
	              tailEvent[1].type === 'blockQuoteMarker' ||
	              tailEvent[1].type === 'listItemIndent'
	            ) ; else {
	              break
	            }
	          }

	          if (
	            firstBlankLineIndex &&
	            (!lineIndex || firstBlankLineIndex < lineIndex)
	          ) {
	            // @ts-expect-error Patched.
	            listItem._spread = true;
	          } // Fix position.

	          listItem.end = Object.assign(
	            {},
	            lineIndex ? events[lineIndex][1].start : event[1].end
	          );
	          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]]);
	          index++;
	          length++;
	        } // Create a new list item.

	        if (event[1].type === 'listItemPrefix') {
	          listItem = {
	            type: 'listItem',
	            // @ts-expect-error Patched
	            _spread: false,
	            start: Object.assign({}, event[1].start)
	          }; // @ts-expect-error: `listItem` is most definitely defined, TS...

	          events.splice(index, 0, ['enter', listItem, event[2]]);
	          index++;
	          length++;
	          firstBlankLineIndex = undefined;
	          atMarker = true;
	        }
	      }
	    } // @ts-expect-error Patched.

	    events[start][1]._spread = listSpread;
	    return length
	  }
	  /**
	   * @type {CompileContext['setData']}
	   * @param [value]
	   */

	  function setData(key, value) {
	    data[key] = value;
	  }
	  /**
	   * @type {CompileContext['getData']}
	   * @template {string} K
	   * @param {K} key
	   * @returns {CompileData[K]}
	   */

	  function getData(key) {
	    return data[key]
	  }
	  /**
	   * @param {Point} d
	   * @returns {Point}
	   */

	  function point(d) {
	    return {
	      line: d.line,
	      column: d.column,
	      offset: d.offset
	    }
	  }
	  /**
	   * @param {(token: Token) => Node} create
	   * @param {Handle} [and]
	   * @returns {Handle}
	   */

	  function opener(create, and) {
	    return open
	    /**
	     * @this {CompileContext}
	     * @param {Token} token
	     * @returns {void}
	     */

	    function open(token) {
	      enter.call(this, create(token), token);
	      if (and) and.call(this, token);
	    }
	  }
	  /** @type {CompileContext['buffer']} */

	  function buffer() {
	    this.stack.push({
	      type: 'fragment',
	      children: []
	    });
	  }
	  /**
	   * @type {CompileContext['enter']}
	   * @template {Node} N
	   * @this {CompileContext}
	   * @param {N} node
	   * @param {Token} token
	   * @param {OnEnterError} [errorHandler]
	   * @returns {N}
	   */

	  function enter(node, token, errorHandler) {
	    const parent = this.stack[this.stack.length - 1];
	    // @ts-expect-error: Assume `Node` can exist as a child of `parent`.
	    parent.children.push(node);
	    this.stack.push(node);
	    this.tokenStack.push([token, errorHandler]); // @ts-expect-error: `end` will be patched later.

	    node.position = {
	      start: point(token.start)
	    };
	    return node
	  }
	  /**
	   * @param {Handle} [and]
	   * @returns {Handle}
	   */

	  function closer(and) {
	    return close
	    /**
	     * @this {CompileContext}
	     * @param {Token} token
	     * @returns {void}
	     */

	    function close(token) {
	      if (and) and.call(this, token);
	      exit.call(this, token);
	    }
	  }
	  /**
	   * @type {CompileContext['exit']}
	   * @this {CompileContext}
	   * @param {Token} token
	   * @param {OnExitError} [onExitError]
	   * @returns {Node}
	   */

	  function exit(token, onExitError) {
	    const node = this.stack.pop();
	    const open = this.tokenStack.pop();

	    if (!open) {
	      throw new Error(
	        'Cannot close `' +
	          token.type +
	          '` (' +
	          stringifyPosition({
	            start: token.start,
	            end: token.end
	          }) +
	          '): it’s not open'
	      )
	    } else if (open[0].type !== token.type) {
	      if (onExitError) {
	        onExitError.call(this, token, open[0]);
	      } else {
	        const handler = open[1] || defaultOnError;
	        handler.call(this, token, open[0]);
	      }
	    }

	    node.position.end = point(token.end);
	    return node
	  }
	  /**
	   * @this {CompileContext}
	   * @returns {string}
	   */

	  function resume() {
	    return toString(this.stack.pop())
	  } //
	  // Handlers.
	  //

	  /** @type {Handle} */

	  function onenterlistordered() {
	    setData('expectingFirstListItemValue', true);
	  }
	  /** @type {Handle} */

	  function onenterlistitemvalue(token) {
	    if (getData('expectingFirstListItemValue')) {
	      const ancestor =
	        /** @type {List} */
	        this.stack[this.stack.length - 2];
	      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10);
	      setData('expectingFirstListItemValue');
	    }
	  }
	  /** @type {Handle} */

	  function onexitcodefencedfenceinfo() {
	    const data = this.resume();
	    const node =
	      /** @type {Code} */
	      this.stack[this.stack.length - 1];
	    node.lang = data;
	  }
	  /** @type {Handle} */

	  function onexitcodefencedfencemeta() {
	    const data = this.resume();
	    const node =
	      /** @type {Code} */
	      this.stack[this.stack.length - 1];
	    node.meta = data;
	  }
	  /** @type {Handle} */

	  function onexitcodefencedfence() {
	    // Exit if this is the closing fence.
	    if (getData('flowCodeInside')) return
	    this.buffer();
	    setData('flowCodeInside', true);
	  }
	  /** @type {Handle} */

	  function onexitcodefenced() {
	    const data = this.resume();
	    const node =
	      /** @type {Code} */
	      this.stack[this.stack.length - 1];
	    node.value = data.replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, '');
	    setData('flowCodeInside');
	  }
	  /** @type {Handle} */

	  function onexitcodeindented() {
	    const data = this.resume();
	    const node =
	      /** @type {Code} */
	      this.stack[this.stack.length - 1];
	    node.value = data.replace(/(\r?\n|\r)$/g, '');
	  }
	  /** @type {Handle} */

	  function onexitdefinitionlabelstring(token) {
	    // Discard label, use the source content instead.
	    const label = this.resume();
	    const node =
	      /** @type {Definition} */
	      this.stack[this.stack.length - 1];
	    node.label = label;
	    node.identifier = normalizeIdentifier(
	      this.sliceSerialize(token)
	    ).toLowerCase();
	  }
	  /** @type {Handle} */

	  function onexitdefinitiontitlestring() {
	    const data = this.resume();
	    const node =
	      /** @type {Definition} */
	      this.stack[this.stack.length - 1];
	    node.title = data;
	  }
	  /** @type {Handle} */

	  function onexitdefinitiondestinationstring() {
	    const data = this.resume();
	    const node =
	      /** @type {Definition} */
	      this.stack[this.stack.length - 1];
	    node.url = data;
	  }
	  /** @type {Handle} */

	  function onexitatxheadingsequence(token) {
	    const node =
	      /** @type {Heading} */
	      this.stack[this.stack.length - 1];

	    if (!node.depth) {
	      const depth = this.sliceSerialize(token).length;
	      node.depth = depth;
	    }
	  }
	  /** @type {Handle} */

	  function onexitsetextheadingtext() {
	    setData('setextHeadingSlurpLineEnding', true);
	  }
	  /** @type {Handle} */

	  function onexitsetextheadinglinesequence(token) {
	    const node =
	      /** @type {Heading} */
	      this.stack[this.stack.length - 1];
	    node.depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2;
	  }
	  /** @type {Handle} */

	  function onexitsetextheading() {
	    setData('setextHeadingSlurpLineEnding');
	  }
	  /** @type {Handle} */

	  function onenterdata(token) {
	    const parent =
	      /** @type {Parent} */
	      this.stack[this.stack.length - 1];
	    /** @type {Node} */

	    let tail = parent.children[parent.children.length - 1];

	    if (!tail || tail.type !== 'text') {
	      // Add a new text node.
	      tail = text(); // @ts-expect-error: we’ll add `end` later.

	      tail.position = {
	        start: point(token.start)
	      }; // @ts-expect-error: Assume `parent` accepts `text`.

	      parent.children.push(tail);
	    }

	    this.stack.push(tail);
	  }
	  /** @type {Handle} */

	  function onexitdata(token) {
	    const tail = this.stack.pop();
	    tail.value += this.sliceSerialize(token);
	    tail.position.end = point(token.end);
	  }
	  /** @type {Handle} */

	  function onexitlineending(token) {
	    const context = this.stack[this.stack.length - 1];

	    // If we’re at a hard break, include the line ending in there.
	    if (getData('atHardBreak')) {
	      const tail = context.children[context.children.length - 1];
	      tail.position.end = point(token.end);
	      setData('atHardBreak');
	      return
	    }

	    if (
	      !getData('setextHeadingSlurpLineEnding') &&
	      config.canContainEols.includes(context.type)
	    ) {
	      onenterdata.call(this, token);
	      onexitdata.call(this, token);
	    }
	  }
	  /** @type {Handle} */

	  function onexithardbreak() {
	    setData('atHardBreak', true);
	  }
	  /** @type {Handle} */

	  function onexithtmlflow() {
	    const data = this.resume();
	    const node =
	      /** @type {HTML} */
	      this.stack[this.stack.length - 1];
	    node.value = data;
	  }
	  /** @type {Handle} */

	  function onexithtmltext() {
	    const data = this.resume();
	    const node =
	      /** @type {HTML} */
	      this.stack[this.stack.length - 1];
	    node.value = data;
	  }
	  /** @type {Handle} */

	  function onexitcodetext() {
	    const data = this.resume();
	    const node =
	      /** @type {InlineCode} */
	      this.stack[this.stack.length - 1];
	    node.value = data;
	  }
	  /** @type {Handle} */

	  function onexitlink() {
	    const context =
	      /** @type {Link & {identifier: string, label: string}} */
	      this.stack[this.stack.length - 1]; // To do: clean.

	    if (getData('inReference')) {
	      context.type += 'Reference'; // @ts-expect-error: mutate.

	      context.referenceType = getData('referenceType') || 'shortcut'; // @ts-expect-error: mutate.

	      delete context.url;
	      delete context.title;
	    } else {
	      // @ts-expect-error: mutate.
	      delete context.identifier; // @ts-expect-error: mutate.

	      delete context.label;
	    }

	    setData('referenceType');
	  }
	  /** @type {Handle} */

	  function onexitimage() {
	    const context =
	      /** @type {Image & {identifier: string, label: string}} */
	      this.stack[this.stack.length - 1]; // To do: clean.

	    if (getData('inReference')) {
	      context.type += 'Reference'; // @ts-expect-error: mutate.

	      context.referenceType = getData('referenceType') || 'shortcut'; // @ts-expect-error: mutate.

	      delete context.url;
	      delete context.title;
	    } else {
	      // @ts-expect-error: mutate.
	      delete context.identifier; // @ts-expect-error: mutate.

	      delete context.label;
	    }

	    setData('referenceType');
	  }
	  /** @type {Handle} */

	  function onexitlabeltext(token) {
	    const ancestor =
	      /** @type {(Link|Image) & {identifier: string, label: string}} */
	      this.stack[this.stack.length - 2];
	    const string = this.sliceSerialize(token);
	    ancestor.label = decodeString(string);
	    ancestor.identifier = normalizeIdentifier(string).toLowerCase();
	  }
	  /** @type {Handle} */

	  function onexitlabel() {
	    const fragment =
	      /** @type {Fragment} */
	      this.stack[this.stack.length - 1];
	    const value = this.resume();
	    const node =
	      /** @type {(Link|Image) & {identifier: string, label: string}} */
	      this.stack[this.stack.length - 1]; // Assume a reference.

	    setData('inReference', true);

	    if (node.type === 'link') {
	      // @ts-expect-error: Assume static phrasing content.
	      node.children = fragment.children;
	    } else {
	      node.alt = value;
	    }
	  }
	  /** @type {Handle} */

	  function onexitresourcedestinationstring() {
	    const data = this.resume();
	    const node =
	      /** @type {Link|Image} */
	      this.stack[this.stack.length - 1];
	    node.url = data;
	  }
	  /** @type {Handle} */

	  function onexitresourcetitlestring() {
	    const data = this.resume();
	    const node =
	      /** @type {Link|Image} */
	      this.stack[this.stack.length - 1];
	    node.title = data;
	  }
	  /** @type {Handle} */

	  function onexitresource() {
	    setData('inReference');
	  }
	  /** @type {Handle} */

	  function onenterreference() {
	    setData('referenceType', 'collapsed');
	  }
	  /** @type {Handle} */

	  function onexitreferencestring(token) {
	    const label = this.resume();
	    const node =
	      /** @type {LinkReference|ImageReference} */
	      this.stack[this.stack.length - 1];
	    node.label = label;
	    node.identifier = normalizeIdentifier(
	      this.sliceSerialize(token)
	    ).toLowerCase();
	    setData('referenceType', 'full');
	  }
	  /** @type {Handle} */

	  function onexitcharacterreferencemarker(token) {
	    setData('characterReferenceType', token.type);
	  }
	  /** @type {Handle} */

	  function onexitcharacterreferencevalue(token) {
	    const data = this.sliceSerialize(token);
	    const type = getData('characterReferenceType');
	    /** @type {string} */

	    let value;

	    if (type) {
	      value = decodeNumericCharacterReference(
	        data,
	        type === 'characterReferenceMarkerNumeric' ? 10 : 16
	      );
	      setData('characterReferenceType');
	    } else {
	      // @ts-expect-error `decodeNamedCharacterReference` can return false for
	      // invalid named character references, but everything we’ve tokenized is
	      // valid.
	      value = decodeNamedCharacterReference(data);
	    }

	    const tail = this.stack.pop();
	    tail.value += value;
	    tail.position.end = point(token.end);
	  }
	  /** @type {Handle} */

	  function onexitautolinkprotocol(token) {
	    onexitdata.call(this, token);
	    const node =
	      /** @type {Link} */
	      this.stack[this.stack.length - 1];
	    node.url = this.sliceSerialize(token);
	  }
	  /** @type {Handle} */

	  function onexitautolinkemail(token) {
	    onexitdata.call(this, token);
	    const node =
	      /** @type {Link} */
	      this.stack[this.stack.length - 1];
	    node.url = 'mailto:' + this.sliceSerialize(token);
	  } //
	  // Creaters.
	  //

	  /** @returns {Blockquote} */

	  function blockQuote() {
	    return {
	      type: 'blockquote',
	      children: []
	    }
	  }
	  /** @returns {Code} */

	  function codeFlow() {
	    return {
	      type: 'code',
	      lang: null,
	      meta: null,
	      value: ''
	    }
	  }
	  /** @returns {InlineCode} */

	  function codeText() {
	    return {
	      type: 'inlineCode',
	      value: ''
	    }
	  }
	  /** @returns {Definition} */

	  function definition() {
	    return {
	      type: 'definition',
	      identifier: '',
	      label: null,
	      title: null,
	      url: ''
	    }
	  }
	  /** @returns {Emphasis} */

	  function emphasis() {
	    return {
	      type: 'emphasis',
	      children: []
	    }
	  }
	  /** @returns {Heading} */

	  function heading() {
	    // @ts-expect-error `depth` will be set later.
	    return {
	      type: 'heading',
	      depth: undefined,
	      children: []
	    }
	  }
	  /** @returns {Break} */

	  function hardBreak() {
	    return {
	      type: 'break'
	    }
	  }
	  /** @returns {HTML} */

	  function html() {
	    return {
	      type: 'html',
	      value: ''
	    }
	  }
	  /** @returns {Image} */

	  function image() {
	    return {
	      type: 'image',
	      title: null,
	      url: '',
	      alt: null
	    }
	  }
	  /** @returns {Link} */

	  function link() {
	    return {
	      type: 'link',
	      title: null,
	      url: '',
	      children: []
	    }
	  }
	  /**
	   * @param {Token} token
	   * @returns {List}
	   */

	  function list(token) {
	    return {
	      type: 'list',
	      ordered: token.type === 'listOrdered',
	      start: null,
	      // @ts-expect-error Patched.
	      spread: token._spread,
	      children: []
	    }
	  }
	  /**
	   * @param {Token} token
	   * @returns {ListItem}
	   */

	  function listItem(token) {
	    return {
	      type: 'listItem',
	      // @ts-expect-error Patched.
	      spread: token._spread,
	      checked: null,
	      children: []
	    }
	  }
	  /** @returns {Paragraph} */

	  function paragraph() {
	    return {
	      type: 'paragraph',
	      children: []
	    }
	  }
	  /** @returns {Strong} */

	  function strong() {
	    return {
	      type: 'strong',
	      children: []
	    }
	  }
	  /** @returns {Text} */

	  function text() {
	    return {
	      type: 'text',
	      value: ''
	    }
	  }
	  /** @returns {ThematicBreak} */

	  function thematicBreak() {
	    return {
	      type: 'thematicBreak'
	    }
	  }
	}
	/**
	 * @param {Extension} combined
	 * @param {Array<Extension|Array<Extension>>} extensions
	 * @returns {Extension}
	 */

	function configure(combined, extensions) {
	  let index = -1;

	  while (++index < extensions.length) {
	    const value = extensions[index];

	    if (Array.isArray(value)) {
	      configure(combined, value);
	    } else {
	      extension(combined, value);
	    }
	  }

	  return combined
	}
	/**
	 * @param {Extension} combined
	 * @param {Extension} extension
	 * @returns {void}
	 */

	function extension(combined, extension) {
	  /** @type {string} */
	  let key;

	  for (key in extension) {
	    if (own$4.call(extension, key)) {
	      const list = key === 'canContainEols' || key === 'transforms';
	      const maybe = own$4.call(combined, key) ? combined[key] : undefined;
	      /* c8 ignore next */

	      const left = maybe || (combined[key] = list ? [] : {});
	      const right = extension[key];

	      if (right) {
	        if (list) {
	          // @ts-expect-error: `left` is an array.
	          combined[key] = [...left, ...right];
	        } else {
	          Object.assign(left, right);
	        }
	      }
	    }
	  }
	}
	/** @type {OnEnterError} */

	function defaultOnError(left, right) {
	  if (left) {
	    throw new Error(
	      'Cannot close `' +
	        left.type +
	        '` (' +
	        stringifyPosition({
	          start: left.start,
	          end: left.end
	        }) +
	        '): a different token (`' +
	        right.type +
	        '`, ' +
	        stringifyPosition({
	          start: right.start,
	          end: right.end
	        }) +
	        ') is open'
	    )
	  } else {
	    throw new Error(
	      'Cannot close document, a token (`' +
	        right.type +
	        '`, ' +
	        stringifyPosition({
	          start: right.start,
	          end: right.end
	        }) +
	        ') is still open'
	    )
	  }
	}

	/**
	 * @typedef {import('mdast').Root} Root
	 * @typedef {import('mdast-util-from-markdown').Options} Options
	 */


	/** @type {import('unified').Plugin<[Options?] | void[], string, Root>} */
	function remarkParse(options) {
	  /** @type {import('unified').ParserFunction<Root>} */
	  const parser = (doc) => {
	    // Assume options.
	    const settings = /** @type {Options} */ (this.data('settings'));

	    return fromMarkdown(
	      doc,
	      Object.assign({}, settings, options, {
	        // Note: these options are not in the readme.
	        // The goal is for them to be set by plugins on `data` instead of being
	        // passed by users.
	        extensions: this.data('micromarkExtensions') || [],
	        mdastExtensions: this.data('fromMarkdownExtensions') || []
	      })
	    )
	  };

	  Object.assign(this, {Parser: parser});
	}

	/**
	 * @typedef {import('unist').Node} Node
	 * @typedef {import('unist').Parent} Parent
	 * @typedef {import('unist').Literal} Literal
	 * @typedef {Object.<string, unknown>} Props
	 * @typedef {Array.<Node>|string} ChildrenOrValue
	 *
	 * @typedef {(<T extends string, P extends Record<string, unknown>, C extends Node[]>(type: T, props: P, children: C) => {type: T, children: C} & P)} BuildParentWithProps
	 * @typedef {(<T extends string, P extends Record<string, unknown>>(type: T, props: P, value: string) => {type: T, value: string} & P)} BuildLiteralWithProps
	 * @typedef {(<T extends string, P extends Record<string, unknown>>(type: T, props: P) => {type: T} & P)} BuildVoidWithProps
	 * @typedef {(<T extends string, C extends Node[]>(type: T, children: C) => {type: T, children: C})} BuildParent
	 * @typedef {(<T extends string>(type: T, value: string) => {type: T, value: string})} BuildLiteral
	 * @typedef {(<T extends string>(type: T) => {type: T})} BuildVoid
	 */

	var u = /**
	 * @type {BuildVoid & BuildVoidWithProps & BuildLiteral & BuildLiteralWithProps & BuildParent & BuildParentWithProps}
	 */ (
	  /**
	   * @param {string} type Type of node
	   * @param {Props|ChildrenOrValue} [props] Additional properties for node (or `children` or `value`)
	   * @param {ChildrenOrValue} [value] `children` or `value` of node
	   * @returns {Node}
	   */
	  function (type, props, value) {
	    /** @type {Node} */
	    var node = {type: String(type)};

	    if (
	      (value === undefined || value === null) &&
	      (typeof props === 'string' || Array.isArray(props))
	    ) {
	      value = props;
	    } else {
	      Object.assign(node, props);
	    }

	    if (Array.isArray(value)) {
	      node.children = value;
	    } else if (value !== undefined && value !== null) {
	      node.value = String(value);
	    }

	    return node
	  }
	);

	/**
	 * @typedef {Object} PointLike
	 * @property {number} [line]
	 * @property {number} [column]
	 * @property {number} [offset]
	 *
	 * @typedef {Object} PositionLike
	 * @property {PointLike} [start]
	 * @property {PointLike} [end]
	 *
	 * @typedef {Object} NodeLike
	 * @property {PositionLike} [position]
	 */

	/**
	 * Check if `node` is *generated*.
	 *
	 * @param {NodeLike} [node]
	 * @returns {boolean}
	 */
	function generated(node) {
	  return (
	    !node ||
	    !node.position ||
	    !node.position.start ||
	    !node.position.start.line ||
	    !node.position.start.column ||
	    !node.position.end ||
	    !node.position.end.line ||
	    !node.position.end.column
	  )
	}

	/**
	 * @typedef {import('mdast').Root|import('mdast').Content} Node
	 * @typedef {import('mdast').Definition} Definition
	 * @typedef {import('unist-util-visit').Visitor<Definition>} DefinitionVisitor
	 */


	const own$3 = {}.hasOwnProperty;

	/**
	 *
	 * @param {Node} node
	 */
	function definitions(node) {
	  /** @type {Object.<string, Definition>} */
	  const cache = Object.create(null);

	  if (!node || !node.type) {
	    throw new Error('mdast-util-definitions expected node')
	  }

	  visit$2(node, 'definition', ondefinition);

	  return getDefinition

	  /** @type {DefinitionVisitor} */
	  function ondefinition(definition) {
	    const id = clean(definition.identifier);
	    if (id && !own$3.call(cache, id)) {
	      cache[id] = definition;
	    }
	  }

	  /**
	   * Get a node from the bound definition-cache.
	   *
	   * @param {string} identifier
	   * @returns {Definition|null}
	   */
	  function getDefinition(identifier) {
	    const id = clean(identifier);
	    return id && own$3.call(cache, id) ? cache[id] : null
	  }
	}

	/**
	 * @param {string} [value]
	 * @returns {string}
	 */
	function clean(value) {
	  return String(value || '').toUpperCase()
	}

	/**
	 * @typedef {import('mdast').Root|import('mdast').Parent['children'][number]} MdastNode
	 * @typedef {import('./index.js').H} H
	 * @typedef {import('./index.js').Handler} Handler
	 * @typedef {import('./index.js').Content} Content
	 */


	const own$2 = {}.hasOwnProperty;

	/**
	 * Transform an unknown node.
	 * @type {Handler}
	 * @param {MdastNode} node
	 */
	function unknown(h, node) {
	  const data = node.data || {};

	  if (
	    'value' in node &&
	    !(
	      own$2.call(data, 'hName') ||
	      own$2.call(data, 'hProperties') ||
	      own$2.call(data, 'hChildren')
	    )
	  ) {
	    return h.augment(node, u('text', node.value))
	  }

	  return h(node, 'div', all(h, node))
	}

	/**
	 * @type {Handler}
	 * @param {MdastNode} node
	 */
	function one(h, node, parent) {
	  const type = node && node.type;
	  /** @type {Handler} */
	  let fn;

	  // Fail on non-nodes.
	  if (!type) {
	    throw new Error('Expected node, got `' + node + '`')
	  }

	  if (own$2.call(h.handlers, type)) {
	    fn = h.handlers[type];
	  } else if (h.passThrough && h.passThrough.includes(type)) {
	    fn = returnNode;
	  } else {
	    fn = h.unknownHandler;
	  }

	  return (typeof fn === 'function' ? fn : unknown)(h, node, parent)
	}

	/**
	 * @type {Handler}
	 * @param {MdastNode} node
	 */
	function returnNode(h, node) {
	  // @ts-expect-error: Pass through custom node.
	  return 'children' in node ? {...node, children: all(h, node)} : node
	}

	/**
	 * @param {H} h
	 * @param {MdastNode} parent
	 */
	function all(h, parent) {
	  /** @type {Array<Content>} */
	  const values = [];

	  if ('children' in parent) {
	    const nodes = parent.children;
	    let index = -1;

	    while (++index < nodes.length) {
	      const result = one(h, nodes[index], parent);

	      if (result) {
	        if (index && nodes[index - 1].type === 'break') {
	          if (!Array.isArray(result) && result.type === 'text') {
	            result.value = result.value.replace(/^\s+/, '');
	          }

	          if (!Array.isArray(result) && result.type === 'element') {
	            const head = result.children[0];

	            if (head && head.type === 'text') {
	              head.value = head.value.replace(/^\s+/, '');
	            }
	          }
	        }

	        if (Array.isArray(result)) {
	          values.push(...result);
	        } else {
	          values.push(result);
	        }
	      }
	    }
	  }

	  return values
	}

	const characterReferences = {'"': 'quot', '&': 'amp', '<': 'lt', '>': 'gt'};

	/**
	 * Encode only the dangerous HTML characters.
	 *
	 * This ensures that certain characters which have special meaning in HTML are
	 * dealt with.
	 * Technically, we can skip `>` and `"` in many cases, but CM includes them.
	 *
	 * @param {string} value
	 * @returns {string}
	 */
	function encode$1(value) {
	  return value.replace(/["&<>]/g, replace)

	  /**
	   * @param {string} value
	   * @returns {string}
	   */
	  function replace(value) {
	    // @ts-expect-error Hush, it’s fine.
	    return '&' + characterReferences[value] + ';'
	  }
	}

	/**
	 * Make a value safe for injection as a URL.
	 *
	 * This encodes unsafe characters with percent-encoding and skips already
	 * encoded sequences (see `normalizeUri` below).
	 * Further unsafe characters are encoded as character references (see
	 * `micromark-util-encode`).
	 *
	 * Then, a regex of allowed protocols can be given, in which case the URL is
	 * sanitized.
	 * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`,
	 * or `/^https?$/i` for `img[src]`.
	 * If the URL includes an unknown protocol (one not matched by `protocol`, such
	 * as a dangerous example, `javascript:`), the value is ignored.
	 *
	 * @param {string|undefined} url
	 * @param {RegExp} [protocol]
	 * @returns {string}
	 */
	function sanitizeUri(url, protocol) {
	  const value = encode$1(normalizeUri(url || ''));

	  {
	    return value
	  }
	}
	/**
	 * Normalize a URL (such as used in definitions).
	 *
	 * Encode unsafe characters with percent-encoding, skipping already encoded
	 * sequences.
	 *
	 * @param {string} value
	 * @returns {string}
	 */

	function normalizeUri(value) {
	  /** @type {string[]} */
	  const result = [];
	  let index = -1;
	  let start = 0;
	  let skip = 0;

	  while (++index < value.length) {
	    const code = value.charCodeAt(index);
	    /** @type {string} */

	    let replace = ''; // A correct percent encoded value.

	    if (
	      code === 37 &&
	      asciiAlphanumeric(value.charCodeAt(index + 1)) &&
	      asciiAlphanumeric(value.charCodeAt(index + 2))
	    ) {
	      skip = 2;
	    } // ASCII.
	    else if (code < 128) {
	      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {
	        replace = String.fromCharCode(code);
	      }
	    } // Astral.
	    else if (code > 55295 && code < 57344) {
	      const next = value.charCodeAt(index + 1); // A correct surrogate pair.

	      if (code < 56320 && next > 56319 && next < 57344) {
	        replace = String.fromCharCode(code, next);
	        skip = 1;
	      } // Lone surrogate.
	      else {
	        replace = '\uFFFD';
	      }
	    } // Unicode.
	    else {
	      replace = String.fromCharCode(code);
	    }

	    if (replace) {
	      result.push(value.slice(start, index), encodeURIComponent(replace));
	      start = index + skip + 1;
	      replace = '';
	    }

	    if (skip) {
	      index += skip;
	      skip = 0;
	    }
	  }

	  return result.join('') + value.slice(start)
	}

	/**
	 * @typedef {import('./index.js').Content} Content
	 */


	/**
	 * Wrap `nodes` with line feeds between each entry.
	 * Optionally adds line feeds at the start and end.
	 *
	 * @param {Array<Content>} nodes
	 * @param {boolean} [loose=false]
	 * @returns {Array<Content>}
	 */
	function wrap$1(nodes, loose) {
	  /** @type {Array<Content>} */
	  const result = [];
	  let index = -1;

	  if (loose) {
	    result.push(u('text', '\n'));
	  }

	  while (++index < nodes.length) {
	    if (index) result.push(u('text', '\n'));
	    result.push(nodes[index]);
	  }

	  if (loose && nodes.length > 0) {
	    result.push(u('text', '\n'));
	  }

	  return result
	}

	/**
	 * @typedef {import('mdast').BlockContent} BlockContent
	 * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition
	 * @typedef {import('hast').Element} Element
	 * @typedef {import('hast').ElementContent} ElementContent
	 * @typedef {import('./index.js').H} H
	 */


	/**
	 * @param {H} h
	 */
	function footer(h) {
	  let index = -1;
	  /** @type {Array<ElementContent>} */
	  const listItems = [];

	  while (++index < h.footnoteOrder.length) {
	    const def = h.footnoteById[h.footnoteOrder[index].toUpperCase()];

	    if (!def) {
	      continue
	    }

	    const content = all(h, def);
	    const id = String(def.identifier);
	    const safeId = sanitizeUri(id.toLowerCase());
	    let referenceIndex = 0;
	    /** @type {Array<ElementContent>} */
	    const backReferences = [];

	    while (++referenceIndex <= h.footnoteCounts[id]) {
	      /** @type {Element} */
	      const backReference = {
	        type: 'element',
	        tagName: 'a',
	        properties: {
	          href:
	            '#' +
	            h.clobberPrefix +
	            'fnref-' +
	            safeId +
	            (referenceIndex > 1 ? '-' + referenceIndex : ''),
	          dataFootnoteBackref: true,
	          className: ['data-footnote-backref'],
	          ariaLabel: h.footnoteBackLabel
	        },
	        children: [{type: 'text', value: '↩'}]
	      };

	      if (referenceIndex > 1) {
	        backReference.children.push({
	          type: 'element',
	          tagName: 'sup',
	          children: [{type: 'text', value: String(referenceIndex)}]
	        });
	      }

	      if (backReferences.length > 0) {
	        backReferences.push({type: 'text', value: ' '});
	      }

	      backReferences.push(backReference);
	    }

	    const tail = content[content.length - 1];

	    if (tail && tail.type === 'element' && tail.tagName === 'p') {
	      const tailTail = tail.children[tail.children.length - 1];
	      if (tailTail && tailTail.type === 'text') {
	        tailTail.value += ' ';
	      } else {
	        tail.children.push({type: 'text', value: ' '});
	      }

	      tail.children.push(...backReferences);
	    } else {
	      content.push(...backReferences);
	    }

	    /** @type {Element} */
	    const listItem = {
	      type: 'element',
	      tagName: 'li',
	      properties: {id: h.clobberPrefix + 'fn-' + safeId},
	      children: wrap$1(content, true)
	    };

	    if (def.position) {
	      listItem.position = def.position;
	    }

	    listItems.push(listItem);
	  }

	  if (listItems.length === 0) {
	    return null
	  }

	  return {
	    type: 'element',
	    tagName: 'section',
	    properties: {dataFootnotes: true, className: ['footnotes']},
	    children: [
	      {
	        type: 'element',
	        tagName: 'h2',
	        properties: {id: 'footnote-label', className: ['sr-only']},
	        children: [u('text', h.footnoteLabel)]
	      },
	      {type: 'text', value: '\n'},
	      {
	        type: 'element',
	        tagName: 'ol',
	        properties: {},
	        children: wrap$1(listItems, true)
	      },
	      {type: 'text', value: '\n'}
	    ]
	  }
	}

	/**
	 * @typedef {import('mdast').Blockquote} Blockquote
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {Blockquote} node
	 */
	function blockquote(h, node) {
	  return h(node, 'blockquote', wrap$1(all(h, node), true))
	}

	/**
	 * @typedef {import('hast').Element} Element
	 * @typedef {import('hast').Text} Text
	 * @typedef {import('mdast').Break} Break
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {Break} node
	 * @returns {Array<Element|Text>}
	 */
	function hardBreak(h, node) {
	  return [h(node, 'br'), u('text', '\n')]
	}

	/**
	 * @typedef {import('mdast').Code} Code
	 * @typedef {import('hast').Element} Element
	 * @typedef {import('hast').Properties} Properties
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {Code} node
	 */
	function code(h, node) {
	  const value = node.value ? node.value + '\n' : '';
	  // To do: next major, use `node.lang` w/o regex, the splitting’s been going
	  // on for years in remark now.
	  const lang = node.lang && node.lang.match(/^[^ \t]+(?=[ \t]|$)/);
	  /** @type {Properties} */
	  const props = {};

	  if (lang) {
	    props.className = ['language-' + lang];
	  }

	  const code = h(node, 'code', props, [u('text', value)]);

	  if (node.meta) {
	    code.data = {meta: node.meta};
	  }

	  return h(node.position, 'pre', [code])
	}

	/**
	 * @typedef {import('mdast').Delete} Delete
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {Delete} node
	 */
	function strikethrough(h, node) {
	  return h(node, 'del', all(h, node))
	}

	/**
	 * @typedef {import('mdast').Emphasis} Emphasis
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {Emphasis} node
	 */
	function emphasis(h, node) {
	  return h(node, 'em', all(h, node))
	}

	/**
	 * @typedef {import('mdast').FootnoteReference} FootnoteReference
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {FootnoteReference} node
	 */
	function footnoteReference(h, node) {
	  const id = String(node.identifier);
	  const safeId = sanitizeUri(id.toLowerCase());
	  const index = h.footnoteOrder.indexOf(id);
	  /** @type {number} */
	  let counter;

	  if (index === -1) {
	    h.footnoteOrder.push(id);
	    h.footnoteCounts[id] = 1;
	    counter = h.footnoteOrder.length;
	  } else {
	    h.footnoteCounts[id]++;
	    counter = index + 1;
	  }

	  const reuseCounter = h.footnoteCounts[id];

	  return h(node, 'sup', [
	    h(
	      node.position,
	      'a',
	      {
	        href: '#' + h.clobberPrefix + 'fn-' + safeId,
	        id:
	          h.clobberPrefix +
	          'fnref-' +
	          safeId +
	          (reuseCounter > 1 ? '-' + reuseCounter : ''),
	        dataFootnoteRef: true,
	        ariaDescribedBy: 'footnote-label'
	      },
	      [u('text', String(counter))]
	    )
	  ])
	}

	/**
	 * @typedef {import('mdast').Footnote} Footnote
	 * @typedef {import('../index.js').Handler} Handler
	 *
	 * @todo
	 *   `footnote` (or “inline note”) are a pandoc footnotes feature (`^[a note]`)
	 *   that does not exist in GFM.
	 *   We still have support for it, so that things remain working with
	 *   `micromark-extension-footnote` and `mdast-util-footnote`, but in the future
	 *   we might be able to remove it?
	 */


	/**
	 * @type {Handler}
	 * @param {Footnote} node
	 */
	function footnote(h, node) {
	  const footnoteById = h.footnoteById;
	  let no = 1;

	  while (no in footnoteById) no++;

	  const identifier = String(no);

	  footnoteById[identifier] = {
	    type: 'footnoteDefinition',
	    identifier,
	    children: [{type: 'paragraph', children: node.children}],
	    position: node.position
	  };

	  return footnoteReference(h, {
	    type: 'footnoteReference',
	    identifier,
	    position: node.position
	  })
	}

	/**
	 * @typedef {import('mdast').Heading} Heading
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {Heading} node
	 */
	function heading(h, node) {
	  return h(node, 'h' + node.depth, all(h, node))
	}

	/**
	 * @typedef {import('mdast').HTML} HTML
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * Return either a `raw` node in dangerous mode, otherwise nothing.
	 *
	 * @type {Handler}
	 * @param {HTML} node
	 */
	function html(h, node) {
	  return h.dangerous ? h.augment(node, u('raw', node.value)) : null
	}

	var encodeCache = {};


	// Create a lookup array where anything but characters in `chars` string
	// and alphanumeric chars is percent-encoded.
	//
	function getEncodeCache(exclude) {
	  var i, ch, cache = encodeCache[exclude];
	  if (cache) { return cache; }

	  cache = encodeCache[exclude] = [];

	  for (i = 0; i < 128; i++) {
	    ch = String.fromCharCode(i);

	    if (/^[0-9a-z]$/i.test(ch)) {
	      // always allow unencoded alphanumeric characters
	      cache.push(ch);
	    } else {
	      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2));
	    }
	  }

	  for (i = 0; i < exclude.length; i++) {
	    cache[exclude.charCodeAt(i)] = exclude[i];
	  }

	  return cache;
	}


	// Encode unsafe characters with percent-encoding, skipping already
	// encoded sequences.
	//
	//  - string       - string to encode
	//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)
	//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)
	//
	function encode(string, exclude, keepEscaped) {
	  var i, l, code, nextCode, cache,
	      result = '';

	  if (typeof exclude !== 'string') {
	    // encode(string, keepEscaped)
	    keepEscaped  = exclude;
	    exclude = encode.defaultChars;
	  }

	  if (typeof keepEscaped === 'undefined') {
	    keepEscaped = true;
	  }

	  cache = getEncodeCache(exclude);

	  for (i = 0, l = string.length; i < l; i++) {
	    code = string.charCodeAt(i);

	    if (keepEscaped && code === 0x25 /* % */ && i + 2 < l) {
	      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {
	        result += string.slice(i, i + 3);
	        i += 2;
	        continue;
	      }
	    }

	    if (code < 128) {
	      result += cache[code];
	      continue;
	    }

	    if (code >= 0xD800 && code <= 0xDFFF) {
	      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {
	        nextCode = string.charCodeAt(i + 1);
	        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {
	          result += encodeURIComponent(string[i] + string[i + 1]);
	          i++;
	          continue;
	        }
	      }
	      result += '%EF%BF%BD';
	      continue;
	    }

	    result += encodeURIComponent(string[i]);
	  }

	  return result;
	}

	encode.defaultChars   = ";/?:@&=+$,-_.!~*'()#";
	encode.componentChars = "-_.!~*'()";


	var encode_1 = encode;

	var normalize$1 = /*@__PURE__*/getDefaultExportFromCjs(encode_1);

	/**
	 * @typedef {import('mdast').LinkReference} LinkReference
	 * @typedef {import('mdast').ImageReference} ImageReference
	 * @typedef {import('./index.js').Handler} Handler
	 * @typedef {import('./index.js').Content} Content
	 */


	/**
	 * Return the content of a reference without definition as plain text.
	 *
	 * @type {Handler}
	 * @param {ImageReference|LinkReference} node
	 * @returns {Content|Array<Content>}
	 */
	function revert(h, node) {
	  const subtype = node.referenceType;
	  let suffix = ']';

	  if (subtype === 'collapsed') {
	    suffix += '[]';
	  } else if (subtype === 'full') {
	    suffix += '[' + (node.label || node.identifier) + ']';
	  }

	  if (node.type === 'imageReference') {
	    return u('text', '![' + node.alt + suffix)
	  }

	  const contents = all(h, node);
	  const head = contents[0];

	  if (head && head.type === 'text') {
	    head.value = '[' + head.value;
	  } else {
	    contents.unshift(u('text', '['));
	  }

	  const tail = contents[contents.length - 1];

	  if (tail && tail.type === 'text') {
	    tail.value += suffix;
	  } else {
	    contents.push(u('text', suffix));
	  }

	  return contents
	}

	/**
	 * @typedef {import('mdast').ImageReference} ImageReference
	 * @typedef {import('hast').Properties} Properties
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {ImageReference} node
	 */
	function imageReference(h, node) {
	  const def = h.definition(node.identifier);

	  if (!def) {
	    return revert(h, node)
	  }

	  /** @type {Properties} */
	  const props = {src: normalize$1(def.url || ''), alt: node.alt};

	  if (def.title !== null && def.title !== undefined) {
	    props.title = def.title;
	  }

	  return h(node, 'img', props)
	}

	/**
	 * @typedef {import('mdast').Image} Image
	 * @typedef {import('hast').Properties} Properties
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {Image} node
	 */
	function image(h, node) {
	  /** @type {Properties} */
	  const props = {src: normalize$1(node.url), alt: node.alt};

	  if (node.title !== null && node.title !== undefined) {
	    props.title = node.title;
	  }

	  return h(node, 'img', props)
	}

	/**
	 * @typedef {import('mdast').InlineCode} InlineCode
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {InlineCode} node
	 */
	function inlineCode(h, node) {
	  return h(node, 'code', [u('text', node.value.replace(/\r?\n|\r/g, ' '))])
	}

	/**
	 * @typedef {import('mdast').LinkReference} LinkReference
	 * @typedef {import('hast').Properties} Properties
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {LinkReference} node
	 */
	function linkReference(h, node) {
	  const def = h.definition(node.identifier);

	  if (!def) {
	    return revert(h, node)
	  }

	  /** @type {Properties} */
	  const props = {href: normalize$1(def.url || '')};

	  if (def.title !== null && def.title !== undefined) {
	    props.title = def.title;
	  }

	  return h(node, 'a', props, all(h, node))
	}

	/**
	 * @typedef {import('mdast').Link} Link
	 * @typedef {import('hast').Properties} Properties
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {Link} node
	 */
	function link(h, node) {
	  /** @type {Properties} */
	  const props = {href: normalize$1(node.url)};

	  if (node.title !== null && node.title !== undefined) {
	    props.title = node.title;
	  }

	  return h(node, 'a', props, all(h, node))
	}

	/**
	 * @typedef {import('mdast').ListItem} ListItem
	 * @typedef {import('mdast').List} List
	 * @typedef {import('hast').Properties} Properties
	 * @typedef {import('hast').Element} Element
	 * @typedef {import('../index.js').Handler} Handler
	 * @typedef {import('../index.js').Content} Content
	 */


	/**
	 * @type {Handler}
	 * @param {ListItem} node
	 * @param {List} parent
	 */
	function listItem(h, node, parent) {
	  const result = all(h, node);
	  const loose = parent ? listLoose(parent) : listItemLoose(node);
	  /** @type {Properties} */
	  const props = {};
	  /** @type {Array<Content>} */
	  const wrapped = [];

	  if (typeof node.checked === 'boolean') {
	    /** @type {Element} */
	    let paragraph;

	    if (
	      result[0] &&
	      result[0].type === 'element' &&
	      result[0].tagName === 'p'
	    ) {
	      paragraph = result[0];
	    } else {
	      paragraph = h(null, 'p', []);
	      result.unshift(paragraph);
	    }

	    if (paragraph.children.length > 0) {
	      paragraph.children.unshift(u('text', ' '));
	    }

	    paragraph.children.unshift(
	      h(null, 'input', {
	        type: 'checkbox',
	        checked: node.checked,
	        disabled: true
	      })
	    );

	    // According to github-markdown-css, this class hides bullet.
	    // See: <https://github.com/sindresorhus/github-markdown-css>.
	    props.className = ['task-list-item'];
	  }

	  let index = -1;

	  while (++index < result.length) {
	    const child = result[index];

	    // Add eols before nodes, except if this is a loose, first paragraph.
	    if (
	      loose ||
	      index !== 0 ||
	      child.type !== 'element' ||
	      child.tagName !== 'p'
	    ) {
	      wrapped.push(u('text', '\n'));
	    }

	    if (child.type === 'element' && child.tagName === 'p' && !loose) {
	      wrapped.push(...child.children);
	    } else {
	      wrapped.push(child);
	    }
	  }

	  const tail = result[result.length - 1];

	  // Add a final eol.
	  if (tail && (loose || !('tagName' in tail) || tail.tagName !== 'p')) {
	    wrapped.push(u('text', '\n'));
	  }

	  return h(node, 'li', props, wrapped)
	}

	/**
	 * @param {List} node
	 * @return {Boolean}
	 */
	function listLoose(node) {
	  let loose = node.spread;
	  const children = node.children;
	  let index = -1;

	  while (!loose && ++index < children.length) {
	    loose = listItemLoose(children[index]);
	  }

	  return Boolean(loose)
	}

	/**
	 * @param {ListItem} node
	 * @return {Boolean}
	 */
	function listItemLoose(node) {
	  const spread = node.spread;

	  return spread === undefined || spread === null
	    ? node.children.length > 1
	    : spread
	}

	/**
	 * @typedef {import('mdast').List} List
	 * @typedef {import('hast').Element} Element
	 * @typedef {import('hast').Properties} Properties
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {List} node
	 * @returns {Element}
	 */
	function list(h, node) {
	  /** @type {Properties} */
	  const props = {};
	  const name = node.ordered ? 'ol' : 'ul';
	  const items = all(h, node);
	  let index = -1;

	  if (typeof node.start === 'number' && node.start !== 1) {
	    props.start = node.start;
	  }

	  // Like GitHub, add a class for custom styling.
	  while (++index < items.length) {
	    const item = items[index];

	    if (
	      item.type === 'element' &&
	      item.tagName === 'li' &&
	      item.properties &&
	      Array.isArray(item.properties.className) &&
	      item.properties.className.includes('task-list-item')
	    ) {
	      props.className = ['contains-task-list'];
	      break
	    }
	  }

	  return h(node, name, props, wrap$1(items, true))
	}

	/**
	 * @typedef {import('mdast').Paragraph} Paragraph
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {Paragraph} node
	 */
	function paragraph(h, node) {
	  return h(node, 'p', all(h, node))
	}

	/**
	 * @typedef {import('mdast').Root} Root
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {Root} node
	 */
	function root(h, node) {
	  // @ts-expect-error `root`s are also fine.
	  return h.augment(node, u('root', wrap$1(all(h, node))))
	}

	/**
	 * @typedef {import('mdast').Strong} Strong
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {Strong} node
	 */
	function strong(h, node) {
	  return h(node, 'strong', all(h, node))
	}

	/**
	 * @typedef {import('mdast').Table} Table
	 * @typedef {import('mdast').TableCell} TableCell
	 * @typedef {import('hast').Element} Element
	 * @typedef {import('../index.js').Handler} Handler
	 * @typedef {import('../index.js').Content} Content
	 */


	/**
	 * @type {Handler}
	 * @param {Table} node
	 */
	function table(h, node) {
	  const rows = node.children;
	  let index = -1;
	  const align = node.align || [];
	  /** @type {Array<Element>} */
	  const result = [];

	  while (++index < rows.length) {
	    const row = rows[index].children;
	    const name = index === 0 ? 'th' : 'td';
	    /** @type {Array<Content>} */
	    const out = [];
	    let cellIndex = -1;
	    const length = node.align ? align.length : row.length;

	    while (++cellIndex < length) {
	      const cell = row[cellIndex];
	      out.push(
	        h(cell, name, {align: align[cellIndex]}, cell ? all(h, cell) : [])
	      );
	    }

	    result[index] = h(rows[index], 'tr', wrap$1(out, true));
	  }

	  return h(
	    node,
	    'table',
	    wrap$1(
	      [h(result[0].position, 'thead', wrap$1([result[0]], true))].concat(
	        result[1]
	          ? h(
	              {
	                start: pointStart(result[1]),
	                end: pointEnd(result[result.length - 1])
	              },
	              'tbody',
	              wrap$1(result.slice(1), true)
	            )
	          : []
	      ),
	      true
	    )
	  )
	}

	/**
	 * @typedef {import('mdast').Text} Text
	 * @typedef {import('../index.js').Handler} Handler
	 */


	/**
	 * @type {Handler}
	 * @param {Text} node
	 */
	function text(h, node) {
	  return h.augment(
	    node,
	    u('text', String(node.value).replace(/[ \t]*(\r?\n|\r)[ \t]*/g, '$1'))
	  )
	}

	/**
	 * @typedef {import('mdast').ThematicBreak} ThematicBreak
	 * @typedef {import('hast').Element} Element
	 * @typedef {import('../index.js').Handler} Handler
	 */

	/**
	 * @type {Handler}
	 * @param {ThematicBreak} [node]
	 * @returns {Element}
	 */
	function thematicBreak(h, node) {
	  return h(node, 'hr')
	}

	const handlers = {
	  blockquote,
	  break: hardBreak,
	  code,
	  delete: strikethrough,
	  emphasis,
	  footnoteReference,
	  footnote,
	  heading,
	  html,
	  imageReference,
	  image,
	  inlineCode,
	  linkReference,
	  link,
	  listItem,
	  list,
	  paragraph,
	  root,
	  strong,
	  table,
	  text,
	  thematicBreak,
	  toml: ignore,
	  yaml: ignore,
	  definition: ignore,
	  footnoteDefinition: ignore
	};

	// Return nothing for nodes that are ignored.
	function ignore() {
	  return null
	}

	/**
	 * @typedef {import('mdast').Root|import('mdast').Parent['children'][number]} MdastNode
	 * @typedef {import('hast').Root|import('hast').Parent['children'][number]} HastNode
	 * @typedef {import('mdast').Parent} Parent
	 * @typedef {import('mdast').Definition} Definition
	 * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition
	 * @typedef {import('hast').Properties} Properties
	 * @typedef {import('hast').Text} Text
	 * @typedef {import('hast').Comment} Comment
	 * @typedef {import('hast').Element} Element
	 * @typedef {import('hast').Root} Root
	 * @typedef {import('hast').ElementContent} Content
	 * @typedef {import('unist-util-position').PositionLike} PositionLike
	 *
	 * @typedef EmbeddedHastFields
	 * @property {string} [hName] Defines the tag name of an element
	 * @property {Properties} [hProperties] Defines the properties of an element
	 * @property {Array<Content>} [hChildren] Defines the (hast) children of an element
	 *
	 * @typedef {Record<string, unknown> & EmbeddedHastFields} Data unist data with embedded hast fields
	 *
	 * @typedef {MdastNode & {data?: Data}} NodeWithData unist node with embedded hast data
	 *
	 * @callback Handler
	 * @param {H} h Handle context
	 * @param {any} node mdast node to handle
	 * @param {Parent|null} parent Parent of `node`
	 * @returns {Content|Array<Content>|null|undefined} hast node
	 *
	 * @callback HFunctionProps
	 * @param {MdastNode|PositionLike|null|undefined} node mdast node or unist position
	 * @param {string} tagName HTML tag name
	 * @param {Properties} props Properties
	 * @param {Array<Content>?} [children] hast content
	 * @returns {Element}
	 *
	 * @callback HFunctionNoProps
	 * @param {MdastNode|PositionLike|null|undefined} node mdast node or unist position
	 * @param {string} tagName HTML tag name
	 * @param {Array<Content>?} [children] hast content
	 * @returns {Element}
	 *
	 * @typedef HFields
	 * @property {boolean} dangerous Whether HTML is allowed
	 * @property {string} clobberPrefix Prefix to use to prevent DOM clobbering
	 * @property {string} footnoteLabel Label to use to introduce the footnote section
	 * @property {string} footnoteBackLabel Label to use to go back to a footnote call from the footnote section
	 * @property {(identifier: string) => Definition|null} definition Definition cache
	 * @property {Record<string, FootnoteDefinition>} footnoteById Footnote cache
	 * @property {Array<string>} footnoteOrder Order in which footnotes occur
	 * @property {Record<string, number>} footnoteCounts Counts the same footnote was used
	 * @property {Handlers} handlers Applied handlers
	 * @property {Handler} unknownHandler Handler for any none not in `passThrough` or otherwise handled
	 * @property {(left: NodeWithData|PositionLike|null|undefined, right: Content) => Content} augment Like `h` but lower-level and usable on non-elements.
	 * @property {Array<string>} passThrough List of node types to pass through untouched (except for their children).
	 *
	 * @typedef Options
	 * @property {boolean} [allowDangerousHtml=false]
	 *   Whether to allow `html` nodes and inject them as `raw` HTML
	 * @property {string} [clobberPrefix='user-content-']
	 *   Prefix to use before the `id` attribute to prevent it from *clobbering*.
	 *   attributes.
	 *   DOM clobbering is this:
	 *
	 *   ```html
	 *   <p id=x></p>
	 *   <script>alert(x)</script>
	 *   ```
	 *
	 *   Elements by their ID are made available in browsers on the `window` object.
	 *   Using a prefix prevents this from being a problem.
	 * @property {string} [footnoteLabel='Footnotes']
	 *   Label to use for the footnotes section.
	 *   Affects screen reader users.
	 *   Change it if you’re authoring in a different language.
	 * @property {string} [footnoteBackLabel='Back to content']
	 *   Label to use from backreferences back to their footnote call.
	 *   Affects screen reader users.
	 *   Change it if you’re authoring in a different language.
	 * @property {Handlers} [handlers]
	 *   Object mapping mdast nodes to functions handling them
	 * @property {Array<string>} [passThrough]
	 *   List of custom mdast node types to pass through (keep) in hast
	 * @property {Handler} [unknownHandler]
	 *   Handler for all unknown nodes.
	 *
	 * @typedef {Record<string, Handler>} Handlers
	 *   Map of node types to handlers
	 * @typedef {HFunctionProps & HFunctionNoProps & HFields} H
	 *   Handle context
	 */


	const own$1 = {}.hasOwnProperty;

	/**
	 * Factory to transform.
	 * @param {MdastNode} tree mdast node
	 * @param {Options} [options] Configuration
	 * @returns {H} `h` function
	 */
	function factory(tree, options) {
	  const settings = options || {};
	  const dangerous = settings.allowDangerousHtml || false;
	  /** @type {Record<string, FootnoteDefinition>} */
	  const footnoteById = {};

	  h.dangerous = dangerous;
	  h.clobberPrefix =
	    settings.clobberPrefix === undefined || settings.clobberPrefix === null
	      ? 'user-content-'
	      : settings.clobberPrefix;
	  h.footnoteLabel = settings.footnoteLabel || 'Footnotes';
	  h.footnoteBackLabel = settings.footnoteBackLabel || 'Back to content';
	  h.definition = definitions(tree);
	  h.footnoteById = footnoteById;
	  /** @type {Array<string>} */
	  h.footnoteOrder = [];
	  /** @type {Record<string, number>} */
	  h.footnoteCounts = {};
	  h.augment = augment;
	  h.handlers = {...handlers, ...settings.handlers};
	  h.unknownHandler = settings.unknownHandler;
	  h.passThrough = settings.passThrough;

	  visit$2(tree, 'footnoteDefinition', (definition) => {
	    const id = String(definition.identifier).toUpperCase();

	    // Mimick CM behavior of link definitions.
	    // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/8290999/index.js#L26>.
	    if (!own$1.call(footnoteById, id)) {
	      footnoteById[id] = definition;
	    }
	  });

	  // @ts-expect-error Hush, it’s fine!
	  return h

	  /**
	   * Finalise the created `right`, a hast node, from `left`, an mdast node.
	   * @param {(NodeWithData|PositionLike)?} left
	   * @param {Content} right
	   * @returns {Content}
	   */
	  function augment(left, right) {
	    // Handle `data.hName`, `data.hProperties, `data.hChildren`.
	    if (left && 'data' in left && left.data) {
	      /** @type {Data} */
	      const data = left.data;

	      if (data.hName) {
	        if (right.type !== 'element') {
	          right = {
	            type: 'element',
	            tagName: '',
	            properties: {},
	            children: []
	          };
	        }

	        right.tagName = data.hName;
	      }

	      if (right.type === 'element' && data.hProperties) {
	        right.properties = {...right.properties, ...data.hProperties};
	      }

	      if ('children' in right && right.children && data.hChildren) {
	        right.children = data.hChildren;
	      }
	    }

	    if (left) {
	      const ctx = 'type' in left ? left : {position: left};

	      if (!generated(ctx)) {
	        right.position = {start: pointStart(ctx), end: pointEnd(ctx)};
	      }
	    }

	    return right
	  }

	  /**
	   * Create an element for `node`.
	   *
	   * @type {HFunctionProps}
	   */
	  function h(node, tagName, props, children) {
	    if (Array.isArray(props)) {
	      children = props;
	      props = {};
	    }

	    // @ts-expect-error augmenting an element yields an element.
	    return augment(node, {
	      type: 'element',
	      tagName,
	      properties: props || {},
	      children: children || []
	    })
	  }
	}

	/**
	 * Transform `tree` (an mdast node) to a hast node.
	 *
	 * @param {MdastNode} tree mdast node
	 * @param {Options} [options] Configuration
	 * @returns {HastNode|null|undefined} hast node
	 */
	function toHast(tree, options) {
	  const h = factory(tree, options);
	  const node = one(h, tree, null);
	  const foot = footer(h);

	  if (foot) {
	    // @ts-expect-error If there’s a footer, there were definitions, meaning block
	    // content.
	    // So assume `node` is a parent node.
	    node.children.push(u('text', '\n'), foot);
	  }

	  return Array.isArray(node) ? {type: 'root', children: node} : node
	}

	/**
	 * @typedef {import('hast').Root} HastRoot
	 * @typedef {import('mdast').Root} MdastRoot
	 * @typedef {import('mdast-util-to-hast').Options} Options
	 * @typedef {import('unified').Processor<any, any, any, any>} Processor
	 *
	 * @typedef {import('mdast-util-to-hast')} DoNotTouchAsThisImportIncludesRawInTree
	 */


	// Note: the `<MdastRoot, HastRoot>` overload doesn’t seem to work :'(

	/**
	 * Plugin that turns markdown into HTML to support rehype.
	 *
	 * *   If a destination processor is given, that processor runs with a new HTML
	 *     (hast) tree (bridge-mode).
	 *     As the given processor runs with a hast tree, and rehype plugins support
	 *     hast, that means rehype plugins can be used with the given processor.
	 *     The hast tree is discarded in the end.
	 *     It’s highly unlikely that you want to do this.
	 * *   The common case is to not pass a destination processor, in which case the
	 *     current processor continues running with a new HTML (hast) tree
	 *     (mutate-mode).
	 *     As the current processor continues with a hast tree, and rehype plugins
	 *     support hast, that means rehype plugins can be used after
	 *     `remark-rehype`.
	 *     It’s likely that this is what you want to do.
	 *
	 * @param destination
	 *   Optional unified processor.
	 * @param options
	 *   Options passed to `mdast-util-to-hast`.
	 */
	const remarkRehype =
	  /** @type {(import('unified').Plugin<[Processor, Options?]|[null|undefined, Options?]|[Options]|[], MdastRoot>)} */
	  (
	    function (destination, options) {
	      return destination && 'run' in destination
	        ? bridge(destination, options)
	        : mutate(destination || options)
	    }
	  );

	/**
	 * Bridge-mode.
	 * Runs the destination with the new hast tree.
	 *
	 * @type {import('unified').Plugin<[Processor, Options?], MdastRoot>}
	 */
	function bridge(destination, options) {
	  return (node, file, next) => {
	    destination.run(toHast(node, options), file, (error) => {
	      next(error);
	    });
	  }
	}

	/**
	 * Mutate-mode.
	 * Further plugins run on the hast tree.
	 *
	 * @type {import('unified').Plugin<[Options?]|void[], MdastRoot, HastRoot>}
	 */
	function mutate(options) {
	  // @ts-expect-error: assume a corresponding node is returned by `toHast`.
	  return (node) => toHast(node, options)
	}

	/**
	 * Throw a given error.
	 *
	 * @param {Error|null|undefined} [error]
	 *   Maybe error.
	 * @returns {asserts error is null|undefined}
	 */
	function bail(error) {
	  if (error) {
	    throw error
	  }
	}

	/*!
	 * Determine if an object is a Buffer
	 *
	 * @author   Feross Aboukhadijeh <https://feross.org>
	 * @license  MIT
	 */

	var isBuffer = function isBuffer (obj) {
	  return obj != null && obj.constructor != null &&
	    typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
	};

	var isBuffer$1 = /*@__PURE__*/getDefaultExportFromCjs(isBuffer);

	function isPlainObject$1(value) {
		if (Object.prototype.toString.call(value) !== '[object Object]') {
			return false;
		}

		const prototype = Object.getPrototypeOf(value);
		return prototype === null || prototype === Object.prototype;
	}

	/**
	 * @typedef {(error?: Error|null|undefined, ...output: Array<any>) => void} Callback
	 * @typedef {(...input: Array<any>) => any} Middleware
	 *
	 * @typedef {(...input: Array<any>) => void} Run
	 *   Call all middleware.
	 * @typedef {(fn: Middleware) => Pipeline} Use
	 *   Add `fn` (middleware) to the list.
	 * @typedef {{run: Run, use: Use}} Pipeline
	 *   Middleware.
	 */

	/**
	 * Create new middleware.
	 *
	 * @returns {Pipeline}
	 */
	function trough() {
	  /** @type {Array<Middleware>} */
	  const fns = [];
	  /** @type {Pipeline} */
	  const pipeline = {run, use};

	  return pipeline

	  /** @type {Run} */
	  function run(...values) {
	    let middlewareIndex = -1;
	    /** @type {Callback} */
	    const callback = values.pop();

	    if (typeof callback !== 'function') {
	      throw new TypeError('Expected function as last argument, not ' + callback)
	    }

	    next(null, ...values);

	    /**
	     * Run the next `fn`, or we’re done.
	     *
	     * @param {Error|null|undefined} error
	     * @param {Array<any>} output
	     */
	    function next(error, ...output) {
	      const fn = fns[++middlewareIndex];
	      let index = -1;

	      if (error) {
	        callback(error);
	        return
	      }

	      // Copy non-nullish input into values.
	      while (++index < values.length) {
	        if (output[index] === null || output[index] === undefined) {
	          output[index] = values[index];
	        }
	      }

	      // Save the newly created `output` for the next call.
	      values = output;

	      // Next or done.
	      if (fn) {
	        wrap(fn, next)(...output);
	      } else {
	        callback(null, ...output);
	      }
	    }
	  }

	  /** @type {Use} */
	  function use(middelware) {
	    if (typeof middelware !== 'function') {
	      throw new TypeError(
	        'Expected `middelware` to be a function, not ' + middelware
	      )
	    }

	    fns.push(middelware);
	    return pipeline
	  }
	}

	/**
	 * Wrap `middleware`.
	 * Can be sync or async; return a promise, receive a callback, or return new
	 * values and errors.
	 *
	 * @param {Middleware} middleware
	 * @param {Callback} callback
	 */
	function wrap(middleware, callback) {
	  /** @type {boolean} */
	  let called;

	  return wrapped

	  /**
	   * Call `middleware`.
	   * @this {any}
	   * @param {Array<any>} parameters
	   * @returns {void}
	   */
	  function wrapped(...parameters) {
	    const fnExpectsCallback = middleware.length > parameters.length;
	    /** @type {any} */
	    let result;

	    if (fnExpectsCallback) {
	      parameters.push(done);
	    }

	    try {
	      result = middleware.apply(this, parameters);
	    } catch (error) {
	      const exception = /** @type {Error} */ (error);

	      // Well, this is quite the pickle.
	      // `middleware` received a callback and called it synchronously, but that
	      // threw an error.
	      // The only thing left to do is to throw the thing instead.
	      if (fnExpectsCallback && called) {
	        throw exception
	      }

	      return done(exception)
	    }

	    if (!fnExpectsCallback) {
	      if (result instanceof Promise) {
	        result.then(then, done);
	      } else if (result instanceof Error) {
	        done(result);
	      } else {
	        then(result);
	      }
	    }
	  }

	  /**
	   * Call `callback`, only once.
	   * @type {Callback}
	   */
	  function done(error, ...output) {
	    if (!called) {
	      called = true;
	      callback(error, ...output);
	    }
	  }

	  /**
	   * Call `done` with one value.
	   *
	   * @param {any} [value]
	   */
	  function then(value) {
	    done(null, value);
	  }
	}

	/**
	 * @typedef {import('unist').Node} Node
	 * @typedef {import('unist').Position} Position
	 * @typedef {import('unist').Point} Point
	 * @typedef {object & {type: string, position?: Position|undefined}} NodeLike
	 */


	class VFileMessage extends Error {
	  /**
	   * Create a message for `reason` at `place` from `origin`.
	   *
	   * When an error is passed in as `reason`, the `stack` is copied.
	   *
	   * @param {string|Error|VFileMessage} reason
	   *   Reason for message.
	   *   Uses the stack and message of the error if given.
	   * @param {Node|NodeLike|Position|Point} [place]
	   *   Place at which the message occurred in a file.
	   * @param {string} [origin]
	   *   Place in code the message originates from (example `'my-package:my-rule-name'`)
	   */
	  constructor(reason, place, origin) {
	    /** @type {[string|null, string|null]} */
	    const parts = [null, null];
	    /** @type {Position} */
	    let position = {
	      // @ts-expect-error: we always follows the structure of `position`.
	      start: {line: null, column: null},
	      // @ts-expect-error: "
	      end: {line: null, column: null}
	    };

	    super();

	    if (typeof place === 'string') {
	      origin = place;
	      place = undefined;
	    }

	    if (typeof origin === 'string') {
	      const index = origin.indexOf(':');

	      if (index === -1) {
	        parts[1] = origin;
	      } else {
	        parts[0] = origin.slice(0, index);
	        parts[1] = origin.slice(index + 1);
	      }
	    }

	    if (place) {
	      // Node.
	      if ('type' in place || 'position' in place) {
	        if (place.position) {
	          // @ts-expect-error: looks like a position.
	          position = place.position;
	        }
	      }
	      // Position.
	      else if ('start' in place || 'end' in place) {
	        // @ts-expect-error: looks like a position.
	        position = place;
	      }
	      // Point.
	      else if ('line' in place || 'column' in place) {
	        position.start = place;
	      }
	    }

	    // Fields from `Error`
	    this.name = stringifyPosition(place) || '1:1';
	    /** @type {string} */
	    this.message = typeof reason === 'object' ? reason.message : reason;
	    /** @type {string} */
	    this.stack = '';

	    if (typeof reason === 'object' && reason.stack) {
	      this.stack = reason.stack;
	    }

	    /**
	     * Reason for message.
	     *
	     * @type {string}
	     */
	    this.reason = this.message;

	    /* eslint-disable no-unused-expressions */
	    /**
	     * Whether this is a fatal problem that marks an associated file as no
	     * longer processable.
	     * If `true`, marks associated file as no longer processable.
	     * If `false`, necessitates a (potential) change.
	     * The value can also be `null` or `undefined`, for things that might not
	     * need changing.
	     *
	     * @type {boolean?}
	     */
	    this.fatal;

	    /**
	     * Starting line of error.
	     *
	     * @type {number?}
	     */
	    this.line = position.start.line;

	    /**
	     * Starting column of error.
	     *
	     * @type {number?}
	     */
	    this.column = position.start.column;

	    /**
	     * Full range information, when available.
	     * Has `start` and `end` fields, both set to an object with `line` and
	     * `column`, set to `number?`.
	     *
	     * @type {Position?}
	     */
	    this.position = position;

	    /**
	     * Namespace of warning (example: `'my-package'`).
	     *
	     * @type {string?}
	     */
	    this.source = parts[0];

	    /**
	     * Category of message (example: `'my-rule-name'`).
	     *
	     * @type {string?}
	     */
	    this.ruleId = parts[1];

	    /**
	     * Path of a file (used throughout the VFile ecosystem).
	     *
	     * @type {string?}
	     */
	    this.file;

	    // The following fields are “well known”.
	    // Not standard.
	    // Feel free to add other non-standard fields to your messages.

	    /**
	     * Specify the source value that’s being reported, which is deemed
	     * incorrect.
	     *
	     * @type {string?}
	     */
	    this.actual;

	    /**
	     * Suggest values that should be used instead of `actual`, one or more
	     * values that are deemed as acceptable.
	     *
	     * @type {Array<string>?}
	     */
	    this.expected;

	    /**
	     * Link to documentation for the message.
	     *
	     * @type {string?}
	     */
	    this.url;

	    /**
	     * Long form description of the message (supported by `vfile-reporter`).
	     *
	     * @type {string?}
	     */
	    this.note;
	    /* eslint-enable no-unused-expressions */
	  }
	}

	VFileMessage.prototype.file = '';
	VFileMessage.prototype.name = '';
	VFileMessage.prototype.reason = '';
	VFileMessage.prototype.message = '';
	VFileMessage.prototype.stack = '';
	VFileMessage.prototype.fatal = null;
	VFileMessage.prototype.column = null;
	VFileMessage.prototype.line = null;
	VFileMessage.prototype.source = null;
	VFileMessage.prototype.ruleId = null;
	VFileMessage.prototype.position = null;

	// A derivative work based on:
	// <https://github.com/browserify/path-browserify>.
	// Which is licensed:
	//
	// MIT License
	//
	// Copyright (c) 2013 James Halliday
	//
	// Permission is hereby granted, free of charge, to any person obtaining a copy of
	// this software and associated documentation files (the "Software"), to deal in
	// the Software without restriction, including without limitation the rights to
	// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
	// the Software, and to permit persons to whom the Software is furnished to do so,
	// subject to the following conditions:
	//
	// The above copyright notice and this permission notice shall be included in all
	// copies or substantial portions of the Software.
	//
	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
	// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
	// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
	// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	// A derivative work based on:
	//
	// Parts of that are extracted from Node’s internal `path` module:
	// <https://github.com/nodejs/node/blob/master/lib/path.js>.
	// Which is licensed:
	//
	// Copyright Joyent, Inc. and other Node contributors.
	//
	// Permission is hereby granted, free of charge, to any person obtaining a
	// copy of this software and associated documentation files (the
	// "Software"), to deal in the Software without restriction, including
	// without limitation the rights to use, copy, modify, merge, publish,
	// distribute, sublicense, and/or sell copies of the Software, and to permit
	// persons to whom the Software is furnished to do so, subject to the
	// following conditions:
	//
	// The above copyright notice and this permission notice shall be included
	// in all copies or substantial portions of the Software.
	//
	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
	// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
	// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
	// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
	// USE OR OTHER DEALINGS IN THE SOFTWARE.

	const path = {basename, dirname, extname, join, sep: '/'};

	/* eslint-disable max-depth, complexity */

	/**
	 * @param {string} path
	 * @param {string} [ext]
	 * @returns {string}
	 */
	function basename(path, ext) {
	  if (ext !== undefined && typeof ext !== 'string') {
	    throw new TypeError('"ext" argument must be a string')
	  }

	  assertPath$1(path);
	  let start = 0;
	  let end = -1;
	  let index = path.length;
	  /** @type {boolean|undefined} */
	  let seenNonSlash;

	  if (ext === undefined || ext.length === 0 || ext.length > path.length) {
	    while (index--) {
	      if (path.charCodeAt(index) === 47 /* `/` */) {
	        // If we reached a path separator that was not part of a set of path
	        // separators at the end of the string, stop now.
	        if (seenNonSlash) {
	          start = index + 1;
	          break
	        }
	      } else if (end < 0) {
	        // We saw the first non-path separator, mark this as the end of our
	        // path component.
	        seenNonSlash = true;
	        end = index + 1;
	      }
	    }

	    return end < 0 ? '' : path.slice(start, end)
	  }

	  if (ext === path) {
	    return ''
	  }

	  let firstNonSlashEnd = -1;
	  let extIndex = ext.length - 1;

	  while (index--) {
	    if (path.charCodeAt(index) === 47 /* `/` */) {
	      // If we reached a path separator that was not part of a set of path
	      // separators at the end of the string, stop now.
	      if (seenNonSlash) {
	        start = index + 1;
	        break
	      }
	    } else {
	      if (firstNonSlashEnd < 0) {
	        // We saw the first non-path separator, remember this index in case
	        // we need it if the extension ends up not matching.
	        seenNonSlash = true;
	        firstNonSlashEnd = index + 1;
	      }

	      if (extIndex > -1) {
	        // Try to match the explicit extension.
	        if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {
	          if (extIndex < 0) {
	            // We matched the extension, so mark this as the end of our path
	            // component
	            end = index;
	          }
	        } else {
	          // Extension does not match, so our result is the entire path
	          // component
	          extIndex = -1;
	          end = firstNonSlashEnd;
	        }
	      }
	    }
	  }

	  if (start === end) {
	    end = firstNonSlashEnd;
	  } else if (end < 0) {
	    end = path.length;
	  }

	  return path.slice(start, end)
	}

	/**
	 * @param {string} path
	 * @returns {string}
	 */
	function dirname(path) {
	  assertPath$1(path);

	  if (path.length === 0) {
	    return '.'
	  }

	  let end = -1;
	  let index = path.length;
	  /** @type {boolean|undefined} */
	  let unmatchedSlash;

	  // Prefix `--` is important to not run on `0`.
	  while (--index) {
	    if (path.charCodeAt(index) === 47 /* `/` */) {
	      if (unmatchedSlash) {
	        end = index;
	        break
	      }
	    } else if (!unmatchedSlash) {
	      // We saw the first non-path separator
	      unmatchedSlash = true;
	    }
	  }

	  return end < 0
	    ? path.charCodeAt(0) === 47 /* `/` */
	      ? '/'
	      : '.'
	    : end === 1 && path.charCodeAt(0) === 47 /* `/` */
	    ? '//'
	    : path.slice(0, end)
	}

	/**
	 * @param {string} path
	 * @returns {string}
	 */
	function extname(path) {
	  assertPath$1(path);

	  let index = path.length;

	  let end = -1;
	  let startPart = 0;
	  let startDot = -1;
	  // Track the state of characters (if any) we see before our first dot and
	  // after any path separator we find.
	  let preDotState = 0;
	  /** @type {boolean|undefined} */
	  let unmatchedSlash;

	  while (index--) {
	    const code = path.charCodeAt(index);

	    if (code === 47 /* `/` */) {
	      // If we reached a path separator that was not part of a set of path
	      // separators at the end of the string, stop now.
	      if (unmatchedSlash) {
	        startPart = index + 1;
	        break
	      }

	      continue
	    }

	    if (end < 0) {
	      // We saw the first non-path separator, mark this as the end of our
	      // extension.
	      unmatchedSlash = true;
	      end = index + 1;
	    }

	    if (code === 46 /* `.` */) {
	      // If this is our first dot, mark it as the start of our extension.
	      if (startDot < 0) {
	        startDot = index;
	      } else if (preDotState !== 1) {
	        preDotState = 1;
	      }
	    } else if (startDot > -1) {
	      // We saw a non-dot and non-path separator before our dot, so we should
	      // have a good chance at having a non-empty extension.
	      preDotState = -1;
	    }
	  }

	  if (
	    startDot < 0 ||
	    end < 0 ||
	    // We saw a non-dot character immediately before the dot.
	    preDotState === 0 ||
	    // The (right-most) trimmed path component is exactly `..`.
	    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
	  ) {
	    return ''
	  }

	  return path.slice(startDot, end)
	}

	/**
	 * @param {Array<string>} segments
	 * @returns {string}
	 */
	function join(...segments) {
	  let index = -1;
	  /** @type {string|undefined} */
	  let joined;

	  while (++index < segments.length) {
	    assertPath$1(segments[index]);

	    if (segments[index]) {
	      joined =
	        joined === undefined ? segments[index] : joined + '/' + segments[index];
	    }
	  }

	  return joined === undefined ? '.' : normalize(joined)
	}

	/**
	 * Note: `normalize` is not exposed as `path.normalize`, so some code is
	 * manually removed from it.
	 *
	 * @param {string} path
	 * @returns {string}
	 */
	function normalize(path) {
	  assertPath$1(path);

	  const absolute = path.charCodeAt(0) === 47; /* `/` */

	  // Normalize the path according to POSIX rules.
	  let value = normalizeString(path, !absolute);

	  if (value.length === 0 && !absolute) {
	    value = '.';
	  }

	  if (value.length > 0 && path.charCodeAt(path.length - 1) === 47 /* / */) {
	    value += '/';
	  }

	  return absolute ? '/' + value : value
	}

	/**
	 * Resolve `.` and `..` elements in a path with directory names.
	 *
	 * @param {string} path
	 * @param {boolean} allowAboveRoot
	 * @returns {string}
	 */
	function normalizeString(path, allowAboveRoot) {
	  let result = '';
	  let lastSegmentLength = 0;
	  let lastSlash = -1;
	  let dots = 0;
	  let index = -1;
	  /** @type {number|undefined} */
	  let code;
	  /** @type {number} */
	  let lastSlashIndex;

	  while (++index <= path.length) {
	    if (index < path.length) {
	      code = path.charCodeAt(index);
	    } else if (code === 47 /* `/` */) {
	      break
	    } else {
	      code = 47; /* `/` */
	    }

	    if (code === 47 /* `/` */) {
	      if (lastSlash === index - 1 || dots === 1) ; else if (lastSlash !== index - 1 && dots === 2) {
	        if (
	          result.length < 2 ||
	          lastSegmentLength !== 2 ||
	          result.charCodeAt(result.length - 1) !== 46 /* `.` */ ||
	          result.charCodeAt(result.length - 2) !== 46 /* `.` */
	        ) {
	          if (result.length > 2) {
	            lastSlashIndex = result.lastIndexOf('/');

	            if (lastSlashIndex !== result.length - 1) {
	              if (lastSlashIndex < 0) {
	                result = '';
	                lastSegmentLength = 0;
	              } else {
	                result = result.slice(0, lastSlashIndex);
	                lastSegmentLength = result.length - 1 - result.lastIndexOf('/');
	              }

	              lastSlash = index;
	              dots = 0;
	              continue
	            }
	          } else if (result.length > 0) {
	            result = '';
	            lastSegmentLength = 0;
	            lastSlash = index;
	            dots = 0;
	            continue
	          }
	        }

	        if (allowAboveRoot) {
	          result = result.length > 0 ? result + '/..' : '..';
	          lastSegmentLength = 2;
	        }
	      } else {
	        if (result.length > 0) {
	          result += '/' + path.slice(lastSlash + 1, index);
	        } else {
	          result = path.slice(lastSlash + 1, index);
	        }

	        lastSegmentLength = index - lastSlash - 1;
	      }

	      lastSlash = index;
	      dots = 0;
	    } else if (code === 46 /* `.` */ && dots > -1) {
	      dots++;
	    } else {
	      dots = -1;
	    }
	  }

	  return result
	}

	/**
	 * @param {string} path
	 */
	function assertPath$1(path) {
	  if (typeof path !== 'string') {
	    throw new TypeError(
	      'Path must be a string. Received ' + JSON.stringify(path)
	    )
	  }
	}

	/* eslint-enable max-depth, complexity */

	// Somewhat based on:
	// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.
	// But I don’t think one tiny line of code can be copyrighted. 😅
	const proc = {cwd};

	function cwd() {
	  return '/'
	}

	/**
	 * @typedef URL
	 * @property {string} hash
	 * @property {string} host
	 * @property {string} hostname
	 * @property {string} href
	 * @property {string} origin
	 * @property {string} password
	 * @property {string} pathname
	 * @property {string} port
	 * @property {string} protocol
	 * @property {string} search
	 * @property {any} searchParams
	 * @property {string} username
	 * @property {() => string} toString
	 * @property {() => string} toJSON
	 */

	/**
	 * @param {unknown} fileURLOrPath
	 * @returns {fileURLOrPath is URL}
	 */
	// From: <https://github.com/nodejs/node/blob/fcf8ba4/lib/internal/url.js#L1501>
	function isUrl(fileURLOrPath) {
	  return (
	    fileURLOrPath !== null &&
	    typeof fileURLOrPath === 'object' &&
	    // @ts-expect-error: indexable.
	    fileURLOrPath.href &&
	    // @ts-expect-error: indexable.
	    fileURLOrPath.origin
	  )
	}

	/// <reference lib="dom" />


	// See: <https://github.com/nodejs/node/blob/fcf8ba4/lib/internal/url.js>

	/**
	 * @param {string|URL} path
	 */
	function urlToPath(path) {
	  if (typeof path === 'string') {
	    path = new URL(path);
	  } else if (!isUrl(path)) {
	    /** @type {NodeJS.ErrnoException} */
	    const error = new TypeError(
	      'The "path" argument must be of type string or an instance of URL. Received `' +
	        path +
	        '`'
	    );
	    error.code = 'ERR_INVALID_ARG_TYPE';
	    throw error
	  }

	  if (path.protocol !== 'file:') {
	    /** @type {NodeJS.ErrnoException} */
	    const error = new TypeError('The URL must be of scheme file');
	    error.code = 'ERR_INVALID_URL_SCHEME';
	    throw error
	  }

	  return getPathFromURLPosix(path)
	}

	/**
	 * @param {URL} url
	 */
	function getPathFromURLPosix(url) {
	  if (url.hostname !== '') {
	    /** @type {NodeJS.ErrnoException} */
	    const error = new TypeError(
	      'File URL host must be "localhost" or empty on darwin'
	    );
	    error.code = 'ERR_INVALID_FILE_URL_HOST';
	    throw error
	  }

	  const pathname = url.pathname;
	  let index = -1;

	  while (++index < pathname.length) {
	    if (
	      pathname.charCodeAt(index) === 37 /* `%` */ &&
	      pathname.charCodeAt(index + 1) === 50 /* `2` */
	    ) {
	      const third = pathname.charCodeAt(index + 2);
	      if (third === 70 /* `F` */ || third === 102 /* `f` */) {
	        /** @type {NodeJS.ErrnoException} */
	        const error = new TypeError(
	          'File URL path must not include encoded / characters'
	        );
	        error.code = 'ERR_INVALID_FILE_URL_PATH';
	        throw error
	      }
	    }
	  }

	  return decodeURIComponent(pathname)
	}

	/**
	 * @typedef {import('unist').Node} Node
	 * @typedef {import('unist').Position} Position
	 * @typedef {import('unist').Point} Point
	 * @typedef {Record<string, unknown> & {type: string, position?: Position|undefined}} NodeLike
	 * @typedef {import('./minurl.shared.js').URL} URL
	 * @typedef {import('..').VFileData} VFileData
	 * @typedef {import('..').VFileValue} VFileValue
	 *
	 * @typedef {'ascii'|'utf8'|'utf-8'|'utf16le'|'ucs2'|'ucs-2'|'base64'|'base64url'|'latin1'|'binary'|'hex'} BufferEncoding
	 *   Encodings supported by the buffer class.
	 *   This is a copy of the typing from Node, copied to prevent Node globals from
	 *   being needed.
	 *   Copied from: <https://github.com/DefinitelyTyped/DefinitelyTyped/blob/90a4ec8/types/node/buffer.d.ts#L170>
	 *
	 * @typedef {VFileValue|VFileOptions|VFile|URL} VFileCompatible
	 *   Things that can be passed to the constructor.
	 *
	 * @typedef VFileCoreOptions
	 * @property {VFileValue} [value]
	 * @property {string} [cwd]
	 * @property {Array<string>} [history]
	 * @property {string|URL} [path]
	 * @property {string} [basename]
	 * @property {string} [stem]
	 * @property {string} [extname]
	 * @property {string} [dirname]
	 * @property {VFileData} [data]
	 *
	 * @typedef Map
	 *   Raw source map, see:
	 *   <https://github.com/mozilla/source-map/blob/58819f0/source-map.d.ts#L15-L23>.
	 * @property {number} version
	 * @property {Array<string>} sources
	 * @property {Array<string>} names
	 * @property {string|undefined} [sourceRoot]
	 * @property {Array<string>|undefined} [sourcesContent]
	 * @property {string} mappings
	 * @property {string} file
	 *
	 * @typedef {{[key: string]: unknown} & VFileCoreOptions} VFileOptions
	 *   Configuration: a bunch of keys that will be shallow copied over to the new
	 *   file.
	 *
	 * @typedef {Record<string, unknown>} VFileReporterSettings
	 * @typedef {<T = VFileReporterSettings>(files: Array<VFile>, options: T) => string} VFileReporter
	 */


	// Order of setting (least specific to most), we need this because otherwise
	// `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a
	// stem can be set.
	const order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];

	class VFile {
	  /**
	   * Create a new virtual file.
	   *
	   * If `options` is `string` or `Buffer`, treats it as `{value: options}`.
	   * If `options` is a `VFile`, shallow copies its data over to the new file.
	   * All other given fields are set on the newly created `VFile`.
	   *
	   * Path related properties are set in the following order (least specific to
	   * most specific): `history`, `path`, `basename`, `stem`, `extname`,
	   * `dirname`.
	   *
	   * It’s not possible to set either `dirname` or `extname` without setting
	   * either `history`, `path`, `basename`, or `stem` as well.
	   *
	   * @param {VFileCompatible} [value]
	   */
	  constructor(value) {
	    /** @type {VFileOptions} */
	    let options;

	    if (!value) {
	      options = {};
	    } else if (typeof value === 'string' || isBuffer$1(value)) {
	      // @ts-expect-error Looks like a buffer.
	      options = {value};
	    } else if (isUrl(value)) {
	      options = {path: value};
	    } else {
	      // @ts-expect-error Looks like file or options.
	      options = value;
	    }

	    /**
	     * Place to store custom information.
	     * It’s OK to store custom data directly on the file, moving it to `data`
	     * gives a little more privacy.
	     * @type {VFileData}
	     */
	    this.data = {};

	    /**
	     * List of messages associated with the file.
	     * @type {Array<VFileMessage>}
	     */
	    this.messages = [];

	    /**
	     * List of file paths the file moved between.
	     * @type {Array<string>}
	     */
	    this.history = [];

	    /**
	     * Base of `path`.
	     * Defaults to `process.cwd()` (`/` in browsers).
	     * @type {string}
	     */
	    this.cwd = proc.cwd();

	    /* eslint-disable no-unused-expressions */
	    /**
	     * Raw value.
	     * @type {VFileValue}
	     */
	    this.value;

	    // The below are non-standard, they are “well-known”.
	    // As in, used in several tools.

	    /**
	     * Whether a file was saved to disk.
	     * This is used by vfile reporters.
	     * @type {boolean}
	     */
	    this.stored;

	    /**
	     * Sometimes files have a non-string representation.
	     * This can be stored in the `result` field.
	     * One example is when turning markdown into React nodes.
	     * This is used by unified to store non-string results.
	     * @type {unknown}
	     */
	    this.result;

	    /**
	     * Sometimes files have a source map associated with them.
	     * This can be stored in the `map` field.
	     * This should be a `RawSourceMap` type from the `source-map` module.
	     * @type {Map|undefined}
	     */
	    this.map;
	    /* eslint-enable no-unused-expressions */

	    // Set path related properties in the correct order.
	    let index = -1;

	    while (++index < order.length) {
	      const prop = order[index];

	      // Note: we specifically use `in` instead of `hasOwnProperty` to accept
	      // `vfile`s too.
	      if (prop in options && options[prop] !== undefined) {
	        // @ts-expect-error: TS is confused by the different types for `history`.
	        this[prop] = prop === 'history' ? [...options[prop]] : options[prop];
	      }
	    }

	    /** @type {string} */
	    let prop;

	    // Set non-path related properties.
	    for (prop in options) {
	      // @ts-expect-error: fine to set other things.
	      if (!order.includes(prop)) this[prop] = options[prop];
	    }
	  }

	  /**
	   * Access full path (`~/index.min.js`).
	   *
	   * @returns {string}
	   */
	  get path() {
	    return this.history[this.history.length - 1]
	  }

	  /**
	   * Set full path (`~/index.min.js`).
	   * Cannot be nullified.
	   *
	   * @param {string|URL} path
	   */
	  set path(path) {
	    if (isUrl(path)) {
	      path = urlToPath(path);
	    }

	    assertNonEmpty(path, 'path');

	    if (this.path !== path) {
	      this.history.push(path);
	    }
	  }

	  /**
	   * Access parent path (`~`).
	   */
	  get dirname() {
	    return typeof this.path === 'string' ? path.dirname(this.path) : undefined
	  }

	  /**
	   * Set parent path (`~`).
	   * Cannot be set if there's no `path` yet.
	   */
	  set dirname(dirname) {
	    assertPath(this.basename, 'dirname');
	    this.path = path.join(dirname || '', this.basename);
	  }

	  /**
	   * Access basename (including extname) (`index.min.js`).
	   */
	  get basename() {
	    return typeof this.path === 'string' ? path.basename(this.path) : undefined
	  }

	  /**
	   * Set basename (`index.min.js`).
	   * Cannot contain path separators.
	   * Cannot be nullified either (use `file.path = file.dirname` instead).
	   */
	  set basename(basename) {
	    assertNonEmpty(basename, 'basename');
	    assertPart(basename, 'basename');
	    this.path = path.join(this.dirname || '', basename);
	  }

	  /**
	   * Access extname (including dot) (`.js`).
	   */
	  get extname() {
	    return typeof this.path === 'string' ? path.extname(this.path) : undefined
	  }

	  /**
	   * Set extname (including dot) (`.js`).
	   * Cannot be set if there's no `path` yet and cannot contain path separators.
	   */
	  set extname(extname) {
	    assertPart(extname, 'extname');
	    assertPath(this.dirname, 'extname');

	    if (extname) {
	      if (extname.charCodeAt(0) !== 46 /* `.` */) {
	        throw new Error('`extname` must start with `.`')
	      }

	      if (extname.includes('.', 1)) {
	        throw new Error('`extname` cannot contain multiple dots')
	      }
	    }

	    this.path = path.join(this.dirname, this.stem + (extname || ''));
	  }

	  /**
	   * Access stem (w/o extname) (`index.min`).
	   */
	  get stem() {
	    return typeof this.path === 'string'
	      ? path.basename(this.path, this.extname)
	      : undefined
	  }

	  /**
	   * Set stem (w/o extname) (`index.min`).
	   * Cannot be nullified, and cannot contain path separators.
	   */
	  set stem(stem) {
	    assertNonEmpty(stem, 'stem');
	    assertPart(stem, 'stem');
	    this.path = path.join(this.dirname || '', stem + (this.extname || ''));
	  }

	  /**
	   * Serialize the file.
	   *
	   * @param {BufferEncoding} [encoding='utf8'] If `file.value` is a buffer, `encoding` is used to serialize buffers.
	   * @returns {string}
	   */
	  toString(encoding) {
	    return (this.value || '').toString(encoding)
	  }

	  /**
	   * Create a message and associates it w/ the file.
	   *
	   * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.
	   * @param {Node|NodeLike|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).
	   * @param {string} [origin] Place in code the message originates from (`string`, optional).
	   * @returns {VFileMessage}
	   */
	  message(reason, place, origin) {
	    const message = new VFileMessage(reason, place, origin);

	    if (this.path) {
	      message.name = this.path + ':' + message.name;
	      message.file = this.path;
	    }

	    message.fatal = false;

	    this.messages.push(message);

	    return message
	  }

	  /**
	   * Info: create a message, associate it with the file, and mark the fatality
	   * as `null`.
	   * Calls `message()` internally.
	   *
	   * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.
	   * @param {Node|NodeLike|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).
	   * @param {string} [origin] Place in code the message originates from (`string`, optional).
	   * @returns {VFileMessage}
	   */
	  info(reason, place, origin) {
	    const message = this.message(reason, place, origin);

	    message.fatal = null;

	    return message
	  }

	  /**
	   * Fail: create a message, associate it with the file, mark the fatality as
	   * `true`.
	   * Note: fatal errors mean a file is no longer processable.
	   * Calls `message()` internally.
	   *
	   * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.
	   * @param {Node|NodeLike|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).
	   * @param {string} [origin] Place in code the message originates from (`string`, optional).
	   * @returns {never}
	   */
	  fail(reason, place, origin) {
	    const message = this.message(reason, place, origin);

	    message.fatal = true;

	    throw message
	  }
	}

	/**
	 * Assert that `part` is not a path (as in, does not contain `path.sep`).
	 *
	 * @param {string|undefined} part
	 * @param {string} name
	 * @returns {void}
	 */
	function assertPart(part, name) {
	  if (part && part.includes(path.sep)) {
	    throw new Error(
	      '`' + name + '` cannot be a path: did not expect `' + path.sep + '`'
	    )
	  }
	}

	/**
	 * Assert that `part` is not empty.
	 *
	 * @param {string|undefined} part
	 * @param {string} name
	 * @returns {asserts part is string}
	 */
	function assertNonEmpty(part, name) {
	  if (!part) {
	    throw new Error('`' + name + '` cannot be empty')
	  }
	}

	/**
	 * Assert `path` exists.
	 *
	 * @param {string|undefined} path
	 * @param {string} name
	 * @returns {asserts path is string}
	 */
	function assertPath(path, name) {
	  if (!path) {
	    throw new Error('Setting `' + name + '` requires `path` to be set too')
	  }
	}

	/**
	 * @typedef {import('unist').Node} Node
	 * @typedef {import('vfile').VFileCompatible} VFileCompatible
	 * @typedef {import('vfile').VFileValue} VFileValue
	 * @typedef {import('..').Processor} Processor
	 * @typedef {import('..').Plugin} Plugin
	 * @typedef {import('..').Preset} Preset
	 * @typedef {import('..').Pluggable} Pluggable
	 * @typedef {import('..').PluggableList} PluggableList
	 * @typedef {import('..').Transformer} Transformer
	 * @typedef {import('..').Parser} Parser
	 * @typedef {import('..').Compiler} Compiler
	 * @typedef {import('..').RunCallback} RunCallback
	 * @typedef {import('..').ProcessCallback} ProcessCallback
	 *
	 * @typedef Context
	 * @property {Node} tree
	 * @property {VFile} file
	 */


	// Expose a frozen processor.
	const unified = base().freeze();

	const own = {}.hasOwnProperty;

	// Function to create the first processor.
	/**
	 * @returns {Processor}
	 */
	function base() {
	  const transformers = trough();
	  /** @type {Processor['attachers']} */
	  const attachers = [];
	  /** @type {Record<string, unknown>} */
	  let namespace = {};
	  /** @type {boolean|undefined} */
	  let frozen;
	  let freezeIndex = -1;

	  // Data management.
	  // @ts-expect-error: overloads are handled.
	  processor.data = data;
	  processor.Parser = undefined;
	  processor.Compiler = undefined;

	  // Lock.
	  processor.freeze = freeze;

	  // Plugins.
	  processor.attachers = attachers;
	  // @ts-expect-error: overloads are handled.
	  processor.use = use;

	  // API.
	  processor.parse = parse;
	  processor.stringify = stringify;
	  // @ts-expect-error: overloads are handled.
	  processor.run = run;
	  processor.runSync = runSync;
	  // @ts-expect-error: overloads are handled.
	  processor.process = process;
	  processor.processSync = processSync;

	  // Expose.
	  return processor

	  // Create a new processor based on the processor in the current scope.
	  /** @type {Processor} */
	  function processor() {
	    const destination = base();
	    let index = -1;

	    while (++index < attachers.length) {
	      destination.use(...attachers[index]);
	    }

	    destination.data(extend$1(true, {}, namespace));

	    return destination
	  }

	  /**
	   * @param {string|Record<string, unknown>} [key]
	   * @param {unknown} [value]
	   * @returns {unknown}
	   */
	  function data(key, value) {
	    if (typeof key === 'string') {
	      // Set `key`.
	      if (arguments.length === 2) {
	        assertUnfrozen('data', frozen);
	        namespace[key] = value;
	        return processor
	      }

	      // Get `key`.
	      return (own.call(namespace, key) && namespace[key]) || null
	    }

	    // Set space.
	    if (key) {
	      assertUnfrozen('data', frozen);
	      namespace = key;
	      return processor
	    }

	    // Get space.
	    return namespace
	  }

	  /** @type {Processor['freeze']} */
	  function freeze() {
	    if (frozen) {
	      return processor
	    }

	    while (++freezeIndex < attachers.length) {
	      const [attacher, ...options] = attachers[freezeIndex];

	      if (options[0] === false) {
	        continue
	      }

	      if (options[0] === true) {
	        options[0] = undefined;
	      }

	      /** @type {Transformer|void} */
	      const transformer = attacher.call(processor, ...options);

	      if (typeof transformer === 'function') {
	        transformers.use(transformer);
	      }
	    }

	    frozen = true;
	    freezeIndex = Number.POSITIVE_INFINITY;

	    return processor
	  }

	  /**
	   * @param {Pluggable|null|undefined} [value]
	   * @param {...unknown} options
	   * @returns {Processor}
	   */
	  function use(value, ...options) {
	    /** @type {Record<string, unknown>|undefined} */
	    let settings;

	    assertUnfrozen('use', frozen);

	    if (value === null || value === undefined) ; else if (typeof value === 'function') {
	      addPlugin(value, ...options);
	    } else if (typeof value === 'object') {
	      if (Array.isArray(value)) {
	        addList(value);
	      } else {
	        addPreset(value);
	      }
	    } else {
	      throw new TypeError('Expected usable value, not `' + value + '`')
	    }

	    if (settings) {
	      namespace.settings = Object.assign(namespace.settings || {}, settings);
	    }

	    return processor

	    /**
	     * @param {import('..').Pluggable<unknown[]>} value
	     * @returns {void}
	     */
	    function add(value) {
	      if (typeof value === 'function') {
	        addPlugin(value);
	      } else if (typeof value === 'object') {
	        if (Array.isArray(value)) {
	          const [plugin, ...options] = value;
	          addPlugin(plugin, ...options);
	        } else {
	          addPreset(value);
	        }
	      } else {
	        throw new TypeError('Expected usable value, not `' + value + '`')
	      }
	    }

	    /**
	     * @param {Preset} result
	     * @returns {void}
	     */
	    function addPreset(result) {
	      addList(result.plugins);

	      if (result.settings) {
	        settings = Object.assign(settings || {}, result.settings);
	      }
	    }

	    /**
	     * @param {PluggableList|null|undefined} [plugins]
	     * @returns {void}
	     */
	    function addList(plugins) {
	      let index = -1;

	      if (plugins === null || plugins === undefined) ; else if (Array.isArray(plugins)) {
	        while (++index < plugins.length) {
	          const thing = plugins[index];
	          add(thing);
	        }
	      } else {
	        throw new TypeError('Expected a list of plugins, not `' + plugins + '`')
	      }
	    }

	    /**
	     * @param {Plugin} plugin
	     * @param {...unknown} [value]
	     * @returns {void}
	     */
	    function addPlugin(plugin, value) {
	      let index = -1;
	      /** @type {Processor['attachers'][number]|undefined} */
	      let entry;

	      while (++index < attachers.length) {
	        if (attachers[index][0] === plugin) {
	          entry = attachers[index];
	          break
	        }
	      }

	      if (entry) {
	        if (isPlainObject$1(entry[1]) && isPlainObject$1(value)) {
	          value = extend$1(true, entry[1], value);
	        }

	        entry[1] = value;
	      } else {
	        // @ts-expect-error: fine.
	        attachers.push([...arguments]);
	      }
	    }
	  }

	  /** @type {Processor['parse']} */
	  function parse(doc) {
	    processor.freeze();
	    const file = vfile(doc);
	    const Parser = processor.Parser;
	    assertParser('parse', Parser);

	    if (newable(Parser, 'parse')) {
	      // @ts-expect-error: `newable` checks this.
	      return new Parser(String(file), file).parse()
	    }

	    // @ts-expect-error: `newable` checks this.
	    return Parser(String(file), file) // eslint-disable-line new-cap
	  }

	  /** @type {Processor['stringify']} */
	  function stringify(node, doc) {
	    processor.freeze();
	    const file = vfile(doc);
	    const Compiler = processor.Compiler;
	    assertCompiler('stringify', Compiler);
	    assertNode(node);

	    if (newable(Compiler, 'compile')) {
	      // @ts-expect-error: `newable` checks this.
	      return new Compiler(node, file).compile()
	    }

	    // @ts-expect-error: `newable` checks this.
	    return Compiler(node, file) // eslint-disable-line new-cap
	  }

	  /**
	   * @param {Node} node
	   * @param {VFileCompatible|RunCallback} [doc]
	   * @param {RunCallback} [callback]
	   * @returns {Promise<Node>|void}
	   */
	  function run(node, doc, callback) {
	    assertNode(node);
	    processor.freeze();

	    if (!callback && typeof doc === 'function') {
	      callback = doc;
	      doc = undefined;
	    }

	    if (!callback) {
	      return new Promise(executor)
	    }

	    executor(null, callback);

	    /**
	     * @param {null|((node: Node) => void)} resolve
	     * @param {(error: Error) => void} reject
	     * @returns {void}
	     */
	    function executor(resolve, reject) {
	      // @ts-expect-error: `doc` can’t be a callback anymore, we checked.
	      transformers.run(node, vfile(doc), done);

	      /**
	       * @param {Error|null} error
	       * @param {Node} tree
	       * @param {VFile} file
	       * @returns {void}
	       */
	      function done(error, tree, file) {
	        tree = tree || node;
	        if (error) {
	          reject(error);
	        } else if (resolve) {
	          resolve(tree);
	        } else {
	          // @ts-expect-error: `callback` is defined if `resolve` is not.
	          callback(null, tree, file);
	        }
	      }
	    }
	  }

	  /** @type {Processor['runSync']} */
	  function runSync(node, file) {
	    /** @type {Node|undefined} */
	    let result;
	    /** @type {boolean|undefined} */
	    let complete;

	    processor.run(node, file, done);

	    assertDone('runSync', 'run', complete);

	    // @ts-expect-error: we either bailed on an error or have a tree.
	    return result

	    /**
	     * @param {Error|null} [error]
	     * @param {Node} [tree]
	     * @returns {void}
	     */
	    function done(error, tree) {
	      bail(error);
	      result = tree;
	      complete = true;
	    }
	  }

	  /**
	   * @param {VFileCompatible} doc
	   * @param {ProcessCallback} [callback]
	   * @returns {Promise<VFile>|undefined}
	   */
	  function process(doc, callback) {
	    processor.freeze();
	    assertParser('process', processor.Parser);
	    assertCompiler('process', processor.Compiler);

	    if (!callback) {
	      return new Promise(executor)
	    }

	    executor(null, callback);

	    /**
	     * @param {null|((file: VFile) => void)} resolve
	     * @param {(error?: Error|null|undefined) => void} reject
	     * @returns {void}
	     */
	    function executor(resolve, reject) {
	      const file = vfile(doc);

	      processor.run(processor.parse(file), file, (error, tree, file) => {
	        if (error || !tree || !file) {
	          done(error);
	        } else {
	          /** @type {unknown} */
	          const result = processor.stringify(tree, file);

	          if (result === undefined || result === null) ; else if (looksLikeAVFileValue(result)) {
	            file.value = result;
	          } else {
	            file.result = result;
	          }

	          done(error, file);
	        }
	      });

	      /**
	       * @param {Error|null|undefined} [error]
	       * @param {VFile|undefined} [file]
	       * @returns {void}
	       */
	      function done(error, file) {
	        if (error || !file) {
	          reject(error);
	        } else if (resolve) {
	          resolve(file);
	        } else {
	          // @ts-expect-error: `callback` is defined if `resolve` is not.
	          callback(null, file);
	        }
	      }
	    }
	  }

	  /** @type {Processor['processSync']} */
	  function processSync(doc) {
	    /** @type {boolean|undefined} */
	    let complete;

	    processor.freeze();
	    assertParser('processSync', processor.Parser);
	    assertCompiler('processSync', processor.Compiler);

	    const file = vfile(doc);

	    processor.process(file, done);

	    assertDone('processSync', 'process', complete);

	    return file

	    /**
	     * @param {Error|null|undefined} [error]
	     * @returns {void}
	     */
	    function done(error) {
	      complete = true;
	      bail(error);
	    }
	  }
	}

	/**
	 * Check if `value` is a constructor.
	 *
	 * @param {unknown} value
	 * @param {string} name
	 * @returns {boolean}
	 */
	function newable(value, name) {
	  return (
	    typeof value === 'function' &&
	    // Prototypes do exist.
	    // type-coverage:ignore-next-line
	    value.prototype &&
	    // A function with keys in its prototype is probably a constructor.
	    // Classes’ prototype methods are not enumerable, so we check if some value
	    // exists in the prototype.
	    // type-coverage:ignore-next-line
	    (keys(value.prototype) || name in value.prototype)
	  )
	}

	/**
	 * Check if `value` is an object with keys.
	 *
	 * @param {Record<string, unknown>} value
	 * @returns {boolean}
	 */
	function keys(value) {
	  /** @type {string} */
	  let key;

	  for (key in value) {
	    if (own.call(value, key)) {
	      return true
	    }
	  }

	  return false
	}

	/**
	 * Assert a parser is available.
	 *
	 * @param {string} name
	 * @param {unknown} value
	 * @returns {asserts value is Parser}
	 */
	function assertParser(name, value) {
	  if (typeof value !== 'function') {
	    throw new TypeError('Cannot `' + name + '` without `Parser`')
	  }
	}

	/**
	 * Assert a compiler is available.
	 *
	 * @param {string} name
	 * @param {unknown} value
	 * @returns {asserts value is Compiler}
	 */
	function assertCompiler(name, value) {
	  if (typeof value !== 'function') {
	    throw new TypeError('Cannot `' + name + '` without `Compiler`')
	  }
	}

	/**
	 * Assert the processor is not frozen.
	 *
	 * @param {string} name
	 * @param {unknown} frozen
	 * @returns {asserts frozen is false}
	 */
	function assertUnfrozen(name, frozen) {
	  if (frozen) {
	    throw new Error(
	      'Cannot call `' +
	        name +
	        '` on a frozen processor.\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'
	    )
	  }
	}

	/**
	 * Assert `node` is a unist node.
	 *
	 * @param {unknown} node
	 * @returns {asserts node is Node}
	 */
	function assertNode(node) {
	  // `isPlainObj` unfortunately uses `any` instead of `unknown`.
	  // type-coverage:ignore-next-line
	  if (!isPlainObject$1(node) || typeof node.type !== 'string') {
	    throw new TypeError('Expected node, got `' + node + '`')
	    // Fine.
	  }
	}

	/**
	 * Assert that `complete` is `true`.
	 *
	 * @param {string} name
	 * @param {string} asyncName
	 * @param {unknown} complete
	 * @returns {asserts complete is true}
	 */
	function assertDone(name, asyncName, complete) {
	  if (!complete) {
	    throw new Error(
	      '`' + name + '` finished async. Use `' + asyncName + '` instead'
	    )
	  }
	}

	/**
	 * @param {VFileCompatible} [value]
	 * @returns {VFile}
	 */
	function vfile(value) {
	  return looksLikeAVFile(value) ? value : new VFile(value)
	}

	/**
	 * @param {VFileCompatible} [value]
	 * @returns {value is VFile}
	 */
	function looksLikeAVFile(value) {
	  return Boolean(
	    value &&
	      typeof value === 'object' &&
	      'message' in value &&
	      'messages' in value
	  )
	}

	/**
	 * @param {unknown} [value]
	 * @returns {value is VFileValue}
	 */
	function looksLikeAVFileValue(value) {
	  return typeof value === 'string' || isBuffer$1(value)
	}

	var thinkbug = "4fd0f5fb276c23f89e61.png";

	var dist$1 = {};

	Object.defineProperty(dist$1, '__esModule', { value: true });

	function _interopDefault$1 (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

	var React = reactExports;
	var React__default = _interopDefault$1(React);

	var RenderIfVisible = function (_a) {
	    var _b = _a.initialVisible, initialVisible = _b === void 0 ? false : _b, _c = _a.defaultHeight, defaultHeight = _c === void 0 ? 300 : _c, _d = _a.visibleOffset, visibleOffset = _d === void 0 ? 1000 : _d, _e = _a.stayRendered, stayRendered = _e === void 0 ? false : _e, _f = _a.root, root = _f === void 0 ? null : _f, _g = _a.rootElement, rootElement = _g === void 0 ? 'div' : _g, _h = _a.rootElementClass, rootElementClass = _h === void 0 ? '' : _h, _j = _a.placeholderElement, placeholderElement = _j === void 0 ? 'div' : _j, _k = _a.placeholderElementClass, placeholderElementClass = _k === void 0 ? '' : _k, children = _a.children;
	    var _l = React.useState(initialVisible), isVisible = _l[0], setIsVisible = _l[1];
	    var _m = React.useState(false), wasVisible = _m[0], setWasVisible = _m[1];
	    var placeholderHeight = React.useRef(defaultHeight);
	    var intersectionRef = React.useRef(null);
	    var placeholderStyle = { height: placeholderHeight.current };
	    var rootClasses = React.useMemo(function () { return "renderIfVisible " + rootElementClass; }, [rootElementClass]);
	    var placeholderClasses = React.useMemo(function () { return "renderIfVisible-placeholder " + placeholderElementClass; }, [placeholderElementClass]);
	    // Set visibility with intersection observer
	    React.useEffect(function () {
	        if (intersectionRef.current) {
	            var observer_1 = new IntersectionObserver(function (entries) {
	                if (typeof window !== undefined && window.requestIdleCallback) {
	                    window.requestIdleCallback(function () { return setIsVisible(entries[0].isIntersecting); }, {
	                        timeout: 600,
	                    });
	                }
	                else {
	                    setIsVisible(entries[0].isIntersecting);
	                }
	            }, { root: root, rootMargin: visibleOffset + "px 0px " + visibleOffset + "px 0px" });
	            observer_1.observe(intersectionRef.current);
	            return function () {
	                if (intersectionRef.current) {
	                    observer_1.unobserve(intersectionRef.current);
	                }
	            };
	        }
	        return function () { };
	    }, [intersectionRef]);
	    // Set true height for placeholder element after render.
	    React.useEffect(function () {
	        if (intersectionRef.current && isVisible) {
	            placeholderHeight.current = intersectionRef.current.offsetHeight;
	            setWasVisible(true);
	        }
	    }, [isVisible, intersectionRef]);
	    return React__default.createElement(rootElement, {
	        children: isVisible || (stayRendered && wasVisible) ? (React__default.createElement(React__default.Fragment, null, children)) : (React__default.createElement(placeholderElement, {
	            className: placeholderClasses,
	            style: placeholderStyle,
	        })),
	        ref: intersectionRef,
	        className: rootClasses,
	    });
	};

	var _default = dist$1.default = RenderIfVisible;

	const IframelyEmbed = React$2.memo(
	    (props) => {
	        const siteConfig = useSiteConfig();

	        reactExports.useEffect(() => {
	            window.iframely && window.iframely.load();
	        });

	        const { data, status } = useQuery(
	            ["iframely", props.url],
	            ({ queryKey }) =>
	                fetch(
	                    `https://cdn.iframe.ly/api/iframely?url=${encodeURIComponent(
                        queryKey[1] 
                    )}&key=${siteConfig.IFRAMELY_KEY}&iframe=1&omit_script=1`
	                ).then((res) => res.json()),
	            {
	                staleTime: Infinity, // never refetch
	                keepPreviousData: true, // but just in case we do, keep using the old data
	                retry: false, // pretty much all error states are an issue with the URL or our account. no reason to retry
	            }
	        );

	        let embedBody = undefined;

	        // prioritize states where we have data so that we don't accidentally swap
	        // to `loading...` on refetch
	        if (data && data.error) {
	            embedBody = (
	                React$2.createElement('div', {
	                    className: tw`co-embed co-loading not-prose flex flex-row gap-8 py-8 pl-8`,}

	                    , React$2.createElement('img', {
	                        className: "max-w-[106px] object-contain" ,
	                        src: serverPathFromImport(thinkbug),
	                        alt: "",}
	                    )
	                    , React$2.createElement('div', { className: "self-center", 'data-testid': "iframely-error",}
	                        , React$2.createElement('p', { className: "font-league text-2xl font-semibold"  ,}, "hmm..."

	                        )
	                        , React$2.createElement('p', { className: "font-atkinson text-2xl" ,}, "something went wrong with this preview."

	                        )
	                        , React$2.createElement('p', { className: "font-atkinson text-2xl" ,}, "here's why: "
	                              , data.error
	                        )
	                    )
	                )
	            );
	        } else if (data && data.html) {
	            embedBody = (
	                // only render the iframely player if it's visible onscreen
	                // because we can't take its children out of the tab order; set
	                // initial visibility to true to minimize glitches for elements
	                // above the fold in a read-more post when the read more is
	                // closed
	                React$2.createElement(_default, { initialVisible: true,}
	                    , React$2.createElement('div', { dangerouslySetInnerHTML: { __html: data.html },} )
	                )
	            );
	        } else if (status === "loading") {
	            // display `loading...` immediately instead of waiting for the request to
	            // actually start
	            embedBody = (
	                React$2.createElement('div', {
	                    className: tw`co-embed co-loading not-prose flex flex-row gap-8 py-8 pl-8`,}

	                    /* TODO: add throbber */
	                    , React$2.createElement('div', { className: "h-[102px] w-[106px]" ,}, " ")
	                    , React$2.createElement('div', { className: "self-center",}
	                        , React$2.createElement('p', { className: "font-atkinson text-2xl" ,}, "loading...")
	                    )
	                )
	            );
	        }

	        return (
	            React$2.createElement('div', { className: tw`co-embed`,}
	                , embedBody
	                , React$2.createElement('div', { className: tw`co-ui-text mt-0 p-3 text-right`,}
	                    , React$2.createElement('a', { href: props.url, target: "_blank", rel: "noopener nofollow" ,}
	                        , props.url
	                    )
	                )
	            )
	        );
	    }
	);

	IframelyEmbed.displayName = "IframelyEmbed";

	const Mention = ({
	    handle,
	}) => {
	    return (
	        React$2.createElement('a', {
	            'data-testid': "mention",
	            href: sitemap.public.project
	                .mainAppProfile({
	                    projectHandle: handle,
	                })
	                .toString(),
	            className: "!font-bold !no-underline hover:!underline"  ,}
	, "@"
	            , handle
	        )
	    );
	};

	/**
	 * Default props included because Mention is used outside of typescript and we
	 * need an easy way to see when it's fucked instead of just crashing
	 */
	Mention.defaultProps = {
	    handle: "ERROR" ,
	};

	// Adapted from https://github.com/twitter/twitter-text

	function regexSupplant(
	    regex,
	    map,
	    flags = ""
	) {
	    if (typeof regex !== "string") {
	        if (regex.global && flags.indexOf("g") < 0) {
	            flags += "g";
	        }
	        if (regex.ignoreCase && flags.indexOf("i") < 0) {
	            flags += "i";
	        }
	        if (regex.multiline && flags.indexOf("m") < 0) {
	            flags += "m";
	        }

	        regex = regex.source;
	    }

	    return new RegExp(
	        regex.replace(/#\{(\w+)\}/g, function (match, name) {
	            let newRegex = map[name] || "";
	            if (typeof newRegex !== "string") {
	                newRegex = newRegex.source;
	            }
	            return newRegex;
	        }),
	        flags
	    );
	}

	const latinAccentChars =
	    /\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u024F\u0253\u0254\u0256\u0257\u0259\u025B\u0263\u0268\u026F\u0272\u0289\u028B\u02BB\u0300-\u036F\u1E00-\u1EFF/;
	const atSigns = /[@＠]/;
	const validMentionPrecedingChars =
	    /(?:^|[^a-zA-Z0-9_!#$%&*@＠\\/]|(?:^|[^a-zA-Z0-9_+~.-\\/]))/;

	const validMention = regexSupplant(
	    "(#{validMentionPrecedingChars})" + // $1: Preceding character
	        "(#{atSigns})" + // $2: At mark
	        "([a-zA-Z0-9-]{3,})", // $3: handle
	    { validMentionPrecedingChars, atSigns },
	    "g"
	);
	const endMentionMatch = regexSupplant(
	    /^(?:#{atSigns}|[#{latinAccentChars}]|:\/\/)/,
	    { atSigns, latinAccentChars }
	);





	function extractMentions(text) {
	    if (!text.match(atSigns)) {
	        return [];
	    }

	    const possibleNames = [];

	    text.replace(
	        validMention,
	        function (
	            match,
	            before,
	            atSign,
	            handle,
	            offset,
	            chunk
	        ) {
	            const after = chunk.slice(offset + match.length);

	            if (!after.match(endMentionMatch)) {
	                const startPosition = offset + before.length;
	                const endPosition = startPosition + handle.length + 1;
	                possibleNames.push({
	                    handle,
	                    indices: [startPosition, endPosition],
	                });
	            }

	            return "";
	        }
	    );

	    return possibleNames;
	}

	const processMatches =
	    (
	        regex,
	        callback






	    ) =>
	    (hast) => {
	        // we only want to check on text nodes for this
	        visit$2(hast, "text", (node, index, parent) => {
	            // there is no such thing as a text node without a parent.
	            // but if there is we want nothing to do with it.
	            if (parent === null || index === null) return;

	            const matches = node.value.match(regex);

	            // if this text has mentions, process them
	            if (matches) {
	                const splits = node.value.split(regex);
	                if (splits.length - 1 !== matches.length) {
	                    // something isn't how it should be. bail.
	                    return;
	                }

	                return callback(matches, splits, node, index, parent);
	            }
	        });
	    };

	const convertMentions = (hast) => {
	    // we only want to check on text nodes for this
	    visit$2(hast, "text", (node, index, parent) => {
	        // there is no such thing as a text node without a parent.
	        // but if there is we want nothing to do with it.
	        if (parent === null || index === null) return;

	        const text = node.value;
	        const names = extractMentions(text);

	        // if this text has mentions, consider processing them
	        if (names.length) {
	            // if we have an `a` in our parent tree, we don't want to process
	            // the mention so that links still work.
	            let hasAnchorParent = false;
	            visitParents$2(parent, { type: "text" }, (newNode, ancestors) => {
	                // since we have to traverse for all text nodes on the parent,
	                // we will pretty often get text nodes that _aren't_ the one
	                // we're trying to operate on. check to make sure they match.
	                if (!_$5.isEqual(node, newNode)) return CONTINUE$2;

	                // flag if we've got an anchro parent
	                hasAnchorParent = !!ancestors.find((el) =>
	                    is$2(el, { type: "element", tagName: "a" })
	                );

	                // if we do, we don't need to check everything else so bail out.
	                if (hasAnchorParent) return EXIT$2;
	            });

	            if (hasAnchorParent) return CONTINUE$2;

	            const els = [];
	            let currentStart = 0;

	            names.forEach((token, idx, names) => {
	                const [startPosition, endPosition] = token.indices;
	                els.push({
	                    type: "text",
	                    value: text.slice(currentStart, startPosition),
	                });
	                els.push({
	                    type: "element",
	                    tagName: "Mention",
	                    properties: {
	                        handle: token.handle,
	                    },
	                    children: [
	                        {
	                            type: "text",
	                            value: `@${token.handle}`,
	                        },
	                    ],
	                });
	                currentStart = endPosition;

	                if (idx === names.length - 1) {
	                    // if we're last we need to grab the rest of the string
	                    els.push({
	                        type: "text",
	                        value: text.slice(currentStart),
	                    });
	                }
	            });

	            parent.children.splice(index, 1, ...els);
	            // skip over all the new elements we just created
	            return [SKIP$2, index + els.length];
	        }
	    });
	};

	const cleanUpFootnotes = (hast) => {
	    visit$2(hast, "element", (node, index, parent) => {
	        if (parent === null || index === null) return;
	        // remove the link from the superscript number
	        if (
	            node.tagName === "a" &&
	            (node.properties?.id )?.includes("fnref")
	        ) {
	            parent.children.splice(index, 1, ...node.children);
	            return [SKIP$2, index];
	        }

	        // remove the little arrow at the bottom
	        if (
	            node.tagName === "a" &&
	            (node.properties?.href )?.includes("fnref")
	        ) {
	            parent.children.splice(index, 1);
	            return [SKIP$2, index];
	        }

	        // replace the invisible label with a hr
	        if (
	            node.tagName === "h2" &&
	            (node.properties?.id )?.includes("footnote-label")
	        ) {
	            const hrEl = {
	                tagName: "hr",
	                type: "element",
	                children: [],
	                properties: {
	                    "aria-label": "Footnotes",
	                    style: "margin-bottom: -0.5rem;",
	                },
	            };
	            parent.children.splice(index, 1, hrEl);
	        }
	    });
	};

	const copyImgAltToTitle = (hast) => {
	    visit$2(hast, { type: "element", tagName: "img" }, (node) => {
	        if (node.properties?.alt) {
	            node.properties.title = node.properties.alt;
	        }
	    });
	};

	const makeIframelyEmbeds = (hast) => {
	    visit$2(hast, { type: "element", tagName: "a" }, (node, index, parent) => {
	        if (parent === null || index === null) return;

	        // GFM autolink literals have the following two properties:
	        // - they have exactly one child, and it's a text child;
	        if (node.children.length != 1 || node.children[0].type != "text")
	            return;
	        // - the starting offset of the text child matches the starting offset
	        //   of the node (angle-bracket autolinks and explicit links differ by 1
	        //   char)
	        if (
	            !node.position ||
	            !node.children[0].position ||
	            node.children[0].position.start.offset != node.position.start.offset
	        )
	            return;

	        // additionally, GFM autolink literals in their own paragraph are the
	        // only child of their parent node.
	        if (parent.children.length != 1) return;

	        // change the type of the parent to a div because you can't nest a div
	        // inside a paragraph
	        if (parent.type === "element") parent.tagName = "div";

	        parent.children.splice(index, 1, {
	            type: "element",
	            tagName: "IframelyEmbed",
	            properties: {
	                url: node.properties?.href,
	            },
	            children: [],
	        });

	        return true;
	    });
	};

	const compileHastAST = function () {
	    const compiler = (node) => {
	        return JSON.stringify(node);
	    };

	    Object.assign(this, { Compiler: compiler });
	};

	const parseHastAST = function () {
	    const parser = (astString) => {
	        const ast = JSON.parse(astString) ;
	        return ast;
	    };

	    Object.assign(this, { Parser: parser });
	};

	const EMOJI_REGEX = /:[a-zA-Z\d-_]+:/gims;

	 


























	function importAll(r) {
	    return r.keys().map((key) => {
	        const name = path$3.basename(key, path$3.extname(key));
	        return {
	            id: name,
	            name,
	            skins: [
	                {
	                    src: sitemap.public.static
	                        .staticAsset({ path: r(key) })
	                        .toString(),
	                },
	            ],
	            keywords: [],
	        };
	    });
	}

	const customEmoji =
	    // require.context is webpack runtime specific and thus not available under jest
	    typeof process !== "undefined" && process.env?.RUN_MODE === "test"
	        ? []
	        : importAll(
	              require.context("../images/emoji", false, /\.(png|jpe?g|svg)$/)
	          );

	const cohostPlusCustomEmoji =
	    // require.context is webpack runtime specific and thus not available under jest
	    typeof process !== "undefined" && process.env?.RUN_MODE === "test"
	        ? []
	        : importAll(
	              require.context(
	                  "../images/plus-emoji",
	                  false,
	                  /\.(png|jpe?g|svg)$/
	              )
	          );

	const indexableCustomEmoji = new Map(
	    customEmoji.reduce((collector, emoji) => {
	        return [...collector, [emoji.name, emoji]];
	    }, [])
	);

	const indexableCohostPlusCustomEmoji = new Map(
	    cohostPlusCustomEmoji.reduce(
	        (collector, emoji) => {
	            return [...collector, [emoji.name, emoji]];
	        },
	        []
	    )
	);





	const parseEmoji = (options) => {
	    const compiler = processMatches(
	        EMOJI_REGEX,
	        (matches, splits, node, index, parent) => {
	            const els = splits.reduce(
	                (collector, curr, index) => {
	                    const currNode = {
	                        type: "text",
	                        value: curr,
	                    };

	                    const pending = [...collector, currNode];

	                    if (index < matches.length) {
	                        const emojiName = matches[index].slice(
	                            1,
	                            matches[index].length - 1
	                        );
	                        let emoji = indexableCustomEmoji.get(emojiName);
	                        if (!emoji && options.cohostPlus) {
	                            emoji =
	                                indexableCohostPlusCustomEmoji.get(emojiName);
	                        }

	                        if (emoji) {
	                            pending.push({
	                                type: "element",
	                                tagName: "CustomEmoji",
	                                properties: {
	                                    name: emoji.name,
	                                    url: emoji.skins[0].src,
	                                },
	                                children: [],
	                            } );
	                        } else {
	                            pending.push({
	                                type: "text",
	                                value: matches[index],
	                            });
	                        }
	                    }

	                    return pending;
	                },
	                [] 
	            );
	            parent.children.splice(index, 1, ...els);
	            // skip over all the new elements we just created
	            return [SKIP$2, index + els.length];
	        }
	    );
	    return compiler;
	};

	var emoji = /*#__PURE__*/Object.freeze({
		__proto__: null,
		cohostPlusCustomEmoji: cohostPlusCustomEmoji,
		customEmoji: customEmoji,
		indexableCohostPlusCustomEmoji: indexableCohostPlusCustomEmoji,
		indexableCustomEmoji: indexableCustomEmoji,
		parseEmoji: parseEmoji
	});

	const MAX_GFM_LINES = 256;

	/* esm.sh - esbuild bundle(css-tree@2.3.1) es2022 production */
	var rs=Object.create;var tr=Object.defineProperty;var ns=Object.getOwnPropertyDescriptor;var os=Object.getOwnPropertyNames;var is$1=Object.getPrototypeOf,as=Object.prototype.hasOwnProperty;var Oe=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),b=(e,t)=>{for(var r in t)tr(e,r,{get:t[r],enumerable:!0});},ss=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of os(t))!as.call(e,o)&&o!==r&&tr(e,o,{get:()=>t[o],enumerable:!(n=ns(t,o))||n.enumerable});return e};var ls=(e,t,r)=>(r=e!=null?rs(is$1(e)):{},ss(tr(r,"default",{value:e,enumerable:!0}),e));var Jo=Oe(ur=>{var Zo="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");ur.encode=function(e){if(0<=e&&e<Zo.length)return Zo[e];throw new TypeError("Must be between 0 and 63: "+e)};ur.decode=function(e){var t=65,r=90,n=97,o=122,i=48,s=57,u=43,c=47,a=26,l=52;return t<=e&&e<=r?e-t:n<=e&&e<=o?e-n+a:i<=e&&e<=s?e-i+l:e==u?62:e==c?63:-1};});var oi=Oe(hr=>{var ei=Jo(),pr=5,ti=1<<pr,ri=ti-1,ni=ti;function ks(e){return e<0?(-e<<1)+1:(e<<1)+0}function ws(e){var t=(e&1)===1,r=e>>1;return t?-r:r}hr.encode=function(t){var r="",n,o=ks(t);do n=o&ri,o>>>=pr,o>0&&(n|=ni),r+=ei.encode(n);while(o>0);return r};hr.decode=function(t,r,n){var o=t.length,i=0,s=0,u,c;do{if(r>=o)throw new Error("Expected more digits in base 64 VLQ value.");if(c=ei.decode(t.charCodeAt(r++)),c===-1)throw new Error("Invalid base64 digit: "+t.charAt(r-1));u=!!(c&ni),c&=ri,i=i+(c<<s),s+=pr;}while(u);n.value=ws(i),n.rest=r;};});var Et=Oe(V=>{function vs(e,t,r){if(t in e)return e[t];if(arguments.length===3)return r;throw new Error('"'+t+'" is a required argument.')}V.getArg=vs;var ii=/^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/,Ss=/^data:.+\,.+$/;function nt(e){var t=e.match(ii);return t?{scheme:t[1],auth:t[2],host:t[3],port:t[4],path:t[5]}:null}V.urlParse=nt;function Ue(e){var t="";return e.scheme&&(t+=e.scheme+":"),t+="//",e.auth&&(t+=e.auth+"@"),e.host&&(t+=e.host),e.port&&(t+=":"+e.port),e.path&&(t+=e.path),t}V.urlGenerate=Ue;var Cs=32;function As(e){var t=[];return function(r){for(var n=0;n<t.length;n++)if(t[n].input===r){var o=t[0];return t[0]=t[n],t[n]=o,t[0].result}var i=e(r);return t.unshift({input:r,result:i}),t.length>Cs&&t.pop(),i}}var mr=As(function(t){var r=t,n=nt(t);if(n){if(!n.path)return t;r=n.path;}for(var o=V.isAbsolute(r),i=[],s=0,u=0;;)if(s=u,u=r.indexOf("/",s),u===-1){i.push(r.slice(s));break}else for(i.push(r.slice(s,u));u<r.length&&r[u]==="/";)u++;for(var c,a=0,u=i.length-1;u>=0;u--)c=i[u],c==="."?i.splice(u,1):c===".."?a++:a>0&&(c===""?(i.splice(u+1,a),a=0):(i.splice(u,2),a--));return r=i.join("/"),r===""&&(r=o?"/":"."),n?(n.path=r,Ue(n)):r});V.normalize=mr;function ai(e,t){e===""&&(e="."),t===""&&(t=".");var r=nt(t),n=nt(e);if(n&&(e=n.path||"/"),r&&!r.scheme)return n&&(r.scheme=n.scheme),Ue(r);if(r||t.match(Ss))return t;if(n&&!n.host&&!n.path)return n.host=t,Ue(n);var o=t.charAt(0)==="/"?t:mr(e.replace(/\/+$/,"")+"/"+t);return n?(n.path=o,Ue(n)):o}V.join=ai;V.isAbsolute=function(e){return e.charAt(0)==="/"||ii.test(e)};function Ts(e,t){e===""&&(e="."),e=e.replace(/\/$/,"");for(var r=0;t.indexOf(e+"/")!==0;){var n=e.lastIndexOf("/");if(n<0||(e=e.slice(0,n),e.match(/^([^\/]+:\/)?\/*$/)))return t;++r;}return Array(r+1).join("../")+t.substr(e.length+1)}V.relative=Ts;var si=function(){var e=Object.create(null);return !("__proto__"in e)}();function li(e){return e}function Es(e){return ci(e)?"$"+e:e}V.toSetString=si?li:Es;function Ls(e){return ci(e)?e.slice(1):e}V.fromSetString=si?li:Ls;function ci(e){if(!e)return !1;var t=e.length;if(t<9||e.charCodeAt(t-1)!==95||e.charCodeAt(t-2)!==95||e.charCodeAt(t-3)!==111||e.charCodeAt(t-4)!==116||e.charCodeAt(t-5)!==111||e.charCodeAt(t-6)!==114||e.charCodeAt(t-7)!==112||e.charCodeAt(t-8)!==95||e.charCodeAt(t-9)!==95)return !1;for(var r=t-10;r>=0;r--)if(e.charCodeAt(r)!==36)return !1;return !0}function Ps(e,t,r){var n=be(e.source,t.source);return n!==0||(n=e.originalLine-t.originalLine,n!==0)||(n=e.originalColumn-t.originalColumn,n!==0||r)||(n=e.generatedColumn-t.generatedColumn,n!==0)||(n=e.generatedLine-t.generatedLine,n!==0)?n:be(e.name,t.name)}V.compareByOriginalPositions=Ps;function Is(e,t,r){var n;return n=e.originalLine-t.originalLine,n!==0||(n=e.originalColumn-t.originalColumn,n!==0||r)||(n=e.generatedColumn-t.generatedColumn,n!==0)||(n=e.generatedLine-t.generatedLine,n!==0)?n:be(e.name,t.name)}V.compareByOriginalPositionsNoSource=Is;function Ds(e,t,r){var n=e.generatedLine-t.generatedLine;return n!==0||(n=e.generatedColumn-t.generatedColumn,n!==0||r)||(n=be(e.source,t.source),n!==0)||(n=e.originalLine-t.originalLine,n!==0)||(n=e.originalColumn-t.originalColumn,n!==0)?n:be(e.name,t.name)}V.compareByGeneratedPositionsDeflated=Ds;function Os(e,t,r){var n=e.generatedColumn-t.generatedColumn;return n!==0||r||(n=be(e.source,t.source),n!==0)||(n=e.originalLine-t.originalLine,n!==0)||(n=e.originalColumn-t.originalColumn,n!==0)?n:be(e.name,t.name)}V.compareByGeneratedPositionsDeflatedNoLine=Os;function be(e,t){return e===t?0:e===null?1:t===null?-1:e>t?1:-1}function Ns(e,t){var r=e.generatedLine-t.generatedLine;return r!==0||(r=e.generatedColumn-t.generatedColumn,r!==0)||(r=be(e.source,t.source),r!==0)||(r=e.originalLine-t.originalLine,r!==0)||(r=e.originalColumn-t.originalColumn,r!==0)?r:be(e.name,t.name)}V.compareByGeneratedPositionsInflated=Ns;function zs(e){return JSON.parse(e.replace(/^\)]}'[^\n]*\n/,""))}V.parseSourceMapInput=zs;function Ms(e,t,r){if(t=t||"",e&&(e[e.length-1]!=="/"&&t[0]!=="/"&&(e+="/"),t=e+t),r){var n=nt(r);if(!n)throw new Error("sourceMapURL could not be parsed");if(n.path){var o=n.path.lastIndexOf("/");o>=0&&(n.path=n.path.substring(0,o+1));}t=ai(Ue(n),t);}return mr(t)}V.computeSourceURL=Ms;});var pi=Oe(ui=>{var fr=Et(),dr=Object.prototype.hasOwnProperty,Le=typeof Map<"u";function xe(){this._array=[],this._set=Le?new Map:Object.create(null);}xe.fromArray=function(t,r){for(var n=new xe,o=0,i=t.length;o<i;o++)n.add(t[o],r);return n};xe.prototype.size=function(){return Le?this._set.size:Object.getOwnPropertyNames(this._set).length};xe.prototype.add=function(t,r){var n=Le?t:fr.toSetString(t),o=Le?this.has(t):dr.call(this._set,n),i=this._array.length;(!o||r)&&this._array.push(t),o||(Le?this._set.set(t,i):this._set[n]=i);};xe.prototype.has=function(t){if(Le)return this._set.has(t);var r=fr.toSetString(t);return dr.call(this._set,r)};xe.prototype.indexOf=function(t){if(Le){var r=this._set.get(t);if(r>=0)return r}else {var n=fr.toSetString(t);if(dr.call(this._set,n))return this._set[n]}throw new Error('"'+t+'" is not in the set.')};xe.prototype.at=function(t){if(t>=0&&t<this._array.length)return this._array[t];throw new Error("No element indexed by "+t)};xe.prototype.toArray=function(){return this._array.slice()};ui.ArraySet=xe;});var fi=Oe(mi=>{var hi=Et();function Rs(e,t){var r=e.generatedLine,n=t.generatedLine,o=e.generatedColumn,i=t.generatedColumn;return n>r||n==r&&i>=o||hi.compareByGeneratedPositionsInflated(e,t)<=0}function Lt(){this._array=[],this._sorted=!0,this._last={generatedLine:-1,generatedColumn:0};}Lt.prototype.unsortedForEach=function(t,r){this._array.forEach(t,r);};Lt.prototype.add=function(t){Rs(this._last,t)?(this._last=t,this._array.push(t)):(this._sorted=!1,this._array.push(t));};Lt.prototype.toArray=function(){return this._sorted||(this._array.sort(hi.compareByGeneratedPositionsInflated),this._sorted=!0),this._array};mi.MappingList=Lt;});var gi=Oe(di=>{var ot=oi(),U=Et(),Pt=pi().ArraySet,Fs=fi().MappingList;function oe(e){e||(e={}),this._file=U.getArg(e,"file",null),this._sourceRoot=U.getArg(e,"sourceRoot",null),this._skipValidation=U.getArg(e,"skipValidation",!1),this._ignoreInvalidMapping=U.getArg(e,"ignoreInvalidMapping",!1),this._sources=new Pt,this._names=new Pt,this._mappings=new Fs,this._sourcesContents=null;}oe.prototype._version=3;oe.fromSourceMap=function(t,r){var n=t.sourceRoot,o=new oe(Object.assign(r||{},{file:t.file,sourceRoot:n}));return t.eachMapping(function(i){var s={generated:{line:i.generatedLine,column:i.generatedColumn}};i.source!=null&&(s.source=i.source,n!=null&&(s.source=U.relative(n,s.source)),s.original={line:i.originalLine,column:i.originalColumn},i.name!=null&&(s.name=i.name)),o.addMapping(s);}),t.sources.forEach(function(i){var s=i;n!==null&&(s=U.relative(n,i)),o._sources.has(s)||o._sources.add(s);var u=t.sourceContentFor(i);u!=null&&o.setSourceContent(i,u);}),o};oe.prototype.addMapping=function(t){var r=U.getArg(t,"generated"),n=U.getArg(t,"original",null),o=U.getArg(t,"source",null),i=U.getArg(t,"name",null);!this._skipValidation&&this._validateMapping(r,n,o,i)===!1||(o!=null&&(o=String(o),this._sources.has(o)||this._sources.add(o)),i!=null&&(i=String(i),this._names.has(i)||this._names.add(i)),this._mappings.add({generatedLine:r.line,generatedColumn:r.column,originalLine:n!=null&&n.line,originalColumn:n!=null&&n.column,source:o,name:i}));};oe.prototype.setSourceContent=function(t,r){var n=t;this._sourceRoot!=null&&(n=U.relative(this._sourceRoot,n)),r!=null?(this._sourcesContents||(this._sourcesContents=Object.create(null)),this._sourcesContents[U.toSetString(n)]=r):this._sourcesContents&&(delete this._sourcesContents[U.toSetString(n)],Object.keys(this._sourcesContents).length===0&&(this._sourcesContents=null));};oe.prototype.applySourceMap=function(t,r,n){var o=r;if(r==null){if(t.file==null)throw new Error(`SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map's "file" property. Both were omitted.`);o=t.file;}var i=this._sourceRoot;i!=null&&(o=U.relative(i,o));var s=new Pt,u=new Pt;this._mappings.unsortedForEach(function(c){if(c.source===o&&c.originalLine!=null){var a=t.originalPositionFor({line:c.originalLine,column:c.originalColumn});a.source!=null&&(c.source=a.source,n!=null&&(c.source=U.join(n,c.source)),i!=null&&(c.source=U.relative(i,c.source)),c.originalLine=a.line,c.originalColumn=a.column,a.name!=null&&(c.name=a.name));}var l=c.source;l!=null&&!s.has(l)&&s.add(l);var p=c.name;p!=null&&!u.has(p)&&u.add(p);},this),this._sources=s,this._names=u,t.sources.forEach(function(c){var a=t.sourceContentFor(c);a!=null&&(n!=null&&(c=U.join(n,c)),i!=null&&(c=U.relative(i,c)),this.setSourceContent(c,a));},this);};oe.prototype._validateMapping=function(t,r,n,o){if(r&&typeof r.line!="number"&&typeof r.column!="number"){var i="original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values.";if(this._ignoreInvalidMapping)return typeof console<"u"&&console.warn&&console.warn(i),!1;throw new Error(i)}if(!(t&&"line"in t&&"column"in t&&t.line>0&&t.column>=0&&!r&&!n&&!o)){if(t&&"line"in t&&"column"in t&&r&&"line"in r&&"column"in r&&t.line>0&&t.column>=0&&r.line>0&&r.column>=0&&n)return;var i="Invalid mapping: "+JSON.stringify({generated:t,source:n,original:r,name:o});if(this._ignoreInvalidMapping)return typeof console<"u"&&console.warn&&console.warn(i),!1;throw new Error(i)}};oe.prototype._serializeMappings=function(){for(var t=0,r=1,n=0,o=0,i=0,s=0,u="",c,a,l,p,m=this._mappings.toArray(),f=0,P=m.length;f<P;f++){if(a=m[f],c="",a.generatedLine!==r)for(t=0;a.generatedLine!==r;)c+=";",r++;else if(f>0){if(!U.compareByGeneratedPositionsInflated(a,m[f-1]))continue;c+=",";}c+=ot.encode(a.generatedColumn-t),t=a.generatedColumn,a.source!=null&&(p=this._sources.indexOf(a.source),c+=ot.encode(p-s),s=p,c+=ot.encode(a.originalLine-1-o),o=a.originalLine-1,c+=ot.encode(a.originalColumn-n),n=a.originalColumn,a.name!=null&&(l=this._names.indexOf(a.name),c+=ot.encode(l-i),i=l)),u+=c;}return u};oe.prototype._generateSourcesContent=function(t,r){return t.map(function(n){if(!this._sourcesContents)return null;r!=null&&(n=U.relative(r,n));var o=U.toSetString(n);return Object.prototype.hasOwnProperty.call(this._sourcesContents,o)?this._sourcesContents[o]:null},this)};oe.prototype.toJSON=function(){var t={version:this._version,sources:this._sources.toArray(),names:this._names.toArray(),mappings:this._serializeMappings()};return this._file!=null&&(t.file=this._file),this._sourceRoot!=null&&(t.sourceRoot=this._sourceRoot),this._sourcesContents&&(t.sourcesContent=this._generateSourcesContent(t.sources,t.sourceRoot)),t};oe.prototype.toString=function(){return JSON.stringify(this.toJSON())};di.SourceMapGenerator=oe;});var $e={};b($e,{AtKeyword:()=>I,BadString:()=>Ae,BadUrl:()=>H,CDC:()=>j,CDO:()=>ue,Colon:()=>D,Comma:()=>Y,Comment:()=>E,Delim:()=>g,Dimension:()=>y,EOF:()=>Xe,Function:()=>x,Hash:()=>v,Ident:()=>h,LeftCurlyBracket:()=>z,LeftParenthesis:()=>T,LeftSquareBracket:()=>_,Number:()=>d,Percentage:()=>A,RightCurlyBracket:()=>W,RightParenthesis:()=>w,RightSquareBracket:()=>G,Semicolon:()=>B,String:()=>q,Url:()=>R,WhiteSpace:()=>k});var Xe=0,h=1,x=2,I=3,v=4,q=5,Ae=6,R=7,H=8,g=9,d=10,A=11,y=12,k=13,ue=14,j=15,D=16,B=17,Y=18,_=19,G=20,T=21,w=22,z=23,W=24,E=25;function F(e){return e>=48&&e<=57}function ee(e){return F(e)||e>=65&&e<=70||e>=97&&e<=102}function yt(e){return e>=65&&e<=90}function cs(e){return e>=97&&e<=122}function us(e){return yt(e)||cs(e)}function ps(e){return e>=128}function xt(e){return us(e)||ps(e)||e===95}function Ne(e){return xt(e)||F(e)||e===45}function hs(e){return e>=0&&e<=8||e===11||e>=14&&e<=31||e===127}function Ze(e){return e===10||e===13||e===12}function pe(e){return Ze(e)||e===32||e===9}function X(e,t){return !(e!==92||Ze(t)||t===0)}function ze(e,t,r){return e===45?xt(t)||t===45||X(t,r):xt(e)?!0:e===92?X(e,t):!1}function kt(e,t,r){return e===43||e===45?F(t)?2:t===46&&F(r)?3:0:e===46?F(t)?2:0:F(e)?1:0}function wt(e){return e===65279||e===65534?1:0}var rr=new Array(128),ms=128,Je=130,nr=131,vt=132,or=133;for(let e=0;e<rr.length;e++)rr[e]=pe(e)&&Je||F(e)&&nr||xt(e)&&vt||hs(e)&&or||e||ms;function St(e){return e<128?rr[e]:vt}function Me(e,t){return t<e.length?e.charCodeAt(t):0}function Ct(e,t,r){return r===13&&Me(e,t+1)===10?2:1}function de(e,t,r){let n=e.charCodeAt(t);return yt(n)&&(n=n|32),n===r}function ge(e,t,r,n){if(r-t!==n.length||t<0||r>e.length)return !1;for(let o=t;o<r;o++){let i=n.charCodeAt(o-t),s=e.charCodeAt(o);if(yt(s)&&(s=s|32),s!==i)return !1}return !0}function Uo(e,t){for(;t>=0&&pe(e.charCodeAt(t));t--);return t+1}function et(e,t){for(;t<e.length&&pe(e.charCodeAt(t));t++);return t}function ir(e,t){for(;t<e.length&&F(e.charCodeAt(t));t++);return t}function se(e,t){if(t+=2,ee(Me(e,t-1))){for(let n=Math.min(e.length,t+5);t<n&&ee(Me(e,t));t++);let r=Me(e,t);pe(r)&&(t+=Ct(e,t,r));}return t}function tt(e,t){for(;t<e.length;t++){let r=e.charCodeAt(t);if(!Ne(r)){if(X(r,Me(e,t+1))){t=se(e,t)-1;continue}break}}return t}function Te(e,t){let r=e.charCodeAt(t);if((r===43||r===45)&&(r=e.charCodeAt(t+=1)),F(r)&&(t=ir(e,t+1),r=e.charCodeAt(t)),r===46&&F(e.charCodeAt(t+1))&&(t+=2,t=ir(e,t)),de(e,t,101)){let n=0;r=e.charCodeAt(t+1),(r===45||r===43)&&(n=1,r=e.charCodeAt(t+2)),F(r)&&(t=ir(e,t+1+n+1));}return t}function At(e,t){for(;t<e.length;t++){let r=e.charCodeAt(t);if(r===41){t++;break}X(r,Me(e,t+1))&&(t=se(e,t));}return t}function Re(e){if(e.length===1&&!ee(e.charCodeAt(0)))return e[0];let t=parseInt(e,16);return (t===0||t>=55296&&t<=57343||t>1114111)&&(t=65533),String.fromCodePoint(t)}var Fe=["EOF-token","ident-token","function-token","at-keyword-token","hash-token","string-token","bad-string-token","url-token","bad-url-token","delim-token","number-token","percentage-token","dimension-token","whitespace-token","CDO-token","CDC-token","colon-token","semicolon-token","comma-token","[-token","]-token","(-token",")-token","{-token","}-token"];function Be(e=null,t){return e===null||e.length<t?new Uint32Array(Math.max(t+1024,16384)):e}var jo=10,fs=12,qo=13;function Wo(e){let t=e.source,r=t.length,n=t.length>0?wt(t.charCodeAt(0)):0,o=Be(e.lines,r),i=Be(e.columns,r),s=e.startLine,u=e.startColumn;for(let c=n;c<r;c++){let a=t.charCodeAt(c);o[c]=s,i[c]=u++,(a===jo||a===qo||a===fs)&&(a===qo&&c+1<r&&t.charCodeAt(c+1)===jo&&(c++,o[c]=s,i[c]=u),s++,u=1);}o[r]=s,i[r]=u,e.lines=o,e.columns=i,e.computed=!0;}var Tt=class{constructor(){this.lines=null,this.columns=null,this.computed=!1;}setSource(t,r=0,n=1,o=1){this.source=t,this.startOffset=r,this.startLine=n,this.startColumn=o,this.computed=!1;}getLocation(t,r){return this.computed||Wo(this),{source:r,offset:this.startOffset+t,line:this.lines[t],column:this.columns[t]}}getLocationRange(t,r,n){return this.computed||Wo(this),{source:n,start:{offset:this.startOffset+t,line:this.lines[t],column:this.columns[t]},end:{offset:this.startOffset+r,line:this.lines[r],column:this.columns[r]}}}};var ne=16777215,we=24,ds=new Map([[2,22],[21,22],[19,20],[23,24]]),rt=class{constructor(t,r){this.setSource(t,r);}reset(){this.eof=!1,this.tokenIndex=-1,this.tokenType=0,this.tokenStart=this.firstCharOffset,this.tokenEnd=this.firstCharOffset;}setSource(t="",r=()=>{}){t=String(t||"");let n=t.length,o=Be(this.offsetAndType,t.length+1),i=Be(this.balance,t.length+1),s=0,u=0,c=0,a=-1;for(this.offsetAndType=null,this.balance=null,r(t,(l,p,m)=>{switch(l){default:i[s]=n;break;case u:{let f=c&ne;for(c=i[f],u=c>>we,i[s]=f,i[f++]=s;f<s;f++)i[f]===n&&(i[f]=s);break}case 21:case 2:case 19:case 23:i[s]=c,u=ds.get(l),c=u<<we|s;break}o[s++]=l<<we|m,a===-1&&(a=p);}),o[s]=0<<we|n,i[s]=n,i[n]=n;c!==0;){let l=c&ne;c=i[l],i[l]=n;}this.source=t,this.firstCharOffset=a===-1?0:a,this.tokenCount=s,this.offsetAndType=o,this.balance=i,this.reset(),this.next();}lookupType(t){return t+=this.tokenIndex,t<this.tokenCount?this.offsetAndType[t]>>we:0}lookupOffset(t){return t+=this.tokenIndex,t<this.tokenCount?this.offsetAndType[t-1]&ne:this.source.length}lookupValue(t,r){return t+=this.tokenIndex,t<this.tokenCount?ge(this.source,this.offsetAndType[t-1]&ne,this.offsetAndType[t]&ne,r):!1}getTokenStart(t){return t===this.tokenIndex?this.tokenStart:t>0?t<this.tokenCount?this.offsetAndType[t-1]&ne:this.offsetAndType[this.tokenCount]&ne:this.firstCharOffset}substrToCursor(t){return this.source.substring(t,this.tokenStart)}isBalanceEdge(t){return this.balance[this.tokenIndex]<t}isDelim(t,r){return r?this.lookupType(r)===9&&this.source.charCodeAt(this.lookupOffset(r))===t:this.tokenType===9&&this.source.charCodeAt(this.tokenStart)===t}skip(t){let r=this.tokenIndex+t;r<this.tokenCount?(this.tokenIndex=r,this.tokenStart=this.offsetAndType[r-1]&ne,r=this.offsetAndType[r],this.tokenType=r>>we,this.tokenEnd=r&ne):(this.tokenIndex=this.tokenCount,this.next());}next(){let t=this.tokenIndex+1;t<this.tokenCount?(this.tokenIndex=t,this.tokenStart=this.tokenEnd,t=this.offsetAndType[t],this.tokenType=t>>we,this.tokenEnd=t&ne):(this.eof=!0,this.tokenIndex=this.tokenCount,this.tokenType=0,this.tokenStart=this.tokenEnd=this.source.length);}skipSC(){for(;this.tokenType===13||this.tokenType===25;)this.next();}skipUntilBalanced(t,r){let n=t,o,i;e:for(;n<this.tokenCount;n++){if(o=this.balance[n],o<t)break e;switch(i=n>0?this.offsetAndType[n-1]&ne:this.firstCharOffset,r(this.source.charCodeAt(i))){case 1:break e;case 2:n++;break e;default:this.balance[o]===n&&(n=o);}}this.skip(n-this.tokenIndex);}forEachToken(t){for(let r=0,n=this.firstCharOffset;r<this.tokenCount;r++){let o=n,i=this.offsetAndType[r],s=i&ne,u=i>>we;n=s,t(u,o,s,r);}}dump(){let t=new Array(this.tokenCount);return this.forEachToken((r,n,o,i)=>{t[i]={idx:i,type:Fe[r],chunk:this.source.substring(n,o),balance:this.balance[i]};}),t}};function ve(e,t){function r(p){return p<u?e.charCodeAt(p):0}function n(){if(a=Te(e,a),ze(r(a),r(a+1),r(a+2))){l=12,a=tt(e,a);return}if(r(a)===37){l=11,a++;return}l=10;}function o(){let p=a;if(a=tt(e,a),ge(e,p,a,"url")&&r(a)===40){if(a=et(e,a+1),r(a)===34||r(a)===39){l=2,a=p+4;return}s();return}if(r(a)===40){l=2,a++;return}l=1;}function i(p){for(p||(p=r(a++)),l=5;a<e.length;a++){let m=e.charCodeAt(a);switch(St(m)){case p:a++;return;case Je:if(Ze(m)){a+=Ct(e,a,m),l=6;return}break;case 92:if(a===e.length-1)break;let f=r(a+1);Ze(f)?a+=Ct(e,a+1,f):X(m,f)&&(a=se(e,a)-1);break}}}function s(){for(l=7,a=et(e,a);a<e.length;a++){let p=e.charCodeAt(a);switch(St(p)){case 41:a++;return;case Je:if(a=et(e,a),r(a)===41||a>=e.length){a<e.length&&a++;return}a=At(e,a),l=8;return;case 34:case 39:case 40:case or:a=At(e,a),l=8;return;case 92:if(X(p,r(a+1))){a=se(e,a)-1;break}a=At(e,a),l=8;return}}}e=String(e||"");let u=e.length,c=wt(r(0)),a=c,l;for(;a<u;){let p=e.charCodeAt(a);switch(St(p)){case Je:l=13,a=et(e,a+1);break;case 34:i();break;case 35:Ne(r(a+1))||X(r(a+1),r(a+2))?(l=4,a=tt(e,a+1)):(l=9,a++);break;case 39:i();break;case 40:l=21,a++;break;case 41:l=22,a++;break;case 43:kt(p,r(a+1),r(a+2))?n():(l=9,a++);break;case 44:l=18,a++;break;case 45:kt(p,r(a+1),r(a+2))?n():r(a+1)===45&&r(a+2)===62?(l=15,a=a+3):ze(p,r(a+1),r(a+2))?o():(l=9,a++);break;case 46:kt(p,r(a+1),r(a+2))?n():(l=9,a++);break;case 47:r(a+1)===42?(l=25,a=e.indexOf("*/",a+2),a=a===-1?e.length:a+2):(l=9,a++);break;case 58:l=16,a++;break;case 59:l=17,a++;break;case 60:r(a+1)===33&&r(a+2)===45&&r(a+3)===45?(l=14,a=a+4):(l=9,a++);break;case 64:ze(r(a+1),r(a+2),r(a+3))?(l=3,a=tt(e,a+1)):(l=9,a++);break;case 91:l=19,a++;break;case 92:X(p,r(a+1))?o():(l=9,a++);break;case 93:l=20,a++;break;case 123:l=23,a++;break;case 125:l=24,a++;break;case nr:n();break;case vt:o();break;default:l=9,a++;}t(l,c,c=a);}}var _e=null,$=class e{static createItem(t){return {prev:null,next:null,data:t}}constructor(){this.head=null,this.tail=null,this.cursor=null;}createItem(t){return e.createItem(t)}allocateCursor(t,r){let n;return _e!==null?(n=_e,_e=_e.cursor,n.prev=t,n.next=r,n.cursor=this.cursor):n={prev:t,next:r,cursor:this.cursor},this.cursor=n,n}releaseCursor(){let{cursor:t}=this;this.cursor=t.cursor,t.prev=null,t.next=null,t.cursor=_e,_e=t;}updateCursors(t,r,n,o){let{cursor:i}=this;for(;i!==null;)i.prev===t&&(i.prev=r),i.next===n&&(i.next=o),i=i.cursor;}*[Symbol.iterator](){for(let t=this.head;t!==null;t=t.next)yield t.data;}get size(){let t=0;for(let r=this.head;r!==null;r=r.next)t++;return t}get isEmpty(){return this.head===null}get first(){return this.head&&this.head.data}get last(){return this.tail&&this.tail.data}fromArray(t){let r=null;this.head=null;for(let n of t){let o=e.createItem(n);r!==null?r.next=o:this.head=o,o.prev=r,r=o;}return this.tail=r,this}toArray(){return [...this]}toJSON(){return [...this]}forEach(t,r=this){let n=this.allocateCursor(null,this.head);for(;n.next!==null;){let o=n.next;n.next=o.next,t.call(r,o.data,o,this);}this.releaseCursor();}forEachRight(t,r=this){let n=this.allocateCursor(this.tail,null);for(;n.prev!==null;){let o=n.prev;n.prev=o.prev,t.call(r,o.data,o,this);}this.releaseCursor();}reduce(t,r,n=this){let o=this.allocateCursor(null,this.head),i=r,s;for(;o.next!==null;)s=o.next,o.next=s.next,i=t.call(n,i,s.data,s,this);return this.releaseCursor(),i}reduceRight(t,r,n=this){let o=this.allocateCursor(this.tail,null),i=r,s;for(;o.prev!==null;)s=o.prev,o.prev=s.prev,i=t.call(n,i,s.data,s,this);return this.releaseCursor(),i}some(t,r=this){for(let n=this.head;n!==null;n=n.next)if(t.call(r,n.data,n,this))return !0;return !1}map(t,r=this){let n=new e;for(let o=this.head;o!==null;o=o.next)n.appendData(t.call(r,o.data,o,this));return n}filter(t,r=this){let n=new e;for(let o=this.head;o!==null;o=o.next)t.call(r,o.data,o,this)&&n.appendData(o.data);return n}nextUntil(t,r,n=this){if(t===null)return;let o=this.allocateCursor(null,t);for(;o.next!==null;){let i=o.next;if(o.next=i.next,r.call(n,i.data,i,this))break}this.releaseCursor();}prevUntil(t,r,n=this){if(t===null)return;let o=this.allocateCursor(t,null);for(;o.prev!==null;){let i=o.prev;if(o.prev=i.prev,r.call(n,i.data,i,this))break}this.releaseCursor();}clear(){this.head=null,this.tail=null;}copy(){let t=new e;for(let r of this)t.appendData(r);return t}prepend(t){return this.updateCursors(null,t,this.head,t),this.head!==null?(this.head.prev=t,t.next=this.head):this.tail=t,this.head=t,this}prependData(t){return this.prepend(e.createItem(t))}append(t){return this.insert(t)}appendData(t){return this.insert(e.createItem(t))}insert(t,r=null){if(r!==null)if(this.updateCursors(r.prev,t,r,t),r.prev===null){if(this.head!==r)throw new Error("before doesn't belong to list");this.head=t,r.prev=t,t.next=r,this.updateCursors(null,t);}else r.prev.next=t,t.prev=r.prev,r.prev=t,t.next=r;else this.updateCursors(this.tail,t,null,t),this.tail!==null?(this.tail.next=t,t.prev=this.tail):this.head=t,this.tail=t;return this}insertData(t,r){return this.insert(e.createItem(t),r)}remove(t){if(this.updateCursors(t,t.prev,t,t.next),t.prev!==null)t.prev.next=t.next;else {if(this.head!==t)throw new Error("item doesn't belong to list");this.head=t.next;}if(t.next!==null)t.next.prev=t.prev;else {if(this.tail!==t)throw new Error("item doesn't belong to list");this.tail=t.prev;}return t.prev=null,t.next=null,t}push(t){this.insert(e.createItem(t));}pop(){return this.tail!==null?this.remove(this.tail):null}unshift(t){this.prepend(e.createItem(t));}shift(){return this.head!==null?this.remove(this.head):null}prependList(t){return this.insertList(t,this.head)}appendList(t){return this.insertList(t)}insertList(t,r){return t.head===null?this:(r!=null?(this.updateCursors(r.prev,t.tail,r,t.head),r.prev!==null?(r.prev.next=t.head,t.head.prev=r.prev):this.head=t.head,r.prev=t.tail,t.tail.next=r):(this.updateCursors(this.tail,t.tail,null,t.head),this.tail!==null?(this.tail.next=t.head,t.head.prev=this.tail):this.head=t.head,this.tail=t.tail),t.head=null,t.tail=null,this)}replace(t,r){"head"in r?this.insertList(r,t):this.insert(r,t),this.remove(t);}};function Ee(e,t){let r=Object.create(SyntaxError.prototype),n=new Error;return Object.assign(r,{name:e,message:t,get stack(){return (n.stack||"").replace(/^(.+\n){1,3}/,`${e}: ${t}
`)}})}var ar=100,Ho=60,Yo="    ";function Go({source:e,line:t,column:r},n){function o(l,p){return i.slice(l,p).map((m,f)=>String(l+f+1).padStart(c)+" |"+m).join(`
`)}let i=e.split(/\r\n?|\n|\f/),s=Math.max(1,t-n)-1,u=Math.min(t+n,i.length+1),c=Math.max(4,String(u).length)+1,a=0;r+=(Yo.length-1)*(i[t-1].substr(0,r-1).match(/\t/g)||[]).length,r>ar&&(a=r-Ho+3,r=Ho-2);for(let l=s;l<=u;l++)l>=0&&l<i.length&&(i[l]=i[l].replace(/\t/g,Yo),i[l]=(a>0&&i[l].length>a?"\u2026":"")+i[l].substr(a,ar-2)+(i[l].length>a+ar-1?"\u2026":""));return [o(s,t),new Array(r+c+2).join("-")+"^",o(t,u)].filter(Boolean).join(`
`)}function sr(e,t,r,n,o){return Object.assign(Ee("SyntaxError",e),{source:t,offset:r,line:n,column:o,sourceFragment(s){return Go({source:t,line:n,column:o},isNaN(s)?0:s)},get formattedMessage(){return `Parse error: ${e}
`+Go({source:t,line:n,column:o},2)}})}function Vo(e){let t=this.createList(),r=!1,n={recognizer:e};for(;!this.eof;){switch(this.tokenType){case 25:this.next();continue;case 13:r=!0,this.next();continue}let o=e.getNode.call(this,n);if(o===void 0)break;r&&(e.onWhiteSpace&&e.onWhiteSpace.call(this,o,t,n),r=!1),t.push(o);}return r&&e.onWhiteSpace&&e.onWhiteSpace.call(this,null,t,n),t}var Ko=()=>{},gs=33,bs=35,lr=59,Qo=123,Xo=0;function xs(e){return function(){return this[e]()}}function cr(e){let t=Object.create(null);for(let r in e){let n=e[r],o=n.parse||n;o&&(t[r]=o);}return t}function ys(e){let t={context:Object.create(null),scope:Object.assign(Object.create(null),e.scope),atrule:cr(e.atrule),pseudo:cr(e.pseudo),node:cr(e.node)};for(let r in e.parseContext)switch(typeof e.parseContext[r]){case"function":t.context[r]=e.parseContext[r];break;case"string":t.context[r]=xs(e.parseContext[r]);break}return {config:t,...t,...t.node}}function $o(e){let t="",r="<unknown>",n=!1,o=Ko,i=!1,s=new Tt,u=Object.assign(new rt,ys(e||{}),{parseAtrulePrelude:!0,parseRulePrelude:!0,parseValue:!0,parseCustomProperty:!1,readSequence:Vo,consumeUntilBalanceEnd:()=>0,consumeUntilLeftCurlyBracket(a){return a===Qo?1:0},consumeUntilLeftCurlyBracketOrSemicolon(a){return a===Qo||a===lr?1:0},consumeUntilExclamationMarkOrSemicolon(a){return a===gs||a===lr?1:0},consumeUntilSemicolonIncluded(a){return a===lr?2:0},createList(){return new $},createSingleNodeList(a){return new $().appendData(a)},getFirstListNode(a){return a&&a.first},getLastListNode(a){return a&&a.last},parseWithFallback(a,l){let p=this.tokenIndex;try{return a.call(this)}catch(m){if(i)throw m;let f=l.call(this,p);return i=!0,o(m,f),i=!1,f}},lookupNonWSType(a){let l;do if(l=this.lookupType(a++),l!==13)return l;while(l!==Xo);return Xo},charCodeAt(a){return a>=0&&a<t.length?t.charCodeAt(a):0},substring(a,l){return t.substring(a,l)},substrToCursor(a){return this.source.substring(a,this.tokenStart)},cmpChar(a,l){return de(t,a,l)},cmpStr(a,l,p){return ge(t,a,l,p)},consume(a){let l=this.tokenStart;return this.eat(a),this.substrToCursor(l)},consumeFunctionName(){let a=t.substring(this.tokenStart,this.tokenEnd-1);return this.eat(2),a},consumeNumber(a){let l=t.substring(this.tokenStart,Te(t,this.tokenStart));return this.eat(a),l},eat(a){if(this.tokenType!==a){let l=Fe[a].slice(0,-6).replace(/-/g," ").replace(/^./,f=>f.toUpperCase()),p=`${/[[\](){}]/.test(l)?`"${l}"`:l} is expected`,m=this.tokenStart;switch(a){case 1:this.tokenType===2||this.tokenType===7?(m=this.tokenEnd-1,p="Identifier is expected but function found"):p="Identifier is expected";break;case 4:this.isDelim(bs)&&(this.next(),m++,p="Name is expected");break;case 11:this.tokenType===10&&(m=this.tokenEnd,p="Percent sign is expected");break}this.error(p,m);}this.next();},eatIdent(a){(this.tokenType!==1||this.lookupValue(0,a)===!1)&&this.error(`Identifier "${a}" is expected`),this.next();},eatDelim(a){this.isDelim(a)||this.error(`Delim "${String.fromCharCode(a)}" is expected`),this.next();},getLocation(a,l){return n?s.getLocationRange(a,l,r):null},getLocationFromList(a){if(n){let l=this.getFirstListNode(a),p=this.getLastListNode(a);return s.getLocationRange(l!==null?l.loc.start.offset-s.startOffset:this.tokenStart,p!==null?p.loc.end.offset-s.startOffset:this.tokenStart,r)}return null},error(a,l){let p=typeof l<"u"&&l<t.length?s.getLocation(l):this.eof?s.getLocation(Uo(t,t.length-1)):s.getLocation(this.tokenStart);throw new sr(a||"Unexpected input",t,p.offset,p.line,p.column)}});return Object.assign(function(a,l){t=a,l=l||{},u.setSource(t,ve),s.setSource(t,l.offset,l.line,l.column),r=l.filename||"<unknown>",n=!!l.positions,o=typeof l.onParseError=="function"?l.onParseError:Ko,i=!1,u.parseAtrulePrelude="parseAtrulePrelude"in l?!!l.parseAtrulePrelude:!0,u.parseRulePrelude="parseRulePrelude"in l?!!l.parseRulePrelude:!0,u.parseValue="parseValue"in l?!!l.parseValue:!0,u.parseCustomProperty="parseCustomProperty"in l?!!l.parseCustomProperty:!1;let{context:p="default",onComment:m}=l;if(!(p in u.context))throw new Error("Unknown context `"+p+"`");typeof m=="function"&&u.forEachToken((P,te,Q)=>{if(P===25){let S=u.getLocation(te,Q),M=ge(t,Q-2,Q,"*/")?t.slice(te+2,Q-2):t.slice(te+2,Q);m(M,S);}});let f=u.context[p].call(u,l);return u.eof||u.error(),f},{SyntaxError:sr,config:u.config})}var xi=ls(gi()),bi=new Set(["Atrule","Selector","Declaration"]);function yi(e){let t=new xi.SourceMapGenerator,r={line:1,column:0},n={line:0,column:0},o={line:1,column:0},i={generated:o},s=1,u=0,c=!1,a=e.node;e.node=function(m){if(m.loc&&m.loc.start&&bi.has(m.type)){let f=m.loc.start.line,P=m.loc.start.column-1;(n.line!==f||n.column!==P)&&(n.line=f,n.column=P,r.line=s,r.column=u,c&&(c=!1,(r.line!==o.line||r.column!==o.column)&&t.addMapping(i)),c=!0,t.addMapping({source:m.loc.source,original:n,generated:r}));}a.call(this,m),c&&bi.has(m.type)&&(o.line=s,o.column=u);};let l=e.emit;e.emit=function(m,f,P){for(let te=0;te<m.length;te++)m.charCodeAt(te)===10?(s++,u=0):u++;l(m,f,P);};let p=e.result;return e.result=function(){return c&&t.addMapping(i),{css:p(),map:t}},e}var It={};b(It,{safe:()=>br,spec:()=>js});var Bs=43,_s=45,gr=(e,t)=>{if(e===9&&(e=t),typeof e=="string"){let r=e.charCodeAt(0);return r>127?32768:r<<8}return e},ki=[[1,1],[1,2],[1,7],[1,8],[1,"-"],[1,10],[1,11],[1,12],[1,15],[1,21],[3,1],[3,2],[3,7],[3,8],[3,"-"],[3,10],[3,11],[3,12],[3,15],[4,1],[4,2],[4,7],[4,8],[4,"-"],[4,10],[4,11],[4,12],[4,15],[12,1],[12,2],[12,7],[12,8],[12,"-"],[12,10],[12,11],[12,12],[12,15],["#",1],["#",2],["#",7],["#",8],["#","-"],["#",10],["#",11],["#",12],["#",15],["-",1],["-",2],["-",7],["-",8],["-","-"],["-",10],["-",11],["-",12],["-",15],[10,1],[10,2],[10,7],[10,8],[10,10],[10,11],[10,12],[10,"%"],[10,15],["@",1],["@",2],["@",7],["@",8],["@","-"],["@",15],[".",10],[".",11],[".",12],["+",10],["+",11],["+",12],["/","*"]],Us=ki.concat([[1,4],[12,4],[4,4],[3,21],[3,5],[3,16],[11,11],[11,12],[11,2],[11,"-"],[22,1],[22,2],[22,11],[22,12],[22,4],[22,"-"]]);function wi(e){let t=new Set(e.map(([r,n])=>gr(r)<<16|gr(n)));return function(r,n,o){let i=gr(n,o),s=o.charCodeAt(0);return (s===_s&&n!==1&&n!==2&&n!==15||s===Bs?t.has(r<<16|s<<8):t.has(r<<16|i))&&this.emit(" ",13,!0),i}}var js=wi(ki),br=wi(Us);var qs=92;function Ws(e,t){if(typeof t=="function"){let r=null;e.children.forEach(n=>{r!==null&&t.call(this,r),this.node(n),r=n;});return}e.children.forEach(this.node,this);}function Hs(e){ve(e,(t,r,n)=>{this.token(t,e.slice(r,n));});}function vi(e){let t=new Map;for(let r in e.node){let n=e.node[r];typeof(n.generate||n)=="function"&&t.set(r,n.generate||n);}return function(r,n){let o="",i=0,s={node(c){if(t.has(c.type))t.get(c.type).call(u,c);else throw new Error("Unknown node type: "+c.type)},tokenBefore:br,token(c,a){i=this.tokenBefore(i,c,a),this.emit(a,c,!1),c===9&&a.charCodeAt(0)===qs&&this.emit(`
`,13,!0);},emit(c){o+=c;},result(){return o}};n&&(typeof n.decorator=="function"&&(s=n.decorator(s)),n.sourceMap&&(s=yi(s)),n.mode in It&&(s.tokenBefore=It[n.mode]));let u={node:c=>s.node(c),children:Ws,token:(c,a)=>s.token(c,a),tokenize:Hs};return s.node(r),s.result()}}function Si(e){return {fromPlainObject(t){return e(t,{enter(r){r.children&&!(r.children instanceof $)&&(r.children=new $().fromArray(r.children));}}),t},toPlainObject(t){return e(t,{leave(r){r.children&&r.children instanceof $&&(r.children=r.children.toArray());}}),t}}}var{hasOwnProperty:xr}=Object.prototype,it=function(){};function Ci(e){return typeof e=="function"?e:it}function Ai(e,t){return function(r,n,o){r.type===t&&e.call(this,r,n,o);}}function Ys(e,t){let r=t.structure,n=[];for(let o in r){if(xr.call(r,o)===!1)continue;let i=r[o],s={name:o,type:!1,nullable:!1};Array.isArray(i)||(i=[i]);for(let u of i)u===null?s.nullable=!0:typeof u=="string"?s.type="node":Array.isArray(u)&&(s.type="list");s.type&&n.push(s);}return n.length?{context:t.walkContext,fields:n}:null}function Gs(e){let t={};for(let r in e.node)if(xr.call(e.node,r)){let n=e.node[r];if(!n.structure)throw new Error("Missed `structure` field in `"+r+"` node type definition");t[r]=Ys(r,n);}return t}function Ti(e,t){let r=e.fields.slice(),n=e.context,o=typeof n=="string";return t&&r.reverse(),function(i,s,u,c){let a;o&&(a=s[n],s[n]=i);for(let l of r){let p=i[l.name];if(!l.nullable||p){if(l.type==="list"){if(t?p.reduceRight(c,!1):p.reduce(c,!1))return !0}else if(u(p))return !0}}o&&(s[n]=a);}}function Ei({StyleSheet:e,Atrule:t,Rule:r,Block:n,DeclarationList:o}){return {Atrule:{StyleSheet:e,Atrule:t,Rule:r,Block:n},Rule:{StyleSheet:e,Atrule:t,Rule:r,Block:n},Declaration:{StyleSheet:e,Atrule:t,Rule:r,Block:n,DeclarationList:o}}}function Li(e){let t=Gs(e),r={},n={},o=Symbol("break-walk"),i=Symbol("skip-node");for(let a in t)xr.call(t,a)&&t[a]!==null&&(r[a]=Ti(t[a],!1),n[a]=Ti(t[a],!0));let s=Ei(r),u=Ei(n),c=function(a,l){function p(S,M,ke){let N=m.call(Q,S,M,ke);return N===o?!0:N===i?!1:!!(P.hasOwnProperty(S.type)&&P[S.type](S,Q,p,te)||f.call(Q,S,M,ke)===o)}let m=it,f=it,P=r,te=(S,M,ke,N)=>S||p(M,ke,N),Q={break:o,skip:i,root:a,stylesheet:null,atrule:null,atrulePrelude:null,rule:null,selector:null,block:null,declaration:null,function:null};if(typeof l=="function")m=l;else if(l&&(m=Ci(l.enter),f=Ci(l.leave),l.reverse&&(P=n),l.visit)){if(s.hasOwnProperty(l.visit))P=l.reverse?u[l.visit]:s[l.visit];else if(!t.hasOwnProperty(l.visit))throw new Error("Bad value `"+l.visit+"` for `visit` option (should be: "+Object.keys(t).sort().join(", ")+")");m=Ai(m,l.visit),f=Ai(f,l.visit);}if(m===it&&f===it)throw new Error("Neither `enter` nor `leave` walker handler is set or both aren't a function");p(a);};return c.break=o,c.skip=i,c.find=function(a,l){let p=null;return c(a,function(m,f,P){if(l.call(this,m,f,P))return p=m,o}),p},c.findLast=function(a,l){let p=null;return c(a,{reverse:!0,enter(m,f,P){if(l.call(this,m,f,P))return p=m,o}}),p},c.findAll=function(a,l){let p=[];return c(a,function(m,f,P){l.call(this,m,f,P)&&p.push(m);}),p},c}function Vs(e){return e}function Ks(e){let{min:t,max:r,comma:n}=e;return t===0&&r===0?n?"#?":"*":t===0&&r===1?"?":t===1&&r===0?n?"#":"+":t===1&&r===1?"":(n?"#":"")+(t===r?"{"+t+"}":"{"+t+","+(r!==0?r:"")+"}")}function Qs(e){switch(e.type){case"Range":return " ["+(e.min===null?"-\u221E":e.min)+","+(e.max===null?"\u221E":e.max)+"]";default:throw new Error("Unknown node type `"+e.type+"`")}}function Xs(e,t,r,n){let o=e.combinator===" "||n?e.combinator:" "+e.combinator+" ",i=e.terms.map(s=>yr(s,t,r,n)).join(o);return e.explicit||r?(n||i[0]===","?"[":"[ ")+i+(n?"]":" ]"):i}function yr(e,t,r,n){let o;switch(e.type){case"Group":o=Xs(e,t,r,n)+(e.disallowEmpty?"!":"");break;case"Multiplier":return yr(e.term,t,r,n)+t(Ks(e),e);case"Type":o="<"+e.name+(e.opts?t(Qs(e.opts),e.opts):"")+">";break;case"Property":o="<'"+e.name+"'>";break;case"Keyword":o=e.name;break;case"AtKeyword":o="@"+e.name;break;case"Function":o=e.name+"(";break;case"String":case"Token":o=e.value;break;case"Comma":o=",";break;default:throw new Error("Unknown node type `"+e.type+"`")}return t(o,e)}function Pe(e,t){let r=Vs,n=!1,o=!1;return typeof t=="function"?r=t:t&&(n=!!t.forceBraces,o=!!t.compact,typeof t.decorate=="function"&&(r=t.decorate)),yr(e,r,n,o)}var Pi={offset:0,line:1,column:1};function $s(e,t){let r=e.tokens,n=e.longestMatch,o=n<r.length&&r[n].node||null,i=o!==t?o:null,s=0,u=0,c=0,a="",l,p;for(let m=0;m<r.length;m++){let f=r[m].value;m===n&&(u=f.length,s=a.length),i!==null&&r[m].node===i&&(m<=n?c++:c=0),a+=f;}return n===r.length||c>1?(l=Dt(i||t,"end")||at(Pi,a),p=at(l)):(l=Dt(i,"start")||at(Dt(t,"start")||Pi,a.slice(0,s)),p=Dt(i,"end")||at(l,a.substr(s,u))),{css:a,mismatchOffset:s,mismatchLength:u,start:l,end:p}}function Dt(e,t){let r=e&&e.loc&&e.loc[t];return r?"line"in r?at(r):r:null}function at({offset:e,line:t,column:r},n){let o={offset:e,line:t,column:r};if(n){let i=n.split(/\n|\r\n?|\f/);o.offset+=n.length,o.line+=i.length-1,o.column=i.length===1?o.column+n.length:i.pop().length+1;}return o}var je=function(e,t){let r=Ee("SyntaxReferenceError",e+(t?" `"+t+"`":""));return r.reference=t,r},Ii=function(e,t,r,n){let o=Ee("SyntaxMatchError",e),{css:i,mismatchOffset:s,mismatchLength:u,start:c,end:a}=$s(n,r);return o.rawMessage=e,o.syntax=t?Pe(t):"<generic>",o.css=i,o.mismatchOffset=s,o.mismatchLength=u,o.message=e+`
  syntax: `+o.syntax+`
   value: `+(i||"<empty string>")+`
  --------`+new Array(o.mismatchOffset+1).join("-")+"^",Object.assign(o,c),o.loc={source:r&&r.loc&&r.loc.source||"<unknown>",start:c,end:a},o};var Ot=new Map,qe=new Map,Nt=45,zt=Zs,kr=Js;function Mt(e,t){return t=t||0,e.length-t>=2&&e.charCodeAt(t)===Nt&&e.charCodeAt(t+1)===Nt}function wr(e,t){if(t=t||0,e.length-t>=3&&e.charCodeAt(t)===Nt&&e.charCodeAt(t+1)!==Nt){let r=e.indexOf("-",t+2);if(r!==-1)return e.substring(t,r+1)}return ""}function Zs(e){if(Ot.has(e))return Ot.get(e);let t=e.toLowerCase(),r=Ot.get(t);if(r===void 0){let n=Mt(t,0),o=n?"":wr(t,0);r=Object.freeze({basename:t.substr(o.length),name:t,prefix:o,vendor:o,custom:n});}return Ot.set(e,r),r}function Js(e){if(qe.has(e))return qe.get(e);let t=e,r=e[0];r==="/"?r=e[1]==="/"?"//":"/":r!=="_"&&r!=="*"&&r!=="$"&&r!=="#"&&r!=="+"&&r!=="&"&&(r="");let n=Mt(t,r.length);if(!n&&(t=t.toLowerCase(),qe.has(t))){let u=qe.get(t);return qe.set(e,u),u}let o=n?"":wr(t,r.length),i=t.substr(0,r.length+o.length),s=Object.freeze({basename:t.substr(i.length),name:t.substr(r.length),hack:r,vendor:o,prefix:i,custom:n});return qe.set(e,s),s}var Rt=["initial","inherit","unset","revert","revert-layer"];var lt=43,he=45,vr=110,We=!0,tl=!1;function Cr(e,t){return e!==null&&e.type===9&&e.value.charCodeAt(0)===t}function st(e,t,r){for(;e!==null&&(e.type===13||e.type===25);)e=r(++t);return t}function Se(e,t,r,n){if(!e)return 0;let o=e.value.charCodeAt(t);if(o===lt||o===he){if(r)return 0;t++;}for(;t<e.value.length;t++)if(!F(e.value.charCodeAt(t)))return 0;return n+1}function Sr(e,t,r){let n=!1,o=st(e,t,r);if(e=r(o),e===null)return t;if(e.type!==10)if(Cr(e,lt)||Cr(e,he)){if(n=!0,o=st(r(++o),o,r),e=r(o),e===null||e.type!==10)return 0}else return t;if(!n){let i=e.value.charCodeAt(0);if(i!==lt&&i!==he)return 0}return Se(e,n?0:1,n,o)}function Ar(e,t){let r=0;if(!e)return 0;if(e.type===10)return Se(e,0,tl,r);if(e.type===1&&e.value.charCodeAt(0)===he){if(!de(e.value,1,vr))return 0;switch(e.value.length){case 2:return Sr(t(++r),r,t);case 3:return e.value.charCodeAt(2)!==he?0:(r=st(t(++r),r,t),e=t(r),Se(e,0,We,r));default:return e.value.charCodeAt(2)!==he?0:Se(e,3,We,r)}}else if(e.type===1||Cr(e,lt)&&t(r+1).type===1){if(e.type!==1&&(e=t(++r)),e===null||!de(e.value,0,vr))return 0;switch(e.value.length){case 1:return Sr(t(++r),r,t);case 2:return e.value.charCodeAt(1)!==he?0:(r=st(t(++r),r,t),e=t(r),Se(e,0,We,r));default:return e.value.charCodeAt(1)!==he?0:Se(e,2,We,r)}}else if(e.type===12){let n=e.value.charCodeAt(0),o=n===lt||n===he?1:0,i=o;for(;i<e.value.length&&F(e.value.charCodeAt(i));i++);return i===o||!de(e.value,i,vr)?0:i+1===e.value.length?Sr(t(++r),r,t):e.value.charCodeAt(i+1)!==he?0:i+2===e.value.length?(r=st(t(++r),r,t),e=t(r),Se(e,0,We,r)):Se(e,i+2,We,r)}return 0}var rl=43,Di=45,Oi=63,nl=117;function Tr(e,t){return e!==null&&e.type===9&&e.value.charCodeAt(0)===t}function ol(e,t){return e.value.charCodeAt(0)===t}function ct(e,t,r){let n=0;for(let o=t;o<e.value.length;o++){let i=e.value.charCodeAt(o);if(i===Di&&r&&n!==0)return ct(e,t+n+1,!1),6;if(!ee(i)||++n>6)return 0}return n}function Ft(e,t,r){if(!e)return 0;for(;Tr(r(t),Oi);){if(++e>6)return 0;t++;}return t}function Er(e,t){let r=0;if(e===null||e.type!==1||!de(e.value,0,nl)||(e=t(++r),e===null))return 0;if(Tr(e,rl))return e=t(++r),e===null?0:e.type===1?Ft(ct(e,0,!0),++r,t):Tr(e,Oi)?Ft(1,++r,t):0;if(e.type===10){let n=ct(e,1,!0);return n===0?0:(e=t(++r),e===null?r:e.type===12||e.type===10?!ol(e,Di)||!ct(e,1,!1)?0:r+1:Ft(n,r,t))}return e.type===12?Ft(ct(e,1,!0),++r,t):0}var il=["calc(","-moz-calc(","-webkit-calc("],Lr=new Map([[2,22],[21,22],[19,20],[23,24]]);function le(e,t){return t<e.length?e.charCodeAt(t):0}function Ni(e,t){return ge(e,0,e.length,t)}function zi(e,t){for(let r=0;r<t.length;r++)if(Ni(e,t[r]))return !0;return !1}function Mi(e,t){return t!==e.length-2?!1:le(e,t)===92&&F(le(e,t+1))}function Bt(e,t,r){if(e&&e.type==="Range"){let n=Number(r!==void 0&&r!==t.length?t.substr(0,r):t);if(isNaN(n)||e.min!==null&&n<e.min&&typeof e.min!="string"||e.max!==null&&n>e.max&&typeof e.max!="string")return !0}return !1}function al(e,t){let r=0,n=[],o=0;e:do{switch(e.type){case 24:case 22:case 20:if(e.type!==r)break e;if(r=n.pop(),n.length===0){o++;break e}break;case 2:case 21:case 19:case 23:n.push(r),r=Lr.get(e.type);break}o++;}while(e=t(o));return o}function ie(e){return function(t,r,n){return t===null?0:t.type===2&&zi(t.value,il)?al(t,r):e(t,r,n)}}function O(e){return function(t){return t===null||t.type!==e?0:1}}function sl(e){if(e===null||e.type!==1)return 0;let t=e.value.toLowerCase();return zi(t,Rt)||Ni(t,"default")?0:1}function ll(e){return e===null||e.type!==1||le(e.value,0)!==45||le(e.value,1)!==45?0:1}function cl(e){if(e===null||e.type!==4)return 0;let t=e.value.length;if(t!==4&&t!==5&&t!==7&&t!==9)return 0;for(let r=1;r<t;r++)if(!ee(le(e.value,r)))return 0;return 1}function ul(e){return e===null||e.type!==4||!ze(le(e.value,1),le(e.value,2),le(e.value,3))?0:1}function pl(e,t){if(!e)return 0;let r=0,n=[],o=0;e:do{switch(e.type){case 6:case 8:break e;case 24:case 22:case 20:if(e.type!==r)break e;r=n.pop();break;case 17:if(r===0)break e;break;case 9:if(r===0&&e.value==="!")break e;break;case 2:case 21:case 19:case 23:n.push(r),r=Lr.get(e.type);break}o++;}while(e=t(o));return o}function hl(e,t){if(!e)return 0;let r=0,n=[],o=0;e:do{switch(e.type){case 6:case 8:break e;case 24:case 22:case 20:if(e.type!==r)break e;r=n.pop();break;case 2:case 21:case 19:case 23:n.push(r),r=Lr.get(e.type);break}o++;}while(e=t(o));return o}function ye(e){return e&&(e=new Set(e)),function(t,r,n){if(t===null||t.type!==12)return 0;let o=Te(t.value,0);if(e!==null){let i=t.value.indexOf("\\",o),s=i===-1||!Mi(t.value,i)?t.value.substr(o):t.value.substring(o,i);if(e.has(s.toLowerCase())===!1)return 0}return Bt(n,t.value,o)?0:1}}function ml(e,t,r){return e===null||e.type!==11||Bt(r,e.value,e.value.length-1)?0:1}function Ri(e){return typeof e!="function"&&(e=function(){return 0}),function(t,r,n){return t!==null&&t.type===10&&Number(t.value)===0?1:e(t,r,n)}}function fl(e,t,r){if(e===null)return 0;let n=Te(e.value,0);return !(n===e.value.length)&&!Mi(e.value,n)||Bt(r,e.value,n)?0:1}function dl(e,t,r){if(e===null||e.type!==10)return 0;let n=le(e.value,0)===43||le(e.value,0)===45?1:0;for(;n<e.value.length;n++)if(!F(le(e.value,n)))return 0;return Bt(r,e.value,n)?0:1}var gl={"ident-token":O(1),"function-token":O(2),"at-keyword-token":O(3),"hash-token":O(4),"string-token":O(5),"bad-string-token":O(6),"url-token":O(7),"bad-url-token":O(8),"delim-token":O(9),"number-token":O(10),"percentage-token":O(11),"dimension-token":O(12),"whitespace-token":O(13),"CDO-token":O(14),"CDC-token":O(15),"colon-token":O(16),"semicolon-token":O(17),"comma-token":O(18),"[-token":O(19),"]-token":O(20),"(-token":O(21),")-token":O(22),"{-token":O(23),"}-token":O(24)},bl={string:O(5),ident:O(1),percentage:ie(ml),zero:Ri(),number:ie(fl),integer:ie(dl),"custom-ident":sl,"custom-property-name":ll,"hex-color":cl,"id-selector":ul,"an-plus-b":Ar,urange:Er,"declaration-value":pl,"any-value":hl};function xl(e){let{angle:t,decibel:r,frequency:n,flex:o,length:i,resolution:s,semitones:u,time:c}=e||{};return {dimension:ie(ye(null)),angle:ie(ye(t)),decibel:ie(ye(r)),frequency:ie(ye(n)),flex:ie(ye(o)),length:ie(Ri(ye(i))),resolution:ie(ye(s)),semitones:ie(ye(u)),time:ie(ye(c))}}function Fi(e){return {...gl,...bl,...xl(e)}}var _t={};b(_t,{angle:()=>kl,decibel:()=>Al,flex:()=>Cl,frequency:()=>vl,length:()=>yl,resolution:()=>Sl,semitones:()=>Tl,time:()=>wl});var yl=["cm","mm","q","in","pt","pc","px","em","rem","ex","rex","cap","rcap","ch","rch","ic","ric","lh","rlh","vw","svw","lvw","dvw","vh","svh","lvh","dvh","vi","svi","lvi","dvi","vb","svb","lvb","dvb","vmin","svmin","lvmin","dvmin","vmax","svmax","lvmax","dvmax","cqw","cqh","cqi","cqb","cqmin","cqmax"],kl=["deg","grad","rad","turn"],wl=["s","ms"],vl=["hz","khz"],Sl=["dpi","dpcm","dppx","x"],Cl=["fr"],Al=["db"],Tl=["st"];var $i={};b($i,{SyntaxError:()=>Ut,generate:()=>Pe,parse:()=>Ge,walk:()=>Vt});function Ut(e,t,r){return Object.assign(Ee("SyntaxError",e),{input:t,offset:r,rawMessage:e,message:e+`
  `+t+`
--`+new Array((r||t.length)+1).join("-")+"^"})}var El=9,Ll=10,Pl=12,Il=13,Dl=32,jt=class{constructor(t){this.str=t,this.pos=0;}charCodeAt(t){return t<this.str.length?this.str.charCodeAt(t):0}charCode(){return this.charCodeAt(this.pos)}nextCharCode(){return this.charCodeAt(this.pos+1)}nextNonWsCode(t){return this.charCodeAt(this.findWsEnd(t))}findWsEnd(t){for(;t<this.str.length;t++){let r=this.str.charCodeAt(t);if(r!==Il&&r!==Ll&&r!==Pl&&r!==Dl&&r!==El)break}return t}substringToPos(t){return this.str.substring(this.pos,this.pos=t)}eat(t){this.charCode()!==t&&this.error("Expect `"+String.fromCharCode(t)+"`"),this.pos++;}peek(){return this.pos<this.str.length?this.str.charAt(this.pos++):""}error(t){throw new Ut(t,this.str,this.pos)}};var Ol=9,Nl=10,zl=12,Ml=13,Rl=32,Yi=33,Dr=35,Bi=38,qt=39,Gi=40,Fl=41,Vi=42,Or=43,Nr=44,_i=45,zr=60,Ki=62,Ir=63,Bl=64,Gt=91,Mr=93,Wt=123,Ui=124,ji=125,qi=8734,ut=new Uint8Array(128).map((e,t)=>/[a-zA-Z0-9\-]/.test(String.fromCharCode(t))?1:0),Wi={" ":1,"&&":2,"||":3,"|":4};function Ht(e){return e.substringToPos(e.findWsEnd(e.pos))}function He(e){let t=e.pos;for(;t<e.str.length;t++){let r=e.str.charCodeAt(t);if(r>=128||ut[r]===0)break}return e.pos===t&&e.error("Expect a keyword"),e.substringToPos(t)}function Yt(e){let t=e.pos;for(;t<e.str.length;t++){let r=e.str.charCodeAt(t);if(r<48||r>57)break}return e.pos===t&&e.error("Expect a number"),e.substringToPos(t)}function _l(e){let t=e.str.indexOf("'",e.pos+1);return t===-1&&(e.pos=e.str.length,e.error("Expect an apostrophe")),e.substringToPos(t+1)}function Hi(e){let t=null,r=null;return e.eat(Wt),t=Yt(e),e.charCode()===Nr?(e.pos++,e.charCode()!==ji&&(r=Yt(e))):r=t,e.eat(ji),{min:Number(t),max:r?Number(r):0}}function Ul(e){let t=null,r=!1;switch(e.charCode()){case Vi:e.pos++,t={min:0,max:0};break;case Or:e.pos++,t={min:1,max:0};break;case Ir:e.pos++,t={min:0,max:1};break;case Dr:e.pos++,r=!0,e.charCode()===Wt?t=Hi(e):e.charCode()===Ir?(e.pos++,t={min:0,max:0}):t={min:1,max:0};break;case Wt:t=Hi(e);break;default:return null}return {type:"Multiplier",comma:r,min:t.min,max:t.max,term:null}}function Ye(e,t){let r=Ul(e);return r!==null?(r.term=t,e.charCode()===Dr&&e.charCodeAt(e.pos-1)===Or?Ye(e,r):r):t}function Pr(e){let t=e.peek();return t===""?null:{type:"Token",value:t}}function jl(e){let t;return e.eat(zr),e.eat(qt),t=He(e),e.eat(qt),e.eat(Ki),Ye(e,{type:"Property",name:t})}function ql(e){let t=null,r=null,n=1;return e.eat(Gt),e.charCode()===_i&&(e.peek(),n=-1),n==-1&&e.charCode()===qi?e.peek():(t=n*Number(Yt(e)),ut[e.charCode()]!==0&&(t+=He(e))),Ht(e),e.eat(Nr),Ht(e),e.charCode()===qi?e.peek():(n=1,e.charCode()===_i&&(e.peek(),n=-1),r=n*Number(Yt(e)),ut[e.charCode()]!==0&&(r+=He(e))),e.eat(Mr),{type:"Range",min:t,max:r}}function Wl(e){let t,r=null;return e.eat(zr),t=He(e),e.charCode()===Gi&&e.nextCharCode()===Fl&&(e.pos+=2,t+="()"),e.charCodeAt(e.findWsEnd(e.pos))===Gt&&(Ht(e),r=ql(e)),e.eat(Ki),Ye(e,{type:"Type",name:t,opts:r})}function Hl(e){let t=He(e);return e.charCode()===Gi?(e.pos++,{type:"Function",name:t}):Ye(e,{type:"Keyword",name:t})}function Yl(e,t){function r(o,i){return {type:"Group",terms:o,combinator:i,disallowEmpty:!1,explicit:!1}}let n;for(t=Object.keys(t).sort((o,i)=>Wi[o]-Wi[i]);t.length>0;){n=t.shift();let o=0,i=0;for(;o<e.length;o++){let s=e[o];s.type==="Combinator"&&(s.value===n?(i===-1&&(i=o-1),e.splice(o,1),o--):(i!==-1&&o-i>1&&(e.splice(i,o-i,r(e.slice(i,o),n)),o=i+1),i=-1));}i!==-1&&t.length&&e.splice(i,o-i,r(e.slice(i,o),n));}return n}function Qi(e){let t=[],r={},n,o=null,i=e.pos;for(;n=Vl(e);)n.type!=="Spaces"&&(n.type==="Combinator"?((o===null||o.type==="Combinator")&&(e.pos=i,e.error("Unexpected combinator")),r[n.value]=!0):o!==null&&o.type!=="Combinator"&&(r[" "]=!0,t.push({type:"Combinator",value:" "})),t.push(n),o=n,i=e.pos);return o!==null&&o.type==="Combinator"&&(e.pos-=i,e.error("Unexpected combinator")),{type:"Group",terms:t,combinator:Yl(t,r)||" ",disallowEmpty:!1,explicit:!1}}function Gl(e){let t;return e.eat(Gt),t=Qi(e),e.eat(Mr),t.explicit=!0,e.charCode()===Yi&&(e.pos++,t.disallowEmpty=!0),t}function Vl(e){let t=e.charCode();if(t<128&&ut[t]===1)return Hl(e);switch(t){case Mr:break;case Gt:return Ye(e,Gl(e));case zr:return e.nextCharCode()===qt?jl(e):Wl(e);case Ui:return {type:"Combinator",value:e.substringToPos(e.pos+(e.nextCharCode()===Ui?2:1))};case Bi:return e.pos++,e.eat(Bi),{type:"Combinator",value:"&&"};case Nr:return e.pos++,{type:"Comma"};case qt:return Ye(e,{type:"String",value:_l(e)});case Rl:case Ol:case Nl:case Ml:case zl:return {type:"Spaces",value:Ht(e)};case Bl:return t=e.nextCharCode(),t<128&&ut[t]===1?(e.pos++,{type:"AtKeyword",name:He(e)}):Pr(e);case Vi:case Or:case Ir:case Dr:case Yi:break;case Wt:if(t=e.nextCharCode(),t<48||t>57)return Pr(e);break;default:return Pr(e)}}function Ge(e){let t=new jt(e),r=Qi(t);return t.pos!==e.length&&t.error("Unexpected input"),r.terms.length===1&&r.terms[0].type==="Group"?r.terms[0]:r}var pt=function(){};function Xi(e){return typeof e=="function"?e:pt}function Vt(e,t,r){function n(s){switch(o.call(r,s),s.type){case"Group":s.terms.forEach(n);break;case"Multiplier":n(s.term);break;case"Type":case"Property":case"Keyword":case"AtKeyword":case"Function":case"String":case"Token":case"Comma":break;default:throw new Error("Unknown type: "+s.type)}i.call(r,s);}let o=pt,i=pt;if(typeof t=="function"?o=t:t&&(o=Xi(t.enter),i=Xi(t.leave)),o===pt&&i===pt)throw new Error("Neither `enter` nor `leave` walker handler is set or both aren't a function");n(e);}var Kl={decorator(e){let t=[],r=null;return {...e,node(n){let o=r;r=n,e.node.call(this,n),r=o;},emit(n,o,i){t.push({type:o,value:n,node:i?null:r});},result(){return t}}}};function Ql(e){let t=[];return ve(e,(r,n,o)=>t.push({type:r,value:e.slice(n,o),node:null})),t}function Zi(e,t){return typeof e=="string"?Ql(e):t.generate(e,Kl)}var C={type:"Match"},L={type:"Mismatch"},Kt={type:"DisallowEmpty"},Xl=40,$l=41;function Z(e,t,r){return t===C&&r===L||e===C&&t===C&&r===C?e:(e.type==="If"&&e.else===L&&t===C&&(t=e.then,e=e.match),{type:"If",match:e,then:t,else:r})}function ea(e){return e.length>2&&e.charCodeAt(e.length-2)===Xl&&e.charCodeAt(e.length-1)===$l}function Ji(e){return e.type==="Keyword"||e.type==="AtKeyword"||e.type==="Function"||e.type==="Type"&&ea(e.name)}function Rr(e,t,r){switch(e){case" ":{let n=C;for(let o=t.length-1;o>=0;o--){let i=t[o];n=Z(i,n,L);}return n}case"|":{let n=L,o=null;for(let i=t.length-1;i>=0;i--){let s=t[i];if(Ji(s)&&(o===null&&i>0&&Ji(t[i-1])&&(o=Object.create(null),n=Z({type:"Enum",map:o},C,n)),o!==null)){let u=(ea(s.name)?s.name.slice(0,-1):s.name).toLowerCase();if(!(u in o)){o[u]=s;continue}}o=null,n=Z(s,C,n);}return n}case"&&":{if(t.length>5)return {type:"MatchOnce",terms:t,all:!0};let n=L;for(let o=t.length-1;o>=0;o--){let i=t[o],s;t.length>1?s=Rr(e,t.filter(function(u){return u!==i}),!1):s=C,n=Z(i,s,n);}return n}case"||":{if(t.length>5)return {type:"MatchOnce",terms:t,all:!1};let n=r?C:L;for(let o=t.length-1;o>=0;o--){let i=t[o],s;t.length>1?s=Rr(e,t.filter(function(u){return u!==i}),!0):s=C,n=Z(i,s,n);}return n}}}function Zl(e){let t=C,r=Fr(e.term);if(e.max===0)r=Z(r,Kt,L),t=Z(r,null,L),t.then=Z(C,C,t),e.comma&&(t.then.else=Z({type:"Comma",syntax:e},t,L));else for(let n=e.min||1;n<=e.max;n++)e.comma&&t!==C&&(t=Z({type:"Comma",syntax:e},t,L)),t=Z(r,Z(C,C,t),L);if(e.min===0)t=Z(C,C,t);else for(let n=0;n<e.min-1;n++)e.comma&&t!==C&&(t=Z({type:"Comma",syntax:e},t,L)),t=Z(r,t,L);return t}function Fr(e){if(typeof e=="function")return {type:"Generic",fn:e};switch(e.type){case"Group":{let t=Rr(e.combinator,e.terms.map(Fr),!1);return e.disallowEmpty&&(t=Z(t,Kt,L)),t}case"Multiplier":return Zl(e);case"Type":case"Property":return {type:e.type,name:e.name,syntax:e};case"Keyword":return {type:e.type,name:e.name.toLowerCase(),syntax:e};case"AtKeyword":return {type:e.type,name:"@"+e.name.toLowerCase(),syntax:e};case"Function":return {type:e.type,name:e.name.toLowerCase()+"(",syntax:e};case"String":return e.value.length===3?{type:"Token",value:e.value.charAt(1),syntax:e}:{type:e.type,value:e.value.substr(1,e.value.length-2).replace(/\\'/g,"'"),syntax:e};case"Token":return {type:e.type,value:e.value,syntax:e};case"Comma":return {type:e.type,syntax:e};default:throw new Error("Unknown node type:",e.type)}}function Qt(e,t){return typeof e=="string"&&(e=Ge(e)),{type:"MatchGraph",match:Fr(e),syntax:t||null,source:e}}var {hasOwnProperty:ta}=Object.prototype,Jl=0,ec=1,_r=2,aa=3,ra="Match",tc="Mismatch",rc="Maximum iteration number exceeded (please fill an issue on https://github.com/csstree/csstree/issues)",na=15e3;function oc(e){let t=null,r=null,n=e;for(;n!==null;)r=n.prev,n.prev=t,t=n,n=r;return t}function Br(e,t){if(e.length!==t.length)return !1;for(let r=0;r<e.length;r++){let n=t.charCodeAt(r),o=e.charCodeAt(r);if(o>=65&&o<=90&&(o=o|32),o!==n)return !1}return !0}function ic(e){return e.type!==9?!1:e.value!=="?"}function oa(e){return e===null?!0:e.type===18||e.type===2||e.type===21||e.type===19||e.type===23||ic(e)}function ia(e){return e===null?!0:e.type===22||e.type===20||e.type===24||e.type===9&&e.value==="/"}function ac(e,t,r){function n(){do M++,S=M<e.length?e[M]:null;while(S!==null&&(S.type===13||S.type===25))}function o(ae){let fe=M+ae;return fe<e.length?e[fe]:null}function i(ae,fe){return {nextState:ae,matchStack:N,syntaxStack:p,thenStack:m,tokenIndex:M,prev:fe}}function s(ae){m={nextState:ae,matchStack:N,syntaxStack:p,prev:m};}function u(ae){f=i(ae,f);}function c(){N={type:ec,syntax:t.syntax,token:S,prev:N},n(),P=null,M>ke&&(ke=M);}function a(){p={syntax:t.syntax,opts:t.syntax.opts||p!==null&&p.opts||null,prev:p},N={type:_r,syntax:t.syntax,token:N.token,prev:N};}function l(){N.type===_r?N=N.prev:N={type:aa,syntax:p.syntax,token:N.token,prev:N},p=p.prev;}let p=null,m=null,f=null,P=null,te=0,Q=null,S=null,M=-1,ke=0,N={type:Jl,syntax:null,token:null,prev:null};for(n();Q===null&&++te<na;)switch(t.type){case"Match":if(m===null){if(S!==null&&(M!==e.length-1||S.value!=="\\0"&&S.value!=="\\9")){t=L;break}Q=ra;break}if(t=m.nextState,t===Kt)if(m.matchStack===N){t=L;break}else t=C;for(;m.syntaxStack!==p;)l();m=m.prev;break;case"Mismatch":if(P!==null&&P!==!1)(f===null||M>f.tokenIndex)&&(f=P,P=!1);else if(f===null){Q=tc;break}t=f.nextState,m=f.thenStack,p=f.syntaxStack,N=f.matchStack,M=f.tokenIndex,S=M<e.length?e[M]:null,f=f.prev;break;case"MatchGraph":t=t.match;break;case"If":t.else!==L&&u(t.else),t.then!==C&&s(t.then),t=t.match;break;case"MatchOnce":t={type:"MatchOnceBuffer",syntax:t,index:0,mask:0};break;case"MatchOnceBuffer":{let K=t.syntax.terms;if(t.index===K.length){if(t.mask===0||t.syntax.all){t=L;break}t=C;break}if(t.mask===(1<<K.length)-1){t=C;break}for(;t.index<K.length;t.index++){let J=1<<t.index;if(!(t.mask&J)){u(t),s({type:"AddMatchOnce",syntax:t.syntax,mask:t.mask|J}),t=K[t.index++];break}}break}case"AddMatchOnce":t={type:"MatchOnceBuffer",syntax:t.syntax,index:0,mask:t.mask};break;case"Enum":if(S!==null){let K=S.value.toLowerCase();if(K.indexOf("\\")!==-1&&(K=K.replace(/\\[09].*$/,"")),ta.call(t.map,K)){t=t.map[K];break}}t=L;break;case"Generic":{let K=p!==null?p.opts:null,J=M+Math.floor(t.fn(S,o,K));if(!isNaN(J)&&J>M){for(;M<J;)c();t=C;}else t=L;break}case"Type":case"Property":{let K=t.type==="Type"?"types":"properties",J=ta.call(r,K)?r[K][t.name]:null;if(!J||!J.match)throw new Error("Bad syntax reference: "+(t.type==="Type"?"<"+t.name+">":"<'"+t.name+"'>"));if(P!==!1&&S!==null&&t.type==="Type"&&(t.name==="custom-ident"&&S.type===1||t.name==="length"&&S.value==="0")){P===null&&(P=i(t,f)),t=L;break}a(),t=J.match;break}case"Keyword":{let K=t.name;if(S!==null){let J=S.value;if(J.indexOf("\\")!==-1&&(J=J.replace(/\\[09].*$/,"")),Br(J,K)){c(),t=C;break}}t=L;break}case"AtKeyword":case"Function":if(S!==null&&Br(S.value,t.name)){c(),t=C;break}t=L;break;case"Token":if(S!==null&&S.value===t.value){c(),t=C;break}t=L;break;case"Comma":S!==null&&S.type===18?oa(N.token)?t=L:(c(),t=ia(S)?L:C):t=oa(N.token)||ia(S)?C:L;break;case"String":let ae="",fe=M;for(;fe<e.length&&ae.length<t.value.length;fe++)ae+=e[fe].value;if(Br(ae,t.value)){for(;M<fe;)c();t=C;}else t=L;break;default:throw new Error("Unknown node type: "+t.type)}switch(Q){case null:console.warn("[csstree-match] BREAK after "+na+" iterations"),Q=rc,N=null;break;case ra:for(;p!==null;)l();break;default:N=null;}return {tokens:e,reason:Q,iterations:te,match:N,longestMatch:ke}}function Ur(e,t,r){let n=ac(e,t,r||{});if(n.match===null)return n;let o=n.match,i=n.match={syntax:t.syntax||null,match:[]},s=[i];for(o=oc(o).prev;o!==null;){switch(o.type){case _r:i.match.push(i={syntax:o.syntax,match:[]}),s.push(i);break;case aa:s.pop(),i=s[s.length-1];break;default:i.match.push({syntax:o.syntax||null,token:o.token.value,node:o.token.node});}o=o.prev;}return n}var qr={};b(qr,{getTrace:()=>sa,isKeyword:()=>cc,isProperty:()=>lc,isType:()=>sc});function sa(e){function t(o){return o===null?!1:o.type==="Type"||o.type==="Property"||o.type==="Keyword"}function r(o){if(Array.isArray(o.match)){for(let i=0;i<o.match.length;i++)if(r(o.match[i]))return t(o.syntax)&&n.unshift(o.syntax),!0}else if(o.node===e)return n=t(o.syntax)?[o.syntax]:[],!0;return !1}let n=null;return this.matched!==null&&r(this.matched),n}function sc(e,t){return jr(this,e,r=>r.type==="Type"&&r.name===t)}function lc(e,t){return jr(this,e,r=>r.type==="Property"&&r.name===t)}function cc(e){return jr(this,e,t=>t.type==="Keyword")}function jr(e,t,r){let n=sa.call(e,t);return n===null?!1:n.some(r)}function la(e){return "node"in e?e.node:la(e.match[0])}function ca(e){return "node"in e?e.node:ca(e.match[e.match.length-1])}function Wr(e,t,r,n,o){function i(u){if(u.syntax!==null&&u.syntax.type===n&&u.syntax.name===o){let c=la(u),a=ca(u);e.syntax.walk(t,function(l,p,m){if(l===c){let f=new $;do{if(f.appendData(p.data),p.data===a)break;p=p.next;}while(p!==null);s.push({parent:m,nodes:f});}});}Array.isArray(u.match)&&u.match.forEach(i);}let s=[];return r.matched!==null&&i(r.matched),s}var{hasOwnProperty:ht}=Object.prototype;function Hr(e){return typeof e=="number"&&isFinite(e)&&Math.floor(e)===e&&e>=0}function ua(e){return !!e&&Hr(e.offset)&&Hr(e.line)&&Hr(e.column)}function uc(e,t){return function(n,o){if(!n||n.constructor!==Object)return o(n,"Type of node should be an Object");for(let i in n){let s=!0;if(ht.call(n,i)!==!1){if(i==="type")n.type!==e&&o(n,"Wrong node type `"+n.type+"`, expected `"+e+"`");else if(i==="loc"){if(n.loc===null)continue;if(n.loc&&n.loc.constructor===Object)if(typeof n.loc.source!="string")i+=".source";else if(!ua(n.loc.start))i+=".start";else if(!ua(n.loc.end))i+=".end";else continue;s=!1;}else if(t.hasOwnProperty(i)){s=!1;for(let u=0;!s&&u<t[i].length;u++){let c=t[i][u];switch(c){case String:s=typeof n[i]=="string";break;case Boolean:s=typeof n[i]=="boolean";break;case null:s=n[i]===null;break;default:typeof c=="string"?s=n[i]&&n[i].type===c:Array.isArray(c)&&(s=n[i]instanceof $);}}}else o(n,"Unknown field `"+i+"` for "+e+" node type");s||o(n,"Bad value for `"+e+"."+i+"`");}}for(let i in t)ht.call(t,i)&&ht.call(n,i)===!1&&o(n,"Field `"+e+"."+i+"` is missed");}}function pc(e,t){let r=t.structure,n={type:String,loc:!0},o={type:'"'+e+'"'};for(let i in r){if(ht.call(r,i)===!1)continue;let s=[],u=n[i]=Array.isArray(r[i])?r[i].slice():[r[i]];for(let c=0;c<u.length;c++){let a=u[c];if(a===String||a===Boolean)s.push(a.name);else if(a===null)s.push("null");else if(typeof a=="string")s.push("<"+a+">");else if(Array.isArray(a))s.push("List");else throw new Error("Wrong value `"+a+"` in `"+e+"."+i+"` structure definition")}o[i]=s.join(" | ");}return {docs:o,check:uc(e,n)}}function pa(e){let t={};if(e.node){for(let r in e.node)if(ht.call(e.node,r)){let n=e.node[r];if(n.structure)t[r]=pc(r,n);else throw new Error("Missed `structure` field in `"+r+"` node type definition")}}return t}var hc=Qt(Rt.join(" | "));function Yr(e,t,r){let n={};for(let o in e)e[o].syntax&&(n[o]=r?e[o].syntax:Pe(e[o].syntax,{compact:t}));return n}function mc(e,t,r){let n={};for(let[o,i]of Object.entries(e))n[o]={prelude:i.prelude&&(r?i.prelude.syntax:Pe(i.prelude.syntax,{compact:t})),descriptors:i.descriptors&&Yr(i.descriptors,t,r)};return n}function fc(e){for(let t=0;t<e.length;t++)if(e[t].value.toLowerCase()==="var(")return !0;return !1}function ce(e,t,r){return {matched:e,iterations:r,error:t,...qr}}function Ve(e,t,r,n){let o=Zi(r,e.syntax),i;return fc(o)?ce(null,new Error("Matching for a tree with var() is not supported")):(n&&(i=Ur(o,e.cssWideKeywordsSyntax,e)),(!n||!i.match)&&(i=Ur(o,t.match,e),!i.match)?ce(null,new Ii(i.reason,t.syntax,r,i),i.iterations):ce(i.match,null,i.iterations))}var Ke=class{constructor(t,r,n){if(this.cssWideKeywordsSyntax=hc,this.syntax=r,this.generic=!1,this.units={..._t},this.atrules=Object.create(null),this.properties=Object.create(null),this.types=Object.create(null),this.structure=n||pa(t),t){if(t.units)for(let o of Object.keys(_t))Array.isArray(t.units[o])&&(this.units[o]=t.units[o]);if(t.types)for(let o in t.types)this.addType_(o,t.types[o]);if(t.generic){this.generic=!0;for(let[o,i]of Object.entries(Fi(this.units)))this.addType_(o,i);}if(t.atrules)for(let o in t.atrules)this.addAtrule_(o,t.atrules[o]);if(t.properties)for(let o in t.properties)this.addProperty_(o,t.properties[o]);}}checkStructure(t){function r(i,s){o.push({node:i,message:s});}let n=this.structure,o=[];return this.syntax.walk(t,function(i){n.hasOwnProperty(i.type)?n[i.type].check(i,r):r(i,"Unknown node type `"+i.type+"`");}),o.length?o:!1}createDescriptor(t,r,n,o=null){let i={type:r,name:n},s={type:r,name:n,parent:o,serializable:typeof t=="string"||t&&typeof t.type=="string",syntax:null,match:null};return typeof t=="function"?s.match=Qt(t,i):(typeof t=="string"?Object.defineProperty(s,"syntax",{get(){return Object.defineProperty(s,"syntax",{value:Ge(t)}),s.syntax}}):s.syntax=t,Object.defineProperty(s,"match",{get(){return Object.defineProperty(s,"match",{value:Qt(s.syntax,i)}),s.match}})),s}addAtrule_(t,r){r&&(this.atrules[t]={type:"Atrule",name:t,prelude:r.prelude?this.createDescriptor(r.prelude,"AtrulePrelude",t):null,descriptors:r.descriptors?Object.keys(r.descriptors).reduce((n,o)=>(n[o]=this.createDescriptor(r.descriptors[o],"AtruleDescriptor",o,t),n),Object.create(null)):null});}addProperty_(t,r){r&&(this.properties[t]=this.createDescriptor(r,"Property",t));}addType_(t,r){r&&(this.types[t]=this.createDescriptor(r,"Type",t));}checkAtruleName(t){if(!this.getAtrule(t))return new je("Unknown at-rule","@"+t)}checkAtrulePrelude(t,r){let n=this.checkAtruleName(t);if(n)return n;let o=this.getAtrule(t);if(!o.prelude&&r)return new SyntaxError("At-rule `@"+t+"` should not contain a prelude");if(o.prelude&&!r&&!Ve(this,o.prelude,"",!1).matched)return new SyntaxError("At-rule `@"+t+"` should contain a prelude")}checkAtruleDescriptorName(t,r){let n=this.checkAtruleName(t);if(n)return n;let o=this.getAtrule(t),i=zt(r);if(!o.descriptors)return new SyntaxError("At-rule `@"+t+"` has no known descriptors");if(!o.descriptors[i.name]&&!o.descriptors[i.basename])return new je("Unknown at-rule descriptor",r)}checkPropertyName(t){if(!this.getProperty(t))return new je("Unknown property",t)}matchAtrulePrelude(t,r){let n=this.checkAtrulePrelude(t,r);if(n)return ce(null,n);let o=this.getAtrule(t);return o.prelude?Ve(this,o.prelude,r||"",!1):ce(null,null)}matchAtruleDescriptor(t,r,n){let o=this.checkAtruleDescriptorName(t,r);if(o)return ce(null,o);let i=this.getAtrule(t),s=zt(r);return Ve(this,i.descriptors[s.name]||i.descriptors[s.basename],n,!1)}matchDeclaration(t){return t.type!=="Declaration"?ce(null,new Error("Not a Declaration node")):this.matchProperty(t.property,t.value)}matchProperty(t,r){if(kr(t).custom)return ce(null,new Error("Lexer matching doesn't applicable for custom properties"));let n=this.checkPropertyName(t);return n?ce(null,n):Ve(this,this.getProperty(t),r,!0)}matchType(t,r){let n=this.getType(t);return n?Ve(this,n,r,!1):ce(null,new je("Unknown type",t))}match(t,r){return typeof t!="string"&&(!t||!t.type)?ce(null,new je("Bad syntax")):((typeof t=="string"||!t.match)&&(t=this.createDescriptor(t,"Type","anonymous")),Ve(this,t,r,!1))}findValueFragments(t,r,n,o){return Wr(this,r,this.matchProperty(t,r),n,o)}findDeclarationValueFragments(t,r,n){return Wr(this,t.value,this.matchDeclaration(t),r,n)}findAllFragments(t,r,n){let o=[];return this.syntax.walk(t,{visit:"Declaration",enter:i=>{o.push.apply(o,this.findDeclarationValueFragments(i,r,n));}}),o}getAtrule(t,r=!0){let n=zt(t);return (n.vendor&&r?this.atrules[n.name]||this.atrules[n.basename]:this.atrules[n.name])||null}getAtrulePrelude(t,r=!0){let n=this.getAtrule(t,r);return n&&n.prelude||null}getAtruleDescriptor(t,r){return this.atrules.hasOwnProperty(t)&&this.atrules.declarators&&this.atrules[t].declarators[r]||null}getProperty(t,r=!0){let n=kr(t);return (n.vendor&&r?this.properties[n.name]||this.properties[n.basename]:this.properties[n.name])||null}getType(t){return hasOwnProperty.call(this.types,t)?this.types[t]:null}validate(){function t(o,i,s,u){if(s.has(i))return s.get(i);s.set(i,!1),u.syntax!==null&&Vt(u.syntax,function(c){if(c.type!=="Type"&&c.type!=="Property")return;let a=c.type==="Type"?o.types:o.properties,l=c.type==="Type"?r:n;(!hasOwnProperty.call(a,c.name)||t(o,c.name,l,a[c.name]))&&s.set(i,!0);},this);}let r=new Map,n=new Map;for(let o in this.types)t(this,o,r,this.types[o]);for(let o in this.properties)t(this,o,n,this.properties[o]);return r=[...r.keys()].filter(o=>r.get(o)),n=[...n.keys()].filter(o=>n.get(o)),r.length||n.length?{types:r,properties:n}:null}dump(t,r){return {generic:this.generic,units:this.units,types:Yr(this.types,!r,t),properties:Yr(this.properties,!r,t),atrules:mc(this.atrules,!r,t)}}toString(){return JSON.stringify(this.dump())}};function Gr(e,t){return typeof t=="string"&&/^\s*\|/.test(t)?typeof e=="string"?e+t:t.replace(/^\s*\|\s*/,""):t||null}function ha(e,t){let r=Object.create(null);for(let[n,o]of Object.entries(e))if(o){r[n]={};for(let i of Object.keys(o))t.includes(i)&&(r[n][i]=o[i]);}return r}function mt(e,t){let r={...e};for(let[n,o]of Object.entries(t))switch(n){case"generic":r[n]=!!o;break;case"units":r[n]={...e[n]};for(let[i,s]of Object.entries(o))r[n][i]=Array.isArray(s)?s:[];break;case"atrules":r[n]={...e[n]};for(let[i,s]of Object.entries(o)){let u=r[n][i]||{},c=r[n][i]={prelude:u.prelude||null,descriptors:{...u.descriptors}};if(s){c.prelude=s.prelude?Gr(c.prelude,s.prelude):c.prelude||null;for(let[a,l]of Object.entries(s.descriptors||{}))c.descriptors[a]=l?Gr(c.descriptors[a],l):null;Object.keys(c.descriptors).length||(c.descriptors=null);}}break;case"types":case"properties":r[n]={...e[n]};for(let[i,s]of Object.entries(o))r[n][i]=Gr(r[n][i],s);break;case"scope":r[n]={...e[n]};for(let[i,s]of Object.entries(o))r[n][i]={...r[n][i],...s};break;case"parseContext":r[n]={...e[n],...o};break;case"atrule":case"pseudo":r[n]={...e[n],...ha(o,["parse"])};break;case"node":r[n]={...e[n],...ha(o,["name","structure","parse","generate","walkContext"])};break}return r}function ma(e){let t=$o(e),r=Li(e),n=vi(e),{fromPlainObject:o,toPlainObject:i}=Si(r),s={lexer:null,createLexer:u=>new Ke(u,s,s.lexer.structure),tokenize:ve,parse:t,generate:n,walk:r,find:r.find,findLast:r.findLast,findAll:r.findAll,fromPlainObject:o,toPlainObject:i,fork(u){let c=mt({},e);return ma(typeof u=="function"?u(c,Object.assign):mt(c,u))}};return s.lexer=new Ke({generic:!0,units:e.units,types:e.types,atrules:e.atrules,properties:e.properties,node:e.node},s),s}var Vr=e=>ma(mt({},e));var fa={generic:!0,units:{angle:["deg","grad","rad","turn"],decibel:["db"],flex:["fr"],frequency:["hz","khz"],length:["cm","mm","q","in","pt","pc","px","em","rem","ex","rex","cap","rcap","ch","rch","ic","ric","lh","rlh","vw","svw","lvw","dvw","vh","svh","lvh","dvh","vi","svi","lvi","dvi","vb","svb","lvb","dvb","vmin","svmin","lvmin","dvmin","vmax","svmax","lvmax","dvmax","cqw","cqh","cqi","cqb","cqmin","cqmax"],resolution:["dpi","dpcm","dppx","x"],semitones:["st"],time:["s","ms"]},types:{"abs()":"abs( <calc-sum> )","absolute-size":"xx-small|x-small|small|medium|large|x-large|xx-large|xxx-large","acos()":"acos( <calc-sum> )","alpha-value":"<number>|<percentage>","angle-percentage":"<angle>|<percentage>","angular-color-hint":"<angle-percentage>","angular-color-stop":"<color>&&<color-stop-angle>?","angular-color-stop-list":"[<angular-color-stop> [, <angular-color-hint>]?]# , <angular-color-stop>","animateable-feature":"scroll-position|contents|<custom-ident>","asin()":"asin( <calc-sum> )","atan()":"atan( <calc-sum> )","atan2()":"atan2( <calc-sum> , <calc-sum> )",attachment:"scroll|fixed|local","attr()":"attr( <attr-name> <type-or-unit>? [, <attr-fallback>]? )","attr-matcher":"['~'|'|'|'^'|'$'|'*']? '='","attr-modifier":"i|s","attribute-selector":"'[' <wq-name> ']'|'[' <wq-name> <attr-matcher> [<string-token>|<ident-token>] <attr-modifier>? ']'","auto-repeat":"repeat( [auto-fill|auto-fit] , [<line-names>? <fixed-size>]+ <line-names>? )","auto-track-list":"[<line-names>? [<fixed-size>|<fixed-repeat>]]* <line-names>? <auto-repeat> [<line-names>? [<fixed-size>|<fixed-repeat>]]* <line-names>?",axis:"block|inline|vertical|horizontal","baseline-position":"[first|last]? baseline","basic-shape":"<inset()>|<circle()>|<ellipse()>|<polygon()>|<path()>","bg-image":"none|<image>","bg-layer":"<bg-image>||<bg-position> [/ <bg-size>]?||<repeat-style>||<attachment>||<box>||<box>","bg-position":"[[left|center|right|top|bottom|<length-percentage>]|[left|center|right|<length-percentage>] [top|center|bottom|<length-percentage>]|[center|[left|right] <length-percentage>?]&&[center|[top|bottom] <length-percentage>?]]","bg-size":"[<length-percentage>|auto]{1,2}|cover|contain","blur()":"blur( <length> )","blend-mode":"normal|multiply|screen|overlay|darken|lighten|color-dodge|color-burn|hard-light|soft-light|difference|exclusion|hue|saturation|color|luminosity",box:"border-box|padding-box|content-box","brightness()":"brightness( <number-percentage> )","calc()":"calc( <calc-sum> )","calc-sum":"<calc-product> [['+'|'-'] <calc-product>]*","calc-product":"<calc-value> ['*' <calc-value>|'/' <number>]*","calc-value":"<number>|<dimension>|<percentage>|<calc-constant>|( <calc-sum> )","calc-constant":"e|pi|infinity|-infinity|NaN","cf-final-image":"<image>|<color>","cf-mixing-image":"<percentage>?&&<image>","circle()":"circle( [<shape-radius>]? [at <position>]? )","clamp()":"clamp( <calc-sum>#{3} )","class-selector":"'.' <ident-token>","clip-source":"<url>",color:"<rgb()>|<rgba()>|<hsl()>|<hsla()>|<hwb()>|<lab()>|<lch()>|<hex-color>|<named-color>|currentcolor|<deprecated-system-color>","color-stop":"<color-stop-length>|<color-stop-angle>","color-stop-angle":"<angle-percentage>{1,2}","color-stop-length":"<length-percentage>{1,2}","color-stop-list":"[<linear-color-stop> [, <linear-color-hint>]?]# , <linear-color-stop>",combinator:"'>'|'+'|'~'|['||']","common-lig-values":"[common-ligatures|no-common-ligatures]","compat-auto":"searchfield|textarea|push-button|slider-horizontal|checkbox|radio|square-button|menulist|listbox|meter|progress-bar|button","composite-style":"clear|copy|source-over|source-in|source-out|source-atop|destination-over|destination-in|destination-out|destination-atop|xor","compositing-operator":"add|subtract|intersect|exclude","compound-selector":"[<type-selector>? <subclass-selector>* [<pseudo-element-selector> <pseudo-class-selector>*]*]!","compound-selector-list":"<compound-selector>#","complex-selector":"<compound-selector> [<combinator>? <compound-selector>]*","complex-selector-list":"<complex-selector>#","conic-gradient()":"conic-gradient( [from <angle>]? [at <position>]? , <angular-color-stop-list> )","contextual-alt-values":"[contextual|no-contextual]","content-distribution":"space-between|space-around|space-evenly|stretch","content-list":"[<string>|contents|<image>|<counter>|<quote>|<target>|<leader()>|<attr()>]+","content-position":"center|start|end|flex-start|flex-end","content-replacement":"<image>","contrast()":"contrast( [<number-percentage>] )","cos()":"cos( <calc-sum> )",counter:"<counter()>|<counters()>","counter()":"counter( <counter-name> , <counter-style>? )","counter-name":"<custom-ident>","counter-style":"<counter-style-name>|symbols( )","counter-style-name":"<custom-ident>","counters()":"counters( <counter-name> , <string> , <counter-style>? )","cross-fade()":"cross-fade( <cf-mixing-image> , <cf-final-image>? )","cubic-bezier-timing-function":"ease|ease-in|ease-out|ease-in-out|cubic-bezier( <number [0,1]> , <number> , <number [0,1]> , <number> )","deprecated-system-color":"ActiveBorder|ActiveCaption|AppWorkspace|Background|ButtonFace|ButtonHighlight|ButtonShadow|ButtonText|CaptionText|GrayText|Highlight|HighlightText|InactiveBorder|InactiveCaption|InactiveCaptionText|InfoBackground|InfoText|Menu|MenuText|Scrollbar|ThreeDDarkShadow|ThreeDFace|ThreeDHighlight|ThreeDLightShadow|ThreeDShadow|Window|WindowFrame|WindowText","discretionary-lig-values":"[discretionary-ligatures|no-discretionary-ligatures]","display-box":"contents|none","display-inside":"flow|flow-root|table|flex|grid|ruby","display-internal":"table-row-group|table-header-group|table-footer-group|table-row|table-cell|table-column-group|table-column|table-caption|ruby-base|ruby-text|ruby-base-container|ruby-text-container","display-legacy":"inline-block|inline-list-item|inline-table|inline-flex|inline-grid","display-listitem":"<display-outside>?&&[flow|flow-root]?&&list-item","display-outside":"block|inline|run-in","drop-shadow()":"drop-shadow( <length>{2,3} <color>? )","east-asian-variant-values":"[jis78|jis83|jis90|jis04|simplified|traditional]","east-asian-width-values":"[full-width|proportional-width]","element()":"element( <custom-ident> , [first|start|last|first-except]? )|element( <id-selector> )","ellipse()":"ellipse( [<shape-radius>{2}]? [at <position>]? )","ending-shape":"circle|ellipse","env()":"env( <custom-ident> , <declaration-value>? )","exp()":"exp( <calc-sum> )","explicit-track-list":"[<line-names>? <track-size>]+ <line-names>?","family-name":"<string>|<custom-ident>+","feature-tag-value":"<string> [<integer>|on|off]?","feature-type":"@stylistic|@historical-forms|@styleset|@character-variant|@swash|@ornaments|@annotation","feature-value-block":"<feature-type> '{' <feature-value-declaration-list> '}'","feature-value-block-list":"<feature-value-block>+","feature-value-declaration":"<custom-ident> : <integer>+ ;","feature-value-declaration-list":"<feature-value-declaration>","feature-value-name":"<custom-ident>","fill-rule":"nonzero|evenodd","filter-function":"<blur()>|<brightness()>|<contrast()>|<drop-shadow()>|<grayscale()>|<hue-rotate()>|<invert()>|<opacity()>|<saturate()>|<sepia()>","filter-function-list":"[<filter-function>|<url>]+","final-bg-layer":"<'background-color'>||<bg-image>||<bg-position> [/ <bg-size>]?||<repeat-style>||<attachment>||<box>||<box>","fixed-breadth":"<length-percentage>","fixed-repeat":"repeat( [<integer [1,\u221E]>] , [<line-names>? <fixed-size>]+ <line-names>? )","fixed-size":"<fixed-breadth>|minmax( <fixed-breadth> , <track-breadth> )|minmax( <inflexible-breadth> , <fixed-breadth> )","font-stretch-absolute":"normal|ultra-condensed|extra-condensed|condensed|semi-condensed|semi-expanded|expanded|extra-expanded|ultra-expanded|<percentage>","font-variant-css21":"[normal|small-caps]","font-weight-absolute":"normal|bold|<number [1,1000]>","frequency-percentage":"<frequency>|<percentage>","general-enclosed":"[<function-token> <any-value> )]|( <ident> <any-value> )","generic-family":"serif|sans-serif|cursive|fantasy|monospace|-apple-system","generic-name":"serif|sans-serif|cursive|fantasy|monospace","geometry-box":"<shape-box>|fill-box|stroke-box|view-box",gradient:"<linear-gradient()>|<repeating-linear-gradient()>|<radial-gradient()>|<repeating-radial-gradient()>|<conic-gradient()>|<repeating-conic-gradient()>|<-legacy-gradient>","grayscale()":"grayscale( <number-percentage> )","grid-line":"auto|<custom-ident>|[<integer>&&<custom-ident>?]|[span&&[<integer>||<custom-ident>]]","historical-lig-values":"[historical-ligatures|no-historical-ligatures]","hsl()":"hsl( <hue> <percentage> <percentage> [/ <alpha-value>]? )|hsl( <hue> , <percentage> , <percentage> , <alpha-value>? )","hsla()":"hsla( <hue> <percentage> <percentage> [/ <alpha-value>]? )|hsla( <hue> , <percentage> , <percentage> , <alpha-value>? )",hue:"<number>|<angle>","hue-rotate()":"hue-rotate( <angle> )","hwb()":"hwb( [<hue>|none] [<percentage>|none] [<percentage>|none] [/ [<alpha-value>|none]]? )","hypot()":"hypot( <calc-sum># )",image:"<url>|<image()>|<image-set()>|<element()>|<paint()>|<cross-fade()>|<gradient>","image()":"image( <image-tags>? [<image-src>? , <color>?]! )","image-set()":"image-set( <image-set-option># )","image-set-option":"[<image>|<string>] [<resolution>||type( <string> )]","image-src":"<url>|<string>","image-tags":"ltr|rtl","inflexible-breadth":"<length-percentage>|min-content|max-content|auto","inset()":"inset( <length-percentage>{1,4} [round <'border-radius'>]? )","invert()":"invert( <number-percentage> )","keyframes-name":"<custom-ident>|<string>","keyframe-block":"<keyframe-selector># { <declaration-list> }","keyframe-block-list":"<keyframe-block>+","keyframe-selector":"from|to|<percentage>","lab()":"lab( [<percentage>|<number>|none] [<percentage>|<number>|none] [<percentage>|<number>|none] [/ [<alpha-value>|none]]? )","layer()":"layer( <layer-name> )","layer-name":"<ident> ['.' <ident>]*","lch()":"lch( [<percentage>|<number>|none] [<percentage>|<number>|none] [<hue>|none] [/ [<alpha-value>|none]]? )","leader()":"leader( <leader-type> )","leader-type":"dotted|solid|space|<string>","length-percentage":"<length>|<percentage>","line-names":"'[' <custom-ident>* ']'","line-name-list":"[<line-names>|<name-repeat>]+","line-style":"none|hidden|dotted|dashed|solid|double|groove|ridge|inset|outset","line-width":"<length>|thin|medium|thick","linear-color-hint":"<length-percentage>","linear-color-stop":"<color> <color-stop-length>?","linear-gradient()":"linear-gradient( [<angle>|to <side-or-corner>]? , <color-stop-list> )","log()":"log( <calc-sum> , <calc-sum>? )","mask-layer":"<mask-reference>||<position> [/ <bg-size>]?||<repeat-style>||<geometry-box>||[<geometry-box>|no-clip]||<compositing-operator>||<masking-mode>","mask-position":"[<length-percentage>|left|center|right] [<length-percentage>|top|center|bottom]?","mask-reference":"none|<image>|<mask-source>","mask-source":"<url>","masking-mode":"alpha|luminance|match-source","matrix()":"matrix( <number>#{6} )","matrix3d()":"matrix3d( <number>#{16} )","max()":"max( <calc-sum># )","media-and":"<media-in-parens> [and <media-in-parens>]+","media-condition":"<media-not>|<media-and>|<media-or>|<media-in-parens>","media-condition-without-or":"<media-not>|<media-and>|<media-in-parens>","media-feature":"( [<mf-plain>|<mf-boolean>|<mf-range>] )","media-in-parens":"( <media-condition> )|<media-feature>|<general-enclosed>","media-not":"not <media-in-parens>","media-or":"<media-in-parens> [or <media-in-parens>]+","media-query":"<media-condition>|[not|only]? <media-type> [and <media-condition-without-or>]?","media-query-list":"<media-query>#","media-type":"<ident>","mf-boolean":"<mf-name>","mf-name":"<ident>","mf-plain":"<mf-name> : <mf-value>","mf-range":"<mf-name> ['<'|'>']? '='? <mf-value>|<mf-value> ['<'|'>']? '='? <mf-name>|<mf-value> '<' '='? <mf-name> '<' '='? <mf-value>|<mf-value> '>' '='? <mf-name> '>' '='? <mf-value>","mf-value":"<number>|<dimension>|<ident>|<ratio>","min()":"min( <calc-sum># )","minmax()":"minmax( [<length-percentage>|min-content|max-content|auto] , [<length-percentage>|<flex>|min-content|max-content|auto] )","mod()":"mod( <calc-sum> , <calc-sum> )","name-repeat":"repeat( [<integer [1,\u221E]>|auto-fill] , <line-names>+ )","named-color":"transparent|aliceblue|antiquewhite|aqua|aquamarine|azure|beige|bisque|black|blanchedalmond|blue|blueviolet|brown|burlywood|cadetblue|chartreuse|chocolate|coral|cornflowerblue|cornsilk|crimson|cyan|darkblue|darkcyan|darkgoldenrod|darkgray|darkgreen|darkgrey|darkkhaki|darkmagenta|darkolivegreen|darkorange|darkorchid|darkred|darksalmon|darkseagreen|darkslateblue|darkslategray|darkslategrey|darkturquoise|darkviolet|deeppink|deepskyblue|dimgray|dimgrey|dodgerblue|firebrick|floralwhite|forestgreen|fuchsia|gainsboro|ghostwhite|gold|goldenrod|gray|green|greenyellow|grey|honeydew|hotpink|indianred|indigo|ivory|khaki|lavender|lavenderblush|lawngreen|lemonchiffon|lightblue|lightcoral|lightcyan|lightgoldenrodyellow|lightgray|lightgreen|lightgrey|lightpink|lightsalmon|lightseagreen|lightskyblue|lightslategray|lightslategrey|lightsteelblue|lightyellow|lime|limegreen|linen|magenta|maroon|mediumaquamarine|mediumblue|mediumorchid|mediumpurple|mediumseagreen|mediumslateblue|mediumspringgreen|mediumturquoise|mediumvioletred|midnightblue|mintcream|mistyrose|moccasin|navajowhite|navy|oldlace|olive|olivedrab|orange|orangered|orchid|palegoldenrod|palegreen|paleturquoise|palevioletred|papayawhip|peachpuff|peru|pink|plum|powderblue|purple|rebeccapurple|red|rosybrown|royalblue|saddlebrown|salmon|sandybrown|seagreen|seashell|sienna|silver|skyblue|slateblue|slategray|slategrey|snow|springgreen|steelblue|tan|teal|thistle|tomato|turquoise|violet|wheat|white|whitesmoke|yellow|yellowgreen|<-non-standard-color>","namespace-prefix":"<ident>","ns-prefix":"[<ident-token>|'*']? '|'","number-percentage":"<number>|<percentage>","numeric-figure-values":"[lining-nums|oldstyle-nums]","numeric-fraction-values":"[diagonal-fractions|stacked-fractions]","numeric-spacing-values":"[proportional-nums|tabular-nums]",nth:"<an-plus-b>|even|odd","opacity()":"opacity( [<number-percentage>] )","overflow-position":"unsafe|safe","outline-radius":"<length>|<percentage>","page-body":"<declaration>? [; <page-body>]?|<page-margin-box> <page-body>","page-margin-box":"<page-margin-box-type> '{' <declaration-list> '}'","page-margin-box-type":"@top-left-corner|@top-left|@top-center|@top-right|@top-right-corner|@bottom-left-corner|@bottom-left|@bottom-center|@bottom-right|@bottom-right-corner|@left-top|@left-middle|@left-bottom|@right-top|@right-middle|@right-bottom","page-selector-list":"[<page-selector>#]?","page-selector":"<pseudo-page>+|<ident> <pseudo-page>*","page-size":"A5|A4|A3|B5|B4|JIS-B5|JIS-B4|letter|legal|ledger","path()":"path( [<fill-rule> ,]? <string> )","paint()":"paint( <ident> , <declaration-value>? )","perspective()":"perspective( [<length [0,\u221E]>|none] )","polygon()":"polygon( <fill-rule>? , [<length-percentage> <length-percentage>]# )",position:"[[left|center|right]||[top|center|bottom]|[left|center|right|<length-percentage>] [top|center|bottom|<length-percentage>]?|[[left|right] <length-percentage>]&&[[top|bottom] <length-percentage>]]","pow()":"pow( <calc-sum> , <calc-sum> )","pseudo-class-selector":"':' <ident-token>|':' <function-token> <any-value> ')'","pseudo-element-selector":"':' <pseudo-class-selector>","pseudo-page":": [left|right|first|blank]",quote:"open-quote|close-quote|no-open-quote|no-close-quote","radial-gradient()":"radial-gradient( [<ending-shape>||<size>]? [at <position>]? , <color-stop-list> )",ratio:"<number [0,\u221E]> [/ <number [0,\u221E]>]?","relative-selector":"<combinator>? <complex-selector>","relative-selector-list":"<relative-selector>#","relative-size":"larger|smaller","rem()":"rem( <calc-sum> , <calc-sum> )","repeat-style":"repeat-x|repeat-y|[repeat|space|round|no-repeat]{1,2}","repeating-conic-gradient()":"repeating-conic-gradient( [from <angle>]? [at <position>]? , <angular-color-stop-list> )","repeating-linear-gradient()":"repeating-linear-gradient( [<angle>|to <side-or-corner>]? , <color-stop-list> )","repeating-radial-gradient()":"repeating-radial-gradient( [<ending-shape>||<size>]? [at <position>]? , <color-stop-list> )","reversed-counter-name":"reversed( <counter-name> )","rgb()":"rgb( <percentage>{3} [/ <alpha-value>]? )|rgb( <number>{3} [/ <alpha-value>]? )|rgb( <percentage>#{3} , <alpha-value>? )|rgb( <number>#{3} , <alpha-value>? )","rgba()":"rgba( <percentage>{3} [/ <alpha-value>]? )|rgba( <number>{3} [/ <alpha-value>]? )|rgba( <percentage>#{3} , <alpha-value>? )|rgba( <number>#{3} , <alpha-value>? )","rotate()":"rotate( [<angle>|<zero>] )","rotate3d()":"rotate3d( <number> , <number> , <number> , [<angle>|<zero>] )","rotateX()":"rotateX( [<angle>|<zero>] )","rotateY()":"rotateY( [<angle>|<zero>] )","rotateZ()":"rotateZ( [<angle>|<zero>] )","round()":"round( <rounding-strategy>? , <calc-sum> , <calc-sum> )","rounding-strategy":"nearest|up|down|to-zero","saturate()":"saturate( <number-percentage> )","scale()":"scale( [<number>|<percentage>]#{1,2} )","scale3d()":"scale3d( [<number>|<percentage>]#{3} )","scaleX()":"scaleX( [<number>|<percentage>] )","scaleY()":"scaleY( [<number>|<percentage>] )","scaleZ()":"scaleZ( [<number>|<percentage>] )",scroller:"root|nearest","self-position":"center|start|end|self-start|self-end|flex-start|flex-end","shape-radius":"<length-percentage>|closest-side|farthest-side","sign()":"sign( <calc-sum> )","skew()":"skew( [<angle>|<zero>] , [<angle>|<zero>]? )","skewX()":"skewX( [<angle>|<zero>] )","skewY()":"skewY( [<angle>|<zero>] )","sepia()":"sepia( <number-percentage> )",shadow:"inset?&&<length>{2,4}&&<color>?","shadow-t":"[<length>{2,3}&&<color>?]",shape:"rect( <top> , <right> , <bottom> , <left> )|rect( <top> <right> <bottom> <left> )","shape-box":"<box>|margin-box","side-or-corner":"[left|right]||[top|bottom]","sin()":"sin( <calc-sum> )","single-animation":"<time>||<easing-function>||<time>||<single-animation-iteration-count>||<single-animation-direction>||<single-animation-fill-mode>||<single-animation-play-state>||[none|<keyframes-name>]","single-animation-direction":"normal|reverse|alternate|alternate-reverse","single-animation-fill-mode":"none|forwards|backwards|both","single-animation-iteration-count":"infinite|<number>","single-animation-play-state":"running|paused","single-animation-timeline":"auto|none|<timeline-name>|scroll( <axis>? <scroller>? )","single-transition":"[none|<single-transition-property>]||<time>||<easing-function>||<time>","single-transition-property":"all|<custom-ident>",size:"closest-side|farthest-side|closest-corner|farthest-corner|<length>|<length-percentage>{2}","sqrt()":"sqrt( <calc-sum> )","step-position":"jump-start|jump-end|jump-none|jump-both|start|end","step-timing-function":"step-start|step-end|steps( <integer> [, <step-position>]? )","subclass-selector":"<id-selector>|<class-selector>|<attribute-selector>|<pseudo-class-selector>","supports-condition":"not <supports-in-parens>|<supports-in-parens> [and <supports-in-parens>]*|<supports-in-parens> [or <supports-in-parens>]*","supports-in-parens":"( <supports-condition> )|<supports-feature>|<general-enclosed>","supports-feature":"<supports-decl>|<supports-selector-fn>","supports-decl":"( <declaration> )","supports-selector-fn":"selector( <complex-selector> )",symbol:"<string>|<image>|<custom-ident>","tan()":"tan( <calc-sum> )",target:"<target-counter()>|<target-counters()>|<target-text()>","target-counter()":"target-counter( [<string>|<url>] , <custom-ident> , <counter-style>? )","target-counters()":"target-counters( [<string>|<url>] , <custom-ident> , <string> , <counter-style>? )","target-text()":"target-text( [<string>|<url>] , [content|before|after|first-letter]? )","time-percentage":"<time>|<percentage>","timeline-name":"<custom-ident>|<string>","easing-function":"linear|<cubic-bezier-timing-function>|<step-timing-function>","track-breadth":"<length-percentage>|<flex>|min-content|max-content|auto","track-list":"[<line-names>? [<track-size>|<track-repeat>]]+ <line-names>?","track-repeat":"repeat( [<integer [1,\u221E]>] , [<line-names>? <track-size>]+ <line-names>? )","track-size":"<track-breadth>|minmax( <inflexible-breadth> , <track-breadth> )|fit-content( <length-percentage> )","transform-function":"<matrix()>|<translate()>|<translateX()>|<translateY()>|<scale()>|<scaleX()>|<scaleY()>|<rotate()>|<skew()>|<skewX()>|<skewY()>|<matrix3d()>|<translate3d()>|<translateZ()>|<scale3d()>|<scaleZ()>|<rotate3d()>|<rotateX()>|<rotateY()>|<rotateZ()>|<perspective()>","transform-list":"<transform-function>+","translate()":"translate( <length-percentage> , <length-percentage>? )","translate3d()":"translate3d( <length-percentage> , <length-percentage> , <length> )","translateX()":"translateX( <length-percentage> )","translateY()":"translateY( <length-percentage> )","translateZ()":"translateZ( <length> )","type-or-unit":"string|color|url|integer|number|length|angle|time|frequency|cap|ch|em|ex|ic|lh|rlh|rem|vb|vi|vw|vh|vmin|vmax|mm|Q|cm|in|pt|pc|px|deg|grad|rad|turn|ms|s|Hz|kHz|%","type-selector":"<wq-name>|<ns-prefix>? '*'","var()":"var( <custom-property-name> , <declaration-value>? )","viewport-length":"auto|<length-percentage>","visual-box":"content-box|padding-box|border-box","wq-name":"<ns-prefix>? <ident-token>","-legacy-gradient":"<-webkit-gradient()>|<-legacy-linear-gradient>|<-legacy-repeating-linear-gradient>|<-legacy-radial-gradient>|<-legacy-repeating-radial-gradient>","-legacy-linear-gradient":"-moz-linear-gradient( <-legacy-linear-gradient-arguments> )|-webkit-linear-gradient( <-legacy-linear-gradient-arguments> )|-o-linear-gradient( <-legacy-linear-gradient-arguments> )","-legacy-repeating-linear-gradient":"-moz-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )|-webkit-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )|-o-repeating-linear-gradient( <-legacy-linear-gradient-arguments> )","-legacy-linear-gradient-arguments":"[<angle>|<side-or-corner>]? , <color-stop-list>","-legacy-radial-gradient":"-moz-radial-gradient( <-legacy-radial-gradient-arguments> )|-webkit-radial-gradient( <-legacy-radial-gradient-arguments> )|-o-radial-gradient( <-legacy-radial-gradient-arguments> )","-legacy-repeating-radial-gradient":"-moz-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )|-webkit-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )|-o-repeating-radial-gradient( <-legacy-radial-gradient-arguments> )","-legacy-radial-gradient-arguments":"[<position> ,]? [[[<-legacy-radial-gradient-shape>||<-legacy-radial-gradient-size>]|[<length>|<percentage>]{2}] ,]? <color-stop-list>","-legacy-radial-gradient-size":"closest-side|closest-corner|farthest-side|farthest-corner|contain|cover","-legacy-radial-gradient-shape":"circle|ellipse","-non-standard-font":"-apple-system-body|-apple-system-headline|-apple-system-subheadline|-apple-system-caption1|-apple-system-caption2|-apple-system-footnote|-apple-system-short-body|-apple-system-short-headline|-apple-system-short-subheadline|-apple-system-short-caption1|-apple-system-short-footnote|-apple-system-tall-body","-non-standard-color":"-moz-ButtonDefault|-moz-ButtonHoverFace|-moz-ButtonHoverText|-moz-CellHighlight|-moz-CellHighlightText|-moz-Combobox|-moz-ComboboxText|-moz-Dialog|-moz-DialogText|-moz-dragtargetzone|-moz-EvenTreeRow|-moz-Field|-moz-FieldText|-moz-html-CellHighlight|-moz-html-CellHighlightText|-moz-mac-accentdarkestshadow|-moz-mac-accentdarkshadow|-moz-mac-accentface|-moz-mac-accentlightesthighlight|-moz-mac-accentlightshadow|-moz-mac-accentregularhighlight|-moz-mac-accentregularshadow|-moz-mac-chrome-active|-moz-mac-chrome-inactive|-moz-mac-focusring|-moz-mac-menuselect|-moz-mac-menushadow|-moz-mac-menutextselect|-moz-MenuHover|-moz-MenuHoverText|-moz-MenuBarText|-moz-MenuBarHoverText|-moz-nativehyperlinktext|-moz-OddTreeRow|-moz-win-communicationstext|-moz-win-mediatext|-moz-activehyperlinktext|-moz-default-background-color|-moz-default-color|-moz-hyperlinktext|-moz-visitedhyperlinktext|-webkit-activelink|-webkit-focus-ring-color|-webkit-link|-webkit-text","-non-standard-image-rendering":"optimize-contrast|-moz-crisp-edges|-o-crisp-edges|-webkit-optimize-contrast","-non-standard-overflow":"-moz-scrollbars-none|-moz-scrollbars-horizontal|-moz-scrollbars-vertical|-moz-hidden-unscrollable","-non-standard-width":"fill-available|min-intrinsic|intrinsic|-moz-available|-moz-fit-content|-moz-min-content|-moz-max-content|-webkit-min-content|-webkit-max-content","-webkit-gradient()":"-webkit-gradient( <-webkit-gradient-type> , <-webkit-gradient-point> [, <-webkit-gradient-point>|, <-webkit-gradient-radius> , <-webkit-gradient-point>] [, <-webkit-gradient-radius>]? [, <-webkit-gradient-color-stop>]* )","-webkit-gradient-color-stop":"from( <color> )|color-stop( [<number-zero-one>|<percentage>] , <color> )|to( <color> )","-webkit-gradient-point":"[left|center|right|<length-percentage>] [top|center|bottom|<length-percentage>]","-webkit-gradient-radius":"<length>|<percentage>","-webkit-gradient-type":"linear|radial","-webkit-mask-box-repeat":"repeat|stretch|round","-webkit-mask-clip-style":"border|border-box|padding|padding-box|content|content-box|text","-ms-filter-function-list":"<-ms-filter-function>+","-ms-filter-function":"<-ms-filter-function-progid>|<-ms-filter-function-legacy>","-ms-filter-function-progid":"'progid:' [<ident-token> '.']* [<ident-token>|<function-token> <any-value>? )]","-ms-filter-function-legacy":"<ident-token>|<function-token> <any-value>? )","-ms-filter":"<string>",age:"child|young|old","attr-name":"<wq-name>","attr-fallback":"<any-value>","bg-clip":"<box>|border|text",bottom:"<length>|auto","generic-voice":"[<age>? <gender> <integer>?]",gender:"male|female|neutral",left:"<length>|auto","mask-image":"<mask-reference>#",paint:"none|<color>|<url> [none|<color>]?|context-fill|context-stroke",right:"<length>|auto","scroll-timeline-axis":"block|inline|vertical|horizontal","scroll-timeline-name":"none|<custom-ident>","single-animation-composition":"replace|add|accumulate","svg-length":"<percentage>|<length>|<number>","svg-writing-mode":"lr-tb|rl-tb|tb-rl|lr|rl|tb",top:"<length>|auto",x:"<number>",y:"<number>",declaration:"<ident-token> : <declaration-value>? ['!' important]?","declaration-list":"[<declaration>? ';']* <declaration>?",url:"url( <string> <url-modifier>* )|<url-token>","url-modifier":"<ident>|<function-token> <any-value> )","number-zero-one":"<number [0,1]>","number-one-or-greater":"<number [1,\u221E]>","-non-standard-display":"-ms-inline-flexbox|-ms-grid|-ms-inline-grid|-webkit-flex|-webkit-inline-flex|-webkit-box|-webkit-inline-box|-moz-inline-stack|-moz-box|-moz-inline-box"},properties:{"--*":"<declaration-value>","-ms-accelerator":"false|true","-ms-block-progression":"tb|rl|bt|lr","-ms-content-zoom-chaining":"none|chained","-ms-content-zooming":"none|zoom","-ms-content-zoom-limit":"<'-ms-content-zoom-limit-min'> <'-ms-content-zoom-limit-max'>","-ms-content-zoom-limit-max":"<percentage>","-ms-content-zoom-limit-min":"<percentage>","-ms-content-zoom-snap":"<'-ms-content-zoom-snap-type'>||<'-ms-content-zoom-snap-points'>","-ms-content-zoom-snap-points":"snapInterval( <percentage> , <percentage> )|snapList( <percentage># )","-ms-content-zoom-snap-type":"none|proximity|mandatory","-ms-filter":"<string>","-ms-flow-from":"[none|<custom-ident>]#","-ms-flow-into":"[none|<custom-ident>]#","-ms-grid-columns":"none|<track-list>|<auto-track-list>","-ms-grid-rows":"none|<track-list>|<auto-track-list>","-ms-high-contrast-adjust":"auto|none","-ms-hyphenate-limit-chars":"auto|<integer>{1,3}","-ms-hyphenate-limit-lines":"no-limit|<integer>","-ms-hyphenate-limit-zone":"<percentage>|<length>","-ms-ime-align":"auto|after","-ms-overflow-style":"auto|none|scrollbar|-ms-autohiding-scrollbar","-ms-scrollbar-3dlight-color":"<color>","-ms-scrollbar-arrow-color":"<color>","-ms-scrollbar-base-color":"<color>","-ms-scrollbar-darkshadow-color":"<color>","-ms-scrollbar-face-color":"<color>","-ms-scrollbar-highlight-color":"<color>","-ms-scrollbar-shadow-color":"<color>","-ms-scrollbar-track-color":"<color>","-ms-scroll-chaining":"chained|none","-ms-scroll-limit":"<'-ms-scroll-limit-x-min'> <'-ms-scroll-limit-y-min'> <'-ms-scroll-limit-x-max'> <'-ms-scroll-limit-y-max'>","-ms-scroll-limit-x-max":"auto|<length>","-ms-scroll-limit-x-min":"<length>","-ms-scroll-limit-y-max":"auto|<length>","-ms-scroll-limit-y-min":"<length>","-ms-scroll-rails":"none|railed","-ms-scroll-snap-points-x":"snapInterval( <length-percentage> , <length-percentage> )|snapList( <length-percentage># )","-ms-scroll-snap-points-y":"snapInterval( <length-percentage> , <length-percentage> )|snapList( <length-percentage># )","-ms-scroll-snap-type":"none|proximity|mandatory","-ms-scroll-snap-x":"<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-x'>","-ms-scroll-snap-y":"<'-ms-scroll-snap-type'> <'-ms-scroll-snap-points-y'>","-ms-scroll-translation":"none|vertical-to-horizontal","-ms-text-autospace":"none|ideograph-alpha|ideograph-numeric|ideograph-parenthesis|ideograph-space","-ms-touch-select":"grippers|none","-ms-user-select":"none|element|text","-ms-wrap-flow":"auto|both|start|end|maximum|clear","-ms-wrap-margin":"<length>","-ms-wrap-through":"wrap|none","-moz-appearance":"none|button|button-arrow-down|button-arrow-next|button-arrow-previous|button-arrow-up|button-bevel|button-focus|caret|checkbox|checkbox-container|checkbox-label|checkmenuitem|dualbutton|groupbox|listbox|listitem|menuarrow|menubar|menucheckbox|menuimage|menuitem|menuitemtext|menulist|menulist-button|menulist-text|menulist-textfield|menupopup|menuradio|menuseparator|meterbar|meterchunk|progressbar|progressbar-vertical|progresschunk|progresschunk-vertical|radio|radio-container|radio-label|radiomenuitem|range|range-thumb|resizer|resizerpanel|scale-horizontal|scalethumbend|scalethumb-horizontal|scalethumbstart|scalethumbtick|scalethumb-vertical|scale-vertical|scrollbarbutton-down|scrollbarbutton-left|scrollbarbutton-right|scrollbarbutton-up|scrollbarthumb-horizontal|scrollbarthumb-vertical|scrollbartrack-horizontal|scrollbartrack-vertical|searchfield|separator|sheet|spinner|spinner-downbutton|spinner-textfield|spinner-upbutton|splitter|statusbar|statusbarpanel|tab|tabpanel|tabpanels|tab-scroll-arrow-back|tab-scroll-arrow-forward|textfield|textfield-multiline|toolbar|toolbarbutton|toolbarbutton-dropdown|toolbargripper|toolbox|tooltip|treeheader|treeheadercell|treeheadersortarrow|treeitem|treeline|treetwisty|treetwistyopen|treeview|-moz-mac-unified-toolbar|-moz-win-borderless-glass|-moz-win-browsertabbar-toolbox|-moz-win-communicationstext|-moz-win-communications-toolbox|-moz-win-exclude-glass|-moz-win-glass|-moz-win-mediatext|-moz-win-media-toolbox|-moz-window-button-box|-moz-window-button-box-maximized|-moz-window-button-close|-moz-window-button-maximize|-moz-window-button-minimize|-moz-window-button-restore|-moz-window-frame-bottom|-moz-window-frame-left|-moz-window-frame-right|-moz-window-titlebar|-moz-window-titlebar-maximized","-moz-binding":"<url>|none","-moz-border-bottom-colors":"<color>+|none","-moz-border-left-colors":"<color>+|none","-moz-border-right-colors":"<color>+|none","-moz-border-top-colors":"<color>+|none","-moz-context-properties":"none|[fill|fill-opacity|stroke|stroke-opacity]#","-moz-float-edge":"border-box|content-box|margin-box|padding-box","-moz-force-broken-image-icon":"0|1","-moz-image-region":"<shape>|auto","-moz-orient":"inline|block|horizontal|vertical","-moz-outline-radius":"<outline-radius>{1,4} [/ <outline-radius>{1,4}]?","-moz-outline-radius-bottomleft":"<outline-radius>","-moz-outline-radius-bottomright":"<outline-radius>","-moz-outline-radius-topleft":"<outline-radius>","-moz-outline-radius-topright":"<outline-radius>","-moz-stack-sizing":"ignore|stretch-to-fit","-moz-text-blink":"none|blink","-moz-user-focus":"ignore|normal|select-after|select-before|select-menu|select-same|select-all|none","-moz-user-input":"auto|none|enabled|disabled","-moz-user-modify":"read-only|read-write|write-only","-moz-window-dragging":"drag|no-drag","-moz-window-shadow":"default|menu|tooltip|sheet|none","-webkit-appearance":"none|button|button-bevel|caps-lock-indicator|caret|checkbox|default-button|inner-spin-button|listbox|listitem|media-controls-background|media-controls-fullscreen-background|media-current-time-display|media-enter-fullscreen-button|media-exit-fullscreen-button|media-fullscreen-button|media-mute-button|media-overlay-play-button|media-play-button|media-seek-back-button|media-seek-forward-button|media-slider|media-sliderthumb|media-time-remaining-display|media-toggle-closed-captions-button|media-volume-slider|media-volume-slider-container|media-volume-sliderthumb|menulist|menulist-button|menulist-text|menulist-textfield|meter|progress-bar|progress-bar-value|push-button|radio|scrollbarbutton-down|scrollbarbutton-left|scrollbarbutton-right|scrollbarbutton-up|scrollbargripper-horizontal|scrollbargripper-vertical|scrollbarthumb-horizontal|scrollbarthumb-vertical|scrollbartrack-horizontal|scrollbartrack-vertical|searchfield|searchfield-cancel-button|searchfield-decoration|searchfield-results-button|searchfield-results-decoration|slider-horizontal|slider-vertical|sliderthumb-horizontal|sliderthumb-vertical|square-button|textarea|textfield|-apple-pay-button","-webkit-border-before":"<'border-width'>||<'border-style'>||<color>","-webkit-border-before-color":"<color>","-webkit-border-before-style":"<'border-style'>","-webkit-border-before-width":"<'border-width'>","-webkit-box-reflect":"[above|below|right|left]? <length>? <image>?","-webkit-line-clamp":"none|<integer>","-webkit-mask":"[<mask-reference>||<position> [/ <bg-size>]?||<repeat-style>||[<box>|border|padding|content|text]||[<box>|border|padding|content]]#","-webkit-mask-attachment":"<attachment>#","-webkit-mask-clip":"[<box>|border|padding|content|text]#","-webkit-mask-composite":"<composite-style>#","-webkit-mask-image":"<mask-reference>#","-webkit-mask-origin":"[<box>|border|padding|content]#","-webkit-mask-position":"<position>#","-webkit-mask-position-x":"[<length-percentage>|left|center|right]#","-webkit-mask-position-y":"[<length-percentage>|top|center|bottom]#","-webkit-mask-repeat":"<repeat-style>#","-webkit-mask-repeat-x":"repeat|no-repeat|space|round","-webkit-mask-repeat-y":"repeat|no-repeat|space|round","-webkit-mask-size":"<bg-size>#","-webkit-overflow-scrolling":"auto|touch","-webkit-tap-highlight-color":"<color>","-webkit-text-fill-color":"<color>","-webkit-text-stroke":"<length>||<color>","-webkit-text-stroke-color":"<color>","-webkit-text-stroke-width":"<length>","-webkit-touch-callout":"default|none","-webkit-user-modify":"read-only|read-write|read-write-plaintext-only","accent-color":"auto|<color>","align-content":"normal|<baseline-position>|<content-distribution>|<overflow-position>? <content-position>","align-items":"normal|stretch|<baseline-position>|[<overflow-position>? <self-position>]","align-self":"auto|normal|stretch|<baseline-position>|<overflow-position>? <self-position>","align-tracks":"[normal|<baseline-position>|<content-distribution>|<overflow-position>? <content-position>]#",all:"initial|inherit|unset|revert|revert-layer",animation:"<single-animation>#","animation-composition":"<single-animation-composition>#","animation-delay":"<time>#","animation-direction":"<single-animation-direction>#","animation-duration":"<time>#","animation-fill-mode":"<single-animation-fill-mode>#","animation-iteration-count":"<single-animation-iteration-count>#","animation-name":"[none|<keyframes-name>]#","animation-play-state":"<single-animation-play-state>#","animation-timing-function":"<easing-function>#","animation-timeline":"<single-animation-timeline>#",appearance:"none|auto|textfield|menulist-button|<compat-auto>","aspect-ratio":"auto|<ratio>",azimuth:"<angle>|[[left-side|far-left|left|center-left|center|center-right|right|far-right|right-side]||behind]|leftwards|rightwards","backdrop-filter":"none|<filter-function-list>","backface-visibility":"visible|hidden",background:"[<bg-layer> ,]* <final-bg-layer>","background-attachment":"<attachment>#","background-blend-mode":"<blend-mode>#","background-clip":"<bg-clip>#","background-color":"<color>","background-image":"<bg-image>#","background-origin":"<box>#","background-position":"<bg-position>#","background-position-x":"[center|[[left|right|x-start|x-end]? <length-percentage>?]!]#","background-position-y":"[center|[[top|bottom|y-start|y-end]? <length-percentage>?]!]#","background-repeat":"<repeat-style>#","background-size":"<bg-size>#","block-overflow":"clip|ellipsis|<string>","block-size":"<'width'>",border:"<line-width>||<line-style>||<color>","border-block":"<'border-top-width'>||<'border-top-style'>||<color>","border-block-color":"<'border-top-color'>{1,2}","border-block-style":"<'border-top-style'>","border-block-width":"<'border-top-width'>","border-block-end":"<'border-top-width'>||<'border-top-style'>||<color>","border-block-end-color":"<'border-top-color'>","border-block-end-style":"<'border-top-style'>","border-block-end-width":"<'border-top-width'>","border-block-start":"<'border-top-width'>||<'border-top-style'>||<color>","border-block-start-color":"<'border-top-color'>","border-block-start-style":"<'border-top-style'>","border-block-start-width":"<'border-top-width'>","border-bottom":"<line-width>||<line-style>||<color>","border-bottom-color":"<'border-top-color'>","border-bottom-left-radius":"<length-percentage>{1,2}","border-bottom-right-radius":"<length-percentage>{1,2}","border-bottom-style":"<line-style>","border-bottom-width":"<line-width>","border-collapse":"collapse|separate","border-color":"<color>{1,4}","border-end-end-radius":"<length-percentage>{1,2}","border-end-start-radius":"<length-percentage>{1,2}","border-image":"<'border-image-source'>||<'border-image-slice'> [/ <'border-image-width'>|/ <'border-image-width'>? / <'border-image-outset'>]?||<'border-image-repeat'>","border-image-outset":"[<length>|<number>]{1,4}","border-image-repeat":"[stretch|repeat|round|space]{1,2}","border-image-slice":"<number-percentage>{1,4}&&fill?","border-image-source":"none|<image>","border-image-width":"[<length-percentage>|<number>|auto]{1,4}","border-inline":"<'border-top-width'>||<'border-top-style'>||<color>","border-inline-end":"<'border-top-width'>||<'border-top-style'>||<color>","border-inline-color":"<'border-top-color'>{1,2}","border-inline-style":"<'border-top-style'>","border-inline-width":"<'border-top-width'>","border-inline-end-color":"<'border-top-color'>","border-inline-end-style":"<'border-top-style'>","border-inline-end-width":"<'border-top-width'>","border-inline-start":"<'border-top-width'>||<'border-top-style'>||<color>","border-inline-start-color":"<'border-top-color'>","border-inline-start-style":"<'border-top-style'>","border-inline-start-width":"<'border-top-width'>","border-left":"<line-width>||<line-style>||<color>","border-left-color":"<color>","border-left-style":"<line-style>","border-left-width":"<line-width>","border-radius":"<length-percentage>{1,4} [/ <length-percentage>{1,4}]?","border-right":"<line-width>||<line-style>||<color>","border-right-color":"<color>","border-right-style":"<line-style>","border-right-width":"<line-width>","border-spacing":"<length> <length>?","border-start-end-radius":"<length-percentage>{1,2}","border-start-start-radius":"<length-percentage>{1,2}","border-style":"<line-style>{1,4}","border-top":"<line-width>||<line-style>||<color>","border-top-color":"<color>","border-top-left-radius":"<length-percentage>{1,2}","border-top-right-radius":"<length-percentage>{1,2}","border-top-style":"<line-style>","border-top-width":"<line-width>","border-width":"<line-width>{1,4}",bottom:"<length>|<percentage>|auto","box-align":"start|center|end|baseline|stretch","box-decoration-break":"slice|clone","box-direction":"normal|reverse|inherit","box-flex":"<number>","box-flex-group":"<integer>","box-lines":"single|multiple","box-ordinal-group":"<integer>","box-orient":"horizontal|vertical|inline-axis|block-axis|inherit","box-pack":"start|center|end|justify","box-shadow":"none|<shadow>#","box-sizing":"content-box|border-box","break-after":"auto|avoid|always|all|avoid-page|page|left|right|recto|verso|avoid-column|column|avoid-region|region","break-before":"auto|avoid|always|all|avoid-page|page|left|right|recto|verso|avoid-column|column|avoid-region|region","break-inside":"auto|avoid|avoid-page|avoid-column|avoid-region","caption-side":"top|bottom|block-start|block-end|inline-start|inline-end",caret:"<'caret-color'>||<'caret-shape'>","caret-color":"auto|<color>","caret-shape":"auto|bar|block|underscore",clear:"none|left|right|both|inline-start|inline-end",clip:"<shape>|auto","clip-path":"<clip-source>|[<basic-shape>||<geometry-box>]|none",color:"<color>","print-color-adjust":"economy|exact","color-scheme":"normal|[light|dark|<custom-ident>]+&&only?","column-count":"<integer>|auto","column-fill":"auto|balance|balance-all","column-gap":"normal|<length-percentage>","column-rule":"<'column-rule-width'>||<'column-rule-style'>||<'column-rule-color'>","column-rule-color":"<color>","column-rule-style":"<'border-style'>","column-rule-width":"<'border-width'>","column-span":"none|all","column-width":"<length>|auto",columns:"<'column-width'>||<'column-count'>",contain:"none|strict|content|[[size||inline-size]||layout||style||paint]","contain-intrinsic-size":"[none|<length>|auto <length>]{1,2}","contain-intrinsic-block-size":"none|<length>|auto <length>","contain-intrinsic-height":"none|<length>|auto <length>","contain-intrinsic-inline-size":"none|<length>|auto <length>","contain-intrinsic-width":"none|<length>|auto <length>",content:"normal|none|[<content-replacement>|<content-list>] [/ [<string>|<counter>]+]?","content-visibility":"visible|auto|hidden","counter-increment":"[<counter-name> <integer>?]+|none","counter-reset":"[<counter-name> <integer>?|<reversed-counter-name> <integer>?]+|none","counter-set":"[<counter-name> <integer>?]+|none",cursor:"[[<url> [<x> <y>]? ,]* [auto|default|none|context-menu|help|pointer|progress|wait|cell|crosshair|text|vertical-text|alias|copy|move|no-drop|not-allowed|e-resize|n-resize|ne-resize|nw-resize|s-resize|se-resize|sw-resize|w-resize|ew-resize|ns-resize|nesw-resize|nwse-resize|col-resize|row-resize|all-scroll|zoom-in|zoom-out|grab|grabbing|hand|-webkit-grab|-webkit-grabbing|-webkit-zoom-in|-webkit-zoom-out|-moz-grab|-moz-grabbing|-moz-zoom-in|-moz-zoom-out]]",direction:"ltr|rtl",display:"[<display-outside>||<display-inside>]|<display-listitem>|<display-internal>|<display-box>|<display-legacy>|<-non-standard-display>","empty-cells":"show|hide",filter:"none|<filter-function-list>|<-ms-filter-function-list>",flex:"none|[<'flex-grow'> <'flex-shrink'>?||<'flex-basis'>]","flex-basis":"content|<'width'>","flex-direction":"row|row-reverse|column|column-reverse","flex-flow":"<'flex-direction'>||<'flex-wrap'>","flex-grow":"<number>","flex-shrink":"<number>","flex-wrap":"nowrap|wrap|wrap-reverse",float:"left|right|none|inline-start|inline-end",font:"[[<'font-style'>||<font-variant-css21>||<'font-weight'>||<'font-stretch'>]? <'font-size'> [/ <'line-height'>]? <'font-family'>]|caption|icon|menu|message-box|small-caption|status-bar","font-family":"[<family-name>|<generic-family>]#","font-feature-settings":"normal|<feature-tag-value>#","font-kerning":"auto|normal|none","font-language-override":"normal|<string>","font-optical-sizing":"auto|none","font-variation-settings":"normal|[<string> <number>]#","font-size":"<absolute-size>|<relative-size>|<length-percentage>","font-size-adjust":"none|[ex-height|cap-height|ch-width|ic-width|ic-height]? [from-font|<number>]","font-smooth":"auto|never|always|<absolute-size>|<length>","font-stretch":"<font-stretch-absolute>","font-style":"normal|italic|oblique <angle>?","font-synthesis":"none|[weight||style||small-caps]","font-variant":"normal|none|[<common-lig-values>||<discretionary-lig-values>||<historical-lig-values>||<contextual-alt-values>||stylistic( <feature-value-name> )||historical-forms||styleset( <feature-value-name># )||character-variant( <feature-value-name># )||swash( <feature-value-name> )||ornaments( <feature-value-name> )||annotation( <feature-value-name> )||[small-caps|all-small-caps|petite-caps|all-petite-caps|unicase|titling-caps]||<numeric-figure-values>||<numeric-spacing-values>||<numeric-fraction-values>||ordinal||slashed-zero||<east-asian-variant-values>||<east-asian-width-values>||ruby]","font-variant-alternates":"normal|[stylistic( <feature-value-name> )||historical-forms||styleset( <feature-value-name># )||character-variant( <feature-value-name># )||swash( <feature-value-name> )||ornaments( <feature-value-name> )||annotation( <feature-value-name> )]","font-variant-caps":"normal|small-caps|all-small-caps|petite-caps|all-petite-caps|unicase|titling-caps","font-variant-east-asian":"normal|[<east-asian-variant-values>||<east-asian-width-values>||ruby]","font-variant-ligatures":"normal|none|[<common-lig-values>||<discretionary-lig-values>||<historical-lig-values>||<contextual-alt-values>]","font-variant-numeric":"normal|[<numeric-figure-values>||<numeric-spacing-values>||<numeric-fraction-values>||ordinal||slashed-zero]","font-variant-position":"normal|sub|super","font-weight":"<font-weight-absolute>|bolder|lighter","forced-color-adjust":"auto|none",gap:"<'row-gap'> <'column-gap'>?",grid:"<'grid-template'>|<'grid-template-rows'> / [auto-flow&&dense?] <'grid-auto-columns'>?|[auto-flow&&dense?] <'grid-auto-rows'>? / <'grid-template-columns'>","grid-area":"<grid-line> [/ <grid-line>]{0,3}","grid-auto-columns":"<track-size>+","grid-auto-flow":"[row|column]||dense","grid-auto-rows":"<track-size>+","grid-column":"<grid-line> [/ <grid-line>]?","grid-column-end":"<grid-line>","grid-column-gap":"<length-percentage>","grid-column-start":"<grid-line>","grid-gap":"<'grid-row-gap'> <'grid-column-gap'>?","grid-row":"<grid-line> [/ <grid-line>]?","grid-row-end":"<grid-line>","grid-row-gap":"<length-percentage>","grid-row-start":"<grid-line>","grid-template":"none|[<'grid-template-rows'> / <'grid-template-columns'>]|[<line-names>? <string> <track-size>? <line-names>?]+ [/ <explicit-track-list>]?","grid-template-areas":"none|<string>+","grid-template-columns":"none|<track-list>|<auto-track-list>|subgrid <line-name-list>?","grid-template-rows":"none|<track-list>|<auto-track-list>|subgrid <line-name-list>?","hanging-punctuation":"none|[first||[force-end|allow-end]||last]",height:"auto|<length>|<percentage>|min-content|max-content|fit-content|fit-content( <length-percentage> )","hyphenate-character":"auto|<string>",hyphens:"none|manual|auto","image-orientation":"from-image|<angle>|[<angle>? flip]","image-rendering":"auto|crisp-edges|pixelated|optimizeSpeed|optimizeQuality|<-non-standard-image-rendering>","image-resolution":"[from-image||<resolution>]&&snap?","ime-mode":"auto|normal|active|inactive|disabled","initial-letter":"normal|[<number> <integer>?]","initial-letter-align":"[auto|alphabetic|hanging|ideographic]","inline-size":"<'width'>","input-security":"auto|none",inset:"<'top'>{1,4}","inset-block":"<'top'>{1,2}","inset-block-end":"<'top'>","inset-block-start":"<'top'>","inset-inline":"<'top'>{1,2}","inset-inline-end":"<'top'>","inset-inline-start":"<'top'>",isolation:"auto|isolate","justify-content":"normal|<content-distribution>|<overflow-position>? [<content-position>|left|right]","justify-items":"normal|stretch|<baseline-position>|<overflow-position>? [<self-position>|left|right]|legacy|legacy&&[left|right|center]","justify-self":"auto|normal|stretch|<baseline-position>|<overflow-position>? [<self-position>|left|right]","justify-tracks":"[normal|<content-distribution>|<overflow-position>? [<content-position>|left|right]]#",left:"<length>|<percentage>|auto","letter-spacing":"normal|<length-percentage>","line-break":"auto|loose|normal|strict|anywhere","line-clamp":"none|<integer>","line-height":"normal|<number>|<length>|<percentage>","line-height-step":"<length>","list-style":"<'list-style-type'>||<'list-style-position'>||<'list-style-image'>","list-style-image":"<image>|none","list-style-position":"inside|outside","list-style-type":"<counter-style>|<string>|none",margin:"[<length>|<percentage>|auto]{1,4}","margin-block":"<'margin-left'>{1,2}","margin-block-end":"<'margin-left'>","margin-block-start":"<'margin-left'>","margin-bottom":"<length>|<percentage>|auto","margin-inline":"<'margin-left'>{1,2}","margin-inline-end":"<'margin-left'>","margin-inline-start":"<'margin-left'>","margin-left":"<length>|<percentage>|auto","margin-right":"<length>|<percentage>|auto","margin-top":"<length>|<percentage>|auto","margin-trim":"none|in-flow|all",mask:"<mask-layer>#","mask-border":"<'mask-border-source'>||<'mask-border-slice'> [/ <'mask-border-width'>? [/ <'mask-border-outset'>]?]?||<'mask-border-repeat'>||<'mask-border-mode'>","mask-border-mode":"luminance|alpha","mask-border-outset":"[<length>|<number>]{1,4}","mask-border-repeat":"[stretch|repeat|round|space]{1,2}","mask-border-slice":"<number-percentage>{1,4} fill?","mask-border-source":"none|<image>","mask-border-width":"[<length-percentage>|<number>|auto]{1,4}","mask-clip":"[<geometry-box>|no-clip]#","mask-composite":"<compositing-operator>#","mask-image":"<mask-reference>#","mask-mode":"<masking-mode>#","mask-origin":"<geometry-box>#","mask-position":"<position>#","mask-repeat":"<repeat-style>#","mask-size":"<bg-size>#","mask-type":"luminance|alpha","masonry-auto-flow":"[pack|next]||[definite-first|ordered]","math-depth":"auto-add|add( <integer> )|<integer>","math-shift":"normal|compact","math-style":"normal|compact","max-block-size":"<'max-width'>","max-height":"none|<length-percentage>|min-content|max-content|fit-content|fit-content( <length-percentage> )","max-inline-size":"<'max-width'>","max-lines":"none|<integer>","max-width":"none|<length-percentage>|min-content|max-content|fit-content|fit-content( <length-percentage> )|<-non-standard-width>","min-block-size":"<'min-width'>","min-height":"auto|<length>|<percentage>|min-content|max-content|fit-content|fit-content( <length-percentage> )","min-inline-size":"<'min-width'>","min-width":"auto|<length>|<percentage>|min-content|max-content|fit-content|fit-content( <length-percentage> )|<-non-standard-width>","mix-blend-mode":"<blend-mode>|plus-lighter","object-fit":"fill|contain|cover|none|scale-down","object-position":"<position>",offset:"[<'offset-position'>? [<'offset-path'> [<'offset-distance'>||<'offset-rotate'>]?]?]! [/ <'offset-anchor'>]?","offset-anchor":"auto|<position>","offset-distance":"<length-percentage>","offset-path":"none|ray( [<angle>&&<size>&&contain?] )|<path()>|<url>|[<basic-shape>||<geometry-box>]","offset-position":"auto|<position>","offset-rotate":"[auto|reverse]||<angle>",opacity:"<alpha-value>",order:"<integer>",orphans:"<integer>",outline:"[<'outline-color'>||<'outline-style'>||<'outline-width'>]","outline-color":"<color>|invert","outline-offset":"<length>","outline-style":"auto|<'border-style'>","outline-width":"<line-width>",overflow:"[visible|hidden|clip|scroll|auto]{1,2}|<-non-standard-overflow>","overflow-anchor":"auto|none","overflow-block":"visible|hidden|clip|scroll|auto","overflow-clip-box":"padding-box|content-box","overflow-clip-margin":"<visual-box>||<length [0,\u221E]>","overflow-inline":"visible|hidden|clip|scroll|auto","overflow-wrap":"normal|break-word|anywhere","overflow-x":"visible|hidden|clip|scroll|auto","overflow-y":"visible|hidden|clip|scroll|auto","overscroll-behavior":"[contain|none|auto]{1,2}","overscroll-behavior-block":"contain|none|auto","overscroll-behavior-inline":"contain|none|auto","overscroll-behavior-x":"contain|none|auto","overscroll-behavior-y":"contain|none|auto",padding:"[<length>|<percentage>]{1,4}","padding-block":"<'padding-left'>{1,2}","padding-block-end":"<'padding-left'>","padding-block-start":"<'padding-left'>","padding-bottom":"<length>|<percentage>","padding-inline":"<'padding-left'>{1,2}","padding-inline-end":"<'padding-left'>","padding-inline-start":"<'padding-left'>","padding-left":"<length>|<percentage>","padding-right":"<length>|<percentage>","padding-top":"<length>|<percentage>","page-break-after":"auto|always|avoid|left|right|recto|verso","page-break-before":"auto|always|avoid|left|right|recto|verso","page-break-inside":"auto|avoid","paint-order":"normal|[fill||stroke||markers]",perspective:"none|<length>","perspective-origin":"<position>","place-content":"<'align-content'> <'justify-content'>?","place-items":"<'align-items'> <'justify-items'>?","place-self":"<'align-self'> <'justify-self'>?","pointer-events":"auto|none|visiblePainted|visibleFill|visibleStroke|visible|painted|fill|stroke|all|inherit",position:"static|relative|absolute|sticky|fixed|-webkit-sticky",quotes:"none|auto|[<string> <string>]+",resize:"none|both|horizontal|vertical|block|inline",right:"<length>|<percentage>|auto",rotate:"none|<angle>|[x|y|z|<number>{3}]&&<angle>","row-gap":"normal|<length-percentage>","ruby-align":"start|center|space-between|space-around","ruby-merge":"separate|collapse|auto","ruby-position":"[alternate||[over|under]]|inter-character",scale:"none|<number>{1,3}","scrollbar-color":"auto|<color>{2}","scrollbar-gutter":"auto|stable&&both-edges?","scrollbar-width":"auto|thin|none","scroll-behavior":"auto|smooth","scroll-margin":"<length>{1,4}","scroll-margin-block":"<length>{1,2}","scroll-margin-block-start":"<length>","scroll-margin-block-end":"<length>","scroll-margin-bottom":"<length>","scroll-margin-inline":"<length>{1,2}","scroll-margin-inline-start":"<length>","scroll-margin-inline-end":"<length>","scroll-margin-left":"<length>","scroll-margin-right":"<length>","scroll-margin-top":"<length>","scroll-padding":"[auto|<length-percentage>]{1,4}","scroll-padding-block":"[auto|<length-percentage>]{1,2}","scroll-padding-block-start":"auto|<length-percentage>","scroll-padding-block-end":"auto|<length-percentage>","scroll-padding-bottom":"auto|<length-percentage>","scroll-padding-inline":"[auto|<length-percentage>]{1,2}","scroll-padding-inline-start":"auto|<length-percentage>","scroll-padding-inline-end":"auto|<length-percentage>","scroll-padding-left":"auto|<length-percentage>","scroll-padding-right":"auto|<length-percentage>","scroll-padding-top":"auto|<length-percentage>","scroll-snap-align":"[none|start|end|center]{1,2}","scroll-snap-coordinate":"none|<position>#","scroll-snap-destination":"<position>","scroll-snap-points-x":"none|repeat( <length-percentage> )","scroll-snap-points-y":"none|repeat( <length-percentage> )","scroll-snap-stop":"normal|always","scroll-snap-type":"none|[x|y|block|inline|both] [mandatory|proximity]?","scroll-snap-type-x":"none|mandatory|proximity","scroll-snap-type-y":"none|mandatory|proximity","scroll-timeline":"<scroll-timeline-name>||<scroll-timeline-axis>","scroll-timeline-axis":"block|inline|vertical|horizontal","scroll-timeline-name":"none|<custom-ident>","shape-image-threshold":"<alpha-value>","shape-margin":"<length-percentage>","shape-outside":"none|[<shape-box>||<basic-shape>]|<image>","tab-size":"<integer>|<length>","table-layout":"auto|fixed","text-align":"start|end|left|right|center|justify|match-parent","text-align-last":"auto|start|end|left|right|center|justify","text-combine-upright":"none|all|[digits <integer>?]","text-decoration":"<'text-decoration-line'>||<'text-decoration-style'>||<'text-decoration-color'>||<'text-decoration-thickness'>","text-decoration-color":"<color>","text-decoration-line":"none|[underline||overline||line-through||blink]|spelling-error|grammar-error","text-decoration-skip":"none|[objects||[spaces|[leading-spaces||trailing-spaces]]||edges||box-decoration]","text-decoration-skip-ink":"auto|all|none","text-decoration-style":"solid|double|dotted|dashed|wavy","text-decoration-thickness":"auto|from-font|<length>|<percentage>","text-emphasis":"<'text-emphasis-style'>||<'text-emphasis-color'>","text-emphasis-color":"<color>","text-emphasis-position":"[over|under]&&[right|left]","text-emphasis-style":"none|[[filled|open]||[dot|circle|double-circle|triangle|sesame]]|<string>","text-indent":"<length-percentage>&&hanging?&&each-line?","text-justify":"auto|inter-character|inter-word|none","text-orientation":"mixed|upright|sideways","text-overflow":"[clip|ellipsis|<string>]{1,2}","text-rendering":"auto|optimizeSpeed|optimizeLegibility|geometricPrecision","text-shadow":"none|<shadow-t>#","text-size-adjust":"none|auto|<percentage>","text-transform":"none|capitalize|uppercase|lowercase|full-width|full-size-kana","text-underline-offset":"auto|<length>|<percentage>","text-underline-position":"auto|from-font|[under||[left|right]]",top:"<length>|<percentage>|auto","touch-action":"auto|none|[[pan-x|pan-left|pan-right]||[pan-y|pan-up|pan-down]||pinch-zoom]|manipulation",transform:"none|<transform-list>","transform-box":"content-box|border-box|fill-box|stroke-box|view-box","transform-origin":"[<length-percentage>|left|center|right|top|bottom]|[[<length-percentage>|left|center|right]&&[<length-percentage>|top|center|bottom]] <length>?","transform-style":"flat|preserve-3d",transition:"<single-transition>#","transition-delay":"<time>#","transition-duration":"<time>#","transition-property":"none|<single-transition-property>#","transition-timing-function":"<easing-function>#",translate:"none|<length-percentage> [<length-percentage> <length>?]?","unicode-bidi":"normal|embed|isolate|bidi-override|isolate-override|plaintext|-moz-isolate|-moz-isolate-override|-moz-plaintext|-webkit-isolate|-webkit-isolate-override|-webkit-plaintext","user-select":"auto|text|none|contain|all","vertical-align":"baseline|sub|super|text-top|text-bottom|middle|top|bottom|<percentage>|<length>",visibility:"visible|hidden|collapse","white-space":"normal|pre|nowrap|pre-wrap|pre-line|break-spaces",widows:"<integer>",width:"auto|<length>|<percentage>|min-content|max-content|fit-content|fit-content( <length-percentage> )|fill|stretch|intrinsic|-moz-max-content|-webkit-max-content|-moz-fit-content|-webkit-fit-content","will-change":"auto|<animateable-feature>#","word-break":"normal|break-all|keep-all|break-word","word-spacing":"normal|<length>","word-wrap":"normal|break-word","writing-mode":"horizontal-tb|vertical-rl|vertical-lr|sideways-rl|sideways-lr|<svg-writing-mode>","z-index":"auto|<integer>",zoom:"normal|reset|<number>|<percentage>","-moz-background-clip":"padding|border","-moz-border-radius-bottomleft":"<'border-bottom-left-radius'>","-moz-border-radius-bottomright":"<'border-bottom-right-radius'>","-moz-border-radius-topleft":"<'border-top-left-radius'>","-moz-border-radius-topright":"<'border-bottom-right-radius'>","-moz-control-character-visibility":"visible|hidden","-moz-osx-font-smoothing":"auto|grayscale","-moz-user-select":"none|text|all|-moz-none","-ms-flex-align":"start|end|center|baseline|stretch","-ms-flex-item-align":"auto|start|end|center|baseline|stretch","-ms-flex-line-pack":"start|end|center|justify|distribute|stretch","-ms-flex-negative":"<'flex-shrink'>","-ms-flex-pack":"start|end|center|justify|distribute","-ms-flex-order":"<integer>","-ms-flex-positive":"<'flex-grow'>","-ms-flex-preferred-size":"<'flex-basis'>","-ms-interpolation-mode":"nearest-neighbor|bicubic","-ms-grid-column-align":"start|end|center|stretch","-ms-grid-row-align":"start|end|center|stretch","-ms-hyphenate-limit-last":"none|always|column|page|spread","-webkit-background-clip":"[<box>|border|padding|content|text]#","-webkit-column-break-after":"always|auto|avoid","-webkit-column-break-before":"always|auto|avoid","-webkit-column-break-inside":"always|auto|avoid","-webkit-font-smoothing":"auto|none|antialiased|subpixel-antialiased","-webkit-mask-box-image":"[<url>|<gradient>|none] [<length-percentage>{4} <-webkit-mask-box-repeat>{2}]?","-webkit-print-color-adjust":"economy|exact","-webkit-text-security":"none|circle|disc|square","-webkit-user-drag":"none|element|auto","-webkit-user-select":"auto|none|text|all","alignment-baseline":"auto|baseline|before-edge|text-before-edge|middle|central|after-edge|text-after-edge|ideographic|alphabetic|hanging|mathematical","baseline-shift":"baseline|sub|super|<svg-length>",behavior:"<url>+","clip-rule":"nonzero|evenodd",cue:"<'cue-before'> <'cue-after'>?","cue-after":"<url> <decibel>?|none","cue-before":"<url> <decibel>?|none","dominant-baseline":"auto|use-script|no-change|reset-size|ideographic|alphabetic|hanging|mathematical|central|middle|text-after-edge|text-before-edge",fill:"<paint>","fill-opacity":"<number-zero-one>","fill-rule":"nonzero|evenodd","glyph-orientation-horizontal":"<angle>","glyph-orientation-vertical":"<angle>",kerning:"auto|<svg-length>",marker:"none|<url>","marker-end":"none|<url>","marker-mid":"none|<url>","marker-start":"none|<url>",pause:"<'pause-before'> <'pause-after'>?","pause-after":"<time>|none|x-weak|weak|medium|strong|x-strong","pause-before":"<time>|none|x-weak|weak|medium|strong|x-strong",rest:"<'rest-before'> <'rest-after'>?","rest-after":"<time>|none|x-weak|weak|medium|strong|x-strong","rest-before":"<time>|none|x-weak|weak|medium|strong|x-strong","shape-rendering":"auto|optimizeSpeed|crispEdges|geometricPrecision",src:"[<url> [format( <string># )]?|local( <family-name> )]#",speak:"auto|none|normal","speak-as":"normal|spell-out||digits||[literal-punctuation|no-punctuation]",stroke:"<paint>","stroke-dasharray":"none|[<svg-length>+]#","stroke-dashoffset":"<svg-length>","stroke-linecap":"butt|round|square","stroke-linejoin":"miter|round|bevel","stroke-miterlimit":"<number-one-or-greater>","stroke-opacity":"<number-zero-one>","stroke-width":"<svg-length>","text-anchor":"start|middle|end","unicode-range":"<urange>#","voice-balance":"<number>|left|center|right|leftwards|rightwards","voice-duration":"auto|<time>","voice-family":"[[<family-name>|<generic-voice>] ,]* [<family-name>|<generic-voice>]|preserve","voice-pitch":"<frequency>&&absolute|[[x-low|low|medium|high|x-high]||[<frequency>|<semitones>|<percentage>]]","voice-range":"<frequency>&&absolute|[[x-low|low|medium|high|x-high]||[<frequency>|<semitones>|<percentage>]]","voice-rate":"[normal|x-slow|slow|medium|fast|x-fast]||<percentage>","voice-stress":"normal|strong|moderate|none|reduced","voice-volume":"silent|[[x-soft|soft|medium|loud|x-loud]||<decibel>]"},atrules:{charset:{prelude:"<string>",descriptors:null},"counter-style":{prelude:"<counter-style-name>",descriptors:{"additive-symbols":"[<integer>&&<symbol>]#",fallback:"<counter-style-name>",negative:"<symbol> <symbol>?",pad:"<integer>&&<symbol>",prefix:"<symbol>",range:"[[<integer>|infinite]{2}]#|auto","speak-as":"auto|bullets|numbers|words|spell-out|<counter-style-name>",suffix:"<symbol>",symbols:"<symbol>+",system:"cyclic|numeric|alphabetic|symbolic|additive|[fixed <integer>?]|[extends <counter-style-name>]"}},document:{prelude:"[<url>|url-prefix( <string> )|domain( <string> )|media-document( <string> )|regexp( <string> )]#",descriptors:null},"font-face":{prelude:null,descriptors:{"ascent-override":"normal|<percentage>","descent-override":"normal|<percentage>","font-display":"[auto|block|swap|fallback|optional]","font-family":"<family-name>","font-feature-settings":"normal|<feature-tag-value>#","font-variation-settings":"normal|[<string> <number>]#","font-stretch":"<font-stretch-absolute>{1,2}","font-style":"normal|italic|oblique <angle>{0,2}","font-weight":"<font-weight-absolute>{1,2}","font-variant":"normal|none|[<common-lig-values>||<discretionary-lig-values>||<historical-lig-values>||<contextual-alt-values>||stylistic( <feature-value-name> )||historical-forms||styleset( <feature-value-name># )||character-variant( <feature-value-name># )||swash( <feature-value-name> )||ornaments( <feature-value-name> )||annotation( <feature-value-name> )||[small-caps|all-small-caps|petite-caps|all-petite-caps|unicase|titling-caps]||<numeric-figure-values>||<numeric-spacing-values>||<numeric-fraction-values>||ordinal||slashed-zero||<east-asian-variant-values>||<east-asian-width-values>||ruby]","line-gap-override":"normal|<percentage>","size-adjust":"<percentage>",src:"[<url> [format( <string># )]?|local( <family-name> )]#","unicode-range":"<urange>#"}},"font-feature-values":{prelude:"<family-name>#",descriptors:null},import:{prelude:"[<string>|<url>] [layer|layer( <layer-name> )]? [supports( [<supports-condition>|<declaration>] )]? <media-query-list>?",descriptors:null},keyframes:{prelude:"<keyframes-name>",descriptors:null},layer:{prelude:"[<layer-name>#|<layer-name>?]",descriptors:null},media:{prelude:"<media-query-list>",descriptors:null},namespace:{prelude:"<namespace-prefix>? [<string>|<url>]",descriptors:null},page:{prelude:"<page-selector-list>",descriptors:{bleed:"auto|<length>",marks:"none|[crop||cross]",size:"<length>{1,2}|auto|[<page-size>||[portrait|landscape]]"}},property:{prelude:"<custom-property-name>",descriptors:{syntax:"<string>",inherits:"true|false","initial-value":"<string>"}},"scroll-timeline":{prelude:"<timeline-name>",descriptors:null},supports:{prelude:"<supports-condition>",descriptors:null},viewport:{prelude:null,descriptors:{height:"<viewport-length>{1,2}","max-height":"<viewport-length>","max-width":"<viewport-length>","max-zoom":"auto|<number>|<percentage>","min-height":"<viewport-length>","min-width":"<viewport-length>","min-zoom":"auto|<number>|<percentage>",orientation:"auto|portrait|landscape","user-zoom":"zoom|fixed","viewport-fit":"auto|contain|cover",width:"<viewport-length>{1,2}",zoom:"auto|<number>|<percentage>"}},nest:{prelude:"<complex-selector-list>",descriptors:null}}};var gt$1={};b(gt$1,{AnPlusB:()=>Xr,Atrule:()=>Zr,AtrulePrelude:()=>en,AttributeSelector:()=>nn,Block:()=>an,Brackets:()=>ln,CDC:()=>un,CDO:()=>hn,ClassSelector:()=>fn,Combinator:()=>gn,Comment:()=>xn,Declaration:()=>kn,DeclarationList:()=>Sn,Dimension:()=>An,Function:()=>En,Hash:()=>Pn,IdSelector:()=>Nn,Identifier:()=>Dn,MediaFeature:()=>Mn,MediaQuery:()=>Fn,MediaQueryList:()=>_n,NestingSelector:()=>jn,Nth:()=>Wn,Number:()=>Yn,Operator:()=>Vn,Parentheses:()=>Qn,Percentage:()=>$n,PseudoClassSelector:()=>Jn,PseudoElementSelector:()=>to,Ratio:()=>no,Raw:()=>io,Rule:()=>so,Selector:()=>co,SelectorList:()=>po,String:()=>bo,StyleSheet:()=>yo,TypeSelector:()=>vo,UnicodeRange:()=>Ao,Url:()=>Do,Value:()=>No,WhiteSpace:()=>Mo});var Xr={};b(Xr,{generate:()=>xc,name:()=>gc,parse:()=>Qr,structure:()=>bc});var me=43,re=45,Xt=110,Ie=!0,dc=!1;function $t(e,t){let r=this.tokenStart+e,n=this.charCodeAt(r);for((n===me||n===re)&&(t&&this.error("Number sign is not allowed"),r++);r<this.tokenEnd;r++)F(this.charCodeAt(r))||this.error("Integer is expected",r);}function Qe(e){return $t.call(this,0,e)}function Ce(e,t){if(!this.cmpChar(this.tokenStart+e,t)){let r="";switch(t){case Xt:r="N is expected";break;case re:r="HyphenMinus is expected";break}this.error(r,this.tokenStart+e);}}function Kr(){let e=0,t=0,r=this.tokenType;for(;r===13||r===25;)r=this.lookupType(++e);if(r!==10)if(this.isDelim(me,e)||this.isDelim(re,e)){t=this.isDelim(me,e)?me:re;do r=this.lookupType(++e);while(r===13||r===25);r!==10&&(this.skip(e),Qe.call(this,Ie));}else return null;return e>0&&this.skip(e),t===0&&(r=this.charCodeAt(this.tokenStart),r!==me&&r!==re&&this.error("Number sign is expected")),Qe.call(this,t!==0),t===re?"-"+this.consume(10):this.consume(10)}var gc="AnPlusB",bc={a:[String,null],b:[String,null]};function Qr(){let e=this.tokenStart,t=null,r=null;if(this.tokenType===10)Qe.call(this,dc),r=this.consume(10);else if(this.tokenType===1&&this.cmpChar(this.tokenStart,re))switch(t="-1",Ce.call(this,1,Xt),this.tokenEnd-this.tokenStart){case 2:this.next(),r=Kr.call(this);break;case 3:Ce.call(this,2,re),this.next(),this.skipSC(),Qe.call(this,Ie),r="-"+this.consume(10);break;default:Ce.call(this,2,re),$t.call(this,3,Ie),this.next(),r=this.substrToCursor(e+2);}else if(this.tokenType===1||this.isDelim(me)&&this.lookupType(1)===1){let n=0;switch(t="1",this.isDelim(me)&&(n=1,this.next()),Ce.call(this,0,Xt),this.tokenEnd-this.tokenStart){case 1:this.next(),r=Kr.call(this);break;case 2:Ce.call(this,1,re),this.next(),this.skipSC(),Qe.call(this,Ie),r="-"+this.consume(10);break;default:Ce.call(this,1,re),$t.call(this,2,Ie),this.next(),r=this.substrToCursor(e+n+1);}}else if(this.tokenType===12){let n=this.charCodeAt(this.tokenStart),o=n===me||n===re,i=this.tokenStart+o;for(;i<this.tokenEnd&&F(this.charCodeAt(i));i++);i===this.tokenStart+o&&this.error("Integer is expected",this.tokenStart+o),Ce.call(this,i-this.tokenStart,Xt),t=this.substring(e,i),i+1===this.tokenEnd?(this.next(),r=Kr.call(this)):(Ce.call(this,i-this.tokenStart+1,re),i+2===this.tokenEnd?(this.next(),this.skipSC(),Qe.call(this,Ie),r="-"+this.consume(10)):($t.call(this,i-this.tokenStart+2,Ie),this.next(),r=this.substrToCursor(i+1)));}else this.error();return t!==null&&t.charCodeAt(0)===me&&(t=t.substr(1)),r!==null&&r.charCodeAt(0)===me&&(r=r.substr(1)),{type:"AnPlusB",loc:this.getLocation(e,this.tokenStart),a:t,b:r}}function xc(e){if(e.a){let t=e.a==="+1"&&"n"||e.a==="1"&&"n"||e.a==="-1"&&"-n"||e.a+"n";if(e.b){let r=e.b[0]==="-"||e.b[0]==="+"?e.b:"+"+e.b;this.tokenize(t+r);}else this.tokenize(t);}else this.tokenize(e.b);}var Zr={};b(Zr,{generate:()=>Sc,name:()=>kc,parse:()=>$r,structure:()=>vc,walkContext:()=>wc});function da(e){return this.Raw(e,this.consumeUntilLeftCurlyBracketOrSemicolon,!0)}function yc(){for(let e=1,t;t=this.lookupType(e);e++){if(t===24)return !0;if(t===23||t===3)return !1}return !1}var kc="Atrule",wc="atrule",vc={name:String,prelude:["AtrulePrelude","Raw",null],block:["Block",null]};function $r(e=!1){let t=this.tokenStart,r,n,o=null,i=null;switch(this.eat(3),r=this.substrToCursor(t+1),n=r.toLowerCase(),this.skipSC(),this.eof===!1&&this.tokenType!==23&&this.tokenType!==17&&(this.parseAtrulePrelude?o=this.parseWithFallback(this.AtrulePrelude.bind(this,r,e),da):o=da.call(this,this.tokenIndex),this.skipSC()),this.tokenType){case 17:this.next();break;case 23:hasOwnProperty.call(this.atrule,n)&&typeof this.atrule[n].block=="function"?i=this.atrule[n].block.call(this,e):i=this.Block(yc.call(this));break}return {type:"Atrule",loc:this.getLocation(t,this.tokenStart),name:r,prelude:o,block:i}}function Sc(e){this.token(3,"@"+e.name),e.prelude!==null&&this.node(e.prelude),e.block?this.node(e.block):this.token(17,";");}var en={};b(en,{generate:()=>Ec,name:()=>Cc,parse:()=>Jr,structure:()=>Tc,walkContext:()=>Ac});var Cc="AtrulePrelude",Ac="atrulePrelude",Tc={children:[[]]};function Jr(e){let t=null;return e!==null&&(e=e.toLowerCase()),this.skipSC(),hasOwnProperty.call(this.atrule,e)&&typeof this.atrule[e].prelude=="function"?t=this.atrule[e].prelude.call(this):t=this.readSequence(this.scope.AtrulePrelude),this.skipSC(),this.eof!==!0&&this.tokenType!==23&&this.tokenType!==17&&this.error("Semicolon or block is expected"),{type:"AtrulePrelude",loc:this.getLocationFromList(t),children:t}}function Ec(e){this.children(e);}var nn={};b(nn,{generate:()=>Mc,name:()=>Nc,parse:()=>rn,structure:()=>zc});var Lc=36,ga=42,Zt=61,Pc=94,tn=124,Ic=126;function Dc(){this.eof&&this.error("Unexpected end of input");let e=this.tokenStart,t=!1;return this.isDelim(ga)?(t=!0,this.next()):this.isDelim(tn)||this.eat(1),this.isDelim(tn)?this.charCodeAt(this.tokenStart+1)!==Zt?(this.next(),this.eat(1)):t&&this.error("Identifier is expected",this.tokenEnd):t&&this.error("Vertical line is expected"),{type:"Identifier",loc:this.getLocation(e,this.tokenStart),name:this.substrToCursor(e)}}function Oc(){let e=this.tokenStart,t=this.charCodeAt(e);return t!==Zt&&t!==Ic&&t!==Pc&&t!==Lc&&t!==ga&&t!==tn&&this.error("Attribute selector (=, ~=, ^=, $=, *=, |=) is expected"),this.next(),t!==Zt&&(this.isDelim(Zt)||this.error("Equal sign is expected"),this.next()),this.substrToCursor(e)}var Nc="AttributeSelector",zc={name:"Identifier",matcher:[String,null],value:["String","Identifier",null],flags:[String,null]};function rn(){let e=this.tokenStart,t,r=null,n=null,o=null;return this.eat(19),this.skipSC(),t=Dc.call(this),this.skipSC(),this.tokenType!==20&&(this.tokenType!==1&&(r=Oc.call(this),this.skipSC(),n=this.tokenType===5?this.String():this.Identifier(),this.skipSC()),this.tokenType===1&&(o=this.consume(1),this.skipSC())),this.eat(20),{type:"AttributeSelector",loc:this.getLocation(e,this.tokenStart),name:t,matcher:r,value:n,flags:o}}function Mc(e){this.token(9,"["),this.node(e.name),e.matcher!==null&&(this.tokenize(e.matcher),this.node(e.value)),e.flags!==null&&this.token(1,e.flags),this.token(9,"]");}var an={};b(an,{generate:()=>jc,name:()=>Bc,parse:()=>on,structure:()=>Uc,walkContext:()=>_c});var Rc=38;function ya(e){return this.Raw(e,null,!0)}function ba(){return this.parseWithFallback(this.Rule,ya)}function xa(e){return this.Raw(e,this.consumeUntilSemicolonIncluded,!0)}function Fc(){if(this.tokenType===17)return xa.call(this,this.tokenIndex);let e=this.parseWithFallback(this.Declaration,xa);return this.tokenType===17&&this.next(),e}var Bc="Block",_c="block",Uc={children:[["Atrule","Rule","Declaration"]]};function on(e){let t=e?Fc:ba,r=this.tokenStart,n=this.createList();this.eat(23);e:for(;!this.eof;)switch(this.tokenType){case 24:break e;case 13:case 25:this.next();break;case 3:n.push(this.parseWithFallback(this.Atrule.bind(this,e),ya));break;default:e&&this.isDelim(Rc)?n.push(ba.call(this)):n.push(t.call(this));}return this.eof||this.eat(24),{type:"Block",loc:this.getLocation(r,this.tokenStart),children:n}}function jc(e){this.token(23,"{"),this.children(e,t=>{t.type==="Declaration"&&this.token(17,";");}),this.token(24,"}");}var ln={};b(ln,{generate:()=>Hc,name:()=>qc,parse:()=>sn,structure:()=>Wc});var qc="Brackets",Wc={children:[[]]};function sn(e,t){let r=this.tokenStart,n=null;return this.eat(19),n=e.call(this,t),this.eof||this.eat(20),{type:"Brackets",loc:this.getLocation(r,this.tokenStart),children:n}}function Hc(e){this.token(9,"["),this.children(e),this.token(9,"]");}var un={};b(un,{generate:()=>Vc,name:()=>Yc,parse:()=>cn,structure:()=>Gc});var Yc="CDC",Gc=[];function cn(){let e=this.tokenStart;return this.eat(15),{type:"CDC",loc:this.getLocation(e,this.tokenStart)}}function Vc(){this.token(15,"-->");}var hn={};b(hn,{generate:()=>Xc,name:()=>Kc,parse:()=>pn,structure:()=>Qc});var Kc="CDO",Qc=[];function pn(){let e=this.tokenStart;return this.eat(14),{type:"CDO",loc:this.getLocation(e,this.tokenStart)}}function Xc(){this.token(14,"<!--");}var fn={};b(fn,{generate:()=>eu,name:()=>Zc,parse:()=>mn,structure:()=>Jc});var $c=46,Zc="ClassSelector",Jc={name:String};function mn(){return this.eatDelim($c),{type:"ClassSelector",loc:this.getLocation(this.tokenStart-1,this.tokenEnd),name:this.consume(1)}}function eu(e){this.token(9,"."),this.token(1,e.name);}var gn={};b(gn,{generate:()=>au,name:()=>ou,parse:()=>dn,structure:()=>iu});var tu=43,ka=47,ru=62,nu=126,ou="Combinator",iu={name:String};function dn(){let e=this.tokenStart,t;switch(this.tokenType){case 13:t=" ";break;case 9:switch(this.charCodeAt(this.tokenStart)){case ru:case tu:case nu:this.next();break;case ka:this.next(),this.eatIdent("deep"),this.eatDelim(ka);break;default:this.error("Combinator is expected");}t=this.substrToCursor(e);break}return {type:"Combinator",loc:this.getLocation(e,this.tokenStart),name:t}}function au(e){this.tokenize(e.name);}var xn={};b(xn,{generate:()=>pu,name:()=>cu,parse:()=>bn,structure:()=>uu});var su=42,lu=47,cu="Comment",uu={value:String};function bn(){let e=this.tokenStart,t=this.tokenEnd;return this.eat(25),t-e+2>=2&&this.charCodeAt(t-2)===su&&this.charCodeAt(t-1)===lu&&(t-=2),{type:"Comment",loc:this.getLocation(e,this.tokenStart),value:this.substring(e+2,t)}}function pu(e){this.token(25,"/*"+e.value+"*/");}var kn={};b(kn,{generate:()=>Su,name:()=>ku,parse:()=>yn,structure:()=>vu,walkContext:()=>wu});var va=33,hu=35,mu=36,fu=38,du=42,gu=43,wa=47;function bu(e){return this.Raw(e,this.consumeUntilExclamationMarkOrSemicolon,!0)}function xu(e){return this.Raw(e,this.consumeUntilExclamationMarkOrSemicolon,!1)}function yu(){let e=this.tokenIndex,t=this.Value();return t.type!=="Raw"&&this.eof===!1&&this.tokenType!==17&&this.isDelim(va)===!1&&this.isBalanceEdge(e)===!1&&this.error(),t}var ku="Declaration",wu="declaration",vu={important:[Boolean,String],property:String,value:["Value","Raw"]};function yn(){let e=this.tokenStart,t=this.tokenIndex,r=Cu.call(this),n=Mt(r),o=n?this.parseCustomProperty:this.parseValue,i=n?xu:bu,s=!1,u;this.skipSC(),this.eat(16);let c=this.tokenIndex;if(n||this.skipSC(),o?u=this.parseWithFallback(yu,i):u=i.call(this,this.tokenIndex),n&&u.type==="Value"&&u.children.isEmpty){for(let a=c-this.tokenIndex;a<=0;a++)if(this.lookupType(a)===13){u.children.appendData({type:"WhiteSpace",loc:null,value:" "});break}}return this.isDelim(va)&&(s=Au.call(this),this.skipSC()),this.eof===!1&&this.tokenType!==17&&this.isBalanceEdge(t)===!1&&this.error(),{type:"Declaration",loc:this.getLocation(e,this.tokenStart),important:s,property:r,value:u}}function Su(e){this.token(1,e.property),this.token(16,":"),this.node(e.value),e.important&&(this.token(9,"!"),this.token(1,e.important===!0?"important":e.important));}function Cu(){let e=this.tokenStart;if(this.tokenType===9)switch(this.charCodeAt(this.tokenStart)){case du:case mu:case gu:case hu:case fu:this.next();break;case wa:this.next(),this.isDelim(wa)&&this.next();break}return this.tokenType===4?this.eat(4):this.eat(1),this.substrToCursor(e)}function Au(){this.eat(9),this.skipSC();let e=this.consume(1);return e==="important"?!0:e}var Sn={};b(Sn,{generate:()=>Pu,name:()=>Eu,parse:()=>vn,structure:()=>Lu});var Tu=38;function wn(e){return this.Raw(e,this.consumeUntilSemicolonIncluded,!0)}var Eu="DeclarationList",Lu={children:[["Declaration","Atrule","Rule"]]};function vn(){let e=this.createList();for(;!this.eof;)switch(this.tokenType){case 13:case 25:case 17:this.next();break;case 3:e.push(this.parseWithFallback(this.Atrule.bind(this,!0),wn));break;default:this.isDelim(Tu)?e.push(this.parseWithFallback(this.Rule,wn)):e.push(this.parseWithFallback(this.Declaration,wn));}return {type:"DeclarationList",loc:this.getLocationFromList(e),children:e}}function Pu(e){this.children(e,t=>{t.type==="Declaration"&&this.token(17,";");});}var An={};b(An,{generate:()=>Ou,name:()=>Iu,parse:()=>Cn,structure:()=>Du});var Iu="Dimension",Du={value:String,unit:String};function Cn(){let e=this.tokenStart,t=this.consumeNumber(12);return {type:"Dimension",loc:this.getLocation(e,this.tokenStart),value:t,unit:this.substring(e+t.length,this.tokenStart)}}function Ou(e){this.token(12,e.value+e.unit);}var En={};b(En,{generate:()=>Ru,name:()=>Nu,parse:()=>Tn,structure:()=>Mu,walkContext:()=>zu});var Nu="Function",zu="function",Mu={name:String,children:[[]]};function Tn(e,t){let r=this.tokenStart,n=this.consumeFunctionName(),o=n.toLowerCase(),i;return i=t.hasOwnProperty(o)?t[o].call(this,t):e.call(this,t),this.eof||this.eat(22),{type:"Function",loc:this.getLocation(r,this.tokenStart),name:n,children:i}}function Ru(e){this.token(2,e.name+"("),this.children(e),this.token(22,")");}var Pn={};b(Pn,{generate:()=>Uu,name:()=>Bu,parse:()=>Ln,structure:()=>_u,xxx:()=>Fu});var Fu="XXX",Bu="Hash",_u={value:String};function Ln(){let e=this.tokenStart;return this.eat(4),{type:"Hash",loc:this.getLocation(e,this.tokenStart),value:this.substrToCursor(e+1)}}function Uu(e){this.token(4,"#"+e.value);}var Dn={};b(Dn,{generate:()=>Wu,name:()=>ju,parse:()=>In,structure:()=>qu});var ju="Identifier",qu={name:String};function In(){return {type:"Identifier",loc:this.getLocation(this.tokenStart,this.tokenEnd),name:this.consume(1)}}function Wu(e){this.token(1,e.name);}var Nn={};b(Nn,{generate:()=>Gu,name:()=>Hu,parse:()=>On,structure:()=>Yu});var Hu="IdSelector",Yu={name:String};function On(){let e=this.tokenStart;return this.eat(4),{type:"IdSelector",loc:this.getLocation(e,this.tokenStart),name:this.substrToCursor(e+1)}}function Gu(e){this.token(9,"#"+e.name);}var Mn={};b(Mn,{generate:()=>Qu,name:()=>Vu,parse:()=>zn,structure:()=>Ku});var Vu="MediaFeature",Ku={name:String,value:["Identifier","Number","Dimension","Ratio",null]};function zn(){let e=this.tokenStart,t,r=null;if(this.eat(21),this.skipSC(),t=this.consume(1),this.skipSC(),this.tokenType!==22){switch(this.eat(16),this.skipSC(),this.tokenType){case 10:this.lookupNonWSType(1)===9?r=this.Ratio():r=this.Number();break;case 12:r=this.Dimension();break;case 1:r=this.Identifier();break;default:this.error("Number, dimension, ratio or identifier is expected");}this.skipSC();}return this.eat(22),{type:"MediaFeature",loc:this.getLocation(e,this.tokenStart),name:t,value:r}}function Qu(e){this.token(21,"("),this.token(1,e.name),e.value!==null&&(this.token(16,":"),this.node(e.value)),this.token(22,")");}var Fn={};b(Fn,{generate:()=>Zu,name:()=>Xu,parse:()=>Rn,structure:()=>$u});var Xu="MediaQuery",$u={children:[["Identifier","MediaFeature","WhiteSpace"]]};function Rn(){let e=this.createList(),t=null;this.skipSC();e:for(;!this.eof;){switch(this.tokenType){case 25:case 13:this.next();continue;case 1:t=this.Identifier();break;case 21:t=this.MediaFeature();break;default:break e}e.push(t);}return t===null&&this.error("Identifier or parenthesis is expected"),{type:"MediaQuery",loc:this.getLocationFromList(e),children:e}}function Zu(e){this.children(e);}var _n={};b(_n,{generate:()=>tp,name:()=>Ju,parse:()=>Bn,structure:()=>ep});var Ju="MediaQueryList",ep={children:[["MediaQuery"]]};function Bn(){let e=this.createList();for(this.skipSC();!this.eof&&(e.push(this.MediaQuery()),this.tokenType===18);)this.next();return {type:"MediaQueryList",loc:this.getLocationFromList(e),children:e}}function tp(e){this.children(e,()=>this.token(18,","));}var jn={};b(jn,{generate:()=>ip,name:()=>np,parse:()=>Un,structure:()=>op});var rp=38,np="NestingSelector",op={};function Un(){let e=this.tokenStart;return this.eatDelim(rp),{type:"NestingSelector",loc:this.getLocation(e,this.tokenStart)}}function ip(){this.token(9,"&");}var Wn={};b(Wn,{generate:()=>lp,name:()=>ap,parse:()=>qn,structure:()=>sp});var ap="Nth",sp={nth:["AnPlusB","Identifier"],selector:["SelectorList",null]};function qn(){this.skipSC();let e=this.tokenStart,t=e,r=null,n;return this.lookupValue(0,"odd")||this.lookupValue(0,"even")?n=this.Identifier():n=this.AnPlusB(),t=this.tokenStart,this.skipSC(),this.lookupValue(0,"of")&&(this.next(),r=this.SelectorList(),t=this.tokenStart),{type:"Nth",loc:this.getLocation(e,t),nth:n,selector:r}}function lp(e){this.node(e.nth),e.selector!==null&&(this.token(1,"of"),this.node(e.selector));}var Yn={};b(Yn,{generate:()=>pp,name:()=>cp,parse:()=>Hn,structure:()=>up});var cp="Number",up={value:String};function Hn(){return {type:"Number",loc:this.getLocation(this.tokenStart,this.tokenEnd),value:this.consume(10)}}function pp(e){this.token(10,e.value);}var Vn={};b(Vn,{generate:()=>fp,name:()=>hp,parse:()=>Gn,structure:()=>mp});var hp="Operator",mp={value:String};function Gn(){let e=this.tokenStart;return this.next(),{type:"Operator",loc:this.getLocation(e,this.tokenStart),value:this.substrToCursor(e)}}function fp(e){this.tokenize(e.value);}var Qn={};b(Qn,{generate:()=>bp,name:()=>dp,parse:()=>Kn,structure:()=>gp});var dp="Parentheses",gp={children:[[]]};function Kn(e,t){let r=this.tokenStart,n=null;return this.eat(21),n=e.call(this,t),this.eof||this.eat(22),{type:"Parentheses",loc:this.getLocation(r,this.tokenStart),children:n}}function bp(e){this.token(21,"("),this.children(e),this.token(22,")");}var $n={};b($n,{generate:()=>kp,name:()=>xp,parse:()=>Xn,structure:()=>yp});var xp="Percentage",yp={value:String};function Xn(){return {type:"Percentage",loc:this.getLocation(this.tokenStart,this.tokenEnd),value:this.consumeNumber(11)}}function kp(e){this.token(11,e.value+"%");}var Jn={};b(Jn,{generate:()=>Cp,name:()=>wp,parse:()=>Zn,structure:()=>Sp,walkContext:()=>vp});var wp="PseudoClassSelector",vp="function",Sp={name:String,children:[["Raw"],null]};function Zn(){let e=this.tokenStart,t=null,r,n;return this.eat(16),this.tokenType===2?(r=this.consumeFunctionName(),n=r.toLowerCase(),hasOwnProperty.call(this.pseudo,n)?(this.skipSC(),t=this.pseudo[n].call(this),this.skipSC()):(t=this.createList(),t.push(this.Raw(this.tokenIndex,null,!1))),this.eat(22)):r=this.consume(1),{type:"PseudoClassSelector",loc:this.getLocation(e,this.tokenStart),name:r,children:t}}function Cp(e){this.token(16,":"),e.children===null?this.token(1,e.name):(this.token(2,e.name+"("),this.children(e),this.token(22,")"));}var to={};b(to,{generate:()=>Lp,name:()=>Ap,parse:()=>eo,structure:()=>Ep,walkContext:()=>Tp});var Ap="PseudoElementSelector",Tp="function",Ep={name:String,children:[["Raw"],null]};function eo(){let e=this.tokenStart,t=null,r,n;return this.eat(16),this.eat(16),this.tokenType===2?(r=this.consumeFunctionName(),n=r.toLowerCase(),hasOwnProperty.call(this.pseudo,n)?(this.skipSC(),t=this.pseudo[n].call(this),this.skipSC()):(t=this.createList(),t.push(this.Raw(this.tokenIndex,null,!1))),this.eat(22)):r=this.consume(1),{type:"PseudoElementSelector",loc:this.getLocation(e,this.tokenStart),name:r,children:t}}function Lp(e){this.token(16,":"),this.token(16,":"),e.children===null?this.token(1,e.name):(this.token(2,e.name+"("),this.children(e),this.token(22,")"));}var no={};b(no,{generate:()=>Np,name:()=>Dp,parse:()=>ro,structure:()=>Op});var Pp=47,Ip=46;function Sa(){this.skipSC();let e=this.consume(10);for(let t=0;t<e.length;t++){let r=e.charCodeAt(t);!F(r)&&r!==Ip&&this.error("Unsigned number is expected",this.tokenStart-e.length+t);}return Number(e)===0&&this.error("Zero number is not allowed",this.tokenStart-e.length),e}var Dp="Ratio",Op={left:String,right:String};function ro(){let e=this.tokenStart,t=Sa.call(this),r;return this.skipSC(),this.eatDelim(Pp),r=Sa.call(this),{type:"Ratio",loc:this.getLocation(e,this.tokenStart),left:t,right:r}}function Np(e){this.token(10,e.left),this.token(9,"/"),this.token(10,e.right);}var io={};b(io,{generate:()=>Fp,name:()=>Mp,parse:()=>oo,structure:()=>Rp});function zp(){return this.tokenIndex>0&&this.lookupType(-1)===13?this.tokenIndex>1?this.getTokenStart(this.tokenIndex-1):this.firstCharOffset:this.tokenStart}var Mp="Raw",Rp={value:String};function oo(e,t,r){let n=this.getTokenStart(e),o;return this.skipUntilBalanced(e,t||this.consumeUntilBalanceEnd),r&&this.tokenStart>n?o=zp.call(this):o=this.tokenStart,{type:"Raw",loc:this.getLocation(n,o),value:this.substring(n,o)}}function Fp(e){this.tokenize(e.value);}var so={};b(so,{generate:()=>qp,name:()=>_p,parse:()=>ao,structure:()=>jp,walkContext:()=>Up});function Ca(e){return this.Raw(e,this.consumeUntilLeftCurlyBracket,!0)}function Bp(){let e=this.SelectorList();return e.type!=="Raw"&&this.eof===!1&&this.tokenType!==23&&this.error(),e}var _p="Rule",Up="rule",jp={prelude:["SelectorList","Raw"],block:["Block"]};function ao(){let e=this.tokenIndex,t=this.tokenStart,r,n;return this.parseRulePrelude?r=this.parseWithFallback(Bp,Ca):r=Ca.call(this,e),n=this.Block(!0),{type:"Rule",loc:this.getLocation(t,this.tokenStart),prelude:r,block:n}}function qp(e){this.node(e.prelude),this.node(e.block);}var co={};b(co,{generate:()=>Yp,name:()=>Wp,parse:()=>lo,structure:()=>Hp});var Wp="Selector",Hp={children:[["TypeSelector","IdSelector","ClassSelector","AttributeSelector","PseudoClassSelector","PseudoElementSelector","Combinator","WhiteSpace"]]};function lo(){let e=this.readSequence(this.scope.Selector);return this.getFirstListNode(e)===null&&this.error("Selector is expected"),{type:"Selector",loc:this.getLocationFromList(e),children:e}}function Yp(e){this.children(e);}var po={};b(po,{generate:()=>Qp,name:()=>Gp,parse:()=>uo,structure:()=>Kp,walkContext:()=>Vp});var Gp="SelectorList",Vp="selector",Kp={children:[["Selector","Raw"]]};function uo(){let e=this.createList();for(;!this.eof;){if(e.push(this.Selector()),this.tokenType===18){this.next();continue}break}return {type:"SelectorList",loc:this.getLocationFromList(e),children:e}}function Qp(e){this.children(e,()=>this.token(18,","));}var bo={};b(bo,{generate:()=>Zp,name:()=>Xp,parse:()=>go,structure:()=>$p});var fo={};b(fo,{decode:()=>ft,encode:()=>mo});var ho=92,Aa=34,Ta=39;function ft(e){let t=e.length,r=e.charCodeAt(0),n=r===Aa||r===Ta?1:0,o=n===1&&t>1&&e.charCodeAt(t-1)===r?t-2:t-1,i="";for(let s=n;s<=o;s++){let u=e.charCodeAt(s);if(u===ho){if(s===o){s!==t-1&&(i=e.substr(s+1));break}if(u=e.charCodeAt(++s),X(ho,u)){let c=s-1,a=se(e,c);s=a-1,i+=Re(e.substring(c+1,a));}else u===13&&e.charCodeAt(s+1)===10&&s++;}else i+=e[s];}return i}function mo(e,t){let r=t?"'":'"',n=t?Ta:Aa,o="",i=!1;for(let s=0;s<e.length;s++){let u=e.charCodeAt(s);if(u===0){o+="\uFFFD";continue}if(u<=31||u===127){o+="\\"+u.toString(16),i=!0;continue}u===n||u===ho?(o+="\\"+e.charAt(s),i=!1):(i&&(ee(u)||pe(u))&&(o+=" "),o+=e.charAt(s),i=!1);}return r+o+r}var Xp="String",$p={value:String};function go(){return {type:"String",loc:this.getLocation(this.tokenStart,this.tokenEnd),value:ft(this.consume(5))}}function Zp(e){this.token(5,mo(e.value));}var yo={};b(yo,{generate:()=>nh,name:()=>eh,parse:()=>xo,structure:()=>rh,walkContext:()=>th});var Jp=33;function Ea(e){return this.Raw(e,null,!1)}var eh="StyleSheet",th="stylesheet",rh={children:[["Comment","CDO","CDC","Atrule","Rule","Raw"]]};function xo(){let e=this.tokenStart,t=this.createList(),r;for(;!this.eof;){switch(this.tokenType){case 13:this.next();continue;case 25:if(this.charCodeAt(this.tokenStart+2)!==Jp){this.next();continue}r=this.Comment();break;case 14:r=this.CDO();break;case 15:r=this.CDC();break;case 3:r=this.parseWithFallback(this.Atrule,Ea);break;default:r=this.parseWithFallback(this.Rule,Ea);}t.push(r);}return {type:"StyleSheet",loc:this.getLocation(e,this.tokenStart),children:t}}function nh(e){this.children(e);}var vo={};b(vo,{generate:()=>sh,name:()=>ih,parse:()=>wo,structure:()=>ah});var oh=42,La=124;function ko(){this.tokenType!==1&&this.isDelim(oh)===!1&&this.error("Identifier or asterisk is expected"),this.next();}var ih="TypeSelector",ah={name:String};function wo(){let e=this.tokenStart;return this.isDelim(La)?(this.next(),ko.call(this)):(ko.call(this),this.isDelim(La)&&(this.next(),ko.call(this))),{type:"TypeSelector",loc:this.getLocation(e,this.tokenStart),name:this.substrToCursor(e)}}function sh(e){this.tokenize(e.name);}var Ao={};b(Ao,{generate:()=>hh,name:()=>uh,parse:()=>Co,structure:()=>ph});var Pa=43,Ia=45,So=63;function dt(e,t){let r=0;for(let n=this.tokenStart+e;n<this.tokenEnd;n++){let o=this.charCodeAt(n);if(o===Ia&&t&&r!==0)return dt.call(this,e+r+1,!1),-1;ee(o)||this.error(t&&r!==0?"Hyphen minus"+(r<6?" or hex digit":"")+" is expected":r<6?"Hex digit is expected":"Unexpected input",n),++r>6&&this.error("Too many hex digits",n);}return this.next(),r}function Jt(e){let t=0;for(;this.isDelim(So);)++t>e&&this.error("Too many question marks"),this.next();}function lh(e){this.charCodeAt(this.tokenStart)!==e&&this.error((e===Pa?"Plus sign":"Hyphen minus")+" is expected");}function ch(){let e=0;switch(this.tokenType){case 10:if(e=dt.call(this,1,!0),this.isDelim(So)){Jt.call(this,6-e);break}if(this.tokenType===12||this.tokenType===10){lh.call(this,Ia),dt.call(this,1,!1);break}break;case 12:e=dt.call(this,1,!0),e>0&&Jt.call(this,6-e);break;default:if(this.eatDelim(Pa),this.tokenType===1){e=dt.call(this,0,!0),e>0&&Jt.call(this,6-e);break}if(this.isDelim(So)){this.next(),Jt.call(this,5);break}this.error("Hex digit or question mark is expected");}}var uh="UnicodeRange",ph={value:String};function Co(){let e=this.tokenStart;return this.eatIdent("u"),ch.call(this),{type:"UnicodeRange",loc:this.getLocation(e,this.tokenStart),value:this.substrToCursor(e)}}function hh(e){this.tokenize(e.value);}var Do={};b(Do,{generate:()=>yh,name:()=>bh,parse:()=>Io,structure:()=>xh});var Po={};b(Po,{decode:()=>Eo,encode:()=>Lo});var mh=32,To=92,fh=34,dh=39,gh=40,Da=41;function Eo(e){let t=e.length,r=4,n=e.charCodeAt(t-1)===Da?t-2:t-1,o="";for(;r<n&&pe(e.charCodeAt(r));)r++;for(;r<n&&pe(e.charCodeAt(n));)n--;for(let i=r;i<=n;i++){let s=e.charCodeAt(i);if(s===To){if(i===n){i!==t-1&&(o=e.substr(i+1));break}if(s=e.charCodeAt(++i),X(To,s)){let u=i-1,c=se(e,u);i=c-1,o+=Re(e.substring(u+1,c));}else s===13&&e.charCodeAt(i+1)===10&&i++;}else o+=e[i];}return o}function Lo(e){let t="",r=!1;for(let n=0;n<e.length;n++){let o=e.charCodeAt(n);if(o===0){t+="\uFFFD";continue}if(o<=31||o===127){t+="\\"+o.toString(16),r=!0;continue}o===mh||o===To||o===fh||o===dh||o===gh||o===Da?(t+="\\"+e.charAt(n),r=!1):(r&&ee(o)&&(t+=" "),t+=e.charAt(n),r=!1);}return "url("+t+")"}var bh="Url",xh={value:String};function Io(){let e=this.tokenStart,t;switch(this.tokenType){case 7:t=Eo(this.consume(7));break;case 2:this.cmpStr(this.tokenStart,this.tokenEnd,"url(")||this.error("Function name must be `url`"),this.eat(2),this.skipSC(),t=ft(this.consume(5)),this.skipSC(),this.eof||this.eat(22);break;default:this.error("Url or Function is expected");}return {type:"Url",loc:this.getLocation(e,this.tokenStart),value:t}}function yh(e){this.token(7,Lo(e.value));}var No={};b(No,{generate:()=>vh,name:()=>kh,parse:()=>Oo,structure:()=>wh});var kh="Value",wh={children:[[]]};function Oo(){let e=this.tokenStart,t=this.readSequence(this.scope.Value);return {type:"Value",loc:this.getLocation(e,this.tokenStart),children:t}}function vh(e){this.children(e);}var Mo={};b(Mo,{generate:()=>Th,name:()=>Ch,parse:()=>zo,structure:()=>Ah});var Sh=Object.freeze({type:"WhiteSpace",loc:null,value:" "}),Ch="WhiteSpace",Ah={value:String};function zo(){return this.eat(13),Sh}function Th(e){this.token(13,e.value);}var Oa={generic:!0,...fa,node:gt$1};var Ro={};b(Ro,{AtrulePrelude:()=>za,Selector:()=>Ra,Value:()=>Ua});var Eh=35,Lh=42,Na=43,Ph=45,Ih=47,Dh=117;function bt(e){switch(this.tokenType){case 4:return this.Hash();case 18:return this.Operator();case 21:return this.Parentheses(this.readSequence,e.recognizer);case 19:return this.Brackets(this.readSequence,e.recognizer);case 5:return this.String();case 12:return this.Dimension();case 11:return this.Percentage();case 10:return this.Number();case 2:return this.cmpStr(this.tokenStart,this.tokenEnd,"url(")?this.Url():this.Function(this.readSequence,e.recognizer);case 7:return this.Url();case 1:return this.cmpChar(this.tokenStart,Dh)&&this.cmpChar(this.tokenStart+1,Na)?this.UnicodeRange():this.Identifier();case 9:{let t=this.charCodeAt(this.tokenStart);if(t===Ih||t===Lh||t===Na||t===Ph)return this.Operator();t===Eh&&this.error("Hex or identifier is expected",this.tokenStart+1);break}}}var za={getNode:bt};var Oh=35,Nh=38,zh=42,Mh=43,Rh=47,Ma=46,Fh=62,Bh=124,_h=126;function Uh(e,t){t.last!==null&&t.last.type!=="Combinator"&&e!==null&&e.type!=="Combinator"&&t.push({type:"Combinator",loc:null,name:" "});}function jh(){switch(this.tokenType){case 19:return this.AttributeSelector();case 4:return this.IdSelector();case 16:return this.lookupType(1)===16?this.PseudoElementSelector():this.PseudoClassSelector();case 1:return this.TypeSelector();case 10:case 11:return this.Percentage();case 12:this.charCodeAt(this.tokenStart)===Ma&&this.error("Identifier is expected",this.tokenStart+1);break;case 9:{switch(this.charCodeAt(this.tokenStart)){case Mh:case Fh:case _h:case Rh:return this.Combinator();case Ma:return this.ClassSelector();case zh:case Bh:return this.TypeSelector();case Oh:return this.IdSelector();case Nh:return this.NestingSelector()}break}}}var Ra={onWhiteSpace:Uh,getNode:jh};function Fa(){return this.createSingleNodeList(this.Raw(this.tokenIndex,null,!1))}function Ba(){let e=this.createList();if(this.skipSC(),e.push(this.Identifier()),this.skipSC(),this.tokenType===18){e.push(this.Operator());let t=this.tokenIndex,r=this.parseCustomProperty?this.Value(null):this.Raw(this.tokenIndex,this.consumeUntilExclamationMarkOrSemicolon,!1);if(r.type==="Value"&&r.children.isEmpty){for(let n=t-this.tokenIndex;n<=0;n++)if(this.lookupType(n)===13){r.children.appendData({type:"WhiteSpace",loc:null,value:" "});break}}e.push(r);}return e}function _a(e){return e!==null&&e.type==="Operator"&&(e.value[e.value.length-1]==="-"||e.value[e.value.length-1]==="+")}var Ua={getNode:bt,onWhiteSpace(e,t){_a(e)&&(e.value=" "+e.value),_a(t.last)&&(t.last.value+=" ");},expression:Fa,var:Ba};var ja={parse:{prelude:null,block(){return this.Block(!0)}}};var qa={parse:{prelude(){let e=this.createList();switch(this.skipSC(),this.tokenType){case 5:e.push(this.String());break;case 7:case 2:e.push(this.Url());break;default:this.error("String or url() is expected");}return (this.lookupNonWSType(0)===1||this.lookupNonWSType(0)===21)&&e.push(this.MediaQueryList()),e},block:null}};var Wa={parse:{prelude(){return this.createSingleNodeList(this.MediaQueryList())},block(e=!1){return this.Block(e)}}};var Ha={parse:{prelude(){return this.createSingleNodeList(this.SelectorList())},block(){return this.Block(!0)}}};var Ya={parse:{prelude(){return this.createSingleNodeList(this.SelectorList())},block(){return this.Block(!0)}}};function qh(){return this.createSingleNodeList(this.Raw(this.tokenIndex,null,!1))}function Wh(){return this.skipSC(),this.tokenType===1&&this.lookupNonWSType(1)===16?this.createSingleNodeList(this.Declaration()):Ga.call(this)}function Ga(){let e=this.createList(),t;this.skipSC();e:for(;!this.eof;){switch(this.tokenType){case 25:case 13:this.next();continue;case 2:t=this.Function(qh,this.scope.AtrulePrelude);break;case 1:t=this.Identifier();break;case 21:t=this.Parentheses(Wh,this.scope.AtrulePrelude);break;default:break e}e.push(t);}return e}var Va={parse:{prelude(){let e=Ga.call(this);return this.getFirstListNode(e)===null&&this.error("Condition is expected"),e},block(e=!1){return this.Block(e)}}};var Ka={"font-face":ja,import:qa,media:Wa,nest:Ha,page:Ya,supports:Va};var De={parse(){return this.createSingleNodeList(this.SelectorList())}},Fo={parse(){return this.createSingleNodeList(this.Selector())}},Qa={parse(){return this.createSingleNodeList(this.Identifier())}},er={parse(){return this.createSingleNodeList(this.Nth())}},Xa={dir:Qa,has:De,lang:Qa,matches:De,is:De,"-moz-any":De,"-webkit-any":De,where:De,not:De,"nth-child":er,"nth-last-child":er,"nth-last-of-type":er,"nth-of-type":er,slotted:Fo,host:Fo,"host-context":Fo};var Bo={};b(Bo,{AnPlusB:()=>Qr,Atrule:()=>$r,AtrulePrelude:()=>Jr,AttributeSelector:()=>rn,Block:()=>on,Brackets:()=>sn,CDC:()=>cn,CDO:()=>pn,ClassSelector:()=>mn,Combinator:()=>dn,Comment:()=>bn,Declaration:()=>yn,DeclarationList:()=>vn,Dimension:()=>Cn,Function:()=>Tn,Hash:()=>Ln,IdSelector:()=>On,Identifier:()=>In,MediaFeature:()=>zn,MediaQuery:()=>Rn,MediaQueryList:()=>Bn,NestingSelector:()=>Un,Nth:()=>qn,Number:()=>Hn,Operator:()=>Gn,Parentheses:()=>Kn,Percentage:()=>Xn,PseudoClassSelector:()=>Zn,PseudoElementSelector:()=>eo,Ratio:()=>ro,Raw:()=>oo,Rule:()=>ao,Selector:()=>lo,SelectorList:()=>uo,String:()=>go,StyleSheet:()=>xo,TypeSelector:()=>wo,UnicodeRange:()=>Co,Url:()=>Io,Value:()=>Oo,WhiteSpace:()=>zo});var $a={parseContext:{default:"StyleSheet",stylesheet:"StyleSheet",atrule:"Atrule",atrulePrelude(e){return this.AtrulePrelude(e.atrule?String(e.atrule):null)},mediaQueryList:"MediaQueryList",mediaQuery:"MediaQuery",rule:"Rule",selectorList:"SelectorList",selector:"Selector",block(){return this.Block(!0)},declarationList:"DeclarationList",declaration:"Declaration",value:"Value"},scope:Ro,atrule:Ka,pseudo:Xa,node:Bo};var Za={node:gt$1};var Ja=Vr({...Oa,...$a,...Za});var ts={};b(ts,{decode:()=>Hh,encode:()=>Yh});var es=92;function Hh(e){let t=e.length-1,r="";for(let n=0;n<e.length;n++){let o=e.charCodeAt(n);if(o===es){if(n===t)break;if(o=e.charCodeAt(++n),X(es,o)){let i=n-1,s=se(e,i);n=s-1,r+=Re(e.substring(i+1,s));}else o===13&&e.charCodeAt(n+1)===10&&n++;}else r+=e[n];}return r}function Yh(e){let t="";if(e.length===1&&e.charCodeAt(0)===45)return "\\-";for(let r=0;r<e.length;r++){let n=e.charCodeAt(r);if(n===0){t+="\uFFFD";continue}if(n<=31||n===127||n>=48&&n<=57&&(r===0||r===1&&e.charCodeAt(0)===45)){t+="\\"+n.toString(16)+" ";continue}Ne(n)?t+=e.charAt(r):t+="\\"+e.charAt(r);}return t}var{tokenize:fb,parse:db,generate:gb,lexer:bb,createLexer:xb,walk:yb,find:kb,findLast:wb,findAll:vb,toPlainObject:Sb,fromPlainObject:Cb,fork:Ab}=Ja;

	const convert = htmlToText.compile({
	    wordwrap: false,
	});
	function rewriteCdnUrls$1() {
	    const rewriteData = window.cohostDL.rewriteData;

	    function rewriteUrl(url) {
	        if (rewriteData?.urls?.[url]) return rewriteData.urls[url];
	        return null;
	    }

	    return function(tree) {
	        const process = (node) => {
	            if (node.properties?.style) {
	                let mutated = false;
	                const tree = db(node.properties.style, { context: 'declarationList' });
	                yb(tree, (node) => {
	                    if (node.type === "Url") {
	                        const resolved = new URL(node.value, rewriteData.base);
	                        const rewritten = rewriteUrl(resolved.toString());
	                        if (rewritten) {
	                            mutated = true;
	                            node.value = rewritten;
	                        }
	                    }
	                });

	                if (mutated) {
	                    node = { ...node, properties: { ...node.properties, style: gb(tree) } };
	                }
	            }

	            const props = ['href', 'src'];
	            for (const prop of props) {
	                if (node.properties?.[prop]) {
	                    const resolved = new URL(node.properties[prop], rewriteData.base);
	                    const rewritten = rewriteUrl(resolved.toString());
	                    if (rewritten) {
	                        node = { ...node, properties: { ...node.properties, [prop]: rewritten } };
	                    }
	                }
	            }
	            if (node.properties?.srcset) {
	                node = { ...node, properties: { ...node.properties } };
	                delete node.properties.srcset;
	            }
	            if (node.children) {
	                let mutated = false;
	                const newChildren = node.children.map(child => {
	                    const result = process(child);
	                    mutated = result !== child;
	                    return result;
	                });
	                if (mutated) return { ...node, children: newChildren };
	            }
	            return node;
	        };
	        return process(tree);
	    };
	}

	const markdownRenderStack = (
	    postDate,
	    lineLength,
	    options
	) => {
	    let stack = unified().use(remarkParse);

	    const ruleset = chooseAgeRuleset(postDate);

	    if (ruleset.singleLineBreaks) {
	        stack = stack.use(remarkBreaks);
	    }

	    if (lineLength < MAX_GFM_LINES) {
	        stack = stack.use(remarkGfm, {
	            singleTilde: false,
	        });
	    }

	    // make a copy so we don't accidentally modify it in-place
	    const effectiveSchema = { ...ruleset.schema };

	    if (options.renderingContext === "ask" && !ruleset.ask.allowEmbeddedMedia) {
	        effectiveSchema.tagNames = _$5.filter(
	            effectiveSchema.tagNames,
	            (tagName) => !["img", "picture", "audio", "video"].includes(tagName)
	        );
	    }

	    return stack
	        .use(remarkRehype, {
	            allowDangerousHtml: true,
	        })
	        .use(() => copyImgAltToTitle)
	        .use(() => cleanUpFootnotes)
	        .use(rehypeRaw)
	        .use(rehypeSanitize, effectiveSchema)
	        .use(() => ruleset.additionalVisitor);
	};

	const ERROR_BOX_NODE = (
	    React$2.createElement(InfoBox, { level: "post-box-warning", className: "not-prose",}
	        , React$2.createElement('p', null, "There was an issue rendering the HTML for this post! This usually means you've messed up syntax on a "

	                   , React$2.createElement('code', null, "style"), " attribute. Please check your syntax!"

	        )
	    )
	);
	const ERROR_BOX_HTML = renderToStaticMarkup(ERROR_BOX_NODE);

	async function renderMarkdownAst(
	    blocks,
	    publishDate,
	    options
	) {
	    const src = blocks.map((block) => block.markdown.content).join("\n\n");
	    let lineLength = 0;

	    // get the max line length among the blocks. while we group all blocks
	    // together for rendering, the performance regression associated with GFM
	    // tables only occurs with single line breaks, which can only exist within a
	    // single block. if the total number of line breaks ACROSS THE ENTIRE POST
	    // is >256, this isn't an issue. we're only impacted if it's in a single
	    // block.
	    for (const block of blocks) {
	        if (lineLength >= MAX_GFM_LINES) {
	            break;
	        }

	        lineLength = Math.max(
	            lineLength,
	            block.markdown.content.split("\n", MAX_GFM_LINES).length
	        );
	    }

	    return markdownRenderStack(publishDate, lineLength, options)
	        .use(() => convertMentions)
	        .use(parseEmoji, { cohostPlus: options.hasCohostPlus })
	        .use(compileHastAST)
	        .process(src)
	        .then((result) => result.value.toString())
	        .catch((e) => {
	            // re-run the renderer with our static error box. we only get errors
	            // when a user has an invalid style tag that fails parsing. our error
	            // box is Known Good so this is not a concern for us.
	            return renderMarkdownAst(
	                [
	                    {
	                        type: "markdown",
	                        markdown: {
	                            content: ERROR_BOX_HTML,
	                        },
	                    },
	                ],
	                publishDate,
	                options
	            );
	        });
	}

	function renderReactFromAst(
	    astString,
	    options
	) {
	    let stack = unified().use(parseHastAST);

	    const externalRel = ["nofollow"];
	    if (options.externalLinksInNewTab) {
	        externalRel.push("noopener");
	    }

	    if (!options.disableEmbeds) {
	        stack = stack.use(() => makeIframelyEmbeds);
	    }

	    try {
	        return (
	            stack
	                .use(rewriteCdnUrls$1).use(rehypeExternalLinks, {
	                    rel: externalRel,
	                    target: options.externalLinksInNewTab ? "_blank" : "_self",
	                })
	                // @ts-expect-error: Typings don't natively support custom elements
	                .use(rehypeReact, {
	                    createElement: reactExports.createElement,
	                    Fragment: reactExports.Fragment,
	                    components: {
	                        Mention,
	                        CustomEmoji,
	                        IframelyEmbed,
	                    },
	                })
	                .processSync(astString).result
	        );
	    } catch (e) {
	        return ERROR_BOX_NODE;
	    }
	}

	function renderMarkdown(src, publishDate) {
	    const lineLength = src.split("\n", MAX_GFM_LINES).length;
	    return markdownRenderStack(publishDate, lineLength, {
	        renderingContext: "post",
	    })
	        .use(rehypeStringify)
	        .processSync(src)
	        .toString();
	}

	function renderPostSummary(
	    viewModel,
	    options
	) {
	    // invocations with either options.rss set true, or options.skipHeadline
	    // set true, have a second field they can use to carry the headline of the
	    // post and don't need to have it embedded herein.
	    const effectiveSkipHeadline = options.skipHeadline || options.rss;

	    if (!options.myPost) {
	        if (viewModel.effectiveAdultContent && viewModel.cws.length > 0) {
	            const cwList = viewModel.cws.join(", ");

	            return instance.t("client:opengraph.cws-and-adult", {
	                defaultValue: "18+ content; content warnings: {{cwList}}",
	                cwList,
	            });
	        } else if (viewModel.cws.length > 0) {
	            const cwList = viewModel.cws.join(", ");

	            return instance.t("client:opengraph.cws", {
	                defaultValue: "(content warning: {{cwList}})",
	                cwList,
	            });
	        } else if (viewModel.effectiveAdultContent) {
	            return instance.t("client:opengraph.adult-content", {
	                defaultValue: "this post contains 18+ content",
	            });
	        }
	    }

	    if (viewModel.transparentShareOfPostId) {
	        // transparent share; find the opaque post above it
	        const originalPost = viewModel.shareTree.find(
	            (vm) => vm.postId === viewModel.transparentShareOfPostId
	        );

	        if (options.rss) {
	            // RSS: just include a link in the summary
	            if (originalPost) {
	                return `Share from @${originalPost.postingProject.handle}: ${originalPost.singlePostPageUrl}`;
	            }
	        } else {
	            // on-site: nest opaque parent's preview inside this one
	            if (originalPost) {
	                return `Share from @${
                    originalPost.postingProject.handle
                }: ${renderPostSummary(originalPost, options)}`;
	            }
	        }
	    }

	    let summary = "";

	    if (viewModel.headline && !effectiveSkipHeadline) {
	        summary = viewModel.headline;
	    } else {
	        const effectiveDate = viewModel.publishedAt
	            ? DateTime_1.fromISO(viewModel.publishedAt).toJSDate()
	            : new Date();

	        const askBlocks = viewModel.blocks.filter(isAskViewBlock);
	        const markdownBlocks = viewModel.blocks.filter(isMarkdownViewBlock);
	        const textBlocks = [...askBlocks, ...markdownBlocks];
	        const textContent = (
	            textBlocks.length > 0 ? textBlocks : viewModel.blocks
	        )
	            .map((block) => summaryContent(block))
	            .join("\n\n");

	        const renderedBody = renderMarkdown(textContent, effectiveDate);

	        summary = convert(renderedBody);
	    }

	    if (options.rss && viewModel.shareOfPostId) {
	        // contentful share, include the link at the start of the summary
	        const originalPost = viewModel.shareTree.find(
	            (vm) => vm.postId === viewModel.shareOfPostId
	        );
	        if (originalPost) {
	            summary = `Share from @${originalPost.postingProject.handle}: ${originalPost.singlePostPageUrl}\n\n${summary}`;
	        }
	    }

	    return summary;
	}

	async function generatePostAst(
	    viewBlocks,
	    publishDate,
	    options
	) {
	    // identify markdown spans
	    const spans


	 = [];
	    let currentSpanStartIndex = null;
	    let readMoreIndex = null;

	    for (let i = 0; i < viewBlocks.length; i++) {
	        const block = viewBlocks[i];
	        const isMarkdownBlock = isMarkdownViewBlock(block);

	        if (isMarkdownBlock) {
	            if (
	                currentSpanStartIndex !== null &&
	                block.markdown.content === "---" &&
	                readMoreIndex === null
	            ) {
	                // inside a span, content is "---", no read-more yet: end the
	                //     span, set read-more index, and start a new one
	                spans.push({
	                    startIndex: currentSpanStartIndex,
	                    endIndex: i,
	                });
	                currentSpanStartIndex = i;
	                readMoreIndex = i;
	            } else if (currentSpanStartIndex !== null) {
	                // inside a span, any other content: keep it going
	                continue;
	            } else {
	                // outside a span: start a new span
	                currentSpanStartIndex = i;
	            }
	        } else {
	            if (currentSpanStartIndex !== null) {
	                // inside a span: end the span
	                spans.push({
	                    startIndex: currentSpanStartIndex,
	                    endIndex: i,
	                });
	                currentSpanStartIndex = null;
	            } else {
	                // outside a span: do nothing
	                continue;
	            }
	        }
	    }

	    // if we ended the post in a span, finish the one we were in
	    if (currentSpanStartIndex !== null) {
	        spans.push({
	            startIndex: currentSpanStartIndex,
	            endIndex: viewBlocks.length,
	        });
	    }

	    // render each span and return AST map
	    return {
	        spans: await Promise.all(
	            spans.map(async (span) => ({
	                startIndex: span.startIndex,
	                endIndex: span.endIndex,
	                ast: await renderMarkdownAst(
	                    viewBlocks.slice(
	                        span.startIndex,
	                        span.endIndex
	                    ) ,
	                    publishDate,
	                    options
	                ),
	            }))
	        ),
	        readMoreIndex,
	    };
	}

	var anonBug = "ca4719f7af550ea00632.png";

	/**
	 * For comments, page descriptions, etc. Everything that accepts markdown and
	 * isn't a post.
	 */


	htmlToText.compile({
	    wordwrap: false,
	});
	function rewriteCdnUrls() {
	    const rewriteData = window.cohostDL.rewriteData;

	    function rewriteUrl(url) {
	        if (rewriteData?.urls?.[url]) return rewriteData.urls[url];
	        return null;
	    }

	    return function(tree) {
	        const process = (node) => {
	            if (node.properties?.style) {
	                let mutated = false;
	                const tree = db(node.properties.style, { context: 'declarationList' });
	                yb(tree, (node) => {
	                    if (node.type === "Url") {
	                        const resolved = new URL(node.value, rewriteData.base);
	                        const rewritten = rewriteUrl(resolved.toString());
	                        if (rewritten) {
	                            mutated = true;
	                            node.value = rewritten;
	                        }
	                    }
	                });

	                if (mutated) {
	                    node = { ...node, properties: { ...node.properties, style: gb(tree) } };
	                }
	            }

	            const props = ['href', 'src'];
	            for (const prop of props) {
	                if (node.properties?.[prop]) {
	                    const resolved = new URL(node.properties[prop], rewriteData.base);
	                    const rewritten = rewriteUrl(resolved.toString());
	                    if (rewritten) {
	                        node = { ...node, properties: { ...node.properties, [prop]: rewritten } };
	                    }
	                }
	            }
	            if (node.properties?.srcset) {
	                node = { ...node, properties: { ...node.properties } };
	                delete node.properties.srcset;
	            }
	            if (node.children) {
	                let mutated = false;
	                const newChildren = node.children.map(child => {
	                    const result = process(child);
	                    mutated = result !== child;
	                    return result;
	                });
	                if (mutated) return { ...node, children: newChildren };
	            }
	            return node;
	        };
	        return process(tree);
	    };
	}

	const markdownRenderStackNoHTML = (
	    postDate,
	    lineLength,
	    options
	) => {
	    let stack = unified().use(remarkParse);

	    const ruleset = chooseAgeRuleset(postDate);

	    if (ruleset.singleLineBreaks) {
	        stack = stack.use(remarkBreaks);
	    }

	    const externalRel = ["nofollow"];
	    if (options.externalLinksInNewTab) {
	        externalRel.push("noopener");
	    }

	    if (lineLength < MAX_GFM_LINES) {
	        stack = stack.use(remarkGfm, {
	            singleTilde: false,
	        });
	    }

	    const effectiveSchema = { ...ruleset.schema };

	    if (options.renderingContext === "ask" && !ruleset.ask.allowEmbeddedMedia) {
	        effectiveSchema.tagNames = _$5.filter(
	            effectiveSchema.tagNames,
	            (tagName) => !["img", "picture", "audio", "video"].includes(tagName)
	        );
	    }

	    return stack
	        .use(remarkRehype)
	        .use(() => copyImgAltToTitle)
	        .use(() => cleanUpFootnotes)
	        .use(rehypeSanitize, effectiveSchema).use(rewriteCdnUrls)
	        .use(() => ruleset.additionalVisitor)
	        .use(rehypeExternalLinks, {
	            rel: externalRel,
	            target: options.externalLinksInNewTab ? "_blank" : "_self",
	        });
	};

	function renderMarkdownReactNoHTML(
	    src,
	    publishDate,
	    options
	) {
	    const components = {
	        Mention,
	        CustomEmoji,
	    };

	    if (options.renderingContext === "artistAlley") {
	        // remove headers for artist alley
	        Object.assign(components, {
	            h1: "strong",
	            h2: "strong",
	            h3: "strong",
	            h4: "strong",
	            h5: "strong",
	            h6: "strong",
	        });
	    }

	    const lineLength = src.split("\n", MAX_GFM_LINES).length;
	    return (
	        markdownRenderStackNoHTML(publishDate, lineLength, options)
	            .use(() => convertMentions)
	            .use(parseEmoji, { cohostPlus: options.hasCohostPlus })
	            // @ts-expect-error: Typings don't natively support custom elements
	            .use(rehypeReact, {
	                createElement: reactExports.createElement,
	                Fragment: reactExports.Fragment,
	                components,
	            })
	            .processSync(src).result
	    );
	}

	const Ask

	 = ({ askBlock: { ask } }) => {
	    const attribution = reactExports.useMemo(() => {
	        if (ask.anon) {
	            return (
	                React$2.createElement('span', { className: "font-bold",}
	                    , ask.loggedIn ? "Anonymous User" : "Anonymous Guest"
	                )
	            );
	        }

	        return (
	            React$2.createElement('a', {
	                className: "font-bold hover:underline" ,
	                href: sitemap.public.project
	                    .mainAppProfile({ projectHandle: ask.askingProject.handle })
	                    .toString(),}
	, "@"
	                , ask.askingProject.handle
	            )
	        );
	    }, [ask.anon, ask.askingProject?.handle, ask.loggedIn]);

	    const displayPrefs = useDisplayPrefs();

	    const rendered = reactExports.useMemo(() => {
	        return renderMarkdownReactNoHTML(ask.content, new Date(ask.sentAt), {
	            renderingContext: "ask",
	            disableEmbeds: true,
	            externalLinksInNewTab: displayPrefs.externalLinksInNewTab,
	            hasCohostPlus: false,
	        });
	    }, [ask.content, ask.sentAt, displayPrefs.externalLinksInNewTab]);

	    return (
	        React$2.createElement('div', {
	            'data-askid': ask.askId,
	            className: tw`co-embedded-ask m-3 grid grid-cols-[2rem_1fr] grid-rows-[2rem_1fr] gap-x-3 gap-y-2 rounded-lg border p-3`,}

	            , ask.anon ? (
	                React$2.createElement('img', {
	                    src: sitemap.public.static
	                        .staticAsset({ path: anonBug })
	                        .toString(),
	                    className: "mask mask-squircle col-start-1 row-start-1 h-8 w-8"     ,
	                    alt: "",}
	                )
	            ) : (
	                React$2.createElement(ProjectAvatar, {
	                    project: ask.askingProject,
	                    noLink: true,
	                    className: "col-start-1 row-start-1 h-8 w-8"   ,}
	                )
	            )
	            , React$2.createElement('span', {
	                className: tw`co-attribution col-start-2 row-start-1 align-middle leading-8`,}

	                , attribution, " asked:" , " "
	            )
	            , React$2.createElement('div', { className: tw`co-prose prose col-start-2 row-start-2`,}
	                , rendered
	            )
	        )
	    );
	};

	const AudioAttachment = ({
	    block,
	}) => {
	    const audio = reactExports.useRef(null);

	    const displayTitle = reactExports.useMemo(() => {
	        const pathEntries = new URL(block.attachment.fileURL, location.href).pathname.split(
	            "/"
	        );
	        let displayTitle = pathEntries[pathEntries.length - 1];

	        if (block.attachment.kind === "audio") {
	            if (block.attachment.title) displayTitle = block.attachment.title;
	        }

	        return displayTitle;
	    }, [block.attachment]);

	    const displayArtist = reactExports.useMemo(() => {
	        let displayArtist = "(unknown artist)";

	        if (block.attachment.kind === "audio") {
	            if (block.attachment.artist)
	                displayArtist = block.attachment.artist;
	        }

	        return displayArtist;
	    }, [block.attachment]);

	    const [displayPlaybackError, setDisplayPlaybackError] = reactExports.useState(false);
	    const { togglePlayback, currentTime, isPlaying, totalDuration, seek } =
	        useAudioPlayback(audio, () => setDisplayPlaybackError(true));

	    return (
	        React$2.createElement('figure', { className: "group relative w-full flex-initial"   ,}
	            , React$2.createElement('figcaption', { className: "sr-only",}
	                , displayArtist, " - "  , displayTitle
	            )
	            , React$2.createElement('audio', {
	                src: block.attachment.fileURL,
	                preload: "metadata",
	                className: "w-full p-2" ,
	                ref: audio,
	                'data-testid': "audio",}

	                , React$2.createElement('a', { href: block.attachment.fileURL,}, "download audio" )
	            )

	            , React$2.createElement('div', { className: "flex flex-row" ,}
	                , React$2.createElement(AudioPlayPauseButton, {
	                    mode: isPlaying ? "playing" : "paused",
	                    className: "flex-shrink-0 flex-grow" ,
	                    togglePlayback: togglePlayback,}
	                )

	                , React$2.createElement('div', { className: "flex w-full flex-col bg-notBlack p-2"    ,}
	                    , displayPlaybackError ? (
	                        React$2.createElement(React$2.Fragment, null
	                            , React$2.createElement('div', { className: "flex flex-row" ,}
	                                , React$2.createElement('div', { className: "flex-1",}, "Your web browser isn't able to play this file."


	                                )
	                                , React$2.createElement('button', {
	                                    type: "button",
	                                    onClick: () =>
	                                        setDisplayPlaybackError(false)
	                                    ,
	                                    className: "flex flex-row text-xs text-mango"   ,}
	, "dismiss error"

	                                    , React$2.createElement(ForwardRef$C, { className: "h-4 w-4" ,} )
	                                )
	                            )
	                            , React$2.createElement('div', { className: "text-xs",}, "You might be able to"
	                                    , " "
	                                , React$2.createElement('a', {
	                                    href: block.attachment.fileURL,
	                                    download: true,
	                                    className: "text-mango",}
	, "download"

	                                ), " ", "it and play it in a dedicated audio player."

	                            )
	                        )
	                    ) : (
	                        React$2.createElement(React$2.Fragment, null
	                            , React$2.createElement('div', { className: "flex flex-row" ,}
	                                , React$2.createElement('div', { className: "flex-1",}, displayTitle)
	                                , React$2.createElement('a', {
	                                    href: block.attachment.fileURL,
	                                    download: true,
	                                    title: "download",}

	                                    , React$2.createElement(ForwardRef$_, { className: "h-6 w-6" ,} )
	                                )
	                            )
	                            , React$2.createElement('div', { className: "text-xs",}, displayArtist)

	                            , React$2.createElement(AudioSeekBar, {
	                                currentTime: currentTime,
	                                totalDuration: totalDuration,
	                                seek: seek,}
	                            )
	                        )
	                    )
	                )
	            )
	        )
	    );
	};

	const Play = (
	    props
	) => (
	    React$2.createElement('svg', {
	        viewBox: "0 0 20 24"   ,
	        fill: "none",
	        xmlns: "http://www.w3.org/2000/svg",
	        ...props,}

	        , React$2.createElement('path', {
	            d: "M18.2864 8.81325L5.98281 0.649686C3.42546 -1.04714 0 0.777437 0 3.83643V20.1636C0 23.2226 3.42546 25.0471 5.98281 23.3503L18.2864 15.1867C20.5712 13.6708 20.5712 10.3292 18.2864 8.81325Z"                  ,
	            fill: "currentColor",}
	        )
	    )
	);

	const Pause = (
	    props
	) => (
	    React$2.createElement('svg', {
	        viewBox: "0 0 24 24"   ,
	        fill: "none",
	        xmlns: "http://www.w3.org/2000/svg",
	        ...props,}

	        , React$2.createElement('path', {
	            fillRule: "evenodd",
	            clipRule: "evenodd",
	            d: "M0 4C0 1.79086 1.79086 0 4 0C6.20914 0 8 1.79086 8 4V20C8 22.2091 6.20914 24 4 24C1.79086 24 0 22.2091 0 20V4ZM20 0C17.7909 0 16 1.79086 16 4V20C16 22.2091 17.7909 24 20 24C22.2091 24 24 22.2091 24 20V4C24 1.79086 22.2091 0 20 0Z"                                          ,
	            fill: "currentColor",}
	        )
	    )
	);

	const PlayPauseButton = ({
	    isPlaying,
	    showPlay,
	    extraClasses,
	    onPlay,
	    onPause,
	}) => {
	    function wrapStopPropagation(handler) {
	        return (e) => {
	            e.stopPropagation();
	            handler();
	        };
	    }

	    return (
	        React$2.createElement('button', {
	            className: classNames(extraClasses, "cursor-pointer"),
	            onClick: 
	                isPlaying
	                    ? wrapStopPropagation(onPause)
	                    : wrapStopPropagation(onPlay)
	            ,
	            type: "button",}

	            , isPlaying ? (
	                React$2.createElement(IconEgg, {
	                    scale: 0.5,
	                    className: "hidden fill-notBlack opacity-90 hover:opacity-100 group-hover:block no-hover:block"     ,
	                    fillOpacity: "0.4",}

	                    , React$2.createElement(Pause, { fillOpacity: "1",} )
	                )
	            ) : showPlay ? (
	                React$2.createElement(IconEgg, {
	                    scale: 0.5,
	                    className: "fill-notBlack opacity-90 hover:opacity-100"  ,
	                    fillOpacity: "0.4",}

	                    , React$2.createElement(Play, { fillOpacity: "1",} )
	                )
	            ) : null
	        )
	    );
	};

	const useImageOptimizer = (
	    src,
	    maxWidth,
	    aspectRatio
	) => {
	    const processedSrc = reactExports.useMemo(() => {
	        if (!src) return undefined;

	        const parsedSrc = new URL(src, document.location.href);

	        if (parsedSrc.protocol === "blob:") {
	            // firefox doesn't like sticking search params onto the end of object
	            // URLs. pass through the URL unchanged.
	            return parsedSrc;
	        }

	        parsedSrc.searchParams.append("width", Math.floor(maxWidth).toString());

	        if (aspectRatio) {
	            parsedSrc.searchParams.append(
	                "height",
	                Math.floor(maxWidth / aspectRatio).toString()
	            );
	            parsedSrc.searchParams.append("fit", "crop");
	        }

	        parsedSrc.searchParams.append("auto", "webp");

	        return parsedSrc;
	    }, [aspectRatio, maxWidth, src]);

	    const srcWithDpr = reactExports.useCallback(
	        (dpr) => {
	            if (!processedSrc) return "";
	            const parsedSrc = new URL(processedSrc.toString());

	            if (parsedSrc.protocol === "blob:") {
	                // firefox doesn't like sticking search params onto the end of object
	                // URLs. pass through the URL unchanged.
	                return parsedSrc.toString();
	            }

	            parsedSrc.searchParams.append("dpr", dpr.toString());
	            return parsedSrc.toString();
	        },
	        [processedSrc]
	    );

	    return srcWithDpr;
	};

	const ImageAttachment = ({
	    block,
	    onClick,
	    maxWidth,
	    aspectRatio,
	}) => {
	    const displayPrefs = useDisplayPrefs();
	    const [src, setSrc] = reactExports.useState(
	        displayPrefs.gifsStartPaused
	            ? block.attachment.previewURL
	            : block.attachment.fileURL
	    );
	    const [isPlaying, setIsPlaying] = reactExports.useState(!displayPrefs.gifsStartPaused);

	    const handlePause = () => {
	        setIsPlaying(false);
	        setSrc(block.attachment.previewURL);
	    };

	    const handlePlay = () => {
	        setIsPlaying(true);
	        setSrc(block.attachment.fileURL);
	    };

	    if (!block.attachment.fileURL) {
	        console.error(
	            `fileURL wasn't provided for attachment with ID ${block.attachment.attachmentId}`
	        );
	        return null;
	    }

	    return (
	        React$2.createElement('button', {
	            onClick: onClick,
	            className: "group relative w-full flex-initial"   ,}

	            , React$2.createElement(ClientAttachment, {
	                block: block,
	                maxWidth: maxWidth,
	                src: src,
	                aspectRatio: aspectRatio,}
	            )
	            , block.attachment.previewURL !== block.attachment.fileURL ? (
	                React$2.createElement(PlayPauseButton, {
	                    isPlaying: isPlaying,
	                    showPlay: 
	                        block.attachment.previewURL !== block.attachment.fileURL
	                    ,
	                    extraClasses: "absolute bottom-3 right-3 w-12"   ,
	                    onPlay: handlePlay,
	                    onPause: handlePause,}
	                )
	            ) : null
	        )
	    );
	};

	const ClientAttachment




	 = ({ block, maxWidth, src, aspectRatio }) => {
	    const imgRef = reactExports.useRef(null);
	    const srcWithDpr = useImageOptimizer(src, maxWidth, aspectRatio);

	    return (
	        React$2.createElement('img', {
	            ref: imgRef,
	            src: srcWithDpr(1),
	            srcSet: `
                ${srcWithDpr(1)} 1x,
                ${srcWithDpr(2)} 2x,
                ${srcWithDpr(3)} 3x,
            `,
	            className: `h-full w-full object-cover`,
	            'data-attachment-id': block.attachment.attachmentId,
	            alt: block.attachment.altText ?? undefined,
	            title: block.attachment.altText ?? undefined,
	            style: {
	                aspectRatio: aspectRatio ? `${aspectRatio} / 1` : undefined,
	            },}
	        )
	    );
	};

	// 65ch = 675px
	const MAX_ROW_WIDTH = 675;





















	const magicContentAttachment

	 = (
	    onClickAttachmentFactory
	) => {
	    const component = ({
	        attachment,
	        index,
	        rowLength,
	        aspectRatio,
	    }) => {
	        switch (attachment.attachment.kind) {
	            case "image":
	                return (
	                    React$2.createElement(ImageAttachment, {
	                        block: attachment,
	                        onClick: onClickAttachmentFactory(attachment),
	                        maxWidth: MAX_ROW_WIDTH / rowLength,
	                        key: index,
	                        aspectRatio: aspectRatio,}
	                    )
	                );
	            case "audio":
	                return (
	                    React$2.createElement(AudioAttachment, {
	                        block: attachment,
	                        onClick: onClickAttachmentFactory(attachment),
	                        maxWidth: MAX_ROW_WIDTH / rowLength,
	                        key: index,
	                        aspectRatio: aspectRatio,}
	                    )
	                );
	        }
	    };
	    component.displayName = "MagicContentAttachment";

	    return component;
	};

	function attachmentKind(attachment) {
	    return attachment.attachment.kind;
	}

	function attachmentDimensions$1(attachment) {
	    if (attachment.attachment.kind === "image") {
	        return {
	            width: attachment.attachment.width ?? 0,
	            height: attachment.attachment.height ?? 0,
	        };
	    } else return undefined;
	}

	const PostBodyInner = ({
	    viewModel,
	    renderUntilBlockIndex,
	    ruleset,
	}) => {
	    const displayPrefs = useDisplayPrefs();

	    // flatten attachment blocks out of rows
	    const attachmentBlocks = viewModel.blocks.reduce(
	        (accumulator, block) => {
	            if (block.type === "attachment") {
	                accumulator.push(block);
	            } else if (block.type === "attachment-row") {
	                accumulator.push(...block.attachments);
	            }
	            return accumulator;
	        },
	        []
	    );

	    // create a clean copy of attachment blocks that we can pass to the lightbox
	    // DO NOT MODIFY THIS ONE!!!
	    const passableAttachmentBlocks = [...attachmentBlocks].filter(
	        (block) => block.attachment.kind === "image"
	    );

	    const { openLightbox, setLightboxContentForPost } = useLightbox();

	    reactExports.useEffect(() => {
	        setLightboxContentForPost(viewModel.postId, passableAttachmentBlocks);
	    });

	    const onClickAttachmentFactory =
	        (attachment) => () => {
	            openLightbox(viewModel.postId, attachment.attachment.attachmentId);
	        };

	    const spansByStartIndex = new Map(
	        viewModel.astMap.spans.map((span) => [span.startIndex, span])
	    );

	    // for pre-sixth age posts, we need to render blocks out of order in case
	    // there's an attachment in the middle of the block list that's been
	    // rendered at the top all this time.
	    let askChild = null;
	    let outlineAttachmentChild = null;

	    const normalFlowChildren = [];

	    let blockIndex = 0;

	    while (blockIndex < renderUntilBlockIndex) {
	        const block = viewModel.blocks[blockIndex];

	        if (isMarkdownViewBlock(block)) {
	            // markdown block!  render the matching span.
	            const span = spansByStartIndex.get(blockIndex);

	            if (!span) {
	                console.error(
	                    `PostBodyInner: couldn't find markdown span starting at index ${blockIndex}`
	                );
	                blockIndex++;
	            } else {
	                normalFlowChildren.push(
	                    React$2.createElement('div', {
	                        className: `co-prose prose my-4 overflow-hidden break-words px-3`,
	                        key: `block-${blockIndex}`,}

	                        , renderReactFromAst(span.ast, {
	                            renderingContext: "post",
	                            disableEmbeds: displayPrefs.disableEmbeds,
	                            externalLinksInNewTab:
	                                displayPrefs.externalLinksInNewTab,
	                        })
	                    )
	                );
	                blockIndex = span.endIndex;
	            }
	        } else if (isAttachmentViewBlock(block)) {
	            // attachment block.  what we do here depends on what age this post
	            // was made in.
	            if (ruleset.forceAttachmentsToTop && !outlineAttachmentChild) {
	                // pre-sixth age post: we gotta outline the attachments, and
	                // haven't done that work yet
	                if (ruleset.attachmentLayoutBehavior === "v2") {
	                    outlineAttachmentChild = (
	                        React$2.createElement(AttachmentLayoutV2, {
	                            attachments: attachmentBlocks,
	                            attachmentKind: attachmentKind,
	                            attachmentDimensions: attachmentDimensions$1,
	                            renderOne: magicContentAttachment(
	                                onClickAttachmentFactory
	                            ),
	                            key: `outline-attachments`,}
	                        )
	                    );
	                } else {
	                    outlineAttachmentChild = (
	                        React$2.createElement(AttachmentLayoutV1, {
	                            attachments: attachmentBlocks,
	                            attachmentKind: attachmentKind,
	                            attachmentDimensions: attachmentDimensions$1,
	                            renderOne: magicContentAttachment(
	                                onClickAttachmentFactory
	                            ),
	                            key: `outline-attachments`,}
	                        )
	                    );
	                }

	                blockIndex++;
	            } else if (ruleset.forceAttachmentsToTop) {
	                // we gotta outline the attachments, but already did it.  just
	                // ignore this block since it's already rendered somewhere else.
	                blockIndex++;
	            } else {
	                // post-sixth age post: spin forward until we run out of attachments,
	                // then lay them out.
	                let nextNonAttachmentIndex = blockIndex;

	                while (nextNonAttachmentIndex < viewModel.blocks.length) {
	                    if (
	                        !isAttachmentViewBlock(
	                            viewModel.blocks[nextNonAttachmentIndex]
	                        )
	                    )
	                        break;
	                    nextNonAttachmentIndex++;
	                }

	                if (ruleset.attachmentLayoutBehavior === "v2") {
	                    normalFlowChildren.push(
	                        React$2.createElement(AttachmentLayoutV2, {
	                            attachments: 
	                                viewModel.blocks.slice(
	                                    blockIndex,
	                                    nextNonAttachmentIndex
	                                ) 
	                            ,
	                            attachmentKind: attachmentKind,
	                            attachmentDimensions: attachmentDimensions$1,
	                            renderOne: magicContentAttachment(
	                                onClickAttachmentFactory
	                            ),
	                            key: `block-${blockIndex}`,}
	                        )
	                    );
	                } else {
	                    normalFlowChildren.push(
	                        React$2.createElement(AttachmentLayoutV1, {
	                            attachments: 
	                                viewModel.blocks.slice(
	                                    blockIndex,
	                                    nextNonAttachmentIndex
	                                ) 
	                            ,
	                            attachmentKind: attachmentKind,
	                            attachmentDimensions: attachmentDimensions$1,
	                            renderOne: magicContentAttachment(
	                                onClickAttachmentFactory
	                            ),
	                            key: `block-${blockIndex}`,}
	                        )
	                    );
	                }

	                blockIndex = nextNonAttachmentIndex;
	            }
	        } else if (isAttachmentRowViewBlock(block)) {
	            // we have an explicit attachment row! these are always rendered in place with the v2 layout regardless of post age, so let's do it.
	            normalFlowChildren.push(
	                React$2.createElement(AttachmentLayoutV2, {
	                    attachments: block.attachments,
	                    attachmentKind: attachmentKind,
	                    attachmentDimensions: attachmentDimensions$1,
	                    renderOne: magicContentAttachment(onClickAttachmentFactory),
	                    key: `block-${blockIndex}`,}
	                )
	            );
	            blockIndex++;
	        } else if (isAskViewBlock(block)) {
	            // ask block.
	            askChild = React$2.createElement(Ask, { askBlock: block, key: `block-${blockIndex}`,} );
	            blockIndex++;
	        } else {
	            throw new Error("PostBodyInner: unexpected block type?");
	        }
	    }

	    return (
	        React$2.createElement(React$2.Fragment, null
	            , askChild
	            , outlineAttachmentChild
	            , normalFlowChildren
	        )
	    );
	};



	const PostBody = React$2.memo(
	    ({ viewModel, skipCollapse = false, effectiveDate }) => {
	        const ruleset = reactExports.useMemo(() => {
	            const postDate = effectiveDate
	                ? new Date(effectiveDate)
	                : new Date();
	            return chooseAgeRuleset(postDate);
	        }, [effectiveDate]);
	        const bodyRef = reactExports.useRef(null);
	        const readMoreRef = reactExports.useRef(null);
	        const readLessRef = reactExports.useRef(null);
	        const [postCollapseState, setPostCollapseState] =
	            reactExports.useState(
	                skipCollapse ? "forced-open" : "default"
	            );
	        const [eligibleForAutocollapse, setEligibleForAutocollapse] = reactExports.useState

	(null);
	        const manualReadMorePresent = viewModel.astMap.readMoreIndex !== null;
	        const collapsePossible =
	            eligibleForAutocollapse || manualReadMorePresent;
	        const collapsed =
	            postCollapseState === "forced-open" ? false : collapsePossible;

	        // cut the inner renderer off early iff the post is collapsed and it
	        // has an explicit read more
	        const renderUntilBlockIndex =
	            collapsed && viewModel.astMap.readMoreIndex !== null
	                ? viewModel.astMap.readMoreIndex
	                : viewModel.blocks.length;

	        const lastPostHeight = reactExports.useRef(0);
	        const hasRun = reactExports.useRef(false);

	        const resize = reactExports.useCallback(
	            (force) => {
	                // we don't want to run immediately after we just did to prevent a loop
	                if (hasRun.current === true && !force) {
	                    return;
	                }
	                if (bodyRef.current && !collapsed) {
	                    const postHeight = bodyRef.current.scrollHeight;
	                    if (postHeight === lastPostHeight.current) {
	                        return;
	                    }
	                    lastPostHeight.current = postHeight;

	                    const pageHeight = Math.max(
	                        document.documentElement.clientHeight,
	                        window.innerHeight || 0
	                    );
	                    const shouldCollapse = postHeight / pageHeight > 2.0;
	                    setEligibleForAutocollapse(shouldCollapse);

	                    hasRun.current = true;
	                }
	            },
	            [bodyRef, collapsed]
	        );

	        const readMore = reactExports.useCallback(() => {
	            setPostCollapseState("forced-open");
	        }, []);

	        const readLess = reactExports.useCallback(() => {
	            let scrollOffset = 0;
	            if (readLessRef?.current) {
	                scrollOffset = readLessRef.current.getBoundingClientRect().top;
	            }
	            setPostCollapseState("forced-closed");

	            requestAnimationFrame(() => {
	                // scroll so that the relative position of "read more" is
	                // identical to the relative position of "read less"
	                // (effectively no scroll)
	                if (readMoreRef?.current) {
	                    const readMoreOffset =
	                        readMoreRef.current.getBoundingClientRect().top;
	                    const scrollTo =
	                        window.scrollY + readMoreOffset - scrollOffset;
	                    // don't smooth scroll, it breaks the effect
	                    window.scroll({ top: scrollTo });
	                }
	            });
	        }, []);

	        /**
	         * this can only run in browser so we don't need to check for if document exists
	         */
	        reactExports.useEffect(() => {
	            resize(false);
	        }, [resize]);

	        reactExports.useEffect(() => {
	            window.iframely &&
	                // iframe just resized, check to see if it's in this post. force
	                // a resize check if it is
	                window.iframely.on("heightChanged", (...args) => {
	                    const iframe = args[0] ;
	                    const parentPostBody = iframe.closest("[data-post-body]");
	                    if (parentPostBody === bodyRef.current) {
	                        resize(true);
	                    }
	                });
	            // empty array so this only runs once On Purpose
	            // eslint-disable-next-line react-hooks/exhaustive-deps
	        }, []);

	        /**
	         * mask the tab order of elements which are collapsed offscreen by a
	         * read more.
	         */
	        reactExports.useEffect(() => {
	            if (!bodyRef.current) return;

	            // gather descendants of the body from the DOM which participate in
	            // tab order
	            function tabOrderedDescendants(element) {
	                if (!(element instanceof HTMLElement)) return [];

	                const tabOrdered = _$5.reduce(
	                    element.children,
	                    (accum, child) => [
	                        ...accum,
	                        ...tabOrderedDescendants(child),
	                    ],
	                    [] 
	                );

	                // > 0 is explicit tab indexing, == 0 is "default, in page order"
	                if (element.tabIndex >= 0) {
	                    tabOrdered.push(element);
	                }

	                return tabOrdered;
	            }

	            const tabOrderedElements = tabOrderedDescendants(bodyRef.current);

	            // give each of them an IntersectionObserver; when an element goes
	            // offscreen (hidden behind a read more), suppress its tab index,
	            // and when it comes back restore it
	            const observer = new IntersectionObserver(
	                (entries) => {
	                    entries.forEach((entry) => {
	                        const targetHtml = entry.target ;

	                        // note: we're flattening positive tabIndexes to zero here,
	                        // instead of taking pains to restore its original value;
	                        // we've never allowed tabIndex attributes in posts, and
	                        // I can't think of a good reason why we'd ever use them so
	                        // just live with this
	                        if (entry.isIntersecting) {
	                            targetHtml.tabIndex = 0;
	                        } else {
	                            targetHtml.tabIndex = -1;
	                        }
	                    });
	                },
	                {
	                    root: bodyRef.current,
	                    threshold: 0.0,
	                }
	            );

	            tabOrderedElements.forEach((element) => observer.observe(element));

	            // empty array so this only runs once On Purpose
	            // eslint-disable-next-line react-hooks/exhaustive-deps
	        }, []);

	        // to preserve proper layout, posts without _any_ markdown spans should
	        // have postbody render as null
	        return viewModel.blocks.length > 0 ? (
	            /*
	                the two layers of overflows here attempt to prevent a combination
	                of post box breakout (discovered by @bark) and bad default tab
	                navigation behavior.  the inner overflow-hidden crops the post
	                content to fit inside the post box, and the outer overflow-clip
	                (where supported) prevents the post content from scrolling around
	                inside the post box when tab focus goes below the "read more"
	                link in situations where we can't prevent that.
	                
	                if you make changes to this, check:
	            
	                https://cohost.org/blep/post/3924485-is-it-just-me-or-ism
	                https://cohost.org/bark-test/post/3891805-my-totally-normal-po

	                to ensure proper rendering
	            */
	            React$2.createElement('div', {
	                className: `${
                    // the disparity between `max-h-screen` and a 2x check
                    // threshold is deliberate
                    collapsed && !manualReadMorePresent ? "max-h-screen" : ""
                } relative overflow-hidden supports-[overflow:clip]:overflow-clip ${
                    ruleset.className
                }`,
	                'data-post-body': true,
	                'data-testid': "post-body",
	                ref: bodyRef,}

	                , React$2.createElement(PostBodyInner, {
	                    viewModel: viewModel,
	                    renderUntilBlockIndex: renderUntilBlockIndex,
	                    ruleset: ruleset,}
	                )
	                , collapsed && !manualReadMorePresent ? (
	                    React$2.createElement('div', { className: "absolute bottom-0 left-0 right-0 flex flex-col px-3"      ,}
	                        , React$2.createElement('span', { className: "co-from-body inline-block h-8 w-full bg-gradient-to-t pl-4"     ,} )
	                        , React$2.createElement('button', {
	                            className: tw`co-link-button co-opaque inline-block pb-3 text-left 
                                text-sm font-bold hover:underline`,
	                            onClick: readMore,
	                            ref: readMoreRef,}
	, "read more"

	                        )
	                    )
	                ) : collapsed ? (
	                    React$2.createElement('button', {
	                        className: tw`co-link-button co-opaque inline-block pb-3 pl-3 text-left text-sm font-bold hover:underline`,
	                        onClick: readMore,
	                        ref: readMoreRef,}
	, "read more"

	                    )
	                ) : collapsePossible ? (
	                    React$2.createElement('button', {
	                        className: tw`co-link-button co-opaque inline-block pb-3 pl-3 text-left text-sm font-bold hover:underline`,
	                        onClick: readLess,
	                        ref: readLessRef,}
	, "read less"

	                    )
	                ) : null
	            )
	        ) : null;
	    }
	);

	PostBody.displayName = "PostBodyV2";

	const PostComposerPreview$1 = () => {
	    const postEditorService = reactExports.useContext(PostComposerContext);
	    const blocks = useSelector$1(postEditorService, selectBlocks);
	    const headline = useSelector$1(postEditorService, selectHeadline$1);
	    const tags = useSelector$1(postEditorService, selectTags$1);

	    const tagListRef = reactExports.useRef(null);

	    const [expanded, setExpanded] = reactExports.useState(false);
	    const [hasRunLayout, setHasRunLayout] = reactExports.useState(false);
	    const toggleExpanded = () => setExpanded(!expanded);

	    reactExports.useEffect(() => {
	        if (!hasRunLayout && tagListRef.current) {
	            setExpanded(
	                tagListRef.current.scrollHeight <=
	                    tagListRef.current.clientHeight
	            );
	            setHasRunLayout(true);
	        }
	    }, [hasRunLayout]);

	    const { t } = useTranslation();

	    const hasCohostPlus = useHasCohostPlus();
	    const postAst = useAsync(
	        () =>
	            generatePostAst(blocks, new Date(), {
	                hasCohostPlus,
	                renderingContext: "post",
	            }),
	        [blocks, hasCohostPlus]
	    );

	    return (
	        React$2.createElement('div', { 'data-post-composer-preview': true,}
	            , headline ? (
	                React$2.createElement('div', { className: "w-full p-3" ,}
	                    , React$2.createElement('h1', {
	                        className: tw`co-prose prose font-atkinson text-xl font-bold`,}

	                        , headline
	                    )
	                )
	            ) : null
	            , React$2.createElement(PreviewsFromAttachments, { canRemove: false,} )
	            , postAst.loading ? (
	                React$2.createElement('div', { className: tw`co-ui-text`,}, "rendering...")
	            ) : postAst.error ? (
	                React$2.createElement('div', { className: tw`co-ui-text`,}, postAst.error.message)
	            ) : (
	                React$2.createElement(PostBody, {
	                    viewModel: {
	                        postId: 0 ,
	                        blocks,
	                        astMap: postAst.value,
	                    },
	                    skipCollapse: true,
	                    effectiveDate: undefined,}
	                )
	            )
	            , tags.length ? (
	                React$2.createElement('div', { className: "w-full max-w-full p-3"  ,}
	                    , React$2.createElement('div', {
	                        ref: tagListRef,
	                        className: tw`co-tags relative w-full overflow-y-hidden break-words leading-none ${
                            expanded ? "" : "max-h-10"
                        }`,}

	                        , React$2.createElement('div', null
	                            , tags.map((tag) => (
	                                React$2.createElement('span', {
	                                    className: "mr-2 inline-block text-sm"  ,
	                                    key: tag,}
	, "#"
	                                    , tag
	                                )
	                            ))
	                        )
	                        , !expanded ? (
	                            React$2.createElement('div', { className: "absolute bottom-0 right-2 flex h-5"    ,}
	                                , React$2.createElement('span', { className: "co-from-body inline-block h-full bg-gradient-to-l pl-4"    ,} )
	                                , React$2.createElement('button', {
	                                    onClick: toggleExpanded,
	                                    className: 
	                                        "co-tags co-opaque inline-block cursor-pointer text-sm font-bold hover:underline"
	                                    ,}

	                                    , t(
	                                        "client:post-preview.expand-tags",
	                                        "see all"
	                                    )
	                                )
	                            )
	                        ) : null
	                    )
	                )
	            ) : null
	        )
	    );
	};

	const TagButton

	 = (props) => {
	    const tokenIconClasses = classNames("inline-block h-3.5", {
	        "group-hover:hidden": props.MouseoverTagIcon !== null,
	    });

	    return (
	        React$2.createElement('button', {
	            className: tw`co-filled-button group flex items-center justify-start gap-1 rounded-full px-2 py-1 text-sm leading-none`,
	            onClick: props.onClick,
	            type: "button",}

	            , React$2.createElement(props.TagIcon, { className: tokenIconClasses,} )
	            , props.MouseoverTagIcon ? (
	                React$2.createElement(props.MouseoverTagIcon, { className: "hidden h-3.5 group-hover:inline-block"  ,} )
	            ) : null
	            , React$2.createElement('span', { className: "block",}, props.tagText)
	        )
	    );
	};

	function useLocalStorage(
	    key,
	    initialValue
	) {
	    // State to store our value
	    // Pass initial state function to useState so logic is only executed once
	    const [storedValue, setStoredValue] = reactExports.useState(() => {
	        if (typeof window === "undefined") {
	            return initialValue;
	        }
	        try {
	            // Get from local storage by key
	            const item = window.localStorage.getItem(key);
	            // Parse stored json or if none return initialValue
	            return item ? (JSON.parse(item) ) : initialValue;
	        } catch (error) {
	            // If error also return initialValue
	            console.error(error);
	            return initialValue;
	        }
	    });
	    // Return a wrapped version of useState's setter function that persists the
	    // new value to localStorage.
	    const setValue = (
	        value
	    ) => {
	        try {
	            // Allow value to be a function so we have same API as useState
	            const valueToStore =
	                value instanceof Function ? value(storedValue) : value;
	            // Save state
	            setStoredValue(valueToStore);
	            // Save to local storage
	            if (typeof window !== "undefined") {
	                window.localStorage.setItem(key, JSON.stringify(valueToStore));
	            }
	        } catch (error) {
	            // A more advanced implementation would handle the error case
	            console.log(error);
	        }
	    };
	    return [storedValue, setValue];
	}

	const TagRecommendationBox$1

	 = (props) => {
	    const postEditorService = reactExports.useContext(PostComposerContext);
	    const dynamicTheme = useDynamicTheme();

	    const tags = useSelector$1(postEditorService, selectTags$1);
	    const [storedState, setStoredState] = useLocalStorage(
	        `tag-recommendations/${props.stateId}`,
	        { open: false }
	    );

	    function appendTag(content) {
	        if (
	            tags.findIndex(
	                (existingTag) =>
	                    existingTag.toLowerCase() === content.toLowerCase()
	            ) !== -1
	        ) {
	            // tag already present; do nothing.
	            return;
	        } else {
	            // tag not currently present; add it.
	            postEditorService.send({
	                type: "TAGS_INPUT",
	                tags: [...tags, content],
	            });
	        }
	    }

	    return (
	        React$2.createElement('div', {
	            className: tw`co-themed-box w-full`,
	            'data-theme': dynamicTheme.current,}

	            , React$2.createElement(ve$3, { defaultOpen: storedState.open,}
	                , React$2.createElement(ve$3.Button, { className: "co-accordion-header flex w-full max-w-prose flex-row rounded-lg px-3 py-1 ui-open:rounded-b-none"        ,}
	                    , ({ open }) => {
	                        // without the conditional, this leads to an infinite render loop
	                        if (open !== storedState.open) setStoredState({ open });

	                        return (
	                            React$2.createElement(React$2.Fragment, null
	                                , React$2.createElement('span', { className: "flex-1 text-left" ,}
	                                    , props.categoryTitle
	                                )
	                                , React$2.createElement(ForwardRef$12, { className: "h-6 self-center ui-open:rotate-180"  ,} )
	                            )
	                        );
	                    }
	                )
	                , React$2.createElement(ve$3.Panel, { className: "co-accordion-body flex w-full max-w-prose flex-row flex-wrap gap-3 rounded-b-lg p-3"        ,}
	                    , React$2.createElement(React$2.Fragment, null
	                        , props.tags.map((tag) => (
	                            React$2.createElement(TagButton, {
	                                key: tag,
	                                TagIcon: ForwardRef$H,
	                                MouseoverTagIcon: ForwardRef$X,
	                                tagText: tag,
	                                onClick: () => appendTag(tag),}
	                            )
	                        ))
	                    )
	                )
	            )
	        )
	    );
	};

	// used to get around hook changing issues
	const EMPTY_ARRAY$1 = [];

	const selectHasErrors$1 = (state) =>
	    state.context.validationErrors.size > 0;
	const selectErrors$1 = (state) =>
	    state.context.validationErrors.size > 0
	        ? Array.from(state.context.validationErrors)
	        : (EMPTY_ARRAY$1 );
	const selectHasPosted$1 = selectStateMatches("posted");
	const selectIsEditing$3 = selectStateMatches("editing");
	const selectCanCollapseCws = (state) =>
	    state.context.cws.length === 0;
	const selectMaxAttachmentsChosen$1 = selectStateMatches({
	    editing: { attachments: "waitingForUpload" },
	});
	const selectNewPostState$1 = (state) =>
	    state.context.newPostState;
	const selectProjectHandle$1 = (state) =>
	    state.context.projectHandle;
	const selectAdultContent$1 = (state) =>
	    state.context.adultContent;
	const selectDirty$1 = (state) =>
	    state.context.dirty;
	const selectPostId$1 = (state) =>
	    state.context.postId;

	// no body, no attachments, no headline (tags excluded for now)
	const selectIsTransparentShare = (state) =>
	    !!state.context.shareOfPostId &&
	    !state.context.headline &&
	    !state.context.attachments.length &&
	    !state.context.markdownBlocks.filter((block) => !!block.markdown.content)
	        .length;

	const selectEditingTransparentShare$1 = (
	    state
	) => state.context.editingTransparentShare;

	 



	const PostComposer$1 =
	    React$2.forwardRef((props, ref) => {
	        const {
	            initialAdultContent,
	            project: initialProject,
	            shareOf,
	            cws,
	            tags,
	            initialPost,
	        } = props;
	        const hasCohostPlus = useHasCohostPlus();
	        const siteConfig = useSiteConfig();
	        const sizeLimits = siteConfig.limits.attachmentSize;
	        const { activated } = useUserInfo();

	        const [context] = reactExports.useState(() => {
	            const context = {
	                projectHandle: initialProject.handle,
	                isActivated: activated,
	                hasCohostPlus,
	                sizeLimits,
	            };

	            if (initialPost) {
	                context.postId = initialPost.postId;
	                context.currentPostState = initialPost.state;
	                context.newPostState = initialPost.state;
	                context.adultContent = initialPost.effectiveAdultContent;
	                context.shareOfPostId = initialPost.shareOfPostId;

	                context.headline = initialPost.headline;
	                context.markdownBlocks = initialPost.blocks.filter(
	                    isMarkdownStorageBlock
	                );
	                // TODO: attachments figure out a better way to make a fake file here
	                context.attachments = parseAttachmentViewBlocks(
	                    initialPost.blocks
	                ).map((block) => {
	                    switch (block.attachment.kind) {
	                        case "audio":
	                            return {
	                                state: AttachmentState.Finished,
	                                attachmentId: block.attachment.attachmentId,
	                                kind: "audio",
	                                metadata: {
	                                    artist: block.attachment.artist ?? "",
	                                    title: block.attachment.title ?? "",
	                                },
	                            };
	                        case "image":
	                            return {
	                                state: AttachmentState.Finished,
	                                attachmentId: block.attachment.attachmentId,
	                                kind: "image",
	                                metadata: {
	                                    altText: block.attachment.altText ?? "",
	                                    width: block.attachment.width ?? 0,
	                                    height: block.attachment.height ?? 0,
	                                },
	                            };
	                    }
	                });

	                // we need to know if the existing post is a transparent share so we
	                // can adjust the rendered composer accordingly
	                context.editingTransparentShare =
	                    !!initialPost.transparentShareOfPostId;

	                context.tags = initialPost.tags;
	                context.cws = initialPost.cws;
	                context.responseToAskId =
	                    initialPost.responseToAskId ?? undefined;
	            } else {
	                if (shareOf) {
	                    context.shareOfPostId = shareOf.postId;
	                }

	                if (props.responseToAskId) {
	                    context.responseToAskId = props.responseToAskId;
	                }

	                if (tags.length) {
	                    context.tags = tags;
	                }

	                if (cws.length) {
	                    context.cws = cws;
	                }

	                context.adultContent = initialAdultContent;
	            }

	            return context;
	        });

	        const [, , service] = useMachine(postEditorMachine, {
	            context,
	            devTools: 'production' === "development",
	        });

	        const hasPosted = useSelector$1(service, selectHasPosted$1);
	        const newPostState = useSelector$1(service, selectNewPostState$1);
	        const projectHandle = useSelector$1(service, selectProjectHandle$1);
	        const dirty = useSelector$1(service, selectDirty$1);
	        const postId = useSelector$1(service, selectPostId$1);

	        useBeforeUnload(() => dirty);

	        reactExports.useImperativeHandle(
	            ref,
	            () => ({
	                attemptClose() {
	                    return !dirty;
	                },
	            }),
	            [dirty]
	        );

	        reactExports.useEffect(() => {
	            if (hasPosted) {
	                if (typeof props.finishedRedirect === "function") {
	                    props.finishedRedirect(postId);
	                    return;
	                } else if (typeof props.finishedRedirect === "string") {
	                    // if we were told somewhere specific to go, go there.
	                    location.replace(props.finishedRedirect);
	                } else if (newPostState === PostState.Unpublished) {
	                    // if it's a draft, go to the drafts page
	                    location.replace(sitemap.public.project.unpublishedPosts());
	                } else {
	                    // otherwise, back to where we came
	                    location.replace(document.referrer);
	                }
	            }
	        }, [
	            props.finishedRedirect,
	            hasPosted,
	            newPostState,
	            projectHandle,
	            props,
	            postId,
	        ]);

	        const postToast = reactExports.useRef();

	        reactExports.useEffect(() => {
	            const subscription = service.subscribe((state) => {
	                // we have to be specific here to avoid creating multiple
	                // toasts.
	                if (
	                    state.matches("posting.startingUpload") &&
	                    !postToast.current
	                ) {
	                    let message = undefined;

	                    switch (newPostState) {
	                        case PostState.Published:
	                            message = "Posting...";
	                            break;
	                        case PostState.Unpublished:
	                            message = "Saving...";
	                            break;
	                    }

	                    if (message) {
	                        postToast.current = n$9.loading(message);
	                    }
	                }

	                if (state.matches("posted")) {
	                    // depending on whether newPostState is Published or
	                    // Unpublished, this post is now posted or saved as a draft
	                    let message = undefined;

	                    switch (newPostState) {
	                        case PostState.Published:
	                            message = "Posted!";
	                            break;
	                        case PostState.Unpublished:
	                            message = "Draft saved!";
	                            break;
	                    }

	                    if (message) {
	                        n$9.success(message, {
	                            id: postToast.current,
	                        });
	                    }
	                }

	                if (state.matches("postingFailed")) {
	                    let message = undefined;

	                    switch (newPostState) {
	                        case PostState.Published:
	                            message = "Couldn't post :(";
	                            break;
	                        case PostState.Unpublished:
	                            message = "Couldn't save :(";
	                            break;
	                    }

	                    if (message) {
	                        n$9.error(message, {
	                            id: postToast.current,
	                        });
	                    }
	                }
	            });
	            return () => {
	                subscription.unsubscribe();
	                postToast.current = undefined;
	            };
	        }, [service, newPostState]);

	        const attachmentComposerRef = reactExports.useRef(null);

	        return (
	            React$2.createElement(PostComposerContext.Provider, { value: service,}
	                , activated ? (
	                    React$2.createElement(AttachmentComposerContext$1.Provider, {
	                        value: attachmentComposerRef,}

	                        , React$2.createElement(AttachmentComposer$1, { ref: attachmentComposerRef,} )
	                        , React$2.createElement(PostComposerInner$1, {
	                            project: initialProject,
	                            isModal: props.isModal,
	                            onClose: props.onClose,}
	                        )
	                    )
	                ) : (
	                    React$2.createElement(UnactivatedPostComposer$1, { isModal: props.isModal,} )
	                )
	            )
	        );
	    });
	PostComposer$1.displayName = "PostComposer";

	const UnactivatedPostComposer$1 =
	    React$2.memo(({ isModal = false }) => {
	        useTranslation();

	        const service = reactExports.useContext(PostComposerContext);
	        const { send } = service;

	        const isEditing = useSelector$1(service, selectIsEditing$3);

	        return (
	            React$2.createElement('div', { className: "cohost-shadow-light dark:cohost-shadow-dark prose mx-auto w-full max-w-full rounded-lg bg-notWhite p-3"        ,}
	                , React$2.createElement('p', null, "Since your account isn't activated yet, you can share this post but can't add anything to it. You can read more about this on"


	                     , " "
	                    , React$2.createElement('a', {
	                        href: "https://help.antisoftware.club/support/solutions/articles/62000224749-details-on-invites-and-the-restrictions-on-un-activated-accounts/",
	                        target: "_blank",
	                        rel: "noreferrer",}
	, "our support site."

	                    )
	                )
	                , React$2.createElement(AuthnButton, {
	                    as: "button",
	                    onClick: () => send({ type: "SUBMIT_POST" }),
	                    disabled: !isEditing,}
	, "share post"

	                )
	            )
	        );
	    });
	UnactivatedPostComposer$1.displayName = "UnactivatedPostComposer";

	const PostComposerInner$1



	 = React$2.memo(({ project: initialProject, isModal = false, onClose }) => {
	    const { t } = useTranslation();
	    const service = reactExports.useContext(PostComposerContext);
	    const { send } = service;

	    const hasCohostPlus = useHasCohostPlus();

	    const { projects } = useEditedProjects();

	    const hasErrors = useSelector$1(service, selectHasErrors$1);
	    const errors = useSelector$1(service, selectErrors$1);
	    const isEditing = useSelector$1(service, selectIsEditing$3);
	    const canCollapseCws = useSelector$1(service, selectCanCollapseCws);
	    const maxAttachmentsChosen = useSelector$1(
	        service,
	        selectMaxAttachmentsChosen$1
	    );
	    const newPostState = useSelector$1(service, selectNewPostState$1);
	    const projectHandle = useSelector$1(service, selectProjectHandle$1);
	    const adultContent = useSelector$1(service, selectAdultContent$1);
	    const isTransparentShare = useSelector$1(service, selectIsTransparentShare);
	    const editingTransparentShare = useSelector$1(
	        service,
	        selectEditingTransparentShare$1
	    );
	    const currentProject = reactExports.useMemo(() => {
	        const project = projects.find(
	            (project) => project.handle === projectHandle
	        );
	        if (project) {
	            return project;
	        }
	        return initialProject;
	    }, [projectHandle, projects, initialProject]);
	    const pinnedTags = currentProject.frequentlyUsedTags;
	    const recentlyUsedTags = trpc.projects.listRecentlyUsedTags.useQuery({
	        projectId: currentProject.projectId,
	    });

	    const toggleEditingCws = reactExports.useCallback(() => {
	        send({
	            type: "TOGGLE_CWS_INPUT",
	        });
	    }, [send]);

	    const setNewPostState = reactExports.useCallback(
	        (newPostState) => {
	            send({
	                type: "SET_POST_STATE",
	                newPostState,
	            });
	        },
	        [send]
	    );

	    const postStates = [
	        {
	            postState: PostState.Published,
	            string: t("client:post-editor.post-now", "post now"),
	        },
	        {
	            postState: PostState.Unpublished,
	            string: t("client:post-editor.save-as-draft", "save draft"),
	        },
	    ];

	    const textAreaRef = reactExports.useRef(null);

	    const dynamicTheme = useDynamicTheme();

	    const onSelectEmoji = reactExports.useCallback(
	        (emoji) => {
	            console.log(textAreaRef.current);
	            if (textAreaRef.current) {
	                const [start, end] = [
	                    textAreaRef.current.selectionStart,
	                    textAreaRef.current.selectionEnd,
	                ];

	                console.log(emoji);

	                textAreaRef.current.setRangeText(
	                    emoji.native ?? emoji.shortcodes,
	                    start,
	                    end,
	                    "end"
	                );

	                send({
	                    type: "BODY_INPUT",
	                    body: textAreaRef.current.value,
	                });
	            }
	        },
	        [send]
	    );

	    const onKeyDown = reactExports.useCallback(
	        (ev) => {
	            if ((ev.metaKey || ev.ctrlKey) && ev.key === "Enter") {
	                ev.preventDefault();
	                send({ type: "SUBMIT_POST" });
	            }
	        },
	        [send]
	    );

	    const onPaste = reactExports.useCallback(
	        (ev) => {
	            const items = ev.clipboardData?.items ?? [];
	            const file = Array.from(items)
	                .filter((item) => item.type.indexOf("image") > -1)
	                .map((item) => item.getAsFile())
	                .filter(isDefined)[0];
	            if (file) {
	                console.log("file size:", file.size / 1024 / 1024, "MB");
	                send({ type: "SELECT_FILE", file });
	                ev.preventDefault();
	                return;
	            }
	        },
	        [send]
	    );

	    reactExports.useEffect(() => {
	        window.document.addEventListener("paste", onPaste);
	        return () => {
	            window.document.removeEventListener("paste", onPaste);
	        };
	    }, [onPaste]);

	    return (
	        // intentionally ignoring this one; just adding a keyboard shortcut for
	        // submitting comments, which is accessible in other ways
	        // eslint-disable-next-line jsx-a11y/no-static-element-interactions
	        React$2.createElement('div', { onKeyDown: onKeyDown,}
	            , React$2.createElement(ErrorBoundary, null
	                , React$2.createElement(LazyDnD, null
	                    , hasErrors ? (
	                        React$2.createElement('div', { className: "mx-auto mb-6 max-w-lg border-2 border-red-700 bg-red-300 p-3 text-notBlack"       ,}
	                            , React$2.createElement('h1', { className: "text-lg font-bold" ,}
	                                , t(
	                                    "client:post-editor.validation-errors",
	                                    "There were some errors:"
	                                )
	                            )
	                            , React$2.createElement('ul', { className: "list-inside list-disc" ,}
	                                , errors.map(([, error]) => (
	                                    React$2.createElement('li', { key: error,}, t(error))
	                                ))
	                            )
	                        )
	                    ) : null
	                    , React$2.createElement('div', { className: "flex flex-row justify-center gap-6"   ,}
	                        , React$2.createElement(ProjectAvatar, { project: currentProject, noLink: true,} )
	                        , React$2.createElement('div', { className: "flex flex-1 flex-col gap-4"   ,}
	                            /* we use `w-screen` here to force the box to use
	                                as much space as possible, fixing the issue where
	                                it resizes while typing. `max-w-prose` prevents
	                                it from overflowing. */
	                            , React$2.createElement('article', {
	                                className: "co-themed-box co-post-box co-post-composer"  ,
	                                'data-theme': dynamicTheme.current,}

	                                , React$2.createElement('header', { className: "co-thread-header",}
	                                    , React$2.createElement('div', { className: "flex flex-row items-center gap-2"   ,}
	                                        , React$2.createElement(ProjectAvatar, {
	                                            project: currentProject,
	                                            hideLock: true,
	                                            className: "h-8 w-8 lg:hidden"  ,
	                                            noLink: true,}
	                                        )
	                                        , React$2.createElement('span', {
	                                            className: tw`co-ui-text relative font-atkinson font-bold`,}

	                                            , React$2.createElement(Ht$1, {
	                                                value: currentProject.handle,
	                                                onChange: (projectHandle) => {
	                                                    send({
	                                                        type: "CHANGE_PROJECT",
	                                                        projectHandle,
	                                                    });
	                                                },}

	                                                , React$2.createElement(Ht$1.Button, {
	                                                    className: "font-atkinson font-bold" ,
	                                                    'data-testId': "posting-as-project",}

	                                                    , ({
	                                                        open,
	                                                    }

	) => (
	                                                        React$2.createElement(React$2.Fragment, null
	                                                            , 
	                                                                currentProject.handle
	                                                            , " "
	                                                            , React$2.createElement(ForwardRef$12, {
	                                                                className: `inline-block h-4 w-4 transition-transform ${
                                                                    open
                                                                        ? "rotate-180"
                                                                        : "rotate-0"
                                                                }`,}
	                                                            )
	                                                        )
	                                                    )
	                                                )
	                                                , React$2.createElement(Ht$1.Options, { className: "cohost-shadow-light absolute left-0 top-full z-10 mt-1 flex min-w-max flex-col divide-y divide-foreground-400 rounded-lg font-normal leading-none text-notWhite"              ,}
	                                                    , projects.map((project) => (
	                                                        React$2.createElement(Ht$1.Option, {
	                                                            key: project.handle,
	                                                            value: 
	                                                                project.handle
	                                                            ,
	                                                            className: `relative cursor-default select-none bg-foreground py-2 pl-8 pr-2 first:rounded-t-lg last:rounded-b-lg hover:bg-foreground-600`,}

	                                                            , ({
	                                                                selected,
	                                                            }

	) => (
	                                                                React$2.createElement(React$2.Fragment, null
	                                                                    , React$2.createElement('span', { className: "block",}
	                                                                        , 
	                                                                            project.handle
	                                                                        
	                                                                    )
	                                                                    , selected ? (
	                                                                        React$2.createElement('span', { className: "absolute inset-y-0 left-0 flex items-center pl-2"     ,}
	                                                                            , React$2.createElement(ForwardRef$15, { className: "h-4 w-4" ,} )
	                                                                        )
	                                                                    ) : null
	                                                                )
	                                                            )
	                                                        )
	                                                    ))
	                                                )
	                                            )
	                                        )
	                                    )
	                                    , React$2.createElement('div', { className: "flex flex-row items-center gap-2"   ,}
	                                        , React$2.createElement('label', { className: "flex flex-row items-center gap-2"   ,}
	                                            , React$2.createElement('span', {
	                                                className: tw`co-ui-text select-none`,}

	                                                , t(
	                                                    "client:post-editor.adult-content",
	                                                    "18+ content?"
	                                                )
	                                            )
	                                            , React$2.createElement('input', {
	                                                type: "checkbox",
	                                                name: "adultContent",
	                                                className: tw`rounded border-2 disabled:cursor-not-allowed`,
	                                                // visually display false if
	                                                // it's a transparent share,
	                                                // since it will be processed in
	                                                // that direction on the server.
	                                                checked: 
	                                                    !isTransparentShare &&
	                                                    adultContent
	                                                ,
	                                                onChange: (e) =>
	                                                    send({
	                                                        type: "SET_ADULT_CONTENT",
	                                                        adultContent:
	                                                            e.currentTarget
	                                                                .checked,
	                                                    })
	                                                ,
	                                                disabled: 
	                                                    isTransparentShare ||
	                                                    !isEditing
	                                                ,}
	                                            )
	                                        )
	                                        , isModal ? (
	                                            React$2.createElement(ForwardRef$C, {
	                                                className: tw`co-link-button h-6 w-6 cursor-pointer`,
	                                                onClick: onClose,}
	                                            )
	                                        ) : null

	                                        /* <EllipsisHorizontalIcon className="h-6 w-6 text-notBlack" /> */
	                                    )
	                                )
	                                , React$2.createElement('hr', { className: "co-hairline",} )
	                                , React$2.createElement(rt$1.Group, null
	                                    , React$2.createElement(rt$1.Panels, null
	                                        , React$2.createElement(rt$1.Panel, null
	                                            , React$2.createElement(EditingPanel$1, {
	                                                textAreaRef: textAreaRef,}
	                                            )
	                                        )
	                                        , React$2.createElement(rt$1.Panel, null
	                                            , React$2.createElement(PostComposerPreview$1, null )
	                                        )
	                                    )
	                                    , React$2.createElement('hr', { className: "co-hairline",} )
	                                    , React$2.createElement('footer', {
	                                        className: tw`co-thread-footer w-full max-w-full rounded-b-lg p-3`,}

	                                        , React$2.createElement('div', { className: "flex items-center justify-between"  ,}
	                                            , React$2.createElement('div', { className: "flex items-center gap-1 md:gap-2"   ,}
	                                                , React$2.createElement(FilePicker, {
	                                                    onFilesPicked: (files) =>
	                                                        send({
	                                                            type: "SELECT_FILE",
	                                                            file: files[0],
	                                                        })
	                                                    ,}

	                                                    , React$2.createElement('button', {
	                                                        disabled: 
	                                                            !isEditing ||
	                                                            maxAttachmentsChosen ||
	                                                            editingTransparentShare
	                                                        ,
	                                                        className: tw`co-link-button disabled:cursor-not-allowed`,
	                                                        title: "attach images or audio"   ,}

	                                                        , React$2.createElement(ForwardRef$13, { className: "inline-block h-6" ,} )
	                                                    )
	                                                )
	                                                , React$2.createElement('button', {
	                                                    disabled: 
	                                                        isTransparentShare ||
	                                                        !isEditing ||
	                                                        !canCollapseCws
	                                                    ,
	                                                    onClick: toggleEditingCws,
	                                                    className: tw`co-link-button disabled:cursor-not-allowed`,
	                                                    title: "add a content warning"   ,}

	                                                    , React$2.createElement(ForwardRef$P, { className: "inline-block h-6" ,} )
	                                                )

	                                                , React$2.createElement(EmojiButton, {
	                                                    onSelectEmoji: 
	                                                        onSelectEmoji
	                                                    ,
	                                                    disabled: !isEditing,
	                                                    hasCohostPlus: 
	                                                        !!hasCohostPlus
	                                                    ,}
	                                                )
	                                                /* markdown button */
	                                                , React$2.createElement('a', {
	                                                    href: sitemap.public
	                                                        .staticContent({
	                                                            slug: "markdown-reference",
	                                                        })
	                                                        .toString(),
	                                                    target: "_blank",
	                                                    rel: "noreferrer",
	                                                    className: tw`co-link-button`,
	                                                    title: "markdown reference" ,}

	                                                    , React$2.createElement(ForwardRef$V, { className: "inline-block h-6" ,} )
	                                                )
	                                            )
	                                            , React$2.createElement(rt$1.List, {
	                                                className: tw`co-tab-bar flex items-center rounded-lg text-sm leading-none`,}

	                                                , React$2.createElement(rt$1, {
	                                                    className: ({ selected }) =>
	                                                        selected
	                                                            ? tw`co-tab-bar co-active rounded-lg px-2 py-2 md:px-3`
	                                                            : `px-2 py-2 md:px-3`
	                                                    ,}

	                                                    , t(
	                                                        "client:post-editor.compose-tab",
	                                                        "compose"
	                                                    )
	                                                )
	                                                , React$2.createElement(rt$1, {
	                                                    className: ({ selected }) =>
	                                                        selected
	                                                            ? tw`co-tab-bar co-active rounded-lg px-2 py-2 md:px-3`
	                                                            : `px-2 py-2 md:px-3`
	                                                    ,}

	                                                    , t(
	                                                        "client:post-editor.preview-tab",
	                                                        "preview"
	                                                    )
	                                                )
	                                            )
	                                            , React$2.createElement('div', { className: "relative inline-flex items-stretch rounded-lg text-sm text-text"     ,}
	                                                , React$2.createElement('button', {
	                                                    className: tw`co-filled-button rounded-l-lg border-r border-r-gray-500 py-2 pl-2 pr-1 leading-none`,
	                                                    onClick: () =>
	                                                        send({
	                                                            type: "SUBMIT_POST",
	                                                        })
	                                                    ,}

	                                                    , newPostState ===
	                                                    PostState.Published
	                                                        ? t(
	                                                              "client:post-editor.post-now",
	                                                              "post now"
	                                                          )
	                                                        : newPostState ===
	                                                          PostState.Unpublished
	                                                        ? t(
	                                                              "client:post-editor.save-as-draft",
	                                                              "save draft"
	                                                          )
	                                                        : null
	                                                )
	                                                , React$2.createElement(Ht$1, {
	                                                    value: newPostState,
	                                                    onChange: setNewPostState,}

	                                                    , React$2.createElement(Ht$1.Button, null
	                                                        , ({
	                                                            open,
	                                                        }

	) => (
	                                                            React$2.createElement('div', {
	                                                                className: tw`co-filled-button rounded-r-lg py-2 pl-1 pr-2 leading-none`,}

	                                                                , React$2.createElement(ForwardRef$12, {
	                                                                    className: `inline-block h-4 w-4 transition-transform ${
                                                                        open
                                                                            ? "rotate-180"
                                                                            : "rotate-0"
                                                                    }`,}
	                                                                )
	                                                            )
	                                                        )
	                                                    )
	                                                    , React$2.createElement(Ht$1.Options, { className: "cohost-shadow-light absolute right-0 top-full mt-1 flex min-w-max flex-col divide-y divide-foreground-400 rounded-lg leading-none"           ,}
	                                                        , postStates.map(
	                                                            ({
	                                                                postState,
	                                                                string,
	                                                            }) => (
	                                                                React$2.createElement(Ht$1.Option, {
	                                                                    key: 
	                                                                        postState
	                                                                    ,
	                                                                    value: 
	                                                                        postState
	                                                                    ,
	                                                                    className: tw`co-filled-button relative cursor-default select-none py-2 pl-8 pr-2 first:rounded-t-lg last:rounded-b-lg`,}

	                                                                    , ({
	                                                                        selected,
	                                                                    }

	) => (
	                                                                        React$2.createElement(React$2.Fragment, null
	                                                                            , React$2.createElement('span', { className: "block",}
	                                                                                , 
	                                                                                    string
	                                                                                
	                                                                            )
	                                                                            , selected ? (
	                                                                                React$2.createElement('span', { className: "absolute inset-y-0 left-0 flex items-center pl-2"     ,}
	                                                                                    , React$2.createElement(ForwardRef$15, { className: "h-4 w-4" ,} )
	                                                                                )
	                                                                            ) : null
	                                                                        )
	                                                                    )
	                                                                )
	                                                            )
	                                                        )
	                                                    )
	                                                )
	                                            )
	                                        )
	                                    )
	                                )
	                            )
	                            , pinnedTags.length > 0 ? (
	                                React$2.createElement(TagRecommendationBox$1, {
	                                    categoryTitle: "pinned tags" ,
	                                    stateId: "pinned",
	                                    tags: pinnedTags,}
	                                )
	                            ) : null
	                            , recentlyUsedTags.data?.tags ? (
	                                React$2.createElement(TagRecommendationBox$1, {
	                                    categoryTitle: "recently used tags"  ,
	                                    stateId: "recently-used",
	                                    tags: recentlyUsedTags.data?.tags,}
	                                )
	                            ) : null
	                            , hasCohostPlus ? (
	                                React$2.createElement('p', { className: "max-w-prose",}, "As a cohost Plus! member, your attachment size upload limit is now 10mb! Go crazy, but keep in mind larger attachments might take a while to upload."




	                                )
	                            ) : null
	                        )
	                    )
	                )
	            )
	        )
	    );
	});
	PostComposerInner$1.displayName = "PostComposerInner";

	var slicedToArray = {exports: {}};

	var arrayWithHoles = {exports: {}};

	(function (module) {
		function _arrayWithHoles(arr) {
		  if (Array.isArray(arr)) return arr;
		}
		module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports; 
	} (arrayWithHoles));

	var arrayWithHolesExports = arrayWithHoles.exports;

	var iterableToArrayLimit = {exports: {}};

	(function (module) {
		function _iterableToArrayLimit(r, l) {
		  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
		  if (null != t) {
		    var e,
		      n,
		      i,
		      u,
		      a = [],
		      f = !0,
		      o = !1;
		    try {
		      if (i = (t = t.call(r)).next, 0 === l) {
		        if (Object(t) !== t) return;
		        f = !1;
		      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
		    } catch (r) {
		      o = !0, n = r;
		    } finally {
		      try {
		        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
		      } finally {
		        if (o) throw n;
		      }
		    }
		    return a;
		  }
		}
		module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports; 
	} (iterableToArrayLimit));

	var iterableToArrayLimitExports = iterableToArrayLimit.exports;

	var unsupportedIterableToArray = {exports: {}};

	var arrayLikeToArray = {exports: {}};

	(function (module) {
		function _arrayLikeToArray(arr, len) {
		  if (len == null || len > arr.length) len = arr.length;
		  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
		  return arr2;
		}
		module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports; 
	} (arrayLikeToArray));

	var arrayLikeToArrayExports = arrayLikeToArray.exports;

	(function (module) {
		var arrayLikeToArray = arrayLikeToArrayExports;
		function _unsupportedIterableToArray(o, minLen) {
		  if (!o) return;
		  if (typeof o === "string") return arrayLikeToArray(o, minLen);
		  var n = Object.prototype.toString.call(o).slice(8, -1);
		  if (n === "Object" && o.constructor) n = o.constructor.name;
		  if (n === "Map" || n === "Set") return Array.from(o);
		  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);
		}
		module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports; 
	} (unsupportedIterableToArray));

	var unsupportedIterableToArrayExports = unsupportedIterableToArray.exports;

	var nonIterableRest = {exports: {}};

	(function (module) {
		function _nonIterableRest() {
		  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
		}
		module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports; 
	} (nonIterableRest));

	var nonIterableRestExports = nonIterableRest.exports;

	(function (module) {
		var arrayWithHoles = arrayWithHolesExports;
		var iterableToArrayLimit = iterableToArrayLimitExports;
		var unsupportedIterableToArray = unsupportedIterableToArrayExports;
		var nonIterableRest = nonIterableRestExports;
		function _slicedToArray(arr, i) {
		  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
		}
		module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports; 
	} (slicedToArray));

	var slicedToArrayExports = slicedToArray.exports;
	var _slicedToArray = /*@__PURE__*/getDefaultExportFromCjs(slicedToArrayExports);

	/**
	 * Reorder a provided `list`
	 * Returns a new array and does not modify the original array
	 */
	function reorder(_ref) {
	  var list = _ref.list,
	    startIndex = _ref.startIndex,
	    finishIndex = _ref.finishIndex;
	  if (startIndex === -1 || finishIndex === -1) {
	    return list;
	  }
	  var result = Array.from(list);
	  var _result$splice = result.splice(startIndex, 1),
	    _result$splice2 = _slicedToArray(_result$splice, 1),
	    removed = _result$splice2[0];
	  result.splice(finishIndex, 0, removed);
	  return result;
	}

	// src/utils/env.ts
	var NOTHING = Symbol.for("immer-nothing");
	var DRAFTABLE = Symbol.for("immer-draftable");
	var DRAFT_STATE = Symbol.for("immer-state");
	function die(error, ...args) {
	  throw new Error(
	    `[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`
	  );
	}

	// src/utils/common.ts
	var getPrototypeOf = Object.getPrototypeOf;
	function isDraft(value) {
	  return !!value && !!value[DRAFT_STATE];
	}
	function isDraftable(value) {
	  if (!value)
	    return false;
	  return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
	}
	var objectCtorString = Object.prototype.constructor.toString();
	function isPlainObject(value) {
	  if (!value || typeof value !== "object")
	    return false;
	  const proto = getPrototypeOf(value);
	  if (proto === null) {
	    return true;
	  }
	  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
	  if (Ctor === Object)
	    return true;
	  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
	}
	function each(obj, iter) {
	  if (getArchtype(obj) === 0 /* Object */) {
	    Reflect.ownKeys(obj).forEach((key) => {
	      iter(key, obj[key], obj);
	    });
	  } else {
	    obj.forEach((entry, index) => iter(index, entry, obj));
	  }
	}
	function getArchtype(thing) {
	  const state = thing[DRAFT_STATE];
	  return state ? state.type_ : Array.isArray(thing) ? 1 /* Array */ : isMap(thing) ? 2 /* Map */ : isSet(thing) ? 3 /* Set */ : 0 /* Object */;
	}
	function has(thing, prop) {
	  return getArchtype(thing) === 2 /* Map */ ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
	}
	function set(thing, propOrOldValue, value) {
	  const t = getArchtype(thing);
	  if (t === 2 /* Map */)
	    thing.set(propOrOldValue, value);
	  else if (t === 3 /* Set */) {
	    thing.add(value);
	  } else
	    thing[propOrOldValue] = value;
	}
	function is(x, y) {
	  if (x === y) {
	    return x !== 0 || 1 / x === 1 / y;
	  } else {
	    return x !== x && y !== y;
	  }
	}
	function isMap(target) {
	  return target instanceof Map;
	}
	function isSet(target) {
	  return target instanceof Set;
	}
	function latest(state) {
	  return state.copy_ || state.base_;
	}
	function shallowCopy(base, strict) {
	  if (isMap(base)) {
	    return new Map(base);
	  }
	  if (isSet(base)) {
	    return new Set(base);
	  }
	  if (Array.isArray(base))
	    return Array.prototype.slice.call(base);
	  if (!strict && isPlainObject(base)) {
	    if (!getPrototypeOf(base)) {
	      const obj = /* @__PURE__ */ Object.create(null);
	      return Object.assign(obj, base);
	    }
	    return { ...base };
	  }
	  const descriptors = Object.getOwnPropertyDescriptors(base);
	  delete descriptors[DRAFT_STATE];
	  let keys = Reflect.ownKeys(descriptors);
	  for (let i = 0; i < keys.length; i++) {
	    const key = keys[i];
	    const desc = descriptors[key];
	    if (desc.writable === false) {
	      desc.writable = true;
	      desc.configurable = true;
	    }
	    if (desc.get || desc.set)
	      descriptors[key] = {
	        configurable: true,
	        writable: true,
	        // could live with !!desc.set as well here...
	        enumerable: desc.enumerable,
	        value: base[key]
	      };
	  }
	  return Object.create(getPrototypeOf(base), descriptors);
	}
	function freeze(obj, deep = false) {
	  if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj))
	    return obj;
	  if (getArchtype(obj) > 1) {
	    obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections;
	  }
	  Object.freeze(obj);
	  if (deep)
	    Object.entries(obj).forEach(([key, value]) => freeze(value, true));
	  return obj;
	}
	function dontMutateFrozenCollections() {
	  die(2);
	}
	function isFrozen(obj) {
	  return Object.isFrozen(obj);
	}

	// src/utils/plugins.ts
	var plugins = {};
	function getPlugin(pluginKey) {
	  const plugin = plugins[pluginKey];
	  if (!plugin) {
	    die(0, pluginKey);
	  }
	  return plugin;
	}

	// src/core/scope.ts
	var currentScope;
	function getCurrentScope() {
	  return currentScope;
	}
	function createScope(parent_, immer_) {
	  return {
	    drafts_: [],
	    parent_,
	    immer_,
	    // Whenever the modified draft contains a draft from another scope, we
	    // need to prevent auto-freezing so the unowned draft can be finalized.
	    canAutoFreeze_: true,
	    unfinalizedDrafts_: 0
	  };
	}
	function usePatchesInScope(scope, patchListener) {
	  if (patchListener) {
	    getPlugin("Patches");
	    scope.patches_ = [];
	    scope.inversePatches_ = [];
	    scope.patchListener_ = patchListener;
	  }
	}
	function revokeScope(scope) {
	  leaveScope(scope);
	  scope.drafts_.forEach(revokeDraft);
	  scope.drafts_ = null;
	}
	function leaveScope(scope) {
	  if (scope === currentScope) {
	    currentScope = scope.parent_;
	  }
	}
	function enterScope(immer2) {
	  return currentScope = createScope(currentScope, immer2);
	}
	function revokeDraft(draft) {
	  const state = draft[DRAFT_STATE];
	  if (state.type_ === 0 /* Object */ || state.type_ === 1 /* Array */)
	    state.revoke_();
	  else
	    state.revoked_ = true;
	}

	// src/core/finalize.ts
	function processResult(result, scope) {
	  scope.unfinalizedDrafts_ = scope.drafts_.length;
	  const baseDraft = scope.drafts_[0];
	  const isReplaced = result !== void 0 && result !== baseDraft;
	  if (isReplaced) {
	    if (baseDraft[DRAFT_STATE].modified_) {
	      revokeScope(scope);
	      die(4);
	    }
	    if (isDraftable(result)) {
	      result = finalize(scope, result);
	      if (!scope.parent_)
	        maybeFreeze(scope, result);
	    }
	    if (scope.patches_) {
	      getPlugin("Patches").generateReplacementPatches_(
	        baseDraft[DRAFT_STATE].base_,
	        result,
	        scope.patches_,
	        scope.inversePatches_
	      );
	    }
	  } else {
	    result = finalize(scope, baseDraft, []);
	  }
	  revokeScope(scope);
	  if (scope.patches_) {
	    scope.patchListener_(scope.patches_, scope.inversePatches_);
	  }
	  return result !== NOTHING ? result : void 0;
	}
	function finalize(rootScope, value, path) {
	  if (isFrozen(value))
	    return value;
	  const state = value[DRAFT_STATE];
	  if (!state) {
	    each(
	      value,
	      (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path)
	    );
	    return value;
	  }
	  if (state.scope_ !== rootScope)
	    return value;
	  if (!state.modified_) {
	    maybeFreeze(rootScope, state.base_, true);
	    return state.base_;
	  }
	  if (!state.finalized_) {
	    state.finalized_ = true;
	    state.scope_.unfinalizedDrafts_--;
	    const result = state.copy_;
	    let resultEach = result;
	    let isSet2 = false;
	    if (state.type_ === 3 /* Set */) {
	      resultEach = new Set(result);
	      result.clear();
	      isSet2 = true;
	    }
	    each(
	      resultEach,
	      (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2)
	    );
	    maybeFreeze(rootScope, result, false);
	    if (path && rootScope.patches_) {
	      getPlugin("Patches").generatePatches_(
	        state,
	        path,
	        rootScope.patches_,
	        rootScope.inversePatches_
	      );
	    }
	  }
	  return state.copy_;
	}
	function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
	  if (isDraft(childValue)) {
	    const path = rootPath && parentState && parentState.type_ !== 3 /* Set */ && // Set objects are atomic since they have no keys.
	    !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0;
	    const res = finalize(rootScope, childValue, path);
	    set(targetObject, prop, res);
	    if (isDraft(res)) {
	      rootScope.canAutoFreeze_ = false;
	    } else
	      return;
	  } else if (targetIsSet) {
	    targetObject.add(childValue);
	  }
	  if (isDraftable(childValue) && !isFrozen(childValue)) {
	    if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) {
	      return;
	    }
	    finalize(rootScope, childValue);
	    if ((!parentState || !parentState.scope_.parent_) && typeof prop !== "symbol" && Object.prototype.propertyIsEnumerable.call(targetObject, prop))
	      maybeFreeze(rootScope, childValue);
	  }
	}
	function maybeFreeze(scope, value, deep = false) {
	  if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) {
	    freeze(value, deep);
	  }
	}

	// src/core/proxy.ts
	function createProxyProxy(base, parent) {
	  const isArray = Array.isArray(base);
	  const state = {
	    type_: isArray ? 1 /* Array */ : 0 /* Object */,
	    // Track which produce call this is associated with.
	    scope_: parent ? parent.scope_ : getCurrentScope(),
	    // True for both shallow and deep changes.
	    modified_: false,
	    // Used during finalization.
	    finalized_: false,
	    // Track which properties have been assigned (true) or deleted (false).
	    assigned_: {},
	    // The parent draft state.
	    parent_: parent,
	    // The base state.
	    base_: base,
	    // The base proxy.
	    draft_: null,
	    // set below
	    // The base copy with any updated values.
	    copy_: null,
	    // Called by the `produce` function.
	    revoke_: null,
	    isManual_: false
	  };
	  let target = state;
	  let traps = objectTraps;
	  if (isArray) {
	    target = [state];
	    traps = arrayTraps;
	  }
	  const { revoke, proxy } = Proxy.revocable(target, traps);
	  state.draft_ = proxy;
	  state.revoke_ = revoke;
	  return proxy;
	}
	var objectTraps = {
	  get(state, prop) {
	    if (prop === DRAFT_STATE)
	      return state;
	    const source = latest(state);
	    if (!has(source, prop)) {
	      return readPropFromProto(state, source, prop);
	    }
	    const value = source[prop];
	    if (state.finalized_ || !isDraftable(value)) {
	      return value;
	    }
	    if (value === peek(state.base_, prop)) {
	      prepareCopy(state);
	      return state.copy_[prop] = createProxy(value, state);
	    }
	    return value;
	  },
	  has(state, prop) {
	    return prop in latest(state);
	  },
	  ownKeys(state) {
	    return Reflect.ownKeys(latest(state));
	  },
	  set(state, prop, value) {
	    const desc = getDescriptorFromProto(latest(state), prop);
	    if (desc?.set) {
	      desc.set.call(state.draft_, value);
	      return true;
	    }
	    if (!state.modified_) {
	      const current2 = peek(latest(state), prop);
	      const currentState = current2?.[DRAFT_STATE];
	      if (currentState && currentState.base_ === value) {
	        state.copy_[prop] = value;
	        state.assigned_[prop] = false;
	        return true;
	      }
	      if (is(value, current2) && (value !== void 0 || has(state.base_, prop)))
	        return true;
	      prepareCopy(state);
	      markChanged(state);
	    }
	    if (state.copy_[prop] === value && // special case: handle new props with value 'undefined'
	    (value !== void 0 || prop in state.copy_) || // special case: NaN
	    Number.isNaN(value) && Number.isNaN(state.copy_[prop]))
	      return true;
	    state.copy_[prop] = value;
	    state.assigned_[prop] = true;
	    return true;
	  },
	  deleteProperty(state, prop) {
	    if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
	      state.assigned_[prop] = false;
	      prepareCopy(state);
	      markChanged(state);
	    } else {
	      delete state.assigned_[prop];
	    }
	    if (state.copy_) {
	      delete state.copy_[prop];
	    }
	    return true;
	  },
	  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
	  // the same guarantee in ES5 mode.
	  getOwnPropertyDescriptor(state, prop) {
	    const owner = latest(state);
	    const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
	    if (!desc)
	      return desc;
	    return {
	      writable: true,
	      configurable: state.type_ !== 1 /* Array */ || prop !== "length",
	      enumerable: desc.enumerable,
	      value: owner[prop]
	    };
	  },
	  defineProperty() {
	    die(11);
	  },
	  getPrototypeOf(state) {
	    return getPrototypeOf(state.base_);
	  },
	  setPrototypeOf() {
	    die(12);
	  }
	};
	var arrayTraps = {};
	each(objectTraps, (key, fn) => {
	  arrayTraps[key] = function() {
	    arguments[0] = arguments[0][0];
	    return fn.apply(this, arguments);
	  };
	});
	arrayTraps.deleteProperty = function(state, prop) {
	  return arrayTraps.set.call(this, state, prop, void 0);
	};
	arrayTraps.set = function(state, prop, value) {
	  return objectTraps.set.call(this, state[0], prop, value, state[0]);
	};
	function peek(draft, prop) {
	  const state = draft[DRAFT_STATE];
	  const source = state ? latest(state) : draft;
	  return source[prop];
	}
	function readPropFromProto(state, source, prop) {
	  const desc = getDescriptorFromProto(source, prop);
	  return desc ? `value` in desc ? desc.value : (
	    // This is a very special case, if the prop is a getter defined by the
	    // prototype, we should invoke it with the draft as context!
	    desc.get?.call(state.draft_)
	  ) : void 0;
	}
	function getDescriptorFromProto(source, prop) {
	  if (!(prop in source))
	    return void 0;
	  let proto = getPrototypeOf(source);
	  while (proto) {
	    const desc = Object.getOwnPropertyDescriptor(proto, prop);
	    if (desc)
	      return desc;
	    proto = getPrototypeOf(proto);
	  }
	  return void 0;
	}
	function markChanged(state) {
	  if (!state.modified_) {
	    state.modified_ = true;
	    if (state.parent_) {
	      markChanged(state.parent_);
	    }
	  }
	}
	function prepareCopy(state) {
	  if (!state.copy_) {
	    state.copy_ = shallowCopy(
	      state.base_,
	      state.scope_.immer_.useStrictShallowCopy_
	    );
	  }
	}

	// src/core/immerClass.ts
	var Immer2 = class {
	  constructor(config) {
	    this.autoFreeze_ = true;
	    this.useStrictShallowCopy_ = false;
	    /**
	     * The `produce` function takes a value and a "recipe function" (whose
	     * return value often depends on the base state). The recipe function is
	     * free to mutate its first argument however it wants. All mutations are
	     * only ever applied to a __copy__ of the base state.
	     *
	     * Pass only a function to create a "curried producer" which relieves you
	     * from passing the recipe function every time.
	     *
	     * Only plain objects and arrays are made mutable. All other objects are
	     * considered uncopyable.
	     *
	     * Note: This function is __bound__ to its `Immer` instance.
	     *
	     * @param {any} base - the initial state
	     * @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified
	     * @param {Function} patchListener - optional function that will be called with all the patches produced here
	     * @returns {any} a new state, or the initial state if nothing was modified
	     */
	    this.produce = (base, recipe, patchListener) => {
	      if (typeof base === "function" && typeof recipe !== "function") {
	        const defaultBase = recipe;
	        recipe = base;
	        const self = this;
	        return function curriedProduce(base2 = defaultBase, ...args) {
	          return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
	        };
	      }
	      if (typeof recipe !== "function")
	        die(6);
	      if (patchListener !== void 0 && typeof patchListener !== "function")
	        die(7);
	      let result;
	      if (isDraftable(base)) {
	        const scope = enterScope(this);
	        const proxy = createProxy(base, void 0);
	        let hasError = true;
	        try {
	          result = recipe(proxy);
	          hasError = false;
	        } finally {
	          if (hasError)
	            revokeScope(scope);
	          else
	            leaveScope(scope);
	        }
	        usePatchesInScope(scope, patchListener);
	        return processResult(result, scope);
	      } else if (!base || typeof base !== "object") {
	        result = recipe(base);
	        if (result === void 0)
	          result = base;
	        if (result === NOTHING)
	          result = void 0;
	        if (this.autoFreeze_)
	          freeze(result, true);
	        if (patchListener) {
	          const p = [];
	          const ip = [];
	          getPlugin("Patches").generateReplacementPatches_(base, result, p, ip);
	          patchListener(p, ip);
	        }
	        return result;
	      } else
	        die(1, base);
	    };
	    this.produceWithPatches = (base, recipe) => {
	      if (typeof base === "function") {
	        return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
	      }
	      let patches, inversePatches;
	      const result = this.produce(base, recipe, (p, ip) => {
	        patches = p;
	        inversePatches = ip;
	      });
	      return [result, patches, inversePatches];
	    };
	    if (typeof config?.autoFreeze === "boolean")
	      this.setAutoFreeze(config.autoFreeze);
	    if (typeof config?.useStrictShallowCopy === "boolean")
	      this.setUseStrictShallowCopy(config.useStrictShallowCopy);
	  }
	  createDraft(base) {
	    if (!isDraftable(base))
	      die(8);
	    if (isDraft(base))
	      base = current(base);
	    const scope = enterScope(this);
	    const proxy = createProxy(base, void 0);
	    proxy[DRAFT_STATE].isManual_ = true;
	    leaveScope(scope);
	    return proxy;
	  }
	  finishDraft(draft, patchListener) {
	    const state = draft && draft[DRAFT_STATE];
	    if (!state || !state.isManual_)
	      die(9);
	    const { scope_: scope } = state;
	    usePatchesInScope(scope, patchListener);
	    return processResult(void 0, scope);
	  }
	  /**
	   * Pass true to automatically freeze all copies created by Immer.
	   *
	   * By default, auto-freezing is enabled.
	   */
	  setAutoFreeze(value) {
	    this.autoFreeze_ = value;
	  }
	  /**
	   * Pass true to enable strict shallow copy.
	   *
	   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
	   */
	  setUseStrictShallowCopy(value) {
	    this.useStrictShallowCopy_ = value;
	  }
	  applyPatches(base, patches) {
	    let i;
	    for (i = patches.length - 1; i >= 0; i--) {
	      const patch = patches[i];
	      if (patch.path.length === 0 && patch.op === "replace") {
	        base = patch.value;
	        break;
	      }
	    }
	    if (i > -1) {
	      patches = patches.slice(i + 1);
	    }
	    const applyPatchesImpl = getPlugin("Patches").applyPatches_;
	    if (isDraft(base)) {
	      return applyPatchesImpl(base, patches);
	    }
	    return this.produce(
	      base,
	      (draft) => applyPatchesImpl(draft, patches)
	    );
	  }
	};
	function createProxy(value, parent) {
	  const draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
	  const scope = parent ? parent.scope_ : getCurrentScope();
	  scope.drafts_.push(draft);
	  return draft;
	}

	// src/core/current.ts
	function current(value) {
	  if (!isDraft(value))
	    die(10, value);
	  return currentImpl(value);
	}
	function currentImpl(value) {
	  if (!isDraftable(value) || isFrozen(value))
	    return value;
	  const state = value[DRAFT_STATE];
	  let copy;
	  if (state) {
	    if (!state.modified_)
	      return state.base_;
	    state.finalized_ = true;
	    copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
	  } else {
	    copy = shallowCopy(value, true);
	  }
	  each(copy, (key, childValue) => {
	    set(copy, key, currentImpl(childValue));
	  });
	  if (state) {
	    state.finalized_ = false;
	  }
	  return copy;
	}

	// src/immer.ts
	var immer = new Immer2();
	var produce = immer.produce;
	immer.produceWithPatches.bind(
	  immer
	);
	immer.setAutoFreeze.bind(immer);
	immer.setUseStrictShallowCopy.bind(immer);
	immer.applyPatches.bind(immer);
	immer.createDraft.bind(immer);
	immer.finishDraft.bind(immer);

	// src/devModeChecks/identityFunctionCheck.ts
	function assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {
	  if (typeof func !== "function") {
	    throw new TypeError(errorMessage);
	  }
	}
	function assertIsObject(object, errorMessage = `expected an object, instead received ${typeof object}`) {
	  if (typeof object !== "object") {
	    throw new TypeError(errorMessage);
	  }
	}
	function assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {
	  if (!array.every((item) => typeof item === "function")) {
	    const itemTypes = array.map(
	      (item) => typeof item === "function" ? `function ${item.name || "unnamed"}()` : typeof item
	    ).join(", ");
	    throw new TypeError(`${errorMessage}[${itemTypes}]`);
	  }
	}
	var ensureIsArray = (item) => {
	  return Array.isArray(item) ? item : [item];
	};
	function getDependencies(createSelectorArgs) {
	  const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;
	  assertIsArrayOfFunctions(
	    dependencies,
	    `createSelector expects all input-selectors to be functions, but received the following types: `
	  );
	  return dependencies;
	}
	function collectInputSelectorResults(dependencies, inputSelectorArgs) {
	  const inputSelectorResults = [];
	  const { length } = dependencies;
	  for (let i = 0; i < length; i++) {
	    inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));
	  }
	  return inputSelectorResults;
	}

	// src/weakMapMemoize.ts
	var StrongRef = class {
	  constructor(value) {
	    this.value = value;
	  }
	  deref() {
	    return this.value;
	  }
	};
	var Ref = typeof WeakRef !== "undefined" ? WeakRef : StrongRef;
	var UNTERMINATED = 0;
	var TERMINATED = 1;
	function createCacheNode() {
	  return {
	    s: UNTERMINATED,
	    v: void 0,
	    o: null,
	    p: null
	  };
	}
	function weakMapMemoize(func, options = {}) {
	  let fnNode = createCacheNode();
	  const { resultEqualityCheck } = options;
	  let lastResult;
	  let resultsCount = 0;
	  function memoized() {
	    let cacheNode = fnNode;
	    const { length } = arguments;
	    for (let i = 0, l = length; i < l; i++) {
	      const arg = arguments[i];
	      if (typeof arg === "function" || typeof arg === "object" && arg !== null) {
	        let objectCache = cacheNode.o;
	        if (objectCache === null) {
	          cacheNode.o = objectCache = /* @__PURE__ */ new WeakMap();
	        }
	        const objectNode = objectCache.get(arg);
	        if (objectNode === void 0) {
	          cacheNode = createCacheNode();
	          objectCache.set(arg, cacheNode);
	        } else {
	          cacheNode = objectNode;
	        }
	      } else {
	        let primitiveCache = cacheNode.p;
	        if (primitiveCache === null) {
	          cacheNode.p = primitiveCache = /* @__PURE__ */ new Map();
	        }
	        const primitiveNode = primitiveCache.get(arg);
	        if (primitiveNode === void 0) {
	          cacheNode = createCacheNode();
	          primitiveCache.set(arg, cacheNode);
	        } else {
	          cacheNode = primitiveNode;
	        }
	      }
	    }
	    const terminatedNode = cacheNode;
	    let result;
	    if (cacheNode.s === TERMINATED) {
	      result = cacheNode.v;
	    } else {
	      result = func.apply(null, arguments);
	      resultsCount++;
	    }
	    terminatedNode.s = TERMINATED;
	    if (resultEqualityCheck) {
	      const lastResultValue = lastResult?.deref?.() ?? lastResult;
	      if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {
	        result = lastResultValue;
	        resultsCount !== 0 && resultsCount--;
	      }
	      const needsWeakRef = typeof result === "object" && result !== null || typeof result === "function";
	      lastResult = needsWeakRef ? new Ref(result) : result;
	    }
	    terminatedNode.v = result;
	    return result;
	  }
	  memoized.clearCache = () => {
	    fnNode = createCacheNode();
	    memoized.resetResultsCount();
	  };
	  memoized.resultsCount = () => resultsCount;
	  memoized.resetResultsCount = () => {
	    resultsCount = 0;
	  };
	  return memoized;
	}

	// src/createSelectorCreator.ts
	function createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {
	  const createSelectorCreatorOptions = typeof memoizeOrOptions === "function" ? {
	    memoize: memoizeOrOptions,
	    memoizeOptions: memoizeOptionsFromArgs
	  } : memoizeOrOptions;
	  const createSelector2 = (...createSelectorArgs) => {
	    let recomputations = 0;
	    let dependencyRecomputations = 0;
	    let lastResult;
	    let directlyPassedOptions = {};
	    let resultFunc = createSelectorArgs.pop();
	    if (typeof resultFunc === "object") {
	      directlyPassedOptions = resultFunc;
	      resultFunc = createSelectorArgs.pop();
	    }
	    assertIsFunction(
	      resultFunc,
	      `createSelector expects an output function after the inputs, but received: [${typeof resultFunc}]`
	    );
	    const combinedOptions = {
	      ...createSelectorCreatorOptions,
	      ...directlyPassedOptions
	    };
	    const {
	      memoize,
	      memoizeOptions = [],
	      argsMemoize = weakMapMemoize,
	      argsMemoizeOptions = [],
	      devModeChecks = {}
	    } = combinedOptions;
	    const finalMemoizeOptions = ensureIsArray(memoizeOptions);
	    const finalArgsMemoizeOptions = ensureIsArray(argsMemoizeOptions);
	    const dependencies = getDependencies(createSelectorArgs);
	    const memoizedResultFunc = memoize(function recomputationWrapper() {
	      recomputations++;
	      return resultFunc.apply(
	        null,
	        arguments
	      );
	    }, ...finalMemoizeOptions);
	    const selector = argsMemoize(function dependenciesChecker() {
	      dependencyRecomputations++;
	      const inputSelectorResults = collectInputSelectorResults(
	        dependencies,
	        arguments
	      );
	      lastResult = memoizedResultFunc.apply(null, inputSelectorResults);
	      return lastResult;
	    }, ...finalArgsMemoizeOptions);
	    return Object.assign(selector, {
	      resultFunc,
	      memoizedResultFunc,
	      dependencies,
	      dependencyRecomputations: () => dependencyRecomputations,
	      resetDependencyRecomputations: () => {
	        dependencyRecomputations = 0;
	      },
	      lastResult: () => lastResult,
	      recomputations: () => recomputations,
	      resetRecomputations: () => {
	        recomputations = 0;
	      },
	      memoize,
	      argsMemoize
	    });
	  };
	  Object.assign(createSelector2, {
	    withTypes: () => createSelector2
	  });
	  return createSelector2;
	}
	var createSelector = /* @__PURE__ */ createSelectorCreator(weakMapMemoize);

	// src/createStructuredSelector.ts
	var createStructuredSelector = Object.assign(
	  (inputSelectorsObject, selectorCreator = createSelector) => {
	    assertIsObject(
	      inputSelectorsObject,
	      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof inputSelectorsObject}`
	    );
	    const inputSelectorKeys = Object.keys(inputSelectorsObject);
	    const dependencies = inputSelectorKeys.map(
	      (key) => inputSelectorsObject[key]
	    );
	    const structuredSelector = selectorCreator(
	      dependencies,
	      (...inputSelectorResults) => {
	        return inputSelectorResults.reduce((composition, value, index) => {
	          composition[inputSelectorKeys[index]] = value;
	          return composition;
	        }, {});
	      }
	    );
	    return structuredSelector;
	  },
	  { withTypes: () => createStructuredSelector }
	);

	// src/index.ts
	function createThunkMiddleware(extraArgument) {
	  const middleware = ({ dispatch, getState }) => (next) => (action) => {
	    if (typeof action === "function") {
	      return action(dispatch, getState, extraArgument);
	    }
	    return next(action);
	  };
	  return middleware;
	}
	var thunk = createThunkMiddleware();
	var withExtraArgument = createThunkMiddleware;

	// src/index.ts
	var createDraftSafeSelectorCreator = (...args) => {
	  const createSelector2 = createSelectorCreator(...args);
	  const createDraftSafeSelector2 = Object.assign((...args2) => {
	    const selector = createSelector2(...args2);
	    const wrappedSelector = (value, ...rest) => selector(isDraft(value) ? current(value) : value, ...rest);
	    Object.assign(wrappedSelector, selector);
	    return wrappedSelector;
	  }, {
	    withTypes: () => createDraftSafeSelector2
	  });
	  return createDraftSafeSelector2;
	};
	createDraftSafeSelectorCreator(weakMapMemoize);
	var composeWithDevTools = typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ : function() {
	  if (arguments.length === 0)
	    return void 0;
	  if (typeof arguments[0] === "object")
	    return compose;
	  return compose.apply(null, arguments);
	};

	// src/tsHelpers.ts
	var hasMatchFunction = (v) => {
	  return v && typeof v.match === "function";
	};

	// src/createAction.ts
	function createAction(type, prepareAction) {
	  function actionCreator(...args) {
	    if (prepareAction) {
	      let prepared = prepareAction(...args);
	      if (!prepared) {
	        throw new Error(formatProdErrorMessage(0) );
	      }
	      return {
	        type,
	        payload: prepared.payload,
	        ..."meta" in prepared && {
	          meta: prepared.meta
	        },
	        ..."error" in prepared && {
	          error: prepared.error
	        }
	      };
	    }
	    return {
	      type,
	      payload: args[0]
	    };
	  }
	  actionCreator.toString = () => `${type}`;
	  actionCreator.type = type;
	  actionCreator.match = (action) => isAction(action) && action.type === type;
	  return actionCreator;
	}
	function find(iterable, comparator) {
	  for (const entry of iterable) {
	    if (comparator(entry)) {
	      return entry;
	    }
	  }
	  return void 0;
	}
	var Tuple = class _Tuple extends Array {
	  constructor(...items) {
	    super(...items);
	    Object.setPrototypeOf(this, _Tuple.prototype);
	  }
	  static get [Symbol.species]() {
	    return _Tuple;
	  }
	  concat(...arr) {
	    return super.concat.apply(this, arr);
	  }
	  prepend(...arr) {
	    if (arr.length === 1 && Array.isArray(arr[0])) {
	      return new _Tuple(...arr[0].concat(this));
	    }
	    return new _Tuple(...arr.concat(this));
	  }
	};
	function freezeDraftable(val) {
	  return isDraftable(val) ? produce(val, () => {
	  }) : val;
	}
	function emplace(map, key, handler) {
	  if (map.has(key)) {
	    let value = map.get(key);
	    if (handler.update) {
	      value = handler.update(value, key, map);
	      map.set(key, value);
	    }
	    return value;
	  }
	  if (!handler.insert)
	    throw new Error(formatProdErrorMessage(10) );
	  const inserted = handler.insert(key, map);
	  map.set(key, inserted);
	  return inserted;
	}

	// src/getDefaultMiddleware.ts
	function isBoolean(x) {
	  return typeof x === "boolean";
	}
	var buildGetDefaultMiddleware = () => function getDefaultMiddleware(options) {
	  const {
	    thunk: thunk$1 = true,
	    immutableCheck = true,
	    serializableCheck = true,
	    actionCreatorCheck = true
	  } = options ?? {};
	  let middlewareArray = new Tuple();
	  if (thunk$1) {
	    if (isBoolean(thunk$1)) {
	      middlewareArray.push(thunk);
	    } else {
	      middlewareArray.push(withExtraArgument(thunk$1.extraArgument));
	    }
	  }
	  return middlewareArray;
	};

	// src/autoBatchEnhancer.ts
	var SHOULD_AUTOBATCH = "RTK_autoBatch";
	var createQueueWithTimer = (timeout) => {
	  return (notify) => {
	    setTimeout(notify, timeout);
	  };
	};
	var rAF = typeof window !== "undefined" && window.requestAnimationFrame ? window.requestAnimationFrame : createQueueWithTimer(10);
	var autoBatchEnhancer = (options = {
	  type: "raf"
	}) => (next) => (...args) => {
	  const store = next(...args);
	  let notifying = true;
	  let shouldNotifyAtEndOfTick = false;
	  let notificationQueued = false;
	  const listeners = /* @__PURE__ */ new Set();
	  const queueCallback = options.type === "tick" ? queueMicrotask : options.type === "raf" ? rAF : options.type === "callback" ? options.queueNotification : createQueueWithTimer(options.timeout);
	  const notifyListeners = () => {
	    notificationQueued = false;
	    if (shouldNotifyAtEndOfTick) {
	      shouldNotifyAtEndOfTick = false;
	      listeners.forEach((l) => l());
	    }
	  };
	  return Object.assign({}, store, {
	    // Override the base `store.subscribe` method to keep original listeners
	    // from running if we're delaying notifications
	    subscribe(listener2) {
	      const wrappedListener = () => notifying && listener2();
	      const unsubscribe = store.subscribe(wrappedListener);
	      listeners.add(listener2);
	      return () => {
	        unsubscribe();
	        listeners.delete(listener2);
	      };
	    },
	    // Override the base `store.dispatch` method so that we can check actions
	    // for the `shouldAutoBatch` flag and determine if batching is active
	    dispatch(action) {
	      try {
	        notifying = !action?.meta?.[SHOULD_AUTOBATCH];
	        shouldNotifyAtEndOfTick = !notifying;
	        if (shouldNotifyAtEndOfTick) {
	          if (!notificationQueued) {
	            notificationQueued = true;
	            queueCallback(notifyListeners);
	          }
	        }
	        return store.dispatch(action);
	      } finally {
	        notifying = true;
	      }
	    }
	  });
	};

	// src/getDefaultEnhancers.ts
	var buildGetDefaultEnhancers = (middlewareEnhancer) => function getDefaultEnhancers(options) {
	  const {
	    autoBatch = true
	  } = options ?? {};
	  let enhancerArray = new Tuple(middlewareEnhancer);
	  if (autoBatch) {
	    enhancerArray.push(autoBatchEnhancer(typeof autoBatch === "object" ? autoBatch : void 0));
	  }
	  return enhancerArray;
	};

	// src/configureStore.ts
	var IS_PRODUCTION = 'production' === "production";
	function configureStore(options) {
	  const getDefaultMiddleware = buildGetDefaultMiddleware();
	  const {
	    reducer = void 0,
	    middleware,
	    devTools = true,
	    preloadedState = void 0,
	    enhancers = void 0
	  } = options || {};
	  let rootReducer;
	  if (typeof reducer === "function") {
	    rootReducer = reducer;
	  } else if (isPlainObject$3(reducer)) {
	    rootReducer = combineReducers(reducer);
	  } else {
	    throw new Error(formatProdErrorMessage(1) );
	  }
	  let finalMiddleware;
	  if (typeof middleware === "function") {
	    finalMiddleware = middleware(getDefaultMiddleware);
	  } else {
	    finalMiddleware = getDefaultMiddleware();
	  }
	  let finalCompose = compose;
	  if (devTools) {
	    finalCompose = composeWithDevTools({
	      // Enable capture of stack traces for dispatched Redux actions
	      trace: !IS_PRODUCTION,
	      ...typeof devTools === "object" && devTools
	    });
	  }
	  const middlewareEnhancer = applyMiddleware(...finalMiddleware);
	  const getDefaultEnhancers = buildGetDefaultEnhancers(middlewareEnhancer);
	  let storeEnhancers = typeof enhancers === "function" ? enhancers(getDefaultEnhancers) : getDefaultEnhancers();
	  const composedEnhancer = finalCompose(...storeEnhancers);
	  return createStore(rootReducer, preloadedState, composedEnhancer);
	}

	// src/mapBuilders.ts
	function executeReducerBuilderCallback(builderCallback) {
	  const actionsMap = {};
	  const actionMatchers = [];
	  let defaultCaseReducer;
	  const builder = {
	    addCase(typeOrActionCreator, reducer) {
	      const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
	      if (!type) {
	        throw new Error(formatProdErrorMessage(28) );
	      }
	      if (type in actionsMap) {
	        throw new Error(formatProdErrorMessage(29) );
	      }
	      actionsMap[type] = reducer;
	      return builder;
	    },
	    addMatcher(matcher, reducer) {
	      actionMatchers.push({
	        matcher,
	        reducer
	      });
	      return builder;
	    },
	    addDefaultCase(reducer) {
	      defaultCaseReducer = reducer;
	      return builder;
	    }
	  };
	  builderCallback(builder);
	  return [actionsMap, actionMatchers, defaultCaseReducer];
	}

	// src/createReducer.ts
	function isStateFunction(x) {
	  return typeof x === "function";
	}
	function createReducer(initialState, mapOrBuilderCallback) {
	  let [actionsMap, finalActionMatchers, finalDefaultCaseReducer] = executeReducerBuilderCallback(mapOrBuilderCallback);
	  let getInitialState;
	  if (isStateFunction(initialState)) {
	    getInitialState = () => freezeDraftable(initialState());
	  } else {
	    const frozenInitialState = freezeDraftable(initialState);
	    getInitialState = () => frozenInitialState;
	  }
	  function reducer(state = getInitialState(), action) {
	    let caseReducers = [actionsMap[action.type], ...finalActionMatchers.filter(({
	      matcher
	    }) => matcher(action)).map(({
	      reducer: reducer2
	    }) => reducer2)];
	    if (caseReducers.filter((cr) => !!cr).length === 0) {
	      caseReducers = [finalDefaultCaseReducer];
	    }
	    return caseReducers.reduce((previousState, caseReducer) => {
	      if (caseReducer) {
	        if (isDraft(previousState)) {
	          const draft = previousState;
	          const result = caseReducer(draft, action);
	          if (result === void 0) {
	            return previousState;
	          }
	          return result;
	        } else if (!isDraftable(previousState)) {
	          const result = caseReducer(previousState, action);
	          if (result === void 0) {
	            if (previousState === null) {
	              return previousState;
	            }
	            throw new Error(formatProdErrorMessage(9) );
	          }
	          return result;
	        } else {
	          return produce(previousState, (draft) => {
	            return caseReducer(draft, action);
	          });
	        }
	      }
	      return previousState;
	    }, state);
	  }
	  reducer.getInitialState = getInitialState;
	  return reducer;
	}

	// src/nanoid.ts
	var urlAlphabet = "ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW";
	var nanoid = (size = 21) => {
	  let id = "";
	  let i = size;
	  while (i--) {
	    id += urlAlphabet[Math.random() * 64 | 0];
	  }
	  return id;
	};

	// src/matchers.ts
	var matches = (matcher, action) => {
	  if (hasMatchFunction(matcher)) {
	    return matcher.match(action);
	  } else {
	    return matcher(action);
	  }
	};
	function isAnyOf(...matchers) {
	  return (action) => {
	    return matchers.some((matcher) => matches(matcher, action));
	  };
	}

	// src/createAsyncThunk.ts
	var commonProperties = ["name", "message", "stack", "code"];
	var RejectWithValue = class {
	  constructor(payload, meta) {
	    this.payload = payload;
	    this.meta = meta;
	  }
	  /*
	  type-only property to distinguish between RejectWithValue and FulfillWithMeta
	  does not exist at runtime
	  */
	  _type;
	};
	var FulfillWithMeta = class {
	  constructor(payload, meta) {
	    this.payload = payload;
	    this.meta = meta;
	  }
	  /*
	  type-only property to distinguish between RejectWithValue and FulfillWithMeta
	  does not exist at runtime
	  */
	  _type;
	};
	var miniSerializeError = (value) => {
	  if (typeof value === "object" && value !== null) {
	    const simpleError = {};
	    for (const property of commonProperties) {
	      if (typeof value[property] === "string") {
	        simpleError[property] = value[property];
	      }
	    }
	    return simpleError;
	  }
	  return {
	    message: String(value)
	  };
	};
	var createAsyncThunk = /* @__PURE__ */ (() => {
	  function createAsyncThunk2(typePrefix, payloadCreator, options) {
	    const fulfilled = createAction(typePrefix + "/fulfilled", (payload, requestId, arg, meta) => ({
	      payload,
	      meta: {
	        ...meta || {},
	        arg,
	        requestId,
	        requestStatus: "fulfilled"
	      }
	    }));
	    const pending = createAction(typePrefix + "/pending", (requestId, arg, meta) => ({
	      payload: void 0,
	      meta: {
	        ...meta || {},
	        arg,
	        requestId,
	        requestStatus: "pending"
	      }
	    }));
	    const rejected = createAction(typePrefix + "/rejected", (error, requestId, arg, payload, meta) => ({
	      payload,
	      error: (options && options.serializeError || miniSerializeError)(error || "Rejected"),
	      meta: {
	        ...meta || {},
	        arg,
	        requestId,
	        rejectedWithValue: !!payload,
	        requestStatus: "rejected",
	        aborted: error?.name === "AbortError",
	        condition: error?.name === "ConditionError"
	      }
	    }));
	    function actionCreator(arg) {
	      return (dispatch, getState, extra) => {
	        const requestId = options?.idGenerator ? options.idGenerator(arg) : nanoid();
	        const abortController = new AbortController();
	        let abortHandler;
	        let abortReason;
	        function abort(reason) {
	          abortReason = reason;
	          abortController.abort();
	        }
	        const promise = async function() {
	          let finalAction;
	          try {
	            let conditionResult = options?.condition?.(arg, {
	              getState,
	              extra
	            });
	            if (isThenable(conditionResult)) {
	              conditionResult = await conditionResult;
	            }
	            if (conditionResult === false || abortController.signal.aborted) {
	              throw {
	                name: "ConditionError",
	                message: "Aborted due to condition callback returning false."
	              };
	            }
	            const abortedPromise = new Promise((_, reject) => {
	              abortHandler = () => {
	                reject({
	                  name: "AbortError",
	                  message: abortReason || "Aborted"
	                });
	              };
	              abortController.signal.addEventListener("abort", abortHandler);
	            });
	            dispatch(pending(requestId, arg, options?.getPendingMeta?.({
	              requestId,
	              arg
	            }, {
	              getState,
	              extra
	            })));
	            finalAction = await Promise.race([abortedPromise, Promise.resolve(payloadCreator(arg, {
	              dispatch,
	              getState,
	              extra,
	              requestId,
	              signal: abortController.signal,
	              abort,
	              rejectWithValue: (value, meta) => {
	                return new RejectWithValue(value, meta);
	              },
	              fulfillWithValue: (value, meta) => {
	                return new FulfillWithMeta(value, meta);
	              }
	            })).then((result) => {
	              if (result instanceof RejectWithValue) {
	                throw result;
	              }
	              if (result instanceof FulfillWithMeta) {
	                return fulfilled(result.payload, requestId, arg, result.meta);
	              }
	              return fulfilled(result, requestId, arg);
	            })]);
	          } catch (err) {
	            finalAction = err instanceof RejectWithValue ? rejected(null, requestId, arg, err.payload, err.meta) : rejected(err, requestId, arg);
	          } finally {
	            if (abortHandler) {
	              abortController.signal.removeEventListener("abort", abortHandler);
	            }
	          }
	          const skipDispatch = options && !options.dispatchConditionRejection && rejected.match(finalAction) && finalAction.meta.condition;
	          if (!skipDispatch) {
	            dispatch(finalAction);
	          }
	          return finalAction;
	        }();
	        return Object.assign(promise, {
	          abort,
	          requestId,
	          arg,
	          unwrap() {
	            return promise.then(unwrapResult);
	          }
	        });
	      };
	    }
	    return Object.assign(actionCreator, {
	      pending,
	      rejected,
	      fulfilled,
	      settled: isAnyOf(rejected, fulfilled),
	      typePrefix
	    });
	  }
	  createAsyncThunk2.withTypes = () => createAsyncThunk2;
	  return createAsyncThunk2;
	})();
	function unwrapResult(action) {
	  if (action.meta && action.meta.rejectedWithValue) {
	    throw action.payload;
	  }
	  if (action.error) {
	    throw action.error;
	  }
	  return action.payload;
	}
	function isThenable(value) {
	  return value !== null && typeof value === "object" && typeof value.then === "function";
	}

	// src/createSlice.ts
	var asyncThunkSymbol = /* @__PURE__ */ Symbol.for("rtk-slice-createasyncthunk");
	function getType(slice, actionKey) {
	  return `${slice}/${actionKey}`;
	}
	function buildCreateSlice({
	  creators
	} = {}) {
	  const cAT = creators?.asyncThunk?.[asyncThunkSymbol];
	  return function createSlice2(options) {
	    const {
	      name,
	      reducerPath = name
	    } = options;
	    if (!name) {
	      throw new Error(formatProdErrorMessage(11) );
	    }
	    if (typeof process !== "undefined" && 'production' === "development") {
	      if (options.initialState === void 0) {
	        console.error("You must provide an `initialState` value that is not `undefined`. You may have misspelled `initialState`");
	      }
	    }
	    const reducers = (typeof options.reducers === "function" ? options.reducers(buildReducerCreators()) : options.reducers) || {};
	    const reducerNames = Object.keys(reducers);
	    const context = {
	      sliceCaseReducersByName: {},
	      sliceCaseReducersByType: {},
	      actionCreators: {},
	      sliceMatchers: []
	    };
	    const contextMethods = {
	      addCase(typeOrActionCreator, reducer2) {
	        const type = typeof typeOrActionCreator === "string" ? typeOrActionCreator : typeOrActionCreator.type;
	        if (!type) {
	          throw new Error(formatProdErrorMessage(12) );
	        }
	        if (type in context.sliceCaseReducersByType) {
	          throw new Error(formatProdErrorMessage(13) );
	        }
	        context.sliceCaseReducersByType[type] = reducer2;
	        return contextMethods;
	      },
	      addMatcher(matcher, reducer2) {
	        context.sliceMatchers.push({
	          matcher,
	          reducer: reducer2
	        });
	        return contextMethods;
	      },
	      exposeAction(name2, actionCreator) {
	        context.actionCreators[name2] = actionCreator;
	        return contextMethods;
	      },
	      exposeCaseReducer(name2, reducer2) {
	        context.sliceCaseReducersByName[name2] = reducer2;
	        return contextMethods;
	      }
	    };
	    reducerNames.forEach((reducerName) => {
	      const reducerDefinition = reducers[reducerName];
	      const reducerDetails = {
	        reducerName,
	        type: getType(name, reducerName),
	        createNotation: typeof options.reducers === "function"
	      };
	      if (isAsyncThunkSliceReducerDefinition(reducerDefinition)) {
	        handleThunkCaseReducerDefinition(reducerDetails, reducerDefinition, contextMethods, cAT);
	      } else {
	        handleNormalReducerDefinition(reducerDetails, reducerDefinition, contextMethods);
	      }
	    });
	    function buildReducer() {
	      const [extraReducers = {}, actionMatchers = [], defaultCaseReducer = void 0] = typeof options.extraReducers === "function" ? executeReducerBuilderCallback(options.extraReducers) : [options.extraReducers];
	      const finalCaseReducers = {
	        ...extraReducers,
	        ...context.sliceCaseReducersByType
	      };
	      return createReducer(options.initialState, (builder) => {
	        for (let key in finalCaseReducers) {
	          builder.addCase(key, finalCaseReducers[key]);
	        }
	        for (let sM of context.sliceMatchers) {
	          builder.addMatcher(sM.matcher, sM.reducer);
	        }
	        for (let m of actionMatchers) {
	          builder.addMatcher(m.matcher, m.reducer);
	        }
	        if (defaultCaseReducer) {
	          builder.addDefaultCase(defaultCaseReducer);
	        }
	      });
	    }
	    const selectSelf = (state) => state;
	    const injectedSelectorCache = /* @__PURE__ */ new Map();
	    let _reducer;
	    function reducer(state, action) {
	      if (!_reducer)
	        _reducer = buildReducer();
	      return _reducer(state, action);
	    }
	    function getInitialState() {
	      if (!_reducer)
	        _reducer = buildReducer();
	      return _reducer.getInitialState();
	    }
	    function makeSelectorProps(reducerPath2, injected = false) {
	      function selectSlice(state) {
	        let sliceState = state[reducerPath2];
	        if (typeof sliceState === "undefined") {
	          if (injected) {
	            sliceState = getInitialState();
	          }
	        }
	        return sliceState;
	      }
	      function getSelectors(selectState = selectSelf) {
	        const selectorCache = emplace(injectedSelectorCache, injected, {
	          insert: () => /* @__PURE__ */ new WeakMap()
	        });
	        return emplace(selectorCache, selectState, {
	          insert: () => {
	            const map = {};
	            for (const [name2, selector] of Object.entries(options.selectors ?? {})) {
	              map[name2] = wrapSelector(selector, selectState, getInitialState, injected);
	            }
	            return map;
	          }
	        });
	      }
	      return {
	        reducerPath: reducerPath2,
	        getSelectors,
	        get selectors() {
	          return getSelectors(selectSlice);
	        },
	        selectSlice
	      };
	    }
	    const slice = {
	      name,
	      reducer,
	      actions: context.actionCreators,
	      caseReducers: context.sliceCaseReducersByName,
	      getInitialState,
	      ...makeSelectorProps(reducerPath),
	      injectInto(injectable, {
	        reducerPath: pathOpt,
	        ...config
	      } = {}) {
	        const newReducerPath = pathOpt ?? reducerPath;
	        injectable.inject({
	          reducerPath: newReducerPath,
	          reducer
	        }, config);
	        return {
	          ...slice,
	          ...makeSelectorProps(newReducerPath, true)
	        };
	      }
	    };
	    return slice;
	  };
	}
	function wrapSelector(selector, selectState, getInitialState, injected) {
	  function wrapper(rootState, ...args) {
	    let sliceState = selectState(rootState);
	    if (typeof sliceState === "undefined") {
	      if (injected) {
	        sliceState = getInitialState();
	      }
	    }
	    return selector(sliceState, ...args);
	  }
	  wrapper.unwrapped = selector;
	  return wrapper;
	}
	var createSlice = /* @__PURE__ */ buildCreateSlice();
	function buildReducerCreators() {
	  function asyncThunk(payloadCreator, config) {
	    return {
	      _reducerDefinitionType: "asyncThunk" /* asyncThunk */,
	      payloadCreator,
	      ...config
	    };
	  }
	  asyncThunk.withTypes = () => asyncThunk;
	  return {
	    reducer(caseReducer) {
	      return Object.assign({
	        // hack so the wrapping function has the same name as the original
	        // we need to create a wrapper so the `reducerDefinitionType` is not assigned to the original
	        [caseReducer.name](...args) {
	          return caseReducer(...args);
	        }
	      }[caseReducer.name], {
	        _reducerDefinitionType: "reducer" /* reducer */
	      });
	    },
	    preparedReducer(prepare, reducer) {
	      return {
	        _reducerDefinitionType: "reducerWithPrepare" /* reducerWithPrepare */,
	        prepare,
	        reducer
	      };
	    },
	    asyncThunk
	  };
	}
	function handleNormalReducerDefinition({
	  type,
	  reducerName,
	  createNotation
	}, maybeReducerWithPrepare, context) {
	  let caseReducer;
	  let prepareCallback;
	  if ("reducer" in maybeReducerWithPrepare) {
	    if (createNotation && !isCaseReducerWithPrepareDefinition(maybeReducerWithPrepare)) {
	      throw new Error(formatProdErrorMessage(17) );
	    }
	    caseReducer = maybeReducerWithPrepare.reducer;
	    prepareCallback = maybeReducerWithPrepare.prepare;
	  } else {
	    caseReducer = maybeReducerWithPrepare;
	  }
	  context.addCase(type, caseReducer).exposeCaseReducer(reducerName, caseReducer).exposeAction(reducerName, prepareCallback ? createAction(type, prepareCallback) : createAction(type));
	}
	function isAsyncThunkSliceReducerDefinition(reducerDefinition) {
	  return reducerDefinition._reducerDefinitionType === "asyncThunk" /* asyncThunk */;
	}
	function isCaseReducerWithPrepareDefinition(reducerDefinition) {
	  return reducerDefinition._reducerDefinitionType === "reducerWithPrepare" /* reducerWithPrepare */;
	}
	function handleThunkCaseReducerDefinition({
	  type,
	  reducerName
	}, reducerDefinition, context, cAT) {
	  if (!cAT) {
	    throw new Error(formatProdErrorMessage(18) );
	  }
	  const {
	    payloadCreator,
	    fulfilled,
	    pending,
	    rejected,
	    settled,
	    options
	  } = reducerDefinition;
	  const thunk = cAT(type, payloadCreator, options);
	  context.exposeAction(reducerName, thunk);
	  if (fulfilled) {
	    context.addCase(thunk.fulfilled, fulfilled);
	  }
	  if (pending) {
	    context.addCase(thunk.pending, pending);
	  }
	  if (rejected) {
	    context.addCase(thunk.rejected, rejected);
	  }
	  if (settled) {
	    context.addMatcher(thunk.settled, settled);
	  }
	  context.exposeCaseReducer(reducerName, {
	    fulfilled: fulfilled || noop,
	    pending: pending || noop,
	    rejected: rejected || noop,
	    settled: settled || noop
	  });
	}
	function noop() {
	}

	// src/listenerMiddleware/exceptions.ts
	var task = "task";
	var listener = "listener";
	var completed = "completed";
	var cancelled = "cancelled";
	var taskCancelled = `task-${cancelled}`;
	var taskCompleted = `task-${completed}`;
	var listenerCancelled = `${listener}-${cancelled}`;
	var listenerCompleted = `${listener}-${completed}`;
	var TaskAbortError = class {
	  constructor(code) {
	    this.code = code;
	    this.message = `${task} ${cancelled} (reason: ${code})`;
	  }
	  name = "TaskAbortError";
	  message;
	};

	// src/listenerMiddleware/utils.ts
	var assertFunction = (func, expected) => {
	  if (typeof func !== "function") {
	    throw new Error(formatProdErrorMessage(32) );
	  }
	};
	var noop2 = () => {
	};
	var catchRejection = (promise, onError = noop2) => {
	  promise.catch(onError);
	  return promise;
	};
	var addAbortSignalListener = (abortSignal, callback) => {
	  abortSignal.addEventListener("abort", callback, {
	    once: true
	  });
	  return () => abortSignal.removeEventListener("abort", callback);
	};
	var abortControllerWithReason = (abortController, reason) => {
	  const signal = abortController.signal;
	  if (signal.aborted) {
	    return;
	  }
	  if (!("reason" in signal)) {
	    Object.defineProperty(signal, "reason", {
	      enumerable: true,
	      value: reason,
	      configurable: true,
	      writable: true
	    });
	  }
	  abortController.abort(reason);
	};

	// src/listenerMiddleware/task.ts
	var validateActive = (signal) => {
	  if (signal.aborted) {
	    const {
	      reason
	    } = signal;
	    throw new TaskAbortError(reason);
	  }
	};
	function raceWithSignal(signal, promise) {
	  let cleanup = noop2;
	  return new Promise((resolve, reject) => {
	    const notifyRejection = () => reject(new TaskAbortError(signal.reason));
	    if (signal.aborted) {
	      notifyRejection();
	      return;
	    }
	    cleanup = addAbortSignalListener(signal, notifyRejection);
	    promise.finally(() => cleanup()).then(resolve, reject);
	  }).finally(() => {
	    cleanup = noop2;
	  });
	}
	var runTask = async (task2, cleanUp) => {
	  try {
	    await Promise.resolve();
	    const value = await task2();
	    return {
	      status: "ok",
	      value
	    };
	  } catch (error) {
	    return {
	      status: error instanceof TaskAbortError ? "cancelled" : "rejected",
	      error
	    };
	  } finally {
	    cleanUp?.();
	  }
	};
	var createPause = (signal) => {
	  return (promise) => {
	    return catchRejection(raceWithSignal(signal, promise).then((output) => {
	      validateActive(signal);
	      return output;
	    }));
	  };
	};
	var createDelay = (signal) => {
	  const pause = createPause(signal);
	  return (timeoutMs) => {
	    return pause(new Promise((resolve) => setTimeout(resolve, timeoutMs)));
	  };
	};

	// src/listenerMiddleware/index.ts
	var {
	  assign
	} = Object;
	var INTERNAL_NIL_TOKEN = {};
	var alm = "listenerMiddleware";
	var createFork = (parentAbortSignal, parentBlockingPromises) => {
	  const linkControllers = (controller) => addAbortSignalListener(parentAbortSignal, () => abortControllerWithReason(controller, parentAbortSignal.reason));
	  return (taskExecutor, opts) => {
	    assertFunction(taskExecutor);
	    const childAbortController = new AbortController();
	    linkControllers(childAbortController);
	    const result = runTask(async () => {
	      validateActive(parentAbortSignal);
	      validateActive(childAbortController.signal);
	      const result2 = await taskExecutor({
	        pause: createPause(childAbortController.signal),
	        delay: createDelay(childAbortController.signal),
	        signal: childAbortController.signal
	      });
	      validateActive(childAbortController.signal);
	      return result2;
	    }, () => abortControllerWithReason(childAbortController, taskCompleted));
	    if (opts?.autoJoin) {
	      parentBlockingPromises.push(result.catch(noop2));
	    }
	    return {
	      result: createPause(parentAbortSignal)(result),
	      cancel() {
	        abortControllerWithReason(childAbortController, taskCancelled);
	      }
	    };
	  };
	};
	var createTakePattern = (startListening, signal) => {
	  const take = async (predicate, timeout) => {
	    validateActive(signal);
	    let unsubscribe = () => {
	    };
	    const tuplePromise = new Promise((resolve, reject) => {
	      let stopListening = startListening({
	        predicate,
	        effect: (action, listenerApi) => {
	          listenerApi.unsubscribe();
	          resolve([action, listenerApi.getState(), listenerApi.getOriginalState()]);
	        }
	      });
	      unsubscribe = () => {
	        stopListening();
	        reject();
	      };
	    });
	    const promises = [tuplePromise];
	    if (timeout != null) {
	      promises.push(new Promise((resolve) => setTimeout(resolve, timeout, null)));
	    }
	    try {
	      const output = await raceWithSignal(signal, Promise.race(promises));
	      validateActive(signal);
	      return output;
	    } finally {
	      unsubscribe();
	    }
	  };
	  return (predicate, timeout) => catchRejection(take(predicate, timeout));
	};
	var getListenerEntryPropsFrom = (options) => {
	  let {
	    type,
	    actionCreator,
	    matcher,
	    predicate,
	    effect
	  } = options;
	  if (type) {
	    predicate = createAction(type).match;
	  } else if (actionCreator) {
	    type = actionCreator.type;
	    predicate = actionCreator.match;
	  } else if (matcher) {
	    predicate = matcher;
	  } else if (predicate) ; else {
	    throw new Error(formatProdErrorMessage(21) );
	  }
	  assertFunction(effect);
	  return {
	    predicate,
	    type,
	    effect
	  };
	};
	var createListenerEntry = Object.assign((options) => {
	  const {
	    type,
	    predicate,
	    effect
	  } = getListenerEntryPropsFrom(options);
	  const id = nanoid();
	  const entry = {
	    id,
	    effect,
	    type,
	    predicate,
	    pending: /* @__PURE__ */ new Set(),
	    unsubscribe: () => {
	      throw new Error(formatProdErrorMessage(22) );
	    }
	  };
	  return entry;
	}, {
	  withTypes: () => createListenerEntry
	});
	var cancelActiveListeners = (entry) => {
	  entry.pending.forEach((controller) => {
	    abortControllerWithReason(controller, listenerCancelled);
	  });
	};
	var createClearListenerMiddleware = (listenerMap) => {
	  return () => {
	    listenerMap.forEach(cancelActiveListeners);
	    listenerMap.clear();
	  };
	};
	var safelyNotifyError = (errorHandler, errorToNotify, errorInfo) => {
	  try {
	    errorHandler(errorToNotify, errorInfo);
	  } catch (errorHandlerError) {
	    setTimeout(() => {
	      throw errorHandlerError;
	    }, 0);
	  }
	};
	var addListener = Object.assign(createAction(`${alm}/add`), {
	  withTypes: () => addListener
	});
	var clearAllListeners = createAction(`${alm}/removeAll`);
	var removeListener = Object.assign(createAction(`${alm}/remove`), {
	  withTypes: () => removeListener
	});
	var defaultErrorHandler = (...args) => {
	  console.error(`${alm}/error`, ...args);
	};
	var createListenerMiddleware = (middlewareOptions = {}) => {
	  const listenerMap = /* @__PURE__ */ new Map();
	  const {
	    extra,
	    onError = defaultErrorHandler
	  } = middlewareOptions;
	  assertFunction(onError);
	  const insertEntry = (entry) => {
	    entry.unsubscribe = () => listenerMap.delete(entry.id);
	    listenerMap.set(entry.id, entry);
	    return (cancelOptions) => {
	      entry.unsubscribe();
	      if (cancelOptions?.cancelActive) {
	        cancelActiveListeners(entry);
	      }
	    };
	  };
	  const startListening = (options) => {
	    let entry = find(Array.from(listenerMap.values()), (existingEntry) => existingEntry.effect === options.effect);
	    if (!entry) {
	      entry = createListenerEntry(options);
	    }
	    return insertEntry(entry);
	  };
	  Object.assign(startListening, {
	    withTypes: () => startListening
	  });
	  const stopListening = (options) => {
	    const {
	      type,
	      effect,
	      predicate
	    } = getListenerEntryPropsFrom(options);
	    const entry = find(Array.from(listenerMap.values()), (entry2) => {
	      const matchPredicateOrType = typeof type === "string" ? entry2.type === type : entry2.predicate === predicate;
	      return matchPredicateOrType && entry2.effect === effect;
	    });
	    if (entry) {
	      entry.unsubscribe();
	      if (options.cancelActive) {
	        cancelActiveListeners(entry);
	      }
	    }
	    return !!entry;
	  };
	  Object.assign(stopListening, {
	    withTypes: () => stopListening
	  });
	  const notifyListener = async (entry, action, api, getOriginalState) => {
	    const internalTaskController = new AbortController();
	    const take = createTakePattern(startListening, internalTaskController.signal);
	    const autoJoinPromises = [];
	    try {
	      entry.pending.add(internalTaskController);
	      await Promise.resolve(entry.effect(
	        action,
	        // Use assign() rather than ... to avoid extra helper functions added to bundle
	        assign({}, api, {
	          getOriginalState,
	          condition: (predicate, timeout) => take(predicate, timeout).then(Boolean),
	          take,
	          delay: createDelay(internalTaskController.signal),
	          pause: createPause(internalTaskController.signal),
	          extra,
	          signal: internalTaskController.signal,
	          fork: createFork(internalTaskController.signal, autoJoinPromises),
	          unsubscribe: entry.unsubscribe,
	          subscribe: () => {
	            listenerMap.set(entry.id, entry);
	          },
	          cancelActiveListeners: () => {
	            entry.pending.forEach((controller, _, set) => {
	              if (controller !== internalTaskController) {
	                abortControllerWithReason(controller, listenerCancelled);
	                set.delete(controller);
	              }
	            });
	          },
	          cancel: () => {
	            abortControllerWithReason(internalTaskController, listenerCancelled);
	            entry.pending.delete(internalTaskController);
	          },
	          throwIfCancelled: () => {
	            validateActive(internalTaskController.signal);
	          }
	        })
	      ));
	    } catch (listenerError) {
	      if (!(listenerError instanceof TaskAbortError)) {
	        safelyNotifyError(onError, listenerError, {
	          raisedBy: "effect"
	        });
	      }
	    } finally {
	      await Promise.all(autoJoinPromises);
	      abortControllerWithReason(internalTaskController, listenerCompleted);
	      entry.pending.delete(internalTaskController);
	    }
	  };
	  const clearListenerMiddleware = createClearListenerMiddleware(listenerMap);
	  const middleware = (api) => (next) => (action) => {
	    if (!isAction(action)) {
	      return next(action);
	    }
	    if (addListener.match(action)) {
	      return startListening(action.payload);
	    }
	    if (clearAllListeners.match(action)) {
	      clearListenerMiddleware();
	      return;
	    }
	    if (removeListener.match(action)) {
	      return stopListening(action.payload);
	    }
	    let originalState = api.getState();
	    const getOriginalState = () => {
	      if (originalState === INTERNAL_NIL_TOKEN) {
	        throw new Error(formatProdErrorMessage(23) );
	      }
	      return originalState;
	    };
	    let result;
	    try {
	      result = next(action);
	      if (listenerMap.size > 0) {
	        const currentState = api.getState();
	        const listenerEntries = Array.from(listenerMap.values());
	        for (const entry of listenerEntries) {
	          let runListener = false;
	          try {
	            runListener = entry.predicate(action, currentState, originalState);
	          } catch (predicateError) {
	            runListener = false;
	            safelyNotifyError(onError, predicateError, {
	              raisedBy: "predicate"
	            });
	          }
	          if (!runListener) {
	            continue;
	          }
	          notifyListener(entry, action, api, getOriginalState);
	        }
	      }
	    } finally {
	      originalState = INTERNAL_NIL_TOKEN;
	    }
	    return result;
	  };
	  return {
	    middleware,
	    startListening,
	    stopListening,
	    clearListeners: clearListenerMiddleware
	  };
	};

	// src/formatProdErrorMessage.ts
	function formatProdErrorMessage(code) {
	  return `Minified Redux Toolkit error #${code}; visit https://redux-toolkit.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
	}

	var prefix = 'Invariant failed';
	function invariant(condition, message) {
	    if (condition) {
	        return;
	    }
	    {
	        throw new Error(prefix);
	    }
	}

	function isAttachmentNode(
	    node
	) {
	    return node.type === "image-attachment" || node.type === "audio-attachment";
	}

	function isImageAttachmentNode(
	    node
	) {
	    return node.type === "image-attachment";
	}
























































































	function generateNodeId() {
	    return lodashExports.uniqueId("node-") ;
	}

	function exportTextRegion(node) {
	    const blocks = node.text
	        .split("\n\n")
	        .map((p) => ({
	            type: "markdown",
	            markdown: {
	                content: p,
	            },
	        }));

	    return { blocks, blocksForPreview: blocks };
	}

	function exportImageAttachmentNode(
	    node
	) {
	    return {
	        blocks: [
	            {
	                type: "attachment",
	                attachment: {
	                    // it's possible for an attachment to have a null ID
	                    // if it's been newly created and not sent to the server
	                    // yet (see ../post-editor-machine.ts:712).  render the
	                    // block as well-formed but semantically invalid until
	                    // post upload finishes.
	                    attachmentId:
	                        node.attachment.attachmentId ??
	                        (nil ),
	                    altText: node.altText,
	                },
	            },
	        ],
	        blocksForPreview: [
	            {
	                type: "attachment",
	                attachment: {
	                    altText: node.altText,
	                    width: node.width,
	                    height: node.height,
	                    attachmentId:
	                        node.attachment.attachmentId ??
	                        (nil ),
	                    kind: "image",
	                    previewURL: node.sourceUrl,
	                    fileURL: node.sourceUrl,
	                },
	            },
	        ],
	    };
	}

	function exportAudioAttachmentNode(
	    node
	) {
	    return {
	        blocks: [
	            {
	                type: "attachment",
	                attachment: {
	                    // it's possible for an attachment to have a null ID
	                    // if it's been newly created and not sent to the server
	                    // yet (see ../post-editor-machine.ts:712).  render the
	                    // block as well-formed but semantically invalid until
	                    // post upload finishes.
	                    attachmentId:
	                        node.attachment.attachmentId ??
	                        (nil ),
	                },
	            },
	        ],
	        blocksForPreview: [
	            {
	                type: "attachment",
	                attachment: {
	                    artist: node.artist,
	                    title: node.title,
	                    attachmentId:
	                        node.attachment.attachmentId ??
	                        (nil ),
	                    kind: "audio",
	                    previewURL: node.sourceUrl,
	                    fileURL: node.sourceUrl,
	                },
	            },
	        ],
	    };
	}

	function exportAttachmentRowNode(
	    node,
	    nodes
	) {
	    const rowStorageBlock = {
	        type: "attachment-row",
	        attachments: [],
	    };
	    const rowViewBlock = {
	        type: "attachment-row",
	        attachments: [],
	    };

	    node.attachments.forEach((attachmentNodeId) => {
	        let thisChildResult = null;

	        const attachmentNode = nodes[attachmentNodeId];
	        if (!attachmentNode) return;

	        switch (attachmentNode.type) {
	            case "image-attachment": {
	                thisChildResult = exportImageAttachmentNode(attachmentNode);
	                break;
	            }
	            case "audio-attachment": {
	                thisChildResult = exportAudioAttachmentNode(attachmentNode);
	                break;
	            }
	            // we only care about attachment nodes
	            default:
	                return;
	        }

	        if (!thisChildResult) return;

	        rowStorageBlock.attachments.push(
	            ...thisChildResult.blocks.filter(isAttachmentStorageBlock)
	        );
	        rowViewBlock.attachments.push(
	            ...thisChildResult.blocksForPreview.filter(isAttachmentViewBlock)
	        );
	    });

	    return { blocks: [rowStorageBlock], blocksForPreview: [rowViewBlock] };
	}

	function exportCohostPost(
	    editorState
	) {
	    // aggregate the contents of all of the root's children
	    const blocks = [];
	    const blocksForPreview = [];

	    for (const nodeId of editorState.nodeOrder) {
	        let thisChildResult = null;

	        const node = editorState.nodes[nodeId];
	        if (!node) continue;

	        switch (node.type) {
	            case "text": {
	                thisChildResult = exportTextRegion(node);
	                break;
	            }
	            case "image-attachment": {
	                thisChildResult = exportImageAttachmentNode(node);
	                break;
	            }
	            case "audio-attachment": {
	                thisChildResult = exportAudioAttachmentNode(node);
	                break;
	            }
	            case "attachment-row": {
	                thisChildResult = exportAttachmentRowNode(
	                    node,
	                    editorState.nodes
	                );
	                break;
	            }
	        }

	        if (!thisChildResult) continue;

	        blocks.push(...thisChildResult.blocks);
	        blocksForPreview.push(...thisChildResult.blocksForPreview);
	    }

	    return {
	        blocks,
	        blocksForPreview,
	    };
	}

	function findAttachmentRowContainingAttachment(
	    nodeId,
	    nodes
	) {
	    return (
	        Object.values(nodes).find(
	            (node) =>
	                node.type === "attachment-row" &&
	                node.attachments.includes(nodeId)
	        )?.nodeId ?? null
	    );
	}

	function makeSourceURL(attachment) {
	    if (
	        attachment &&
	        attachment.state === AttachmentState.Finished &&
	        attachment.attachmentId
	    ) {
	        return sitemap.public
	            .redirectToAttachment({
	                attachmentId: attachment.attachmentId,
	            })
	            .toString();
	    } else if (attachment && attachment.uploadData) {
	        return attachment.uploadData.objectURL;
	    } else {
	        return sitemap.public.static
	            .staticAsset({ path: missingAttachment })
	            .toString();
	    }
	}

	function nodeFromAttachment(block) {
	    const attachment = {
	        attachmentId: block.attachment.attachmentId,
	        state: AttachmentState.Finished,
	        uploadState: "finished",
	    };

	    if (block.attachment.kind === "audio") {
	        const newNode = {
	            type: "audio-attachment",
	            attachment,
	            sourceUrl: makeSourceURL(attachment),
	            artist: block.attachment.artist ?? "",
	            title: block.attachment.title ?? "",
	            nodeId: generateNodeId(),
	        };
	        return newNode;
	    } else if (block.attachment.kind === "image") {
	        const newNode = {
	            type: "image-attachment",
	            attachment,
	            sourceUrl: makeSourceURL(attachment),
	            altText: block.attachment.altText ?? "",
	            width: block.attachment.width ?? 0,
	            height: block.attachment.height ?? 0,
	            nodeId: generateNodeId(),
	        };

	        return newNode;
	    }
	}

	function attachmentRowWithAttachments(
	    attachments
	) {
	    const rowNode = {
	        type: "attachment-row",
	        attachments: [],
	        nodeId: generateNodeId(),
	    };

	    for (const attachment of attachments) {
	        rowNode.attachments.push(attachment.nodeId);
	    }

	    return rowNode;
	}

	function importCohostPost(
	    blocks
	) {
	    const nodes = {};
	    const nodeOrder = [];
	    let accumulatedText = "";
	    let accumulatedAttachmentRow = [];

	    // run this in all handlers that don't involve text.
	    function handleAccumulatedText() {
	        if (accumulatedText.length > 0) {
	            const textNode = {
	                type: "text",
	                text: accumulatedText,
	                nodeId: generateNodeId(),
	            };

	            nodes[textNode.nodeId] = textNode;
	            nodeOrder.push(textNode.nodeId);
	            accumulatedText = "";
	        }
	    }

	    // run this in all handlers that don't involve image attachments.
	    function handleAccumulatedAttachmentRow() {
	        if (accumulatedAttachmentRow.length === 0) return;

	        accumulatedAttachmentRow.forEach((attachment) => {
	            nodes[attachment.nodeId] = attachment;
	        });

	        if (accumulatedAttachmentRow.length % 2 === 0) {
	            // even
	            for (let i = 0; i < accumulatedAttachmentRow.length; i += 2) {
	                const row = attachmentRowWithAttachments(
	                    accumulatedAttachmentRow.slice(i, i + 2)
	                );

	                nodes[row.nodeId] = row;
	                nodeOrder.push(row.nodeId);
	            }
	        } else if (accumulatedAttachmentRow.length >= 3) {
	            // odd, >= 3 (currently only exactly 3, this will change at some point)
	            const firstThree = accumulatedAttachmentRow.splice(0, 3);
	            const firstThreeRow = attachmentRowWithAttachments(firstThree);
	            nodes[firstThreeRow.nodeId] = firstThreeRow;
	            nodeOrder.push(firstThreeRow.nodeId);
	            for (let i = 0; i < accumulatedAttachmentRow.length; i += 2) {
	                const row = attachmentRowWithAttachments(
	                    accumulatedAttachmentRow.slice(i, i + 2)
	                );

	                nodes[row.nodeId] = row;
	                nodeOrder.push(row.nodeId);
	            }
	        } else {
	            // only one
	            const row = attachmentRowWithAttachments(accumulatedAttachmentRow);

	            nodes[row.nodeId] = row;
	            nodeOrder.push(row.nodeId);
	        }

	        accumulatedAttachmentRow = [];
	    }

	    for (const block of blocks) {
	        if (isAskViewBlock(block)) {
	            // this doesn't get loaded into the content editor
	            continue;
	        }

	        if (isMarkdownViewBlock(block)) {
	            handleAccumulatedAttachmentRow();

	            // adjacent markdown blocks should be separated by a paragraph break
	            if (accumulatedText.length > 0) {
	                accumulatedText += "\n\n";
	            }

	            accumulatedText += block.markdown.content;
	        }

	        if (isAttachmentRowViewBlock(block)) {
	            handleAccumulatedText();
	            handleAccumulatedAttachmentRow();

	            const rowNode = {
	                type: "attachment-row",
	                attachments: [],
	                nodeId: generateNodeId(),
	            };

	            for (const attachmentBlock of block.attachments) {
	                const newNode = nodeFromAttachment(attachmentBlock);
	                if (newNode) {
	                    rowNode.attachments.push(newNode.nodeId);
	                    nodes[newNode.nodeId] = newNode;
	                }
	            }
	            nodes[rowNode.nodeId] = rowNode;
	            nodeOrder.push(rowNode.nodeId);
	        }

	        if (isAttachmentViewBlock(block)) {
	            handleAccumulatedText();

	            const newNode = nodeFromAttachment(block);

	            if (newNode) {
	                if (isImageAttachmentNode(newNode)) {
	                    accumulatedAttachmentRow.push(newNode);
	                } else {
	                    nodes[newNode.nodeId] = newNode;
	                    nodeOrder.push(newNode.nodeId);
	                }
	            }
	        }
	    }

	    // reached the end of the post. handle any remaining text or attachment
	    // rows. attachments first.
	    handleAccumulatedAttachmentRow();

	    // now text. we don't check length here because we always want to end with a
	    // text node, empty or not.
	    const textNode = {
	        type: "text",
	        text: accumulatedText,
	        nodeId: generateNodeId(),
	    };

	    nodes[textNode.nodeId] = textNode;
	    nodeOrder.push(textNode.nodeId);
	    accumulatedText = "";

	    return { nodes, nodeOrder };
	}

	/**
	 * this needs to have its own file because reducer.tsx needs to import it in
	 * order to add middleware listeners, but all the other natural places to put
	 * it would create an import cycle which makes jest choke and die.
	 */


	const listenerMiddleware = createListenerMiddleware();
	const startAppListening = listenerMiddleware.startListening.withTypes


	();

	addListener.withTypes();

	const _selectBody = (state) => state.body;
	const _selectRenderedPost = createSelector([_selectBody], (body) =>
	    exportCohostPost(body)
	);

	const selectAttachmentNodeIdsToUpload = createSelector(
	    [_selectBody],
	    (body) => {
	        const nodeIds = [];

	        Object.values(body.nodes).forEach((node) => {
	            if (
	                isAttachmentNode(node) &&
	                node.attachment.state === AttachmentState.Pending
	            ) {
	                nodeIds.push(node.nodeId);
	            }
	        });

	        return nodeIds;
	    }
	);

	const getImageDimensions = (
	    url
	) => {
	    return new Promise((resolve, reject) => {
	        const img = new Image();
	        img.onload = () =>
	            resolve({
	                width: img.width,
	                height: img.height,
	            });
	        img.onerror = (error) => reject(error);
	        img.src = url;
	    });
	};

	const submit = createAsyncThunk(
	    "postComposer/submit/start",
	    (_void, thunkApi) => {
	        // ================== validate post =======================
	        // post contains content if it contains any attachment block, or
	        // any markdown block with positive-length content
	        const state = (thunkApi.getState() ).postComposer;
	        const { blocks } = _selectRenderedPost(state);
	        const anyContentfulBlocks = _$5.some(
	            blocks,
	            (block) =>
	                isAttachmentStorageBlock(block) ||
	                (isAttachmentRowStorageBlock(block) &&
	                    block.attachments.length > 0) ||
	                (isMarkdownStorageBlock(block) &&
	                    block.markdown.content.trim().length > 0)
	        );

	        const anyContent =
	            !isEmpty(state.headline) ||
	            anyContentfulBlocks ||
	            state.shareOfPostId;
	        const anyBrokenAttachments = _$5.some(
	            Object.values(state.body.nodes),
	            (node) =>
	                isAttachmentNode(node) &&
	                // allow for NIL uuid for non-uploaded attachments to avoid zod parsing issues
	                node.attachment.state !== AttachmentState.Pending &&
	                node.attachment.attachmentId === nil
	        );

	        if (anyBrokenAttachments) {
	            // t("client:post-editor.broken-attachment", "at least one of the attachments on this post failed to upload.  please remove it and try attaching it again.")
	            throw thunkApi.rejectWithValue(
	                "client:post-editor.broken-attachment"
	            );
	        }

	        if (!anyContent) {
	            // t("client:post-editor.must-contain-content", "must contain a headline, any body content, or any attachment")
	            throw thunkApi.rejectWithValue(
	                "client:post-editor.must-contain-content"
	            );
	        }

	        // state.dirty = false;

	        // ===================== start posting ====================
	        const pendingAttachmentNodeIds = selectAttachmentNodeIdsToUpload(state);

	        if (!state.postId) {
	            // new post?  we need to create the post first so attachments have
	            // something to attach to
	            void thunkApi.dispatch(submitCreatePost());
	        } else {
	            if (pendingAttachmentNodeIds.length) {
	                // skip straight to uploading attachments
	                pendingAttachmentNodeIds.forEach(
	                    (nodeId) =>
	                        void thunkApi.dispatch(
	                            submitUploadAttachment({
	                                nodeId,
	                                postId: state.postId,
	                            })
	                        )
	                );
	            } else {
	                // skip straight to editing an existing post
	                void thunkApi.dispatch(submitUpdatePost());
	            }
	        }
	    }
	);

	const submitCreatePost = createAsyncThunk



	("postComposer/submit/createPost", async (_void, thunkApi) => {
	    const state = (thunkApi.getState() ).postComposer;
	    const { blocks } = _selectRenderedPost(state);
	    let stateAfterCreate = PostState.Unpublished;

	    if (selectAttachmentNodeIdsToUpload(state).length === 0) {
	        // no attachments to upload, skip right to being done
	        stateAfterCreate = state.newPostState;
	    }

	    const body = {
	        postState: stateAfterCreate,
	        headline: state.headline,
	        adultContent: state.adultContent,
	        blocks,
	        cws: state.cws.filter((cw) => cw.length > 0).map((cw) => cw.trim()),
	        tags: state.tags
	            .filter((tag) => tag.length > 0)
	            .map((tag) => tag.trim()),
	        shareOfPostId:
	            state.shareOfPostId && !isNaN(state.shareOfPostId)
	                ? state.shareOfPostId
	                : undefined,
	        responseToAskId: state.responseToAskId
	            ? state.responseToAskId
	            : undefined,
	    };

	    const trpcClient = getVanillaClient();

	    try {
	        const postId = (
	            await trpcClient.posts.create.mutate({
	                projectHandle: state.projectHandle,
	                content: body,
	            })
	        ).postId;

	        // if there are attachments to upload, we need to do that; otherwise
	        // we're done
	        const pendingAttachmentNodeIds = selectAttachmentNodeIdsToUpload(state);

	        if (pendingAttachmentNodeIds.length) {
	            pendingAttachmentNodeIds.forEach(
	                (nodeId) =>
	                    void thunkApi.dispatch(
	                        submitUploadAttachment({
	                            nodeId,
	                            postId,
	                        })
	                    )
	            );

	            return { postId, nextPostEditorState: "uploading" };
	        } else {
	            return { postId, nextPostEditorState: "finished" };
	        }
	    } catch (e) {
	        throw thunkApi.rejectWithValue("network error: posts.create");
	    }
	});

	const submitUploadAttachment = createAsyncThunk



	(
	    "postComposer/submit/uploadAttachmentRegion",
	    async ({ nodeId, postId }, thunkApi) => {
	        const state = (thunkApi.getState() ).postComposer;
	        const node = state.body.nodes[nodeId];

	        if (!isAttachmentNode(node)) {
	            throw thunkApi.rejectWithValue(
	                "internal error: attempting to upload a node that's not an attachment"
	            );
	        }

	        const {
	            attachment: { uploadData: localData },
	        } = node;
	        const trpcClient = getVanillaClient();

	        if (!localData) {
	            throw thunkApi.rejectWithValue(
	                "internal error: trying to upload an attachment without a file!"
	            );
	        }

	        let startAttachmentData

	;

	        const blob = await (await fetch(localData.objectURL)).blob();

	        try {
	            switch (node.type) {
	                case "image-attachment":
	                    startAttachmentData =
	                        await trpcClient.posts.attachment.start.mutate({
	                            projectHandle: state.projectHandle,
	                            postId,
	                            filename: localData.filename,
	                            contentType: localData.contentType,
	                            contentLength: localData.size,
	                            width: node.width,
	                            height: node.height,
	                        });
	                    break;
	                case "audio-attachment":
	                    startAttachmentData =
	                        await trpcClient.posts.attachment.start.mutate({
	                            projectHandle: state.projectHandle,
	                            postId,
	                            filename: localData.filename,
	                            contentType: localData.contentType,
	                            contentLength: localData.size,
	                            metadata: {
	                                title: node.title,
	                                artist: node.artist,
	                            },
	                        });
	                    break;
	            }
	        } catch (e) {
	            throw thunkApi.rejectWithValue(
	                "network error: posts.attachment.start"
	            );
	        }

	        // - upload
	        if (!startAttachmentData.url) {
	            console.error(localData, blob, startAttachmentData.url);
	            throw thunkApi.rejectWithValue(
	                "internal error: missing upload URL for pending attachment!"
	            );
	        }

	        const formData = new FormData();
	        for (const name in startAttachmentData.requiredFields) {
	            formData.append(name, startAttachmentData.requiredFields[name]);
	        }
	        formData.append("file", blob);
	        formData.append("Content-Type", localData.contentType);

	        try {
	            await axios$1.post(startAttachmentData.url, formData, {
	                withCredentials: false,
	            });
	        } catch (e) {
	            throw thunkApi.rejectWithValue("network error: error uploading");
	        }

	        // - finish attachment
	        try {
	            await trpcClient.posts.attachment.finish.mutate({
	                projectHandle: state.projectHandle,
	                postId,
	                attachmentId: startAttachmentData.attachmentId,
	            });

	            return {
	                attachmentId: startAttachmentData.attachmentId,
	            };
	        } catch (e) {
	            throw thunkApi.rejectWithValue(
	                "network error: posts.attachment.finish"
	            );
	        }
	    }
	);

	const submitUpdatePost = createAsyncThunk



	("postComposer/submit/updatePost", async (_void, thunkApi) => {
	    const state = (thunkApi.getState() ).postComposer;
	    const trpcClient = getVanillaClient();
	    const { blocks } = _selectRenderedPost(state);

	    const body = {
	        postState: state.newPostState,
	        headline: state.headline,
	        adultContent: state.adultContent,
	        blocks,
	        cws: state.cws.filter((cw) => cw.length > 0).map((cw) => cw.trim()),
	        tags: state.tags
	            .filter((tag) => tag.length > 0)
	            .map((tag) => tag.trim()),
	        shareOfPostId:
	            state.shareOfPostId && !isNaN(state.shareOfPostId)
	                ? state.shareOfPostId
	                : undefined,
	    };

	    try {
	        await trpcClient.posts.update.mutate({
	            projectHandle: state.projectHandle,
	            postId: state.postId,
	            content: body,
	        });
	    } catch (e) {
	        throw thunkApi.rejectWithValue("network error: posts.update");
	    }
	});

	// used to get around hook changing issues
	const EMPTY_ARRAY = [];

	function createBlankBody() {
	    const emptyTextNode = {
	        type: "text",
	        text: "",
	        nodeId: generateNodeId(),
	    };

	    return {
	        nodes: { [emptyTextNode.nodeId]: emptyTextNode },
	        nodeOrder: [emptyTextNode.nodeId],
	    };
	}

	const initialState = {
	    state: "not-ready",
	    siteConfig: defaultConfig,
	    // we need to have a value set for projecthandle
	    // state so we deliberately set invalid ones since it'll be
	    // overwritten in the post composer.
	    projectHandle: "" ,
	    isActivated: false,
	    hasCohostPlus: false,
	    currentPostState: undefined,
	    headline: "",
	    body: createBlankBody(),
	    validationErrors: {},
	    newPostState: PostState.Published,
	    shareOfPostId: null,
	    responseToAskId: null,
	    adultContent: false,
	    maximumAllowedAttachments: 4,
	    tags: [],
	    cws: [],
	    cwsInputOpen: false,
	    dirty: false,
	    editingTransparentShare: false,
	    mostRecentTextNode: null,
	};

	const postComposerSlice = createSlice({
	    name: "postComposer",
	    initialState,
	    reducers: (create) => ({
	        initForNewPost(
	            state,
	            action










	        ) {
	            // FIXME: this is terrible and should be decomposed but it's an
	            // interim measure until more of the app is converted over to redux
	            state.state = "editing";
	            state.projectHandle = action.payload.handle;
	            state.isActivated = action.payload.isActivated;
	            state.hasCohostPlus = action.payload.hasCohostPlus;
	            state.siteConfig = action.payload.siteConfig;

	            state.shareOfPostId = action.payload.shareOf;
	            state.responseToAskId = action.payload.responseToAskId;

	            state.body = createBlankBody();
	            state.tags = action.payload.tags;
	            state.cws = action.payload.cws;
	        },
	        initForEditing(
	            state,
	            action






	        ) {
	            // FIXME: this is terrible and should be decomposed but it's an
	            // interim measure until more of the app is converted over to redux
	            state.state = "editing";
	            state.projectHandle = action.payload.handle;
	            state.isActivated = action.payload.isActivated;
	            state.hasCohostPlus = action.payload.hasCohostPlus;
	            state.siteConfig = action.payload.siteConfig;

	            const post = action.payload.post;
	            state.postId = post.postId;
	            state.currentPostState = post.state;
	            state.newPostState = post.state;
	            state.adultContent = post.effectiveAdultContent;
	            state.shareOfPostId = post.shareOfPostId;
	            state.headline = post.headline;

	            state.body = importCohostPost(post.blocks);

	            // we need to know if the existing post is a transparent share so we
	            // can adjust the rendered composer accordingly
	            state.editingTransparentShare = !!post.transparentShareOfPostId;

	            state.tags = post.tags;
	            state.cws = post.cws;
	            state.responseToAskId = post.responseToAskId ?? null;
	        },
	        updateTextRegion(
	            state,
	            action



	        ) {
	            const node = state.body.nodes[action.payload.nodeId];
	            invariant(
	                node.type === "text");

	            node.text = action.payload.text;
	            state.body.nodes[action.payload.nodeId] = node;
	            state.dirty = true;
	            state.mostRecentTextNode = action.payload.nodeId;
	        },
	        updateImageAltText(
	            state,
	            action



	        ) {
	            const oldNode = state.body.nodes[action.payload.nodeId];

	            if (oldNode.type !== "image-attachment") {
	                throw `assertion failure: node at index ${action.payload.nodeId} is not image`;
	            }

	            state.body.nodes[action.payload.nodeId] = {
	                ...oldNode,
	                altText: action.payload.altText,
	            };
	        },
	        updateAudioMetadata(
	            state,
	            action




	        ) {
	            const oldNode = state.body.nodes[action.payload.nodeId];

	            if (oldNode.type !== "audio-attachment") {
	                throw `assertion failure: node at index ${action.payload.nodeId} is not audio`;
	            }

	            state.body.nodes[action.payload.nodeId] = {
	                ...oldNode,
	                artist: action.payload.artist,
	                title: action.payload.title,
	            };
	        },
	        insertNewTextAtSelection(state, action) {
	            const selectedNodeId = state.mostRecentTextNode;

	            // TODO: this wasn't touched by jae, need to verify functionality
	            // (do this during the live test phase)

	            // TODO: figure out what we want to do in these error cases
	            if (selectedNodeId === null) {
	                throw new Error("selection isn't inside a text region?");
	            }

	            const selectedNode = state.body.nodes[selectedNodeId];

	            if (selectedNode.type !== "text") {
	                throw new Error("unexpected selected region type?");
	            }

	            const selectionOffset = document.getSelection()?.anchorOffset;

	            // insert text at the insertion point
	            state.body.nodes[selectedNodeId] = {
	                type: "text",
	                text:
	                    selectedNode.text.slice(0, selectionOffset) +
	                    action.payload +
	                    selectedNode.text.slice(selectionOffset),
	                nodeId: selectedNodeId,
	            };
	            state.dirty = true;
	            state.mostRecentTextNode = selectedNodeId;
	        },
	        insertFile(
	            state,
	            action
	        ) {
	            function insertAttachment(
	                attachment

















	            ) {
	                const attachmentNode =
	                    attachment.kind === "image"
	                        ? {
	                              type: "image-attachment",
	                              attachment: attachment.attachment,
	                              sourceUrl: attachment.sourceUrl,
	                              altText: attachment.altText,
	                              width: attachment.width,
	                              height: attachment.height,
	                              nodeId: generateNodeId(),
	                          }
	                        : {
	                              type: "audio-attachment",
	                              attachment: attachment.attachment,
	                              sourceUrl: attachment.sourceUrl,
	                              artist: attachment.artist,
	                              title: attachment.title,
	                              nodeId: generateNodeId(),
	                          };

	                state.body.nodes[attachmentNode.nodeId] = attachmentNode;

	                const nodeIdAtPosition =
	                    state.body.nodeOrder[attachment.position];
	                const nodeAtPosition = state.body.nodes[nodeIdAtPosition];

	                // image attachments get placed in an existing row if (1) one exists
	                // at the location we're requesting (2) the row isn't full (3 images
	                // max)
	                if (attachment.kind === "image") {
	                    if (
	                        nodeAtPosition &&
	                        nodeAtPosition.type === "attachment-row" &&
	                        nodeAtPosition.attachments.length < 3
	                    ) {
	                        nodeAtPosition.attachments.push(attachmentNode.nodeId);
	                    } else {
	                        // make a new row and stick the image in it
	                        const rowNode = {
	                            type: "attachment-row",
	                            attachments: [attachmentNode.nodeId],
	                            nodeId: generateNodeId(),
	                        };
	                        state.body.nodeOrder.splice(
	                            attachment.position,
	                            0,
	                            rowNode.nodeId
	                        );
	                        state.body.nodes[rowNode.nodeId] = rowNode;
	                    }
	                } else {
	                    // audio attachments can't be in rows
	                    state.body.nodeOrder.splice(
	                        attachment.position,
	                        0,
	                        attachmentNode.nodeId
	                    );
	                }

	                delete state.validationErrors["attachments"];

	                state.dirty = true;
	            }

	            const effectiveLimit = state.hasCohostPlus
	                ? state.siteConfig.limits.attachmentSize.cohostPlus
	                : state.siteConfig.limits.attachmentSize.normal;

	            const attachmentCount = Object.values(state.body.nodes).filter(
	                isAttachmentNode
	            ).length;
	            if (attachmentCount >= state.siteConfig.limits.attachmentCount) {
	                // t("client:post-editor.too-many-attachments", "you can only add up to 10 attachments to a post!")
	                state.validationErrors["attachments"] =
	                    "client:post-editor.too-many-attachments";
	                return;
	            }

	            const file = action.payload.file;

	            const validityResult = isValidAttachmentContentType(
	                state.siteConfig,
	                file.type
	            );

	            if (!validityResult.valid) {
	                // t("client:post-editor.attachment-must-be-image", "one or more attachments is not of a supported file type!")
	                state.validationErrors["attachments"] =
	                    "client:post-editor.attachment-must-be-image";
	                return;
	            }

	            if (file.size > effectiveLimit) {
	                // TODO: figure out how to get the interpolation to work
	                // here since we're just passing the key.
	                // t("client:post-editor.attachment-too-large", "attachments must be less than 5mb!")
	                // t("client:post-editor.attachment-too-large-cohost-plus", "attachments must be less than 10mb!")
	                const key = state.hasCohostPlus
	                    ? "client:post-editor.attachment-too-large-cohost-plus"
	                    : "client:post-editor.attachment-too-large";
	                state.validationErrors["attachments"] = key;
	                return;
	            }

	            const objectURL = URL.createObjectURL(file);

	            switch (validityResult.kind) {
	                case "image": {
	                    const dimensions = { width: 0, height: 0 };

	                    const newAttachment = {
	                        kind: "image" ,
	                        uploadData: {
	                            objectURL,
	                            filename: file.name,
	                            size: file.size,
	                            contentType: file.type,
	                        },
	                        state: AttachmentState.Pending,
	                        uploadState: "not-started" ,
	                    };

	                    // insert into last attachment row, or at the end if none is available
	                    const position = state.body.nodeOrder.findIndex(
	                        (nodeId) => {
	                            const node = state.body.nodes[nodeId];
	                            return (
	                                node.type === "attachment-row" &&
	                                node.attachments.length < 3
	                            );
	                        }
	                    );

	                    insertAttachment({
	                        position,
	                        kind: "image",
	                        sourceUrl: objectURL,
	                        attachment: newAttachment,
	                        altText: "",
	                        width: dimensions.width,
	                        height: dimensions.height,
	                    });

	                    return;
	                }
	                case "audio": {
	                    const newAttachment = {
	                        kind: "audio" ,
	                        uploadData: {
	                            objectURL,
	                            filename: file.name,
	                            size: file.size,
	                            contentType: file.type,
	                        },
	                        state: AttachmentState.Pending,
	                        uploadState: "not-started" ,
	                    };

	                    insertAttachment({
	                        position: -1,
	                        kind: "audio",
	                        sourceUrl: objectURL,
	                        attachment: newAttachment,
	                        artist: "",
	                        title: "",
	                    });

	                    return;
	                }
	            }
	        },
	        updateAttachmentDimensions(
	            state,
	            action




	        ) {
	            const node = state.body.nodes[action.payload.nodeId];

	            if (node.type !== "image-attachment") {
	                throw new Error("expected image attachment node");
	            }

	            state.body.nodes[action.payload.nodeId] = {
	                ...node,
	                width: action.payload.width,
	                height: action.payload.height,
	            };
	        },
	        moveAttachmentToNewRow(
	            state,
	            action




	        ) {
	            const { attachmentNodeId, relativeNodeId, position } =
	                action.payload;

	            const node = state.body.nodes[attachmentNodeId];

	            if (node.type === "image-attachment") {
	                // image attachment flow, we need attachment rows here.
	                const currentRowNodeId = findAttachmentRowContainingAttachment(
	                    attachmentNodeId,
	                    state.body.nodes
	                );

	                if (currentRowNodeId === null) {
	                    throw new Error("attachment not in a row");
	                }

	                // create new row
	                const newRow = {
	                    type: "attachment-row",
	                    attachments: [attachmentNodeId],
	                    nodeId: generateNodeId(),
	                };

	                // find where we're putting it
	                const relativeNodeIndex =
	                    state.body.nodeOrder.indexOf(relativeNodeId);
	                const insertionIndex =
	                    position === "before"
	                        ? relativeNodeIndex
	                        : relativeNodeIndex + 1;

	                // insert the new row
	                state.body.nodeOrder.splice(insertionIndex, 0, newRow.nodeId);
	                state.body.nodes[newRow.nodeId] = newRow;

	                // remove the attachment from its current row
	                const currentRow = state.body.nodes[currentRowNodeId];
	                if (!currentRow || currentRow.type !== "attachment-row") {
	                    throw new Error("attachment not in a row");
	                }
	                currentRow.attachments = currentRow.attachments.filter(
	                    (id) => id !== attachmentNodeId
	                );
	                if (currentRow.attachments.length === 0) {
	                    // row is now empty, remove it from the tree
	                    state.body.nodeOrder = state.body.nodeOrder.filter(
	                        (id) => id !== currentRowNodeId
	                    );
	                    delete state.body.nodes[currentRowNodeId];
	                }
	            } else {
	                // find where it currently is
	                const currentNodeIndex =
	                    state.body.nodeOrder.indexOf(attachmentNodeId);

	                // find where we're putting it
	                const relativeNodeIndex =
	                    state.body.nodeOrder.indexOf(relativeNodeId);
	                const newIndex =
	                    position === "before"
	                        ? relativeNodeIndex
	                        : relativeNodeIndex + 1;

	                state.body.nodeOrder = reorder({
	                    list: state.body.nodeOrder,
	                    startIndex: currentNodeIndex,
	                    finishIndex: newIndex,
	                });
	            }

	            // finish up
	            state.dirty = true;
	        },
	        moveAttachmentToExistingRow(
	            state,
	            action




	        ) {
	            const { attachmentNodeId, rowNodeId, positionInRow } =
	                action.payload;
	            const currentRowNodeId = findAttachmentRowContainingAttachment(
	                attachmentNodeId,
	                state.body.nodes
	            );

	            if (currentRowNodeId === null) {
	                throw new Error("attachment not in a row");
	            }

	            if (currentRowNodeId !== rowNodeId) {
	                // remove it from its current row
	                const currentRow = state.body.nodes[currentRowNodeId];
	                if (!currentRow || currentRow.type !== "attachment-row") {
	                    throw new Error("attachment not in a row");
	                }
	                currentRow.attachments = currentRow.attachments.filter(
	                    (id) => id !== attachmentNodeId
	                );
	                if (currentRow.attachments.length === 0) {
	                    // row is now empty, remove it from the tree
	                    state.body.nodeOrder = state.body.nodeOrder.filter(
	                        (id) => id !== currentRowNodeId
	                    );
	                    delete state.body.nodes[currentRowNodeId];
	                }
	                // add to the new row
	                const newRow = state.body.nodes[rowNodeId];
	                if (!newRow || newRow.type !== "attachment-row") {
	                    throw new Error("attachment not in a row");
	                }
	                newRow.attachments.splice(positionInRow, 0, attachmentNodeId);
	            } else {
	                // same row, just rearrange
	                const currentRow = state.body.nodes[currentRowNodeId];
	                if (!currentRow || currentRow.type !== "attachment-row") {
	                    throw new Error("attachment not in a row");
	                }

	                const reordered = reorder({
	                    list: currentRow.attachments,
	                    startIndex:
	                        currentRow.attachments.indexOf(attachmentNodeId),
	                    finishIndex: positionInRow,
	                });
	                currentRow.attachments = reordered;
	            }

	            state.dirty = true;
	        },
	        deleteNodeAtIndex(state, action) {
	            const node = state.body.nodes[action.payload];
	            if (node.type === "attachment-row") {
	                if (node.attachments.length > 0) return;
	            } else if (isAttachmentNode(node)) {
	                // check if it's in the node order. if not, we need to find the
	                // row it's in and remove from there.
	                if (!state.body.nodeOrder.includes(action.payload)) {
	                    for (const rowId of state.body.nodeOrder) {
	                        const row = state.body.nodes[rowId];
	                        if (
	                            row.type === "attachment-row" &&
	                            row.attachments.includes(action.payload)
	                        ) {
	                            row.attachments = row.attachments.filter(
	                                (attachmentId) =>
	                                    attachmentId !== action.payload
	                            );
	                            break;
	                        }
	                    }
	                }
	            }
	            state.body.nodeOrder = state.body.nodeOrder.filter(
	                (nodeId) => nodeId !== action.payload
	            );
	            delete state.body.nodes[action.payload];
	            state.dirty = true;
	        },
	        insertTextNodeAtEnd(state) {
	            const emptyTextNode = {
	                type: "text",
	                text: "",
	                nodeId: generateNodeId(),
	            };

	            state.body.nodes[emptyTextNode.nodeId] = emptyTextNode;
	            state.body.nodeOrder.push(emptyTextNode.nodeId);
	            state.dirty = true;
	        },
	        setActiveProject(state, action) {
	            state.projectHandle = action.payload;
	        },
	        setAdultContent(state, action) {
	            state.adultContent = action.payload;
	        },
	        setCws(state, action) {
	            state.cws = action.payload;
	            state.dirty = true;
	        },
	        setHeadline(state, action) {
	            state.headline = action.payload.replace("\n", " ").slice(0, 140);
	            state.dirty = true;
	        },
	        setNewPostState(state, action) {
	            state.newPostState = action.payload;
	            state.dirty = true;
	        },
	        setTags(state, action) {
	            state.tags = action.payload;
	            state.dirty = true;
	        },
	        toggleCwsInputOpen(state) {
	            // if there's already text input then you can't disable CWs
	            if (state.cws.length > 0) state.cwsInputOpen = true;
	            state.cwsInputOpen = !state.cwsInputOpen;
	        },
	        abandon() {
	            return { ...initialState };
	        },
	        mergeTextNodes(
	            state,
	            action


	        ) {
	            const { firstNodeId } = action.payload;
	            const nodeOrder = state.body.nodeOrder;
	            const firstNodeIndex = nodeOrder.indexOf(firstNodeId);
	            const secondNodeIndex = firstNodeIndex + 1;

	            if (secondNodeIndex >= nodeOrder.length) {
	                // nothing to do here
	                return;
	            }

	            const firstNode = state.body.nodes[firstNodeId];
	            const secondNode = state.body.nodes[nodeOrder[secondNodeIndex]];

	            if (firstNode.type !== "text" || secondNode.type !== "text") {
	                // nothing to do here
	                return;
	            }

	            if (secondNode.text.trim().length === 0) {
	                // we have an empty node, just remove it and move on.
	                state.body.nodeOrder.splice(secondNodeIndex, 1);
	                delete state.body.nodes[secondNode.nodeId];
	                return;
	            }

	            // merge the text
	            firstNode.text += "\n\n" + secondNode.text;

	            // remove the second node
	            state.body.nodeOrder.splice(secondNodeIndex, 1);
	            delete state.body.nodes[secondNode.nodeId];
	        },
	        splitTextNodeAndInsertAttachment(
	            state,
	            action




	        ) {
	            const { textNodeId, attachmentNodeId, splitBlockIndex } =
	                action.payload;
	            const textNode = state.body.nodes[textNodeId];
	            const attachmentNode = state.body.nodes[attachmentNodeId];

	            if (textNode.type !== "text") {
	                throw new Error("can't split non-text node");
	            }

	            if (!isAttachmentNode(attachmentNode)) {
	                throw new Error("can't split with non-attachment node");
	            }

	            // get the text blocks
	            const blocks = textNode.text
	                .trim()
	                .split("\n\n")
	                .map((text) => text.trim());

	            const beforeBlocks = blocks.slice(0, splitBlockIndex);
	            const afterBlocks = blocks.slice(splitBlockIndex);

	            // update the text node
	            textNode.text = beforeBlocks.join("\n\n");

	            // create the new text node
	            const newText = {
	                type: "text",
	                text: afterBlocks.join("\n\n"),
	                nodeId: generateNodeId(),
	            };

	            // images are in rows
	            if (attachmentNode.type === "image-attachment") {
	                // create the attachment row node
	                const newRow = {
	                    type: "attachment-row",
	                    attachments: [attachmentNodeId],
	                    nodeId: generateNodeId(),
	                };

	                // remove the attachment from its old row
	                const oldRowId = findAttachmentRowContainingAttachment(
	                    attachmentNodeId,
	                    state.body.nodes
	                );
	                if (oldRowId) {
	                    const oldRow = state.body.nodes[oldRowId];
	                    if (oldRow.type === "attachment-row") {
	                        oldRow.attachments = oldRow.attachments.filter(
	                            (id) => id !== attachmentNodeId
	                        );

	                        // remove it if it's empty
	                        if (oldRow.attachments.length === 0) {
	                            state.body.nodeOrder = state.body.nodeOrder.filter(
	                                (id) => id !== oldRowId
	                            );
	                            delete state.body.nodes[oldRowId];
	                        }
	                    }
	                }

	                // insert the new nodes
	                state.body.nodes[newRow.nodeId] = newRow;

	                state.body.nodeOrder.splice(
	                    state.body.nodeOrder.indexOf(textNodeId) + 1,
	                    0,
	                    newRow.nodeId,
	                    newText.nodeId
	                );
	            } else {
	                // audio attachments are just in the body. remove from its old position and move it to the new one.
	                state.body.nodeOrder = state.body.nodeOrder.filter(
	                    (id) => id !== attachmentNodeId
	                );

	                state.body.nodeOrder.splice(
	                    state.body.nodeOrder.indexOf(textNodeId) + 1,
	                    0,
	                    attachmentNodeId,
	                    newText.nodeId
	                );
	            }

	            state.body.nodes[newText.nodeId] = newText;

	            state.dirty = true;
	        },
	    }),
	    extraReducers: (builder) => {
	        builder.addCase(submit.pending, (state) => {
	            state.state = "uploading";
	        });

	        builder.addCase(submit.rejected, (state, action) => {
	            if (action.payload) {
	                state.validationErrors["app"] = action.payload;
	            }
	            state.state = "editing";
	        });

	        builder.addCase(submit.fulfilled, (state) => {
	            state.state = "editing";
	            state.dirty = false;
	        });

	        builder.addCase(submitCreatePost.rejected, (state, action) => {
	            if (action.payload) {
	                state.validationErrors["app"] = action.payload;
	            }
	            state.state = "failed";
	        });

	        builder.addCase(submitCreatePost.fulfilled, (state, action) => {
	            state.postId = action.payload.postId;
	            state.state = action.payload.nextPostEditorState;
	        });

	        builder.addCase(submitUploadAttachment.rejected, (state, action) => {
	            if (action.payload) {
	                state.validationErrors["app"] = action.payload;
	            }
	            state.state = "failed";
	        });

	        builder.addCase(submitUploadAttachment.fulfilled, (state, action) => {
	            const nodeId = action.meta.arg.nodeId;
	            // we've already successfully uploaded this region as an attachment,
	            // so just assume that it's an attachment node
	            const node = state.body.nodes[nodeId] ;

	            state.body.nodes[nodeId] = {
	                ...node,
	                attachment: {
	                    ...node.attachment,
	                    attachmentId: action.payload.attachmentId,
	                    state: AttachmentState.Finished,
	                    uploadState: "finished",
	                },
	            };
	        });

	        builder.addCase(submitUpdatePost.rejected, (state, action) => {
	            if (action.payload) {
	                state.validationErrors["app"] = action.payload;
	            }
	            state.state = "failed";
	        });

	        builder.addCase(submitUpdatePost.fulfilled, (state) => {
	            state.state = "finished";
	        });

	        startAppListening({
	            actionCreator: submitUploadAttachment.fulfilled,
	            effect: (action, listenerApi) => {
	                const state = listenerApi.getState().postComposer;
	                const attachmentsToUpload =
	                    selectAttachmentNodeIdsToUpload(state);

	                if (attachmentsToUpload.length == 0) {
	                    // we're done uploading attachments; update the post
	                    void listenerApi.dispatch(submitUpdatePost());
	                }
	            },
	        });

	        // cleanup empty attachment rows
	        startAppListening({
	            predicate: (action, state) =>
	                Object.values(state.postComposer.body.nodes).some(
	                    (node) =>
	                        node.type === "attachment-row" &&
	                        node.attachments.length === 0
	                ),
	            effect: (action, listenerApi) => {
	                const state = listenerApi.getState().postComposer;
	                const emptyRowIds = Object.values(state.body.nodes)
	                    .filter(
	                        (node) =>
	                            node.type === "attachment-row" &&
	                            node.attachments.length === 0
	                    )
	                    .map((node) => node.nodeId);

	                emptyRowIds.forEach((rowId) =>
	                    listenerApi.dispatch(deleteNodeAtIndex(rowId))
	                );
	            },
	        });

	        // merge text nodes
	        startAppListening({
	            predicate: (action, state) => {
	                // check for adjacent text nodes
	                const nodeOrder = state.postComposer.body.nodeOrder;
	                return nodeOrder.some((nodeId, index) => {
	                    if (index === nodeOrder.length - 1) return false;

	                    const node = state.postComposer.body.nodes[nodeId];
	                    const nextNode =
	                        state.postComposer.body.nodes[nodeOrder[index + 1]];

	                    return node.type === "text" && nextNode.type === "text";
	                });
	            },
	            effect: (action, listenerApi) => {
	                const state = listenerApi.getState().postComposer;
	                const nodeOrder = state.body.nodeOrder;
	                const firstNodeId = nodeOrder.find((nodeId, index) => {
	                    if (index === nodeOrder.length - 1) return false;

	                    const node = state.body.nodes[nodeId];
	                    const nextNode = state.body.nodes[nodeOrder[index + 1]];

	                    return node.type === "text" && nextNode.type === "text";
	                });

	                if (firstNodeId) {
	                    listenerApi.dispatch(mergeTextNodes({ firstNodeId }));
	                }
	            },
	        });

	        // make sure we always have a text node at the end
	        startAppListening({
	            predicate: (action, state) => {
	                const lastNode =
	                    state.postComposer.body.nodes[
	                        state.postComposer.body.nodeOrder[
	                            state.postComposer.body.nodeOrder.length - 1
	                        ]
	                    ];
	                if (!lastNode) return false;

	                return lastNode.type !== "text";
	            },
	            effect: (action, listenerApi) => {
	                listenerApi.dispatch(insertTextNodeAtEnd());
	            },
	        });

	        // update image dimensions
	        startAppListening({
	            actionCreator: insertFile,
	            effect: async (action, listenerApi) => {
	                listenerApi.cancelActiveListeners();

	                const state = listenerApi.getState().postComposer;

	                // get image attachments with empty dimensions
	                const attachments = Object.values(state.body.nodes).filter(
	                    (node) =>
	                        node.type === "image-attachment" &&
	                        (!node.width || !node.height)
	                ) ;
	                await Promise.all(
	                    attachments.map(async (attachment) => {
	                        if (!attachment.attachment.uploadData?.objectURL) {
	                            return;
	                        }
	                        const dimensions = await getImageDimensions(
	                            attachment.attachment.uploadData?.objectURL
	                        );
	                        listenerApi.dispatch(
	                            updateAttachmentDimensions({
	                                nodeId: attachment.nodeId,
	                                width: dimensions.width,
	                                height: dimensions.height,
	                            })
	                        );
	                    })
	                );
	            },
	        });
	    },
	    selectors: {
	        selectAdultContent: (state) => state.adultContent,
	        selectAttachmentNodeIdsToUpload,
	        selectBody: (state) => state.body,
	        selectCreatingTransparentShare: (state) => {
	            const { blocks } = _selectRenderedPost(state);

	            return !!state.shareOfPostId && !state.headline && !blocks.length;
	        },
	        selectCws: (state) => state.cws,
	        selectCwsButtonEnabled: (state) =>
	            !state.cwsInputOpen || state.cws.length == 0,
	        selectCwsInputOpen: (state) => state.cwsInputOpen,
	        selectDirty: (state) => state.dirty,
	        selectEditingTransparentShare: (state) => state.editingTransparentShare,
	        selectErrors: (state) =>
	            _$5.size(state.validationErrors) > 0
	                ? _$5.values(state.validationErrors)
	                : EMPTY_ARRAY,
	        selectHasErrors: (state) => _$5.size(state.validationErrors) > 0,
	        selectHasPosted: (state) => state.state === "finished",
	        selectHeadline: (state) => state.headline,
	        selectIsEditing: (state) => state.state === "editing",
	        selectMaxAttachmentsChosen: (state) =>
	            _$5.filter(state.body.nodes, (node) => isAttachmentNode(node))
	                .length >= state.maximumAllowedAttachments,
	        selectNewPostState: (state) => state.newPostState,
	        selectPostId: (state) => state.postId,
	        selectProjectHandle: (state) => state.projectHandle,
	        selectRenderedPost: _selectRenderedPost,
	        selectShareOfPostId: (state) => state.shareOfPostId,
	        selectTags: (state) => state.tags,
	    },
	});

	const {
	    initForNewPost,
	    initForEditing,
	    deleteNodeAtIndex,
	    insertFile,
	    insertNewTextAtSelection,
	    moveAttachmentToExistingRow,
	    setActiveProject,
	    setAdultContent,
	    setCws,
	    setHeadline,
	    setNewPostState,
	    setTags,
	    toggleCwsInputOpen,
	    updateAudioMetadata,
	    updateImageAltText,
	    updateTextRegion,
	    abandon,
	    moveAttachmentToNewRow,
	    insertTextNodeAtEnd,
	    mergeTextNodes,
	    splitTextNodeAndInsertAttachment,
	    updateAttachmentDimensions,
	} = postComposerSlice.actions;
	const {
	    selectAdultContent,
	    selectBody: selectBody$1,
	    selectCreatingTransparentShare,
	    selectCws,
	    selectCwsButtonEnabled,
	    selectCwsInputOpen,
	    selectDirty,
	    selectEditingTransparentShare,
	    selectErrors,
	    selectHasErrors,
	    selectHasPosted,
	    selectHeadline,
	    selectIsEditing: selectIsEditing$2,
	    selectMaxAttachmentsChosen,
	    selectNewPostState,
	    selectPostId,
	    selectProjectHandle,
	    selectRenderedPost,
	    selectShareOfPostId,
	    selectTags,
	} = postComposerSlice.selectors;
	postComposerSlice.reducer;

	const CwsInput = () => {
	    const { t } = useTranslation();

	    const isEditing = useSelector(selectIsEditing$2);
	    const cws = useSelector(selectCws);
	    const cwsInputOpen = useSelector(selectCwsInputOpen);
	    const dispatch = useDispatch();

	    const onCwsChange = reactExports.useCallback(
	        (cws) => {
	            dispatch(setCws(cws));
	        },
	        [dispatch]
	    );

	    return cwsInputOpen ? (
	        React$2.createElement(TokenInput, {
	            TokenIcon: ForwardRef$3,
	            className: "co-editable-body w-full p-0 px-3 leading-none"    ,
	            tokens: cws,
	            setTokens: onCwsChange,
	            placeholder: t(
	                "client:post-editor.cws-placeholder",
	                "add content warnings"
	            ),
	            disabled: !isEditing,
	            fieldName: "CW",}
	        )
	    ) : null;
	};

	const useAppDispatch = useDispatch;
	const useAppSelector = useSelector;

	const HeadlineInput = React$2.memo(() => {
	    const dispatch = useAppDispatch();
	    const { t } = useTranslation();

	    const onHeadlineInput =
	        reactExports.useCallback(
	            ({ currentTarget }) => {
	                dispatch(setHeadline(currentTarget.value));
	            },
	            [dispatch]
	        );

	    const headline = useAppSelector(selectHeadline);
	    const isEditing = useAppSelector(selectIsEditing$2);

	    return (
	        React$2.createElement('div', { className: "flex w-full flex-row items-end justify-between gap-3"     ,}
	            , React$2.createElement(ExpandingTextArea, {
	                className: tw`co-editable-body w-full flex-1 resize-none overflow-hidden 
                    break-words border-none p-0 px-3 font-atkinson text-xl font-bold focus:ring-0`,
	                placeholder: t(
	                    "client:post-editor.headline-placeholder",
	                    "headline"
	                ),
	                name: "headline",
	                onInput: onHeadlineInput,
	                disabled: !isEditing,
	                minRows: 1,
	                value: headline,}
	            )
	            , headline.length > 100 ? (
	                React$2.createElement('div', { className: "flex-none px-3 tabular-nums text-gray-500"   ,}
	                    , headline.length, "/140"

	                )
	            ) : null
	        )
	    );
	});
	HeadlineInput.displayName = "HeadlineInput";

	const TagsInput = () => {
	    const dispatch = useAppDispatch();
	    const tags = useAppSelector(selectTags);
	    const isEditing = useAppSelector(selectIsEditing$2);

	    const { t } = useTranslation();

	    const onTagsChange = reactExports.useCallback(
	        (tags) => {
	            dispatch(setTags(tags));
	        },
	        [dispatch]
	    );

	    return (
	        React$2.createElement(TokenInput, {
	            className: "co-editable-body w-full p-0 px-3 leading-none"    ,
	            TokenIcon: ForwardRef$2,
	            tokens: tags,
	            setTokens: onTagsChange,
	            placeholder: t("client:post-editor.tags-placeholder", "#add tags"),
	            disabled: !isEditing,
	            getSuggestions: true,
	            fieldName: "tag",}
	        )
	    );
	};

	const AttachmentComposer = reactExports.forwardRef

	((props, ref) => {
	    const body = useAppSelector(selectBody$1);
	    const dispatch = useAppDispatch();
	    const [isOpen, setIsOpen] = reactExports.useState(false);
	    const dynamicTheme = useDynamicTheme();

	    const [activeNodeId, setActiveNodeId] = reactExports.useState(null);
	    const activeNode = activeNodeId
	        ? (body.nodes[activeNodeId] )
	        : null;

	    reactExports.useImperativeHandle(
	        ref,
	        () => {
	            return {
	                open(initialNodeId) {
	                    setIsOpen(true);
	                    setActiveNodeId(initialNodeId);
	                },
	            };
	        },
	        []
	    );

	    const onAltTextChange = reactExports.useCallback

	(
	        (e) => {
	            if (activeNodeId) {
	                dispatch(
	                    updateImageAltText({
	                        nodeId: activeNodeId,
	                        altText: e.currentTarget.value,
	                    })
	                );
	            }
	        },
	        [activeNodeId, dispatch]
	    );

	    const [dialogRef, setDialogRef] = reactExports.useState(null);

	    reactExports.useEffect(() => {
	        if (isOpen && dialogRef?.open !== true) {
	            dialogRef?.showModal();
	        } else if (!isOpen && dialogRef?.open === true) {
	            dialogRef?.close();
	        }
	    }, [dialogRef, isOpen]);

	    const imageNodes = reactExports.useMemo(() => {
	        const nodes = [];

	        Object.values(body.nodes).forEach((node, index) => {
	            // TODO: fix index to actually reflect attachment order
	            if (!isImageAttachmentNode(node)) return;

	            nodes.push({ node, index });
	        });

	        return nodes;
	    }, [body]);

	    return (
	        React$2.createElement('dialog', {
	            ref: setDialogRef,
	            // @ts-expect-error again, typedefs are broken for dialog
	            onClose: () => {
	                setIsOpen(false);
	            },
	            'data-theme': dynamicTheme.current,
	            className: "co-themed-box co-attachment-composer cohost-shadow-light dark:cohost-shadow-dark h-max w-full max-w-prose flex-col gap-2 rounded-lg p-3 backdrop:bg-notBlack/90 open:flex"            ,}

	            , React$2.createElement('div', { className: "flex flex-row justify-center gap-9"   ,}
	                , imageNodes.map(({ index, node }) => (
	                    React$2.createElement('button', {
	                        key: node.nodeId,
	                        onClick: () => setActiveNodeId(node.nodeId),}

	                        , React$2.createElement('img', {
	                            src: node.sourceUrl,
	                            className: classNames(
	                                "h-[4.5rem] w-[4.5rem] object-cover",
	                                node.nodeId === activeNodeId
	                                    ? tw`co-active border-4`
	                                    : "opacity-50"
	                            ),
	                            alt: node.altText,}
	                        )
	                    )
	                ))
	            )

	            , React$2.createElement('label', null
	                , React$2.createElement('p', { className: tw`co-ui-text font-bold`,}, "image description" )

	                , React$2.createElement(ExpandingTextArea, {
	                    name: "alt-text",
	                    minRows: 1,
	                    onChange: onAltTextChange,
	                    className: "co-editable-body",
	                    value: activeNode?.altText,}
	                )
	            )

	            , React$2.createElement(BasicButton, {
	                buttonSize: "regular",
	                buttonColor: "post-box-filled",
	                extraClasses: "self-end",
	                onClick: () => setIsOpen(false),}
	, "done"

	            )
	        )
	    );
	});
	AttachmentComposer.displayName = "AttachmentComposer";

	const AttachmentComposerContext = React$2.createContext

	(undefined);

	function _typeof(obj) {
	  "@babel/helpers - typeof";

	  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
	    return typeof obj;
	  } : function (obj) {
	    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
	  }, _typeof(obj);
	}

	function _toPrimitive(input, hint) {
	  if (_typeof(input) !== "object" || input === null) return input;
	  var prim = input[Symbol.toPrimitive];
	  if (prim !== undefined) {
	    var res = prim.call(input, hint || "default");
	    if (_typeof(res) !== "object") return res;
	    throw new TypeError("@@toPrimitive must return a primitive value.");
	  }
	  return (hint === "string" ? String : Number)(input);
	}

	function _toPropertyKey(arg) {
	  var key = _toPrimitive(arg, "string");
	  return _typeof(key) === "symbol" ? key : String(key);
	}

	function _defineProperty(obj, key, value) {
	  key = _toPropertyKey(key);
	  if (key in obj) {
	    Object.defineProperty(obj, key, {
	      value: value,
	      enumerable: true,
	      configurable: true,
	      writable: true
	    });
	  } else {
	    obj[key] = value;
	  }
	  return obj;
	}

	function ownKeys$2(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
	function _objectSpread$2(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$2(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$2(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
	// re-exporting type to make it easy to use

	var getDistanceToEdge = {
	  top: function top(rect, client) {
	    return Math.abs(client.y - rect.top);
	  },
	  right: function right(rect, client) {
	    return Math.abs(rect.right - client.x);
	  },
	  bottom: function bottom(rect, client) {
	    return Math.abs(rect.bottom - client.y);
	  },
	  left: function left(rect, client) {
	    return Math.abs(client.x - rect.left);
	  }
	};

	// using a symbol so we can guarantee a key with a unique value
	var uniqueKey = Symbol('closestEdge');

	/**
	 * Adds a unique `Symbol` to the `userData` object. Use with `extractClosestEdge()` for type safe lookups.
	 */
	function attachClosestEdge(userData, _ref) {
	  var _entries$sort$0$edge, _entries$sort$;
	  var element = _ref.element,
	    input = _ref.input,
	    allowedEdges = _ref.allowedEdges;
	  var client = {
	    x: input.clientX,
	    y: input.clientY
	  };
	  // I tried caching the result of `getBoundingClientRect()` for a single
	  // frame in order to improve performance.
	  // However, on measurement I saw no improvement. So no longer caching
	  var rect = element.getBoundingClientRect();
	  var entries = allowedEdges.map(function (edge) {
	    return {
	      edge: edge,
	      value: getDistanceToEdge[edge](rect, client)
	    };
	  });

	  // edge can be `null` when `allowedEdges` is []
	  var addClosestEdge = (_entries$sort$0$edge = (_entries$sort$ = entries.sort(function (a, b) {
	    return a.value - b.value;
	  })[0]) === null || _entries$sort$ === void 0 ? void 0 : _entries$sort$.edge) !== null && _entries$sort$0$edge !== void 0 ? _entries$sort$0$edge : null;
	  return _objectSpread$2(_objectSpread$2({}, userData), {}, _defineProperty({}, uniqueKey, addClosestEdge));
	}

	/**
	 * Returns the value added by `attachClosestEdge()` to the `userData` object. It will return `null` if there is no value.
	 */
	function extractClosestEdge(userData) {
	  var _ref2;
	  return (_ref2 = userData[uniqueKey]) !== null && _ref2 !== void 0 ? _ref2 : null;
	}

	/** Create a new combined function that will call all the provided functions */
	function combine() {
	  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
	    fns[_key] = arguments[_key];
	  }
	  return function cleanup() {
	    fns.forEach(function (fn) {
	      return fn();
	    });
	  };
	}

	var dist = {};

	var bind$1 = {};

	Object.defineProperty(bind$1, "__esModule", { value: true });
	bind$1.bind = void 0;
	function bind(target, _a) {
	    var type = _a.type, listener = _a.listener, options = _a.options;
	    target.addEventListener(type, listener, options);
	    return function unbind() {
	        target.removeEventListener(type, listener, options);
	    };
	}
	bind$1.bind = bind;

	var bindAll$1 = {};

	var __assign = (commonjsGlobal && commonjsGlobal.__assign) || function () {
	    __assign = Object.assign || function(t) {
	        for (var s, i = 1, n = arguments.length; i < n; i++) {
	            s = arguments[i];
	            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
	                t[p] = s[p];
	        }
	        return t;
	    };
	    return __assign.apply(this, arguments);
	};
	Object.defineProperty(bindAll$1, "__esModule", { value: true });
	bindAll$1.bindAll = void 0;
	var bind_1 = bind$1;
	function toOptions(value) {
	    if (typeof value === 'undefined') {
	        return undefined;
	    }
	    if (typeof value === 'boolean') {
	        return {
	            capture: value,
	        };
	    }
	    return value;
	}
	function getBinding(original, sharedOptions) {
	    if (sharedOptions == null) {
	        return original;
	    }
	    var binding = __assign(__assign({}, original), { options: __assign(__assign({}, toOptions(sharedOptions)), toOptions(original.options)) });
	    return binding;
	}
	function bindAll(target, bindings, sharedOptions) {
	    var unbinds = bindings.map(function (original) {
	        var binding = getBinding(original, sharedOptions);
	        return (0, bind_1.bind)(target, binding);
	    });
	    return function unbindAll() {
	        unbinds.forEach(function (unbind) { return unbind(); });
	    };
	}
	bindAll$1.bindAll = bindAll;

	(function (exports) {
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.bindAll = exports.bind = void 0;
		var bind_1 = bind$1;
		Object.defineProperty(exports, "bind", { enumerable: true, get: function () { return bind_1.bind; } });
		var bind_all_1 = bindAll$1;
		Object.defineProperty(exports, "bindAll", { enumerable: true, get: function () { return bind_all_1.bindAll; } }); 
	} (dist));

	function _arrayLikeToArray$2(arr, len) {
	  if (len == null || len > arr.length) len = arr.length;
	  for (var i = 0, arr2 = new Array(len); i < len; i++) {
	    arr2[i] = arr[i];
	  }
	  return arr2;
	}

	function _arrayWithoutHoles(arr) {
	  if (Array.isArray(arr)) return _arrayLikeToArray$2(arr);
	}

	function _iterableToArray(iter) {
	  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
	}

	function _unsupportedIterableToArray$2(o, minLen) {
	  if (!o) return;
	  if (typeof o === "string") return _arrayLikeToArray$2(o, minLen);
	  var n = Object.prototype.toString.call(o).slice(8, -1);
	  if (n === "Object" && o.constructor) n = o.constructor.name;
	  if (n === "Map" || n === "Set") return Array.from(o);
	  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$2(o, minLen);
	}

	function _nonIterableSpread() {
	  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
	}

	function _toConsumableArray(arr) {
	  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray$2(arr) || _nonIterableSpread();
	}

	/**
	 * Create a new function that will cache the result of it's first call forever.
	 * This is similar to `memoize-one`, except the cache for `memoize-one` can be
	 * updated if the arguments change.
	 *
	 * @example
	 * function sayHello(name: string): string {
	 *   return `Hello ${name}`;
	 * }
	 * const cached = cacheFirst(sayHello);
	 *
	 * cached('Alex');
	 * cached('Declan'); // original result of `sayHello` call is returned
	 */
	function cacheFirst(fn) {
	  var result = null;
	  return function single() {
	    if (!result) {
	      result = {
	        value: fn.apply(void 0, arguments)
	      };
	    }
	    return result.value;
	  };
	}

	// using `cache` as our `isFirefox()` result will not change in a browser

	/**
	 * Returns `true` if a `Firefox` browser
	 * */
	var isFirefox = cacheFirst(function isFirefox() {
	  return navigator.userAgent.includes('Firefox');
	});

	// using `cache` as our `isSafari()` result will not change in a browser

	/**
	 * Returns `true` if a `Safari` browser.
	 * Returns `true` if the browser is running on iOS (they are all Safari).
	 * */
	var isSafari = cacheFirst(function isSafari() {
	  var _navigator = navigator,
	    userAgent = _navigator.userAgent;
	  return userAgent.includes('AppleWebKit') && !userAgent.includes('Chrome');
	});

	/* For "dragenter" events, the browser should set `relatedTarget` to the previous element.
	 * For external drag operations, our first "dragenter" event should have a `event.relatedTarget` of `null`.
	 *
	 *  Unfortunately in Safari `event.relatedTarget` is *always* set to `null`
	 *  Safari bug: https://bugs.webkit.org/show_bug.cgi?id=242627
	 *  To work around this we count "dragenter" and "dragleave" events */

	// Using symbols for event properties so we don't clash with
	// anything on the `event` object
	var symbols = {
	  isLeavingWindow: Symbol('leaving'),
	  isEnteringWindow: Symbol('entering')
	};
	function isEnteringWindowInSafari(_ref) {
	  var dragEnter = _ref.dragEnter;
	  if (!isSafari()) {
	    return false;
	  }
	  return dragEnter.hasOwnProperty(symbols.isEnteringWindow);
	}
	function isLeavingWindowInSafari(_ref2) {
	  var dragLeave = _ref2.dragLeave;
	  if (!isSafari()) {
	    return false;
	  }
	  return dragLeave.hasOwnProperty(symbols.isLeavingWindow);
	}
	(function fixSafari() {
	  // Don't do anything when server side rendering
	  if (typeof window === 'undefined') {
	    return;
	  }
	  if (!isSafari()) {
	    return;
	  }
	  function getInitialState() {
	    return {
	      enterCount: 0,
	      isOverWindow: false
	    };
	  }
	  var state = getInitialState();
	  function resetState() {
	    state = getInitialState();
	  }

	  // These event listeners are bound _forever_ and _never_ removed
	  // We don't bother cleaning up these event listeners (for now)
	  // as this workaround is only for Safari

	  // This is how the event count works:
	  //
	  // lift (+1 enterCount)
	  // - dragstart(draggable) [enterCount: 0]
	  // - dragenter(draggable) [enterCount: 1]
	  // leaving draggable (+0 enterCount)
	  // - dragenter(document.body) [enterCount: 2]
	  // - dragleave(draggable) [enterCount: 1]
	  // leaving window (-1 enterCount)
	  // - dragleave(document.body) [enterCount: 0] {leaving the window}

	  // Things to note:
	  // - dragenter and dragleave bubble
	  // - the first dragenter when entering a window might not be on `window`
	  //   - it could be on an element that is pressed up against the window
	  //   - (so we cannot rely on `event.target` values)

	  dist.bindAll(window, [{
	    type: 'dragstart',
	    listener: function listener() {
	      state.enterCount = 0;
	      // drag start occurs in the source window
	      state.isOverWindow = true;
	      // When a drag first starts it will also trigger a "dragenter" on the draggable element
	    }
	  }, {
	    type: 'drop',
	    listener: resetState
	  }, {
	    type: 'dragend',
	    listener: resetState
	  }, {
	    type: 'dragenter',
	    listener: function listener(event) {
	      if (!state.isOverWindow && state.enterCount === 0) {
	        // Patching the `event` object
	        // The `event` object is shared with all event listeners for the event
	        // @ts-expect-error: adding property to the event object
	        event[symbols.isEnteringWindow] = true;
	      }
	      state.isOverWindow = true;
	      state.enterCount++;
	    }
	  }, {
	    type: 'dragleave',
	    listener: function listener(event) {
	      state.enterCount--;
	      if (state.isOverWindow && state.enterCount === 0) {
	        // Patching the `event` object as it is shared with all event listeners
	        // The `event` object is shared with all event listeners for the event
	        // @ts-expect-error: adding property to the event object
	        event[symbols.isLeavingWindow] = true;
	        state.isOverWindow = false;
	      }
	    }
	  }],
	  // using `capture: true` so that adding event listeners
	  // in bubble phase will have the correct symbols
	  {
	    capture: true
	  });
	})();

	/**
	 * Does the `EventTarget` look like a `Node` based on "duck typing".
	 *
	 * Helpful when the `Node` might be outside of the current document
	 * so we cannot to an `target instanceof Node` check.
	 */
	function isNodeLike(target) {
	  return 'nodeName' in target;
	}

	/**
	 * Is an `EventTarget` a `Node` from another `window`?
	 */
	function isFromAnotherWindow(eventTarget) {
	  return isNodeLike(eventTarget) && eventTarget.ownerDocument !== document;
	}

	function isLeavingWindow(_ref) {
	  var dragLeave = _ref.dragLeave;
	  var type = dragLeave.type,
	    relatedTarget = dragLeave.relatedTarget;
	  if (type !== 'dragleave') {
	    return false;
	  }
	  if (isSafari()) {
	    return isLeavingWindowInSafari({
	      dragLeave: dragLeave
	    });
	  }

	  // Standard check: if going to `null` we are leaving the `window`
	  if (relatedTarget == null) {
	    return true;
	  }

	  /**
	   * 🦊 Exception: `iframe` in Firefox (`125.0`)
	   *
	   * Case 1: parent `window` → child `iframe`
	   * `dragLeave.relatedTarget` is element _inside_ the child `iframe`
	   * (foreign element)
	   *
	   * Case 2: child `iframe` → parent `window`
	   * `dragLeave.relatedTarget` is the `iframe` in the parent `window`
	   * (foreign element)
	   */

	  if (isFirefox()) {
	    return isFromAnotherWindow(relatedTarget);
	  }

	  /**
	   * 🌏 Exception: `iframe` in Chrome (`124.0`)
	   *
	   * Case 1: parent `window` → child `iframe`
	   * `dragLeave.relatedTarget` is the `iframe` in the parent `window`
	   *
	   * Case 2: child `iframe` → parent `window`
	   * `dragLeave.relatedTarget` is `null` *(standard check)*
	   */

	  // Case 2
	  // Using `instanceof` check as the element will be in the same `window`
	  return relatedTarget instanceof HTMLIFrameElement;
	}

	function getBindingsForBrokenDrags(_ref) {
	  var onDragEnd = _ref.onDragEnd;
	  return [
	  // ## Detecting drag ending for removed draggables
	  //
	  // If a draggable element is removed during a drag and the user drops:
	  // 1. if over a valid drop target: we get a "drop" event to know the drag is finished
	  // 2. if not over a valid drop target (or cancelled): we get nothing
	  // The "dragend" event will not fire on the source draggable if it has been
	  // removed from the DOM.
	  // So we need to figure out if a drag operation has finished by looking at other events
	  // We can do this by looking at other events

	  // ### First detection: "pointermove" events

	  // 1. "pointermove" events cannot fire during a drag and drop operation
	  // according to the spec. So if we get a "pointermove" it means that
	  // the drag and drop operations has finished. So if we get a "pointermove"
	  // we know that the drag is over
	  // 2. 🦊😤 Drag and drop operations are _supposed_ to suppress
	  // other pointer events. However, firefox will allow a few
	  // pointer event to get through after a drag starts.
	  // The most I've seen is 3
	  {
	    type: 'pointermove',
	    listener: function () {
	      var callCount = 0;
	      return function listener() {
	        // Using 20 as it is far bigger than the most observed (3)
	        if (callCount < 20) {
	          callCount++;
	          return;
	        }
	        onDragEnd();
	      };
	    }()
	  },
	  // ### Second detection: "pointerdown" events

	  // If we receive this event then we know that a drag operation has finished
	  // and potentially another one is about to start.
	  // Note: `pointerdown` fires on all browsers / platforms before "dragstart"
	  {
	    type: 'pointerdown',
	    listener: onDragEnd
	  }];
	}

	/** Set a `style` property on a `HTMLElement`
	 *
	 * @returns a `cleanup` function to restore the `style` property to it's original state
	 */
	function setStyle(el, _ref) {
	  var property = _ref.property,
	    rule = _ref.rule,
	    _ref$priority = _ref.priority,
	    priority = _ref$priority === void 0 ? '' : _ref$priority;
	  var originalValue = el.style.getPropertyValue(property);
	  var originalPriority = el.style.getPropertyPriority(property);
	  el.style.setProperty(property, rule, priority);
	  return function cleanup() {
	    el.style.setProperty(property, originalValue, originalPriority);
	  };
	}

	/**
	 * Allow the user to continue to interact with the element their pointer is over at the end of the drag.
	 * This is important to allow the user to be able to click, drag (etc) after they have finished a drag
	 *
	 * @returns a `cleanup` function to restore all elements under the users pointer to their original state
	 */
	function allowPointerEventsOnElementUnderPointer(_ref2) {
	  var current = _ref2.current;
	  var underUsersPointer = document.elementFromPoint(current.input.clientX, current.input.clientY);
	  if (!(underUsersPointer instanceof HTMLElement)) {
	    return null;
	  }

	  // Debug note: change from 'pointer-events: none' to 'background: green'
	  // to get a better sense of what is being achieved
	  return setStyle(underUsersPointer, {
	    property: 'pointer-events',
	    rule: 'auto',
	    priority: 'important'
	  });
	}
	function blockPointerEventsOnEverything() {
	  var _element$sheet;
	  var element = document.createElement('style');
	  // Adding a data attribute so to make it super clear to consumers
	  // (and to our tests) what this temporary style tag is for
	  element.setAttribute('pdnd-post-drag-fix', 'true');
	  document.head.appendChild(element);

	  // Debug note: change from 'pointer-events: none' to 'background: red'
	  // to get a better sense of what is being achieved
	  (_element$sheet = element.sheet) === null || _element$sheet === void 0 || _element$sheet.insertRule('* { pointer-events: none !important; }');
	  return function cleanup() {
	    document.head.removeChild(element);
	  };
	}

	/** 🔥🤮 Fix (Chrome, Safari and Firefox) bug where the element under where the user started dragging
	 * (on the viewport) is entered into by the browser after a drag finishes ("drop" or "dragend")
	 *
	 * @description
	 *
	 * Block pointer events on all elements except for the specific element that pointer is currently over
	 *
	 * - [Visual explanation of bug](https://twitter.com/alexandereardon/status/1633614212873465856)
	 * - [Chrome bug](https://bugs.chromium.org/p/chromium/issues/detail?id=410328)
	 */
	function fixPostDragPointerBug(_ref3) {
	  var current = _ref3.current;
	  // Queuing a microtask to give any opportunity for frameworks to update their UI in a microtask
	  // Note: react@18 does standard state updates in a microtask
	  // We do this so our `atDestination` gets the _actual_ element that is under the users pointer
	  // at the end of the drag.
	  queueMicrotask(function () {
	    var undoUnderPointer = allowPointerEventsOnElementUnderPointer({
	      current: current
	    });

	    // This will also block pointer-events on the children of the element under the users pointer.
	    // This is what we want. If the user drops on a container element we don't want the children
	    // of the container to be incorrectly entered into
	    var undoGlobalBlock = blockPointerEventsOnEverything();
	    function cleanup() {
	      unbindEvents();
	      undoUnderPointer === null || undoUnderPointer === void 0 || undoUnderPointer();
	      undoGlobalBlock();
	    }
	    var unbindEvents = dist.bindAll(window, [{
	      type: 'pointerdown',
	      listener: cleanup
	    }, {
	      type: 'pointermove',
	      listener: cleanup
	    }, {
	      type: 'focusin',
	      listener: cleanup
	    }, {
	      type: 'focusout',
	      listener: cleanup
	    },
	    // a 'pointerdown' should happen before 'dragstart', but just being super safe
	    {
	      type: 'dragstart',
	      listener: cleanup
	    },
	    // if the user has dragged something out of the window
	    // and then is dragging something back into the window
	    // the first events we will see are "dragenter" (and then "dragover").
	    // So if we see any of these we need to clear the post drag fix.
	    {
	      type: 'dragenter',
	      listener: cleanup
	    }, {
	      type: 'dragover',
	      listener: cleanup
	    }], {
	      // Using `capture` is more likely to not be impacted by consumers stopping events
	      capture: true
	    });
	  });
	}

	function getInput(event) {
	  return {
	    altKey: event.altKey,
	    button: event.button,
	    buttons: event.buttons,
	    ctrlKey: event.ctrlKey,
	    metaKey: event.metaKey,
	    shiftKey: event.shiftKey,
	    clientX: event.clientX,
	    clientY: event.clientY,
	    pageX: event.pageX,
	    pageY: event.pageY
	  };
	}

	var rafSchd = function rafSchd(fn) {
	  var lastArgs = [];
	  var frameId = null;

	  var wrapperFn = function wrapperFn() {
	    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }

	    lastArgs = args;

	    if (frameId) {
	      return;
	    }

	    frameId = requestAnimationFrame(function () {
	      frameId = null;
	      fn.apply(void 0, lastArgs);
	    });
	  };

	  wrapperFn.cancel = function () {
	    if (!frameId) {
	      return;
	    }

	    cancelAnimationFrame(frameId);
	    frameId = null;
	  };

	  return wrapperFn;
	};

	var scheduleOnDrag = rafSchd(function (fn) {
	  return fn();
	});
	var dragStart = function () {
	  var scheduled = null;
	  function schedule(fn) {
	    var frameId = requestAnimationFrame(function () {
	      scheduled = null;
	      fn();
	    });
	    scheduled = {
	      frameId: frameId,
	      fn: fn
	    };
	  }
	  function flush() {
	    if (scheduled) {
	      cancelAnimationFrame(scheduled.frameId);
	      scheduled.fn();
	      scheduled = null;
	    }
	  }
	  return {
	    schedule: schedule,
	    flush: flush
	  };
	}();
	function makeDispatch(_ref) {
	  var source = _ref.source,
	    initial = _ref.initial,
	    dispatchEvent = _ref.dispatchEvent;
	  var previous = {
	    dropTargets: []
	  };
	  function safeDispatch(args) {
	    dispatchEvent(args);
	    previous = {
	      dropTargets: args.payload.location.current.dropTargets
	    };
	  }
	  var dispatch = {
	    start: function start(_ref2) {
	      var nativeSetDragImage = _ref2.nativeSetDragImage;
	      // Ensuring that both `onGenerateDragPreview` and `onDragStart` get the same location.
	      // We do this so that `previous` is`[]` in `onDragStart` (which is logical)
	      var location = {
	        current: initial,
	        previous: previous,
	        initial: initial
	      };
	      // a `onGenerateDragPreview` does _not_ add another entry for `previous`
	      // onDragPreview
	      safeDispatch({
	        eventName: 'onGenerateDragPreview',
	        payload: {
	          source: source,
	          location: location,
	          nativeSetDragImage: nativeSetDragImage
	        }
	      });
	      dragStart.schedule(function () {
	        safeDispatch({
	          eventName: 'onDragStart',
	          payload: {
	            source: source,
	            location: location
	          }
	        });
	      });
	    },
	    dragUpdate: function dragUpdate(_ref3) {
	      var current = _ref3.current;
	      dragStart.flush();
	      scheduleOnDrag.cancel();
	      safeDispatch({
	        eventName: 'onDropTargetChange',
	        payload: {
	          source: source,
	          location: {
	            initial: initial,
	            previous: previous,
	            current: current
	          }
	        }
	      });
	    },
	    drag: function drag(_ref4) {
	      var current = _ref4.current;
	      scheduleOnDrag(function () {
	        dragStart.flush();
	        var location = {
	          initial: initial,
	          previous: previous,
	          current: current
	        };
	        safeDispatch({
	          eventName: 'onDrag',
	          payload: {
	            source: source,
	            location: location
	          }
	        });
	      });
	    },
	    drop: function drop(_ref5) {
	      var current = _ref5.current,
	        updatedSourcePayload = _ref5.updatedSourcePayload;
	      dragStart.flush();
	      scheduleOnDrag.cancel();
	      safeDispatch({
	        eventName: 'onDrop',
	        payload: {
	          source: updatedSourcePayload !== null && updatedSourcePayload !== void 0 ? updatedSourcePayload : source,
	          location: {
	            current: current,
	            previous: previous,
	            initial: initial
	          }
	        }
	      });
	    }
	  };
	  return dispatch;
	}

	var globalState = {
	  isActive: false
	};
	function canStart() {
	  return !globalState.isActive;
	}
	function getNativeSetDragImage(event) {
	  if (event.dataTransfer) {
	    // need to use `.bind` as `setDragImage` is required
	    // to be run with `event.dataTransfer` as the "this" context
	    return event.dataTransfer.setDragImage.bind(event.dataTransfer);
	  }
	  return null;
	}
	function hasHierarchyChanged(_ref) {
	  var current = _ref.current,
	    next = _ref.next;
	  if (current.length !== next.length) {
	    return true;
	  }
	  // not checking stickiness, data or dropEffect,
	  // just whether the hierarchy has changed
	  for (var i = 0; i < current.length; i++) {
	    if (current[i].element !== next[i].element) {
	      return true;
	    }
	  }
	  return false;
	}
	function start(_ref2) {
	  var event = _ref2.event,
	    dragType = _ref2.dragType,
	    getDropTargetsOver = _ref2.getDropTargetsOver,
	    dispatchEvent = _ref2.dispatchEvent;
	  if (!canStart()) {
	    return;
	  }
	  var initial = getStartLocation({
	    event: event,
	    dragType: dragType,
	    getDropTargetsOver: getDropTargetsOver
	  });
	  globalState.isActive = true;
	  var state = {
	    current: initial
	  };

	  // Setting initial drop effect for the drag
	  setDropEffectOnEvent({
	    event: event,
	    current: initial.dropTargets
	  });
	  var dispatch = makeDispatch({
	    source: dragType.payload,
	    dispatchEvent: dispatchEvent,
	    initial: initial
	  });
	  function updateDropTargets(next) {
	    // only looking at whether hierarchy has changed to determine whether something as 'changed'
	    var hasChanged = hasHierarchyChanged({
	      current: state.current.dropTargets,
	      next: next.dropTargets
	    });

	    // Always updating the state to include latest data, dropEffect and stickiness
	    // Only updating consumers if the hierarchy has changed in some way
	    // Consumers can get the latest data by using `onDrag`
	    state.current = next;
	    if (hasChanged) {
	      dispatch.dragUpdate({
	        current: state.current
	      });
	    }
	  }
	  function onUpdateEvent(event) {
	    var input = getInput(event);
	    var nextDropTargets = getDropTargetsOver({
	      target: event.target,
	      input: input,
	      source: dragType.payload,
	      current: state.current.dropTargets
	    });
	    if (nextDropTargets.length) {
	      // 🩸 must call `event.preventDefault()` to allow a browser drop to occur
	      event.preventDefault();
	      setDropEffectOnEvent({
	        event: event,
	        current: nextDropTargets
	      });
	    }
	    updateDropTargets({
	      dropTargets: nextDropTargets,
	      input: input
	    });
	  }
	  function cancel() {
	    // The spec behaviour is that when a drag is cancelled, or when dropping on no drop targets,
	    // a "dragleave" event is fired on the active drop target before a "dragend" event.
	    // We are replicating that behaviour in `cancel` if there are any active drop targets to
	    // ensure consistent behaviour.
	    //
	    // Note: When cancelling, or dropping on no drop targets, a "dragleave" event
	    // will have already cleared the dropTargets to `[]` (as that particular "dragleave" has a `relatedTarget` of `null`)

	    if (state.current.dropTargets.length) {
	      updateDropTargets({
	        dropTargets: [],
	        input: state.current.input
	      });
	    }
	    dispatch.drop({
	      current: state.current,
	      updatedSourcePayload: null
	    });
	    finish();
	  }
	  function finish() {
	    globalState.isActive = false;
	    unbindEvents();
	  }
	  var unbindEvents = dist.bindAll(window, [{
	    // 👋 Note: we are repurposing the `dragover` event as our `drag` event
	    // this is because firefox does not publish pointer coordinates during
	    // a `drag` event, but does for every other type of drag event
	    // `dragover` fires on all elements that are being dragged over
	    // Because we are binding to `window` - our `dragover` is effectively the same as a `drag`
	    // 🦊😤
	    type: 'dragover',
	    listener: function listener(event) {
	      // We need to regularly calculate the drop targets in order to allow:
	      //  - dynamic `canDrop()` checks
	      //  - rapid updating `getData()` calls to attach data in response to user input (eg for edge detection)
	      // Sadly we cannot schedule inspecting changes resulting from this event
	      // we need to be able to conditionally cancel the event with `event.preventDefault()`
	      // to enable the correct native drop experience.

	      // 1. check to see if anything has changed
	      onUpdateEvent(event);

	      // 2. let consumers know a move has occurred
	      // This will include the latest 'input' values
	      dispatch.drag({
	        current: state.current
	      });
	    }
	  }, {
	    type: 'dragenter',
	    listener: onUpdateEvent
	  }, {
	    type: 'dragleave',
	    listener: function listener(event) {
	      if (!isLeavingWindow({
	        dragLeave: event
	      })) {
	        return;
	      }

	      /**
	       * At this point we don't know if a drag is being cancelled,
	       * or if a drag is leaving the `window`.
	       *
	       * Both have:
	       *   1. "dragleave" (with `relatedTarget: null`)
	       *   2. "dragend" (a "dragend" can occur when outside the `window`)
	       *
	       * **Clearing drop targets**
	       *
	       * For either case we are clearing the the drop targets
	       *
	       * - cancelling: we clear drop targets in `"dragend"` anyway
	       * - leaving the `window`: we clear the drop targets (to clear stickiness)
	       *
	       * **Leaving the window and finishing the drag**
	       *
	       * _internal drags_
	       *
	       * - The drag continues when the user is outside the `window`
	       *   and can resume if the user drags back over the `window`,
	       *   or end when the user drops in an external `window`.
	       * - We will get a `"dragend"`, or we can listen for other
	       *   events to determine the drag is finished when the user re-enters the `window`).
	       *
	       * _external drags_
	       *
	       * - We conclude the drag operation.
	       * - We have no idea if the user will drag back over the `window`,
	       *   or if the drag ends elsewhere.
	       * - We will create a new drag if the user re-enters the `window`.
	       *
	       * **Not updating `input`**
	       *
	       * 🐛 Bug[Chrome] the final `"dragleave"` has default input values (eg `clientX == 0`)
	       * Workaround: intentionally not updating `input` in "dragleave"
	       * rather than the users current input values
	       * - [Conversation](https://twitter.com/alexandereardon/status/1642697633864241152)
	       * - [Bug](https://bugs.chromium.org/p/chromium/issues/detail?id=1429937)
	       **/

	      updateDropTargets({
	        input: state.current.input,
	        dropTargets: []
	      });
	      if (dragType.startedFrom === 'external') {
	        cancel();
	      }
	    }
	  }, {
	    type: 'drop',
	    listener: function listener(event) {
	      // A "drop" can only happen if the browser allowed the drop

	      // Accepting drop operation.
	      // Also: opting out of standard browser drop behaviour for the drag
	      event.preventDefault();

	      // applying the latest drop effect to the event
	      setDropEffectOnEvent({
	        event: event,
	        current: state.current.dropTargets
	      });
	      dispatch.drop({
	        current: state.current,
	        // When dropping something native, we need to extract the latest
	        // `.items` from the "drop" event as it is now accessible
	        updatedSourcePayload: dragType.type === 'external' ? dragType.getDropPayload(event) : null
	      });
	      finish();

	      // Applying this fix after `dispatch.drop` so that frameworks have the opportunity
	      // to update UI in response to a "onDrop".
	      if (dragType.startedFrom === 'internal') {
	        fixPostDragPointerBug({
	          current: state.current
	        });
	      }
	    }
	  }, {
	    // "dragend" fires when on the drag source (eg a draggable element)
	    // when the drag is finished.
	    // "dragend" will fire after "drop" (if there was a successful drop)
	    // "dragend" does not fire if the draggable source has been removed during the drag
	    // or for external drag sources (eg files)

	    // This "dragend" listener will not fire if there was a successful drop
	    // as we will have already removed the event listener
	    type: 'dragend',
	    listener: function listener(event) {
	      cancel();

	      // Applying this fix after `dispatch.drop` so that frameworks have the opportunity
	      // to update UI in response to a "onDrop".
	      if (dragType.startedFrom === 'internal') {
	        fixPostDragPointerBug({
	          current: state.current
	        });
	      }
	    }
	  }].concat(_toConsumableArray(getBindingsForBrokenDrags({
	    onDragEnd: cancel
	  }))),
	  // Once we have started a managed drag operation it is important that we see / own all drag events
	  // We got one adoption bug pop up where some code was stopping (`event.stopPropagation()`)
	  // all "drop" events in the bubble phase on the `document.body`.
	  // This meant that we never saw the "drop" event.
	  {
	    capture: true
	  });
	  dispatch.start({
	    nativeSetDragImage: getNativeSetDragImage(event)
	  });
	}
	function setDropEffectOnEvent(_ref3) {
	  var _current$;
	  var event = _ref3.event,
	    current = _ref3.current;
	  // setting the `dropEffect` to be the innerMost drop targets dropEffect
	  var innerMost = (_current$ = current[0]) === null || _current$ === void 0 ? void 0 : _current$.dropEffect;
	  if (innerMost != null && event.dataTransfer) {
	    event.dataTransfer.dropEffect = innerMost;
	  }
	}
	function getStartLocation(_ref4) {
	  var event = _ref4.event,
	    dragType = _ref4.dragType,
	    getDropTargetsOver = _ref4.getDropTargetsOver;
	  var input = getInput(event);

	  // When dragging from outside of the browser,
	  // the drag is not being sourced from any local drop targets
	  if (dragType.startedFrom === 'external') {
	    return {
	      input: input,
	      dropTargets: []
	    };
	  }
	  var dropTargets = getDropTargetsOver({
	    input: input,
	    source: dragType.payload,
	    target: event.target,
	    current: []
	  });
	  return {
	    input: input,
	    dropTargets: dropTargets
	  };
	}
	var lifecycle = {
	  canStart: canStart,
	  start: start
	};

	// Extending `Map` to allow us to link Key and Values together

	var ledger = new Map();
	function registerUsage(_ref) {
	  var typeKey = _ref.typeKey,
	    mount = _ref.mount;
	  var entry = ledger.get(typeKey);
	  if (entry) {
	    entry.usageCount++;
	    return entry;
	  }
	  var initial = {
	    typeKey: typeKey,
	    unmount: mount(),
	    usageCount: 1
	  };
	  ledger.set(typeKey, initial);
	  return initial;
	}
	function register(args) {
	  var entry = registerUsage(args);
	  return function unregister() {
	    entry.usageCount--;
	    if (entry.usageCount > 0) {
	      return;
	    }
	    // Only a single usage left, remove it
	    entry.unmount();
	    ledger.delete(args.typeKey);
	  };
	}

	function addAttribute(element, _ref) {
	  var attribute = _ref.attribute,
	    value = _ref.value;
	  element.setAttribute(attribute, value);
	  return function () {
	    return element.removeAttribute(attribute);
	  };
	}

	function ownKeys$1(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
	function _objectSpread$1(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$1(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$1(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
	function _createForOfIteratorHelper$1(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray$1(o)) || allowArrayLike) { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
	function _unsupportedIterableToArray$1(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray$1(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray$1(o, minLen); }
	function _arrayLikeToArray$1(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
	function copyReverse(array) {
	  return array.slice(0).reverse();
	}
	function makeDropTarget(_ref) {
	  var typeKey = _ref.typeKey,
	    defaultDropEffect = _ref.defaultDropEffect;
	  var registry = new WeakMap();
	  var dropTargetDataAtt = "data-drop-target-for-".concat(typeKey);
	  var dropTargetSelector = "[".concat(dropTargetDataAtt, "]");
	  function addToRegistry(args) {
	    registry.set(args.element, args);
	    return function () {
	      return registry.delete(args.element);
	    };
	  }
	  function dropTargetForConsumers(args) {
	    return combine(addAttribute(args.element, {
	      attribute: dropTargetDataAtt,
	      value: 'true'
	    }), addToRegistry(args));
	  }
	  function getActualDropTargets(_ref2) {
	    var _args$getData, _args$getData2, _args$getDropEffect, _args$getDropEffect2;
	    var source = _ref2.source,
	      target = _ref2.target,
	      input = _ref2.input,
	      _ref2$result = _ref2.result,
	      result = _ref2$result === void 0 ? [] : _ref2$result;
	    if (target == null) {
	      return result;
	    }
	    if (!(target instanceof Element)) {
	      // For "text-selection" drags, the original `target`
	      // is not an `Element`, so we need to start looking from
	      // the parent element
	      if (target instanceof Node) {
	        return getActualDropTargets({
	          source: source,
	          target: target.parentElement,
	          input: input,
	          result: result
	        });
	      }

	      // not sure what we are working with,
	      // so we can exit.
	      return result;
	    }
	    var closest = target.closest(dropTargetSelector);

	    // Cannot find anything else
	    if (closest == null) {
	      return result;
	    }
	    var args = registry.get(closest);

	    // error: something had a dropTargetSelector but we could not
	    // find a match. For now, failing silently
	    if (args == null) {
	      return result;
	    }
	    var feedback = {
	      input: input,
	      source: source,
	      element: args.element
	    };

	    // if dropping is not allowed, skip this drop target
	    // and continue looking up the DOM tree
	    if (args.canDrop && !args.canDrop(feedback)) {
	      return getActualDropTargets({
	        source: source,
	        target: args.element.parentElement,
	        input: input,
	        result: result
	      });
	    }

	    // calculate our new record
	    var data = (_args$getData = (_args$getData2 = args.getData) === null || _args$getData2 === void 0 ? void 0 : _args$getData2.call(args, feedback)) !== null && _args$getData !== void 0 ? _args$getData : {};
	    var dropEffect = (_args$getDropEffect = (_args$getDropEffect2 = args.getDropEffect) === null || _args$getDropEffect2 === void 0 ? void 0 : _args$getDropEffect2.call(args, feedback)) !== null && _args$getDropEffect !== void 0 ? _args$getDropEffect : defaultDropEffect;
	    var record = {
	      data: data,
	      element: args.element,
	      dropEffect: dropEffect,
	      // we are collecting _actual_ drop targets, so these are
	      // being applied _not_ due to stickiness
	      isActiveDueToStickiness: false
	    };
	    return getActualDropTargets({
	      source: source,
	      target: args.element.parentElement,
	      input: input,
	      // Using bubble ordering. Same ordering as `event.getPath()`
	      result: [].concat(_toConsumableArray(result), [record])
	    });
	  }
	  function notifyCurrent(_ref3) {
	    var eventName = _ref3.eventName,
	      payload = _ref3.payload;
	    var _iterator = _createForOfIteratorHelper$1(payload.location.current.dropTargets),
	      _step;
	    try {
	      for (_iterator.s(); !(_step = _iterator.n()).done;) {
	        var _entry$eventName;
	        var record = _step.value;
	        var entry = registry.get(record.element);
	        var _args = _objectSpread$1(_objectSpread$1({}, payload), {}, {
	          self: record
	        });
	        entry === null || entry === void 0 || (_entry$eventName = entry[eventName]) === null || _entry$eventName === void 0 || _entry$eventName.call(entry,
	        // I cannot seem to get the types right here.
	        // TS doesn't seem to like that one event can need `nativeSetDragImage`
	        // @ts-expect-error
	        _args);
	      }
	    } catch (err) {
	      _iterator.e(err);
	    } finally {
	      _iterator.f();
	    }
	  }
	  var actions = {
	    onGenerateDragPreview: notifyCurrent,
	    onDrag: notifyCurrent,
	    onDragStart: notifyCurrent,
	    onDrop: notifyCurrent,
	    onDropTargetChange: function onDropTargetChange(_ref4) {
	      var payload = _ref4.payload;
	      var isCurrent = new Set(payload.location.current.dropTargets.map(function (record) {
	        return record.element;
	      }));
	      var visited = new Set();
	      var _iterator2 = _createForOfIteratorHelper$1(payload.location.previous.dropTargets),
	        _step2;
	      try {
	        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
	          var _entry$onDropTargetCh;
	          var record = _step2.value;
	          visited.add(record.element);
	          var entry = registry.get(record.element);
	          var isOver = isCurrent.has(record.element);
	          var _args2 = _objectSpread$1(_objectSpread$1({}, payload), {}, {
	            self: record
	          });
	          entry === null || entry === void 0 || (_entry$onDropTargetCh = entry.onDropTargetChange) === null || _entry$onDropTargetCh === void 0 || _entry$onDropTargetCh.call(entry, _args2);

	          // if we cannot find the drop target in the current array, then it has been left
	          if (!isOver) {
	            var _entry$onDragLeave;
	            entry === null || entry === void 0 || (_entry$onDragLeave = entry.onDragLeave) === null || _entry$onDragLeave === void 0 || _entry$onDragLeave.call(entry, _args2);
	          }
	        }
	      } catch (err) {
	        _iterator2.e(err);
	      } finally {
	        _iterator2.f();
	      }
	      var _iterator3 = _createForOfIteratorHelper$1(payload.location.current.dropTargets),
	        _step3;
	      try {
	        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
	          var _entry$onDropTargetCh2, _entry$onDragEnter;
	          var _record = _step3.value;
	          // already published an update to this drop target
	          if (visited.has(_record.element)) {
	            continue;
	          }
	          // at this point we have a new drop target that is being entered into
	          var _args3 = _objectSpread$1(_objectSpread$1({}, payload), {}, {
	            self: _record
	          });
	          var _entry = registry.get(_record.element);
	          _entry === null || _entry === void 0 || (_entry$onDropTargetCh2 = _entry.onDropTargetChange) === null || _entry$onDropTargetCh2 === void 0 || _entry$onDropTargetCh2.call(_entry, _args3);
	          _entry === null || _entry === void 0 || (_entry$onDragEnter = _entry.onDragEnter) === null || _entry$onDragEnter === void 0 || _entry$onDragEnter.call(_entry, _args3);
	        }
	      } catch (err) {
	        _iterator3.e(err);
	      } finally {
	        _iterator3.f();
	      }
	    }
	  };
	  function dispatchEvent(args) {
	    actions[args.eventName](args);
	  }
	  function getIsOver(_ref5) {
	    var source = _ref5.source,
	      target = _ref5.target,
	      input = _ref5.input,
	      current = _ref5.current;
	    var actual = getActualDropTargets({
	      source: source,
	      target: target,
	      input: input
	    });

	    // stickiness is only relevant when we have less
	    // drop targets than we did before
	    if (actual.length >= current.length) {
	      return actual;
	    }

	    // less 'actual' drop targets than before,
	    // we need to see if 'stickiness' applies

	    // An old drop target will continue to be dropped on if:
	    // 1. it has the same parent
	    // 2. nothing exists in it's previous index

	    var lastCaptureOrdered = copyReverse(current);
	    var actualCaptureOrdered = copyReverse(actual);
	    var resultCaptureOrdered = [];
	    for (var index = 0; index < lastCaptureOrdered.length; index++) {
	      var _argsForLast$getIsSti;
	      var last = lastCaptureOrdered[index];
	      var fresh = actualCaptureOrdered[index];

	      // if a record is in the new index -> use that
	      // it will have the latest data + dropEffect
	      if (fresh != null) {
	        resultCaptureOrdered.push(fresh);
	        continue;
	      }

	      // At this point we have no drop target in the old spot
	      // Check to see if we can use a previous sticky drop target

	      // The "parent" is the one inside of `resultCaptureOrdered`
	      // (the parent might be a drop target that was sticky)
	      var parent = resultCaptureOrdered[index - 1];
	      var lastParent = lastCaptureOrdered[index - 1];

	      // Stickiness is based on parent relationships, so if the parent relationship has change
	      // then we can stop our search
	      if ((parent === null || parent === void 0 ? void 0 : parent.element) !== (lastParent === null || lastParent === void 0 ? void 0 : lastParent.element)) {
	        break;
	      }

	      // We need to check whether the old drop target can still be dropped on

	      var argsForLast = registry.get(last.element);

	      // We cannot drop on a drop target that is no longer mounted
	      if (!argsForLast) {
	        break;
	      }
	      var feedback = {
	        input: input,
	        source: source,
	        element: argsForLast.element
	      };

	      // We cannot drop on a drop target that no longer allows being dropped on
	      if (argsForLast.canDrop && !argsForLast.canDrop(feedback)) {
	        break;
	      }

	      // We cannot drop on a drop target that is no longer sticky
	      if (!((_argsForLast$getIsSti = argsForLast.getIsSticky) !== null && _argsForLast$getIsSti !== void 0 && _argsForLast$getIsSti.call(argsForLast, feedback))) {
	        break;
	      }

	      // Note: intentionally not recollecting `getData()` or `getDropEffect()`
	      // Previous values for `data` and `dropEffect` will be borrowed
	      // This is to prevent things like the 'closest edge' changing when
	      // no longer over a drop target.
	      // We could change our mind on this behaviour in the future

	      resultCaptureOrdered.push(_objectSpread$1(_objectSpread$1({}, last), {}, {
	        // making it clear to consumers this drop target is active due to stickiness
	        isActiveDueToStickiness: true
	      }));
	    }

	    // return bubble ordered result
	    return copyReverse(resultCaptureOrdered);
	  }
	  return {
	    dropTargetForConsumers: dropTargetForConsumers,
	    getIsOver: getIsOver,
	    dispatchEvent: dispatchEvent
	  };
	}

	function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike) { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
	function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
	function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
	function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
	function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
	function makeMonitor() {
	  var registry = new Set();
	  var dragging = null;
	  function tryAddToActive(monitor) {
	    if (!dragging) {
	      return;
	    }
	    // Monitor is allowed to monitor events if:
	    // 1. It has no `canMonitor` function (default is that a monitor can listen to everything)
	    // 2. `canMonitor` returns true
	    if (!monitor.canMonitor || monitor.canMonitor(dragging.canMonitorArgs)) {
	      dragging.active.add(monitor);
	    }
	  }
	  function monitorForConsumers(args) {
	    // We are giving each `args` a new reference so that you
	    // can create multiple monitors with the same `args`.
	    var entry = _objectSpread({}, args);
	    registry.add(entry);

	    // if there is an active drag we need to see if this new monitor is relevant
	    tryAddToActive(entry);
	    return function cleanup() {
	      registry.delete(entry);

	      // We need to stop publishing events during a drag to this monitor!
	      if (dragging) {
	        dragging.active.delete(entry);
	      }
	    };
	  }
	  function dispatchEvent(_ref) {
	    var eventName = _ref.eventName,
	      payload = _ref.payload;
	    if (eventName === 'onGenerateDragPreview') {
	      dragging = {
	        canMonitorArgs: {
	          initial: payload.location.initial,
	          source: payload.source
	        },
	        active: new Set()
	      };
	      var _iterator = _createForOfIteratorHelper(registry),
	        _step;
	      try {
	        for (_iterator.s(); !(_step = _iterator.n()).done;) {
	          var monitor = _step.value;
	          tryAddToActive(monitor);
	        }
	      } catch (err) {
	        _iterator.e(err);
	      } finally {
	        _iterator.f();
	      }
	    }

	    // This should never happen.
	    if (!dragging) {
	      return;
	    }

	    // Creating an array from the set _before_ iterating
	    // This is so that monitors added during the current event will not be called.
	    // This behaviour matches native EventTargets where an event listener
	    // cannot add another event listener during an active event to the same
	    // event target in the same event (for us we have a single global event target)
	    var active = Array.from(dragging.active);
	    for (var _i = 0, _active = active; _i < _active.length; _i++) {
	      var _monitor = _active[_i];
	      // A monitor can be removed by another monitor during an event.
	      // We need to check that the monitor is still registered before calling it
	      if (dragging.active.has(_monitor)) {
	        var _monitor$eventName;
	        // @ts-expect-error: I cannot get this type working!
	        (_monitor$eventName = _monitor[eventName]) === null || _monitor$eventName === void 0 || _monitor$eventName.call(_monitor, payload);
	      }
	    }
	    if (eventName === 'onDrop') {
	      dragging.active.clear();
	      dragging = null;
	    }
	  }
	  return {
	    dispatchEvent: dispatchEvent,
	    monitorForConsumers: monitorForConsumers
	  };
	}

	function makeAdapter(_ref) {
	  var typeKey = _ref.typeKey,
	    mount = _ref.mount,
	    dispatchEventToSource = _ref.dispatchEventToSource,
	    defaultDropEffect = _ref.defaultDropEffect;
	  var monitorAPI = makeMonitor();
	  var dropTargetAPI = makeDropTarget({
	    typeKey: typeKey,
	    defaultDropEffect: defaultDropEffect
	  });
	  function dispatchEvent(args) {
	    // 1. forward the event to source
	    dispatchEventToSource === null || dispatchEventToSource === void 0 || dispatchEventToSource(args);

	    // 2. forward the event to relevant dropTargets
	    dropTargetAPI.dispatchEvent(args);

	    // 3. forward event to monitors
	    monitorAPI.dispatchEvent(args);
	  }
	  function start(_ref2) {
	    var event = _ref2.event,
	      dragType = _ref2.dragType;
	    lifecycle.start({
	      event: event,
	      dragType: dragType,
	      getDropTargetsOver: dropTargetAPI.getIsOver,
	      dispatchEvent: dispatchEvent
	    });
	  }
	  function registerUsage() {
	    function mountAdapter() {
	      var api = {
	        canStart: lifecycle.canStart,
	        start: start
	      };
	      return mount(api);
	    }
	    return register({
	      typeKey: typeKey,
	      mount: mountAdapter
	    });
	  }
	  return {
	    registerUsage: registerUsage,
	    dropTarget: dropTargetAPI.dropTargetForConsumers,
	    monitor: monitorAPI.monitorForConsumers
	  };
	}

	// using `cache` as our `isAndroid()` result will not change in a browser
	var isAndroid = cacheFirst(function isAndroid() {
	  return navigator.userAgent.toLocaleLowerCase().includes('android');
	});
	var androidFallbackText = 'pdnd:android-fallback';

	// Why we put the media types in their own files:
	//
	// - we are not putting them all in one file as not all adapters need all types
	// - we are not putting them in the external helpers as some things just need the
	//   types and not the external functions code
	var textMediaType = 'text/plain';

	// Why we put the media types in their own files:
	//
	// - we are not putting them all in one file as not all adapters need all types
	// - we are not putting them in the external helpers as some things just need the
	//   types and not the external functions code
	var urlMediaType = 'text/uri-list';

	/**
	 * This key has been pulled into a separate module
	 * so that the external adapter does not need to import
	 * the element adapter
	 */
	var elementAdapterNativeDataKey = 'application/vnd.pdnd';

	var draggableRegistry = new WeakMap();
	function addToRegistry(args) {
	  draggableRegistry.set(args.element, args);
	  return function cleanup() {
	    draggableRegistry.delete(args.element);
	  };
	}
	var adapter$1 = makeAdapter({
	  typeKey: 'element',
	  defaultDropEffect: 'move',
	  mount: function mount(api) {
	    /**  Binding event listeners the `document` rather than `window` so that
	     * this adapter always gets preference over the text adapter.
	     * `document` is the first `EventTarget` under `window`
	     * https://twitter.com/alexandereardon/status/1604658588311465985
	     */
	    return dist.bind(document, {
	      type: 'dragstart',
	      listener: function listener(event) {
	        var _entry$dragHandle, _entry$getInitialData, _entry$getInitialData2, _entry$dragHandle2, _entry$getInitialData3, _entry$getInitialData4;
	        if (!api.canStart(event)) {
	          return;
	        }

	        // If the "dragstart" event is cancelled, then a drag won't start
	        // There will be no further drag operation events (eg no "dragend" event)
	        if (event.defaultPrevented) {
	          return;
	        }

	        // Technically `dataTransfer` can be `null` according to the types
	        // But that behaviour does not seem to appear in the spec.
	        // If there is not `dataTransfer`, we can assume something is wrong and not
	        // start a drag
	        if (!event.dataTransfer) {
	          return;
	        }

	        // the closest parent that is a draggable element will be marked as
	        // the `event.target` for the event
	        var target = event.target;

	        // this source is only for elements
	        // Note: only HTMLElements can have the "draggable" attribute
	        if (!(target instanceof HTMLElement)) {
	          return null;
	        }

	        // see if the thing being dragged is owned by us
	        var entry = draggableRegistry.get(target);

	        // no matching element found
	        // → dragging an element with `draggable="true"` that is not controlled by us
	        if (!entry) {
	          return null;
	        }
	        var input = getInput(event);
	        var feedback = {
	          element: entry.element,
	          dragHandle: (_entry$dragHandle = entry.dragHandle) !== null && _entry$dragHandle !== void 0 ? _entry$dragHandle : null,
	          input: input
	        };

	        // Check: does the draggable want to allow dragging?
	        if (entry.canDrag && !entry.canDrag(feedback)) {
	          // cancel drag operation if we cannot drag
	          event.preventDefault();
	          return null;
	        }

	        // Check: is there a drag handle and is the user using it?
	        if (entry.dragHandle) {
	          var over = document.elementFromPoint(input.clientX, input.clientY);

	          // if we are not dragging from the drag handle (or something inside the drag handle)
	          // then we will cancel the active drag
	          if (!entry.dragHandle.contains(over)) {
	            event.preventDefault();
	            return null;
	          }
	        }

	        /**
	         *  **Goal**
	         *  Pass information to other applications
	         *
	         * **Approach**
	         *  Put data into the native data store
	         *
	         *  **What about the native adapter?**
	         *  When the element adapter puts native data into the native data store
	         *  the native adapter is not triggered in the current window,
	         *  but a native adapter in an external window _can_ be triggered
	         *
	         *  **Why bake this into core?**
	         *  This functionality could be pulled out and exposed inside of
	         *  `onGenerateDragPreview`. But decided to make it a part of the
	         *  base API as it felt like a common enough use case and ended
	         *  up being a similar amount of code to include this function as
	         *  it was to expose the hook for it
	         */
	        var nativeData = (_entry$getInitialData = (_entry$getInitialData2 = entry.getInitialDataForExternal) === null || _entry$getInitialData2 === void 0 ? void 0 : _entry$getInitialData2.call(entry, feedback)) !== null && _entry$getInitialData !== void 0 ? _entry$getInitialData : null;
	        if (nativeData) {
	          for (var _i = 0, _Object$entries = Object.entries(nativeData); _i < _Object$entries.length; _i++) {
	            var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
	              key = _Object$entries$_i[0],
	              data = _Object$entries$_i[1];
	            event.dataTransfer.setData(key, data !== null && data !== void 0 ? data : '');
	          }
	        }

	        /**
	         *  📱 For Android devices, a drag operation will not start unless
	         * "text/plain" or "text/uri-list" data exists in the native data store
	         * https://twitter.com/alexandereardon/status/1732189803754713424
	         *
	         * Tested on:
	         * Device: Google Pixel 5
	         * Android version: 14 (November 5, 2023)
	         * Chrome version: 120.0
	         */
	        var types = event.dataTransfer.types;
	        if (isAndroid() && !types.includes(textMediaType) && !types.includes(urlMediaType)) {
	          event.dataTransfer.setData(textMediaType, androidFallbackText);
	        }

	        /**
	         * 1. Must set any media type for `iOS15` to work
	         * 2. We are also doing adding data so that the native adapter
	         * can know that the element adapter has handled this drag
	         *
	         * We used to wrap this `setData()` in a `try/catch` for Firefox,
	         * but it looks like that was not needed.
	         *
	         * Tested using: https://codesandbox.io/s/checking-firefox-throw-behaviour-on-dragstart-qt8h4f
	         *
	         * - ✅ Firefox@70.0 (Oct 2019) on macOS Sonoma
	         * - ✅ Firefox@70.0 (Oct 2019) on macOS Big Sur
	         * - ✅ Firefox@70.0 (Oct 2019) on Windows 10
	         *
	         * // just checking a few more combinations to be super safe
	         *
	         * - ✅ Chrome@78 (Oct 2019) on macOS Big Sur
	         * - ✅ Chrome@78 (Oct 2019) on Windows 10
	         * - ✅ Safari@14.1 on macOS Big Sur
	         */
	        event.dataTransfer.setData(elementAdapterNativeDataKey, '');
	        var payload = {
	          element: entry.element,
	          dragHandle: (_entry$dragHandle2 = entry.dragHandle) !== null && _entry$dragHandle2 !== void 0 ? _entry$dragHandle2 : null,
	          data: (_entry$getInitialData3 = (_entry$getInitialData4 = entry.getInitialData) === null || _entry$getInitialData4 === void 0 ? void 0 : _entry$getInitialData4.call(entry, feedback)) !== null && _entry$getInitialData3 !== void 0 ? _entry$getInitialData3 : {}
	        };
	        var dragType = {
	          type: 'element',
	          payload: payload,
	          startedFrom: 'internal'
	        };
	        api.start({
	          event: event,
	          dragType: dragType
	        });
	      }
	    });
	  },
	  dispatchEventToSource: function dispatchEventToSource(_ref) {
	    var _draggableRegistry$ge, _draggableRegistry$ge2;
	    var eventName = _ref.eventName,
	      payload = _ref.payload;
	    // During a drag operation, a draggable can be:
	    // - remounted with different functions
	    // - removed completely
	    // So we need to get the latest entry from the registry in order
	    // to call the latest event functions

	    (_draggableRegistry$ge = draggableRegistry.get(payload.source.element)) === null || _draggableRegistry$ge === void 0 || (_draggableRegistry$ge2 = _draggableRegistry$ge[eventName]) === null || _draggableRegistry$ge2 === void 0 || _draggableRegistry$ge2.call(_draggableRegistry$ge,
	    // I cannot seem to get the types right here.
	    // TS doesn't seem to like that one event can need `nativeSetDragImage`
	    // @ts-expect-error
	    payload);
	  }
	});
	var dropTargetForElements = adapter$1.dropTarget;
	function draggable(args) {
	  return combine(
	  // making the draggable register the adapter rather than drop targets
	  // this is because you *must* have a draggable element to start a drag
	  // but you _might_ not have any drop targets immediately
	  // (You might create drop targets async)
	  adapter$1.registerUsage(), addToRegistry(args), addAttribute(args.element, {
	    attribute: 'draggable',
	    value: 'true'
	  }));
	}

	/** Common event payload for all events */

	/** A map containing payloads for all events */

	/** Common event payload for all drop target events */

	/** A map containing payloads for all events on drop targets */

	/** Arguments given to all feedback functions (eg `canDrag()`) on for a `draggable()` */

	/** Arguments given to all feedback functions (eg `canDrop()`) on a `dropTargetForElements()` */

	/** Arguments given to all monitor feedback functions (eg `canMonitor()`) for a `monitorForElements` */

	// https://github.com/atlassian/pragmatic-drag-and-drop/blob/main/packages/docs/constellation/05-core-package/09-recipes/typing-data.mdx
	const privateKey = Symbol("EditorNode");







	function getEditorNodeDragData(
	    data
	) {
	    return {
	        [privateKey]: true,
	        ...data,
	    };
	}

	function isEditorNodeDragData(
	    data
	) {
	    return Boolean(data[privateKey]);
	}

	const line = {
	    borderRadius: 0,
	    thickness: 2,
	};
























	const edgeStyles = {
	    top: {
	        height: line.thickness,
	        top: "var(--local-line-offset)",
	        right: 0,
	        left: 0,
	    },
	    right: {
	        width: line.thickness,
	        top: 0,
	        right: "var(--local-line-offset)",
	        bottom: 0,
	    },
	    bottom: {
	        height: line.thickness,
	        right: 0,
	        bottom: "var(--local-line-offset)",
	        left: 0,
	    },
	    left: {
	        width: line.thickness,
	        top: 0,
	        bottom: 0,
	        left: "var(--local-line-offset)",
	    },
	};

	/**
	 * __Drop indicator__
	 *
	 * A drop indicator is used to communicate the intended resting place of the draggable item. The orientation of the drop indicator should always match the direction of the content flow.
	 */
	function DropIndicator({ edge, gap = "0px" }) {
	    /**
	     * To clearly communicate the resting place of a draggable item during a drag operation,
	     * the drop indicator should be positioned half way between draggable items.
	     */
	    const lineOffset = `calc(-0.5 * (${gap} + ${line.thickness}px))`;

	    return (
	        React$2.createElement('div', {
	            className: "co-drop-indicator",
	            style: 
	                {
	                    ...edgeStyles[edge],
	                    "--local-line-offset": lineOffset,
	                } 
	            ,}
	        )
	    );
	}

	const ContentEditorTextRegion

	 = ({ nodeId }) => {
	    const dispatch = useAppDispatch();
	    const body = useAppSelector(selectBody$1);
	    const node = body.nodes[nodeId];
	    const nodeIndex = body.nodeOrder.indexOf(nodeId);

	    if (node.type !== "text") {
	        throw new Error("node ID doesn't map to a text node");
	    }

	    const innerRef = reactExports.useRef(null);
	    const containerRef = reactExports.useRef(null);
	    const [closestEdge, setClosestEdge] = reactExports.useState(null);
	    const [isDragging, setIsDragging] = reactExports.useState(false);

	    const isLastNode = body.nodeOrder[body.nodeOrder.length - 1] === nodeId;

	    const { t } = useTranslation();

	    const blocks = reactExports.useMemo(
	        () =>
	            node.text
	                .trim()
	                .split("\n\n")
	                .map((text) => text.trim()),
	        [node.text]
	    );

	    function onChange(event) {
	        dispatch(updateTextRegion({ nodeId, text: event.target.value }));
	    }

	    reactExports.useEffect(() => {
	        const element = containerRef.current;
	        invariant(element);

	        return combine(
	            dropTargetForElements({
	                element,
	                getData({ input }) {
	                    return attachClosestEdge(
	                        getEditorNodeDragData({
	                            nodeId,
	                            nodeType: "text",
	                        }),
	                        {
	                            allowedEdges: ["bottom", "top"],
	                            input,
	                            element: element,
	                        }
	                    );
	                },
	                onDrop({ source: { data }, location, self }) {
	                    setClosestEdge(null);
	                    setIsDragging(false);
	                },
	                onDrag({ self, source, location }) {
	                    const data = source.data;
	                    if (!isEditorNodeDragData(data)) {
	                        return;
	                    }

	                    setIsDragging(true);

	                    const isSource = data.nodeId === nodeId;
	                    if (isSource) {
	                        setClosestEdge(null);
	                        return;
	                    }
	                },
	                onDragLeave() {
	                    setIsDragging(false);
	                    setClosestEdge(null);
	                },
	            })
	        );
	    }, [blocks.length, dispatch, nodeId, nodeIndex]);

	    const fakeEditor = reactExports.useMemo(() => {
	        return (
	            React$2.createElement('div', {
	                className: `${
                    isDragging ? "" : "invisible"
                } co-editable-body absolute top-0 flex
                w-full resize-none flex-col gap-6 overflow-x-hidden whitespace-pre-wrap break-words border-none px-3 pb-2`,}

	                , blocks.map((block, index) => {
	                    return (
	                        React$2.createElement(FakeEditorBlock, {
	                            block: block,
	                            index: index,
	                            numNodes: blocks.length,
	                            key: index,
	                            nodeId: nodeId,}
	                        )
	                    );
	                })
	            )
	        );
	    }, [blocks, isDragging, nodeId]);

	    const onPaste = reactExports.useCallback(
	        (ev) => {
	            const items = ev.clipboardData?.items ?? [];
	            const file = Array.from(items)
	                .filter((item) => item.type.indexOf("image") > -1)
	                .map((item) => item.getAsFile())
	                .filter(isDefined)[0];
	            if (file) {
	                dispatch(
	                    insertFile({
	                        atPosition: nodeIndex + 1,
	                        file,
	                    })
	                );
	                ev.preventDefault();
	                return;
	            }
	        },
	        [dispatch, nodeIndex]
	    );

	    return (
	        React$2.createElement('div', { className: "relative", ref: containerRef,}
	            , React$2.createElement(ExpandingTextArea, {
	                onInput: onChange,
	                className: `${
                    isDragging ? "invisible" : ""
                } co-editable-body w-full resize-none overflow-hidden border-none
                p-0 px-3 focus:ring-0`,
	                placeholder: t(
	                    "client:post-editor.body-placeholder",
	                    "post body (accepts markdown!)"
	                ),
	                minRows: isLastNode ? 4 : 1,
	                value: node.text,
	                ref: innerRef,
	                onPaste: onPaste,}
	            )
	            , fakeEditor
	        )
	    );
	};

	const FakeEditorBlock




	 = ({ block, index, nodeId, numNodes }) => {
	    const dispatch = useAppDispatch();
	    const containerRef = reactExports.useRef(null);
	    const [closestEdge, setClosestEdge] = reactExports.useState(null);

	    reactExports.useEffect(() => {
	        const element = containerRef.current;
	        invariant(element);

	        return dropTargetForElements({
	            element,
	            // blocks are sticky so that we can drop between them more cleanly
	            getIsSticky: () => true,
	            getData({ input }) {
	                return attachClosestEdge(
	                    {},
	                    {
	                        allowedEdges: ["bottom", "top"],
	                        input,
	                        element: element,
	                    }
	                );
	            },
	            onDrag({ self, source, location }) {
	                const data = source.data;
	                if (!isEditorNodeDragData(data)) {
	                    return;
	                }

	                const closestEdge = extractClosestEdge(self.data);

	                setClosestEdge(closestEdge);
	            },
	            onDragLeave() {
	                setClosestEdge(null);
	            },
	            onDrop({ source: { data }, self }) {
	                setClosestEdge(null);

	                if (!isEditorNodeDragData(data)) return;

	                // check if we're splitting a text node
	                const edge = extractClosestEdge(self.data);
	                if (edge !== "top" && edge !== "bottom") return;

	                if (
	                    (edge === "top" && index === 0) ||
	                    (edge === "bottom" && index === numNodes - 1)
	                ) {
	                    // new row, this shit's easy
	                    dispatch(
	                        moveAttachmentToNewRow({
	                            attachmentNodeId: data.nodeId,
	                            relativeNodeId: nodeId,
	                            position: edge === "top" ? "before" : "after",
	                        })
	                    );
	                    return;
	                }

	                // ok we gotta do a split
	                dispatch(
	                    splitTextNodeAndInsertAttachment({
	                        attachmentNodeId: data.nodeId,
	                        splitBlockIndex: edge === "top" ? index : index + 1,
	                        textNodeId: nodeId,
	                    })
	                );
	            },
	        });
	    }, [dispatch, index, nodeId, numNodes]);

	    return (
	        React$2.createElement('div', { 'data-blockindex': index, className: "relative", ref: containerRef,}
	            , closestEdge && React$2.createElement(DropIndicator, { edge: closestEdge, gap: "4px",} )
	            , block
	        )
	    );
	};

	const MoveIcon = (
	    props
	) => (
	    React$2.createElement('svg', {
	        viewBox: "0 0 20 20"   ,
	        fill: "none",
	        xmlns: "http://www.w3.org/2000/svg",
	        ...props,}

	        , React$2.createElement('path', {
	            d: "M10 1V19M10 1L7.54545 3.45455M10 1L12.4545 3.45455M10 19L7.54545 16.5455M10 19L12.4545 16.5455M19 10H1M19 10L16.5455 7.54545M19 10L16.5455 12.4545M1 10L3.45455 7.54545M1 10L3.45455 12.4545"                  ,
	            stroke: "currentColor",
	            strokeWidth: "2",
	            strokeLinecap: "round",
	            strokeLinejoin: "round",}
	        )
	    )
	);

	const ImageAttachmentEditor


	 = React$2.memo(({ nodeId, aspectRatio }) => {
	    const dispatch = useAppDispatch();
	    const node = useAppSelector(selectBody$1).nodes[nodeId];

	    if (node.type !== "image-attachment") {
	        throw new Error(`node ${nodeId} isn't image attachment?`);
	    }

	    const isEditing = useAppSelector(selectIsEditing$2);
	    const attachmentComposerRef = reactExports.useContext(AttachmentComposerContext);
	    const { t } = useTranslation();
	    const imageRef = reactExports.useRef(null);
	    const isSelected = false; // TODO: fix

	    const shadeState

	 = reactExports.useMemo(() => {
	        invariant(
	            node.type === "image-attachment");
	        if (!isEditing) {
	            // isn't editing; display upload status
	            if (node.attachment.state === AttachmentState.Finished) {
	                return {
	                    mode: "uploading",
	                    displayString: t(
	                        "client:post-editor.attachment-state.finished",
	                        "uploaded!"
	                    ),
	                };
	            }

	            if (node.attachment.uploadState === "starting") {
	                return {
	                    mode: "uploading",
	                    displayString: t(
	                        "client:post-editor.attachment-state.starting",
	                        "starting..."
	                    ),
	                };
	            } else if (node.attachment.uploadState === "finishing") {
	                return {
	                    mode: "uploading",
	                    displayString: t(
	                        "client:post-editor.attachment-state.finishing",
	                        "finishing up..."
	                    ),
	                };
	            } else {
	                return {
	                    mode: "uploading",
	                    displayString: t(
	                        "client:post-editor.attachment-state.pending",
	                        "uploading..."
	                    ),
	                };
	            }
	        } else {
	            // is editing; display shade in move mode iff selected
	            {
	                return {
	                    mode: "none",
	                };
	            }
	        }
	    }, [
	        node.type,
	        node.attachment.state,
	        node.attachment.uploadState,
	        isEditing,
	        t,
	        isSelected,
	    ]);

	    const [closestEdge, setClosestEdge] = reactExports.useState(null);
	    const [dragState, setDragState] = reactExports.useState("none");

	    reactExports.useEffect(() => {
	        invariant(imageRef.current);
	        return combine(
	            draggable({
	                element: imageRef.current,
	                getInitialData: () =>
	                    getEditorNodeDragData({
	                        nodeId,
	                        nodeType: "image-attachment",
	                    }),
	                onDragStart() {
	                    setDragState("dragging");
	                },
	                onDrop() {
	                    setDragState("none");
	                },
	            }),
	            dropTargetForElements({
	                element: imageRef.current,
	                getIsSticky: () => true,
	                getData({ input }) {
	                    invariant(imageRef.current);
	                    return attachClosestEdge(
	                        getEditorNodeDragData({
	                            nodeId,
	                            nodeType: "image-attachment",
	                        }),
	                        {
	                            element: imageRef.current,
	                            input,
	                            allowedEdges: ["left", "right"],
	                        }
	                    );
	                },
	                onDrag({ self, source }) {
	                    const data = source.data;
	                    if (!isEditorNodeDragData(data)) {
	                        return;
	                    }

	                    const isSource = data.nodeId === nodeId;
	                    if (isSource) {
	                        setClosestEdge(null);
	                        return;
	                    }

	                    const closestEdge = extractClosestEdge(self.data);

	                    setClosestEdge(closestEdge);
	                },
	                onDragLeave() {
	                    setClosestEdge(null);
	                },
	                onDrop() {
	                    setClosestEdge(null);
	                },
	            })
	        );
	    }, [nodeId]);

	    const sourceURL = reactExports.useMemo(() => {
	        invariant(
	            node.type === "image-attachment");
	        return makeSourceURL(node.attachment);
	    }, [node.attachment, node.type]);
	    const altTextButtonLabel = reactExports.useMemo(() => {
	        invariant(
	            node.type === "image-attachment");
	        return node.altText.length > 0 ? "edit description" : "add description";
	    }, [node.altText.length, node.type]);
	    const topLevelClasses = classNames("group relative w-full flex-initial", {
	        "co-selected-block ring-2": isSelected,
	    });

	    return (
	        React$2.createElement('div', { className: topLevelClasses,}
	            , closestEdge && React$2.createElement(DropIndicator, { edge: closestEdge, gap: "4px",} )
	            , React$2.createElement('img', {
	                src: sourceURL,
	                className: `no-touch-callout h-full w-full object-cover ${
                    dragState === "dragging" ? "opacity-10" : ""
                }`,
	                style: {
	                    aspectRatio: aspectRatio ? `${aspectRatio} / 1` : undefined,
	                },
	                alt: node.altText,
	                ref: imageRef,}
	            )
	            , nodeId !== null ? (
	                React$2.createElement(React$2.Fragment, null
	                    , React$2.createElement(AttachmentDeleteButton, {
	                        onDelete: () => {
	                            dispatch(deleteNodeAtIndex(nodeId));
	                        },}
	                    )
	                    , React$2.createElement(BasicButton, {
	                        buttonSize: "small",
	                        buttonColor: "cherry",
	                        extraClasses: "absolute bottom-3 left-3"  ,
	                        disabled: !isEditing || !attachmentComposerRef?.current,
	                        onClick: () =>
	                            attachmentComposerRef?.current?.open(nodeId)
	                        ,}

	                        , altTextButtonLabel
	                    )
	                )
	            ) : null
	            , React$2.createElement('div', {
	                className: `absolute inset-0 flex items-center justify-center bg-gray-700 bg-opacity-80 text-notWhite ${
                    shadeState.mode !== "none" ? "block" : "hidden"
                }`,}

	                , shadeState.mode === "uploading" ? (
	                    shadeState.displayString
	                ) : (
	                    React$2.createElement('div', { className: "flex flex-col items-center"  ,}
	                        , React$2.createElement(MoveIcon, { className: "m-auto h-8 w-8 text-notWhite"   ,} )
	                        , t("client:post-editor.drag-to-move", "drag to move")
	                    )
	                )
	            )
	        )
	    );
	});
	ImageAttachmentEditor.displayName = "ImageAttachmentEditor";

	const AudioAttachmentEditor

	 = ({ nodeId }) => {
	    const dispatch = useAppDispatch();
	    const isEditing = useAppSelector(selectIsEditing$2);
	    const body = useAppSelector(selectBody$1);
	    const node = body.nodes[nodeId];
	    const nodePosition = body.nodeOrder.indexOf(nodeId);

	    if (node.type !== "audio-attachment") {
	        throw new Error(`region ${nodeId} isn't audio attachment?`);
	    }

	    const sourceURL = makeSourceURL(node.attachment);
	    const isSelected = false;

	    const audio = reactExports.useRef(null);

	    const titleElement = reactExports.useRef(null);
	    const artistElement = reactExports.useRef(null);

	    const { togglePlayback, isPlaying } = useAudioPlayback(audio);

	    const inputStyleClasses = `
        w-full rounded-lg border-2 bg-transparent 
        read-only:bg-gray-700 border-gray-400 text-notWhite 
        placeholder:text-gray-400 focus:border-notWhite
    `;

	    const onMetadataChange = reactExports.useCallback

	(
	        (e) => {
	            if (titleElement.current && artistElement.current) {
	                dispatch(
	                    updateAudioMetadata({
	                        nodeId,
	                        title: titleElement.current.value,
	                        artist: artistElement.current.value,
	                    })
	                );
	            }
	        },
	        [dispatch, nodeId]
	    );

	    const playPauseMode = reactExports.useMemo(() => {
	        invariant(
	            node.type === "audio-attachment");

	        if (isEditing) {
	            return isPlaying ? "playing" : "paused";
	        } else {
	            if (node.attachment.state === AttachmentState.Finished) {
	                return "uploading:finished";
	            }

	            if (node.attachment.uploadState === "starting") {
	                return "uploading:starting";
	            } else if (node.attachment.uploadState === "finishing") {
	                return "uploading:finishing";
	            } else {
	                return "uploading:pending";
	            }
	        }
	    }, [
	        node.type,
	        node.attachment.state,
	        node.attachment.uploadState,
	        isEditing,
	        isPlaying,
	    ]);

	    const onDelete = reactExports.useCallback(() => {
	        dispatch(deleteNodeAtIndex(nodeId));
	    }, [nodeId, dispatch]);

	    const topLevelClasses = classNames("group relative w-full flex-initial", {
	        "co-selected-block ring-2": isSelected,
	    });

	    const dragHandleRef = reactExports.useRef(null);

	    const containerRef = reactExports.useRef(null);
	    const [closestEdge, setClosestEdge] = reactExports.useState(null);
	    const [dragState, setDragState] = reactExports.useState("none");

	    reactExports.useEffect(() => {
	        const element = containerRef.current;
	        invariant(element);

	        return combine(
	            draggable({
	                element,
	                getInitialData: () =>
	                    getEditorNodeDragData({
	                        nodeId,
	                        nodeType: "audio-attachment",
	                    }),
	                onDragStart() {
	                    setDragState("dragging");
	                },
	                onDrop() {
	                    setDragState("none");
	                },
	                dragHandle: dragHandleRef.current ?? undefined,
	            }),
	            dropTargetForElements({
	                element,
	                getIsSticky: () => true,
	                getData({ input }) {
	                    invariant(containerRef.current);
	                    return attachClosestEdge(
	                        getEditorNodeDragData({
	                            nodeId,
	                            nodeType: "audio-attachment",
	                        }),
	                        {
	                            allowedEdges: ["bottom", "top"],
	                            input,
	                            element: containerRef.current,
	                        }
	                    );
	                },
	                onDrop({ source: { data }, location, self }) {
	                    console.log("we droppin", data);
	                    setClosestEdge(null);

	                    if (!isEditorNodeDragData(data)) return;

	                    // we might be going outside a row. let's find out.
	                    const edge = extractClosestEdge(self.data);
	                    if (edge !== "top" && edge !== "bottom") return;

	                    // ok. new row time.
	                    dispatch(
	                        moveAttachmentToNewRow({
	                            attachmentNodeId: data.nodeId,
	                            relativeNodeId: nodeId,
	                            position: edge === "top" ? "before" : "after",
	                        })
	                    );
	                },
	                onDrag({ self, source }) {
	                    const data = source.data;
	                    if (!isEditorNodeDragData(data)) {
	                        return;
	                    }

	                    const isSource = data.nodeId === nodeId;
	                    if (isSource) {
	                        setClosestEdge(null);
	                        return;
	                    }

	                    const closestEdge = extractClosestEdge(self.data);

	                    console.log("closest edge", closestEdge);

	                    setClosestEdge(closestEdge);
	                },
	                onDragLeave() {
	                    setClosestEdge(null);
	                },
	            })
	        );
	    }, [dispatch, node, nodeId, nodePosition]);

	    return (
	        React$2.createElement('figure', { className: topLevelClasses, ref: containerRef,}
	            , closestEdge && React$2.createElement(DropIndicator, { edge: closestEdge, gap: "4px",} )
	            /* eslint-disable-next-line jsx-a11y/media-has-caption */
	            , React$2.createElement('audio', {
	                src: sourceURL,
	                preload: "metadata",
	                className: "w-full p-2" ,
	                ref: audio,}
	            )

	            , React$2.createElement('div', { className: "flex flex-row" ,}
	                , React$2.createElement('div', { className: "flex flex-col gap-1"  ,}
	                    /* drag handle */
	                    , React$2.createElement('div', {
	                        className: "flex w-[76px] basis-1/2 items-center bg-cherry"    ,
	                        title: "move this attachment"  ,
	                        ref: dragHandleRef,}

	                        , React$2.createElement(MoveIcon, { className: "m-auto h-8 w-8 text-notWhite"   ,} )
	                    )

	                    , React$2.createElement(AudioPlayPauseButton, {
	                        mode: playPauseMode,
	                        className: "basis-1/2",
	                        togglePlayback: togglePlayback,}
	                    )
	                )

	                , React$2.createElement('div', { className: "flex w-full flex-col bg-notBlack p-2"    ,}
	                    , React$2.createElement(AttachmentDeleteButton, { onDelete: onDelete,} )
	                    , React$2.createElement('input', {
	                        className: classNames(inputStyleClasses, "mb-1"),
	                        type: "text",
	                        placeholder: "add title information"  ,
	                        defaultValue: node.title,
	                        ref: titleElement,
	                        onChange: onMetadataChange,
	                        disabled: !isEditing,}
	                    )
	                    , React$2.createElement('input', {
	                        className: inputStyleClasses,
	                        type: "text",
	                        name: "artist",
	                        placeholder: "add artist information"  ,
	                        defaultValue: node.artist,
	                        ref: artistElement,
	                        onChange: onMetadataChange,
	                        disabled: !isEditing,}
	                    )
	                )
	            )
	        )
	    );
	};
	AudioAttachmentEditor.displayName = "AudioAttachmentEditor";

	function attachmentDimensions(attachment) {
	    if (attachment.type === "image-attachment") {
	        return {
	            width: attachment.width,
	            height: attachment.height,
	        };
	    } else if (attachment.type === "audio-attachment") {
	        return undefined;
	    }
	}

	const AttachmentRowEditor = ({
	    nodeId,
	}) => {
	    const dispatch = useAppDispatch();
	    const body = useAppSelector(selectBody$1);
	    const allNodes = body.nodes;
	    const node = allNodes[nodeId];
	    const nodePosition = body.nodeOrder.indexOf(nodeId);

	    if (node.type !== "attachment-row") {
	        throw new Error(`region ${nodeId} isn't attachment row?`);
	    }

	    const containerRef = reactExports.useRef(null);
	    const [closestEdge, setClosestEdge] = reactExports.useState(null);

	    reactExports.useEffect(() => {
	        const element = containerRef.current;
	        invariant(element);

	        return combine(
	            dropTargetForElements({
	                element,
	                getIsSticky: () => true,
	                getData({ input }) {
	                    invariant(containerRef.current);
	                    return attachClosestEdge(
	                        getEditorNodeDragData({
	                            nodeId,
	                            nodeType: "attachment-row",
	                        }),
	                        {
	                            allowedEdges: ["bottom", "top"],
	                            input,
	                            element: containerRef.current,
	                        }
	                    );
	                },
	                onDrop({ source: { data }, location, self }) {
	                    setClosestEdge(null);

	                    if (!isEditorNodeDragData(data)) return;

	                    // figure out where to place it in our current list
	                    const attachmentTarget = location.current.dropTargets.find(
	                        (dropTarget) => {
	                            if (
	                                !isEditorNodeDragData(dropTarget.data) ||
	                                dropTarget.data.nodeId === data.nodeId
	                            )
	                                return false;
	                            const edge = extractClosestEdge(dropTarget.data);
	                            return edge === "left" || edge === "right";
	                        }
	                    );

	                    // we're going in the row! nice
	                    if (attachmentTarget) {
	                        if (!isEditorNodeDragData(attachmentTarget.data))
	                            return;

	                        const closestEdge = extractClosestEdge(
	                            attachmentTarget.data
	                        );
	                        const attachmentIndex = node.attachments.indexOf(
	                            attachmentTarget.data.nodeId
	                        );
	                        const insertLocation =
	                            closestEdge === "left"
	                                ? Math.max(attachmentIndex - 1, 0)
	                                : attachmentIndex + 1;
	                        dispatch(
	                            moveAttachmentToExistingRow({
	                                attachmentNodeId: data.nodeId,
	                                rowNodeId: nodeId,
	                                positionInRow: insertLocation,
	                            })
	                        );

	                        return;
	                    }

	                    // we might be going outside a row. let's find out.
	                    const edge = extractClosestEdge(self.data);
	                    if (edge !== "top" && edge !== "bottom") return;

	                    // ok. new row time.
	                    dispatch(
	                        moveAttachmentToNewRow({
	                            attachmentNodeId: data.nodeId,
	                            relativeNodeId: nodeId,
	                            position: edge === "top" ? "before" : "after",
	                        })
	                    );
	                },
	                onDrag({ self, source, location }) {
	                    const data = source.data;
	                    if (!isEditorNodeDragData(data)) {
	                        return;
	                    }

	                    const isSource = data.nodeId === nodeId;
	                    if (isSource) {
	                        setClosestEdge(null);
	                        return;
	                    }

	                    const closestEdge = extractClosestEdge(self.data);

	                    // verify if any of our contained attachments have a closest
	                    // edge set. we don't want to double render the indicator.
	                    const locationSet = location.current.dropTargets.some(
	                        (dropTarget) => {
	                            if (!isEditorNodeDragData(dropTarget.data))
	                                return false;

	                            // ignore ourselves
	                            const targetData = getEditorNodeDragData(
	                                dropTarget.data
	                            );
	                            if (targetData.nodeId === nodeId) return false;

	                            // ignore the source
	                            if (targetData.nodeId === data.nodeId) return false;

	                            const closestEdge = extractClosestEdge(
	                                dropTarget.data
	                            );
	                            return closestEdge !== null;
	                        }
	                    );

	                    setClosestEdge(locationSet ? null : closestEdge);
	                },
	                onDragLeave() {
	                    setClosestEdge(null);
	                },
	            })
	        );
	    }, [dispatch, node.attachments, nodeId, nodePosition]);

	    const aspectRatio = reactExports.useMemo(() => {
	        const attachmentNodes = node.attachments
	            .map((attachmentId) => allNodes[attachmentId])
	            .filter(isDefined)
	            .filter(isAttachmentNode);

	        if (attachmentNodes.length === 0) return undefined;

	        const largestAttachment = attachmentNodes.reduce((prev, curr) => {
	            const currDimensions = attachmentDimensions(curr),
	                prevDimensions = prev ? attachmentDimensions(prev) : undefined;

	            if (
	                currDimensions &&
	                (!prevDimensions ||
	                    currDimensions.height * currDimensions.width >
	                        prevDimensions.height * prevDimensions.width)
	            ) {
	                return curr;
	            } else {
	                return prev;
	            }
	        });

	        const largestAttachmentDimensions = largestAttachment
	            ? attachmentDimensions(largestAttachment)
	            : undefined;
	        let aspectRatio = undefined;

	        if (attachmentNodes.length > 1) {
	            if (
	                largestAttachmentDimensions &&
	                largestAttachmentDimensions.width &&
	                largestAttachmentDimensions.height
	            ) {
	                aspectRatio =
	                    largestAttachmentDimensions.width /
	                    largestAttachmentDimensions.height;
	            } else {
	                aspectRatio = 16 / 9;
	            }
	        }

	        return aspectRatio;
	    }, [allNodes, node.attachments]);

	    return (
	        React$2.createElement('div', {
	            className: "relative flex items-center justify-between"   ,
	            ref: containerRef,}

	            , closestEdge && React$2.createElement(DropIndicator, { edge: closestEdge, gap: "4px",} )
	            , node.attachments.map((attachmentId) => {
	                const attachmentNode = allNodes[attachmentId];
	                if (attachmentNode.type === "image-attachment") {
	                    return (
	                        React$2.createElement(ImageAttachmentEditor, {
	                            key: attachmentId,
	                            nodeId: attachmentId,
	                            aspectRatio: aspectRatio,}
	                        )
	                    );
	                } else if (attachmentNode.type === "audio-attachment") {
	                    return (
	                        React$2.createElement(AudioAttachmentEditor, {
	                            key: attachmentId,
	                            nodeId: attachmentId,}
	                        )
	                    );
	                }
	            })
	        )
	    );
	};

	const ContentEditor = (props) => {
	    useAppDispatch();
	    const body = useAppSelector(selectBody$1);
	    const containerRef = reactExports.useRef(null);

	    const children = body.nodeOrder.map((nodeId) => {
	        const node = body.nodes[nodeId];
	        if (node.type === "text") {
	            return React$2.createElement(ContentEditorTextRegion, { key: nodeId, nodeId: nodeId,} );
	        } else if (node.type === "image-attachment") {
	            return React$2.createElement(ImageAttachmentEditor, { key: nodeId, nodeId: nodeId,} );
	        } else if (node.type === "audio-attachment") {
	            return React$2.createElement(AudioAttachmentEditor, { key: nodeId, nodeId: nodeId,} );
	        } else if (node.type === "attachment-row") {
	            return React$2.createElement(AttachmentRowEditor, { key: nodeId, nodeId: nodeId,} );
	        }
	    });

	    return (
	        React$2.createElement('div', { className: "flex flex-col gap-3"  , ref: containerRef,}
	            , children
	        )
	    );
	};

	function isEnteringWindow(_ref) {
	  var dragEnter = _ref.dragEnter;
	  var type = dragEnter.type,
	    relatedTarget = dragEnter.relatedTarget;
	  if (type !== 'dragenter') {
	    return false;
	  }
	  if (isSafari()) {
	    return isEnteringWindowInSafari({
	      dragEnter: dragEnter
	    });
	  }

	  // standard check
	  if (relatedTarget == null) {
	    return true;
	  }

	  /**
	   * 🦊 Exception: `iframe` in Firefox (`125.0`)
	   *
	   * Case 1: parent `window` → child `iframe`
	   * `relatedTarget` is the `iframe` element in the parent `window`
	   * (foreign element)
	   *
	   * Case 2: child `iframe` → parent `window`
	   * `relatedTarget` is an element inside the child `iframe`
	   * (foreign element)
	   */

	  if (isFirefox()) {
	    return isFromAnotherWindow(relatedTarget);
	  }

	  /**
	   * 🌏 Exception: `iframe` in Chrome (`124.0`)
	   *
	   * Case 1: parent `window` → child `iframe`
	   * `relatedTarget` is `null` *(standard check)*
	   *
	   * Case 2: child `iframe` → parent `window`
	   * `relatedTarget` is the `iframe` element in the parent `window`
	   */

	  // Case 2
	  // Using `instanceof` check as the element will be in the same `window`
	  return relatedTarget instanceof HTMLIFrameElement;
	}

	function isAnAvailableType(_ref) {
	  var type = _ref.type,
	    value = _ref.value;
	  // We don't want to expose our private elementAdapter key / value
	  if (type === elementAdapterNativeDataKey) {
	    return false;
	  }
	  // Not exposing "text/plain" if it contains the android fallback text
	  // We _could_ add an `isAndroid()` check, but it's probably safest
	  // to trim this data out, regardless of what OS we see it on.
	  if (type === textMediaType && value === androidFallbackText) {
	    return false;
	  }
	  return true;
	}
	function getAvailableTypes(transfer) {
	  return Array.from(transfer.types).filter(function (type) {
	    return isAnAvailableType({
	      type: type,
	      value: transfer.getData(type)
	    });
	  });
	}
	function getAvailableItems(dataTransfer) {
	  // item.kind is 'string' | 'file'
	  // For 'string' item.type is the mimeType (eg 'text/plain')
	  // For 'file' item.type is the file type (eg 'image/jpg')

	  return Array.from(dataTransfer.items).filter(function (item) {
	    return item.kind === 'file' || isAnAvailableType({
	      type: item.type,
	      value: dataTransfer.getData(item.type)
	    });
	  });
	}
	var didDragStartLocally = false;
	var adapter = makeAdapter({
	  typeKey: 'external',
	  // for external drags, we are generally making a copy of something that is being dragged
	  defaultDropEffect: 'copy',
	  mount: function mount(api) {
	    // Binding to the `window` so that the element adapter
	    // has a chance to get in first on the`document`.
	    // We are giving preference to the element adapter.
	    return dist.bind(window, {
	      type: 'dragenter',
	      listener: function listener(event) {
	        // drag operation was started within the document, it won't be an "external" drag
	        if (didDragStartLocally) {
	          return;
	        }

	        // Note: not checking if event was cancelled (`event.defaultPrevented`) as
	        // cancelling a "dragenter" accepts the drag operation (not prevent it)

	        // Something has gone wrong with our drag event
	        if (!event.dataTransfer) {
	          return;
	        }
	        if (!api.canStart(event)) {
	          return;
	        }
	        if (!isEnteringWindow({
	          dragEnter: event
	        })) {
	          return;
	        }

	        // Note: not checking types for `elementAdapterNativeDataKey` as we expect to see that
	        // key when pdnd started the drag in another document
	        var types = getAvailableTypes(event.dataTransfer);
	        if (!types.length) {
	          return;
	        }
	        var locked = {
	          types: types,
	          items: [],
	          getStringData: function getStringData() {
	            return null;
	          }
	        };
	        api.start({
	          event: event,
	          dragType: {
	            type: 'external',
	            startedFrom: 'external',
	            payload: locked,
	            getDropPayload: function getDropPayload(event) {
	              // this would be a platform error
	              // trying to handle it gracefully rather than throwing (for now)
	              if (!event.dataTransfer) {
	                return locked;
	              }
	              var items = getAvailableItems(event.dataTransfer);
	              // need to use `.bind` as `getData` is required
	              // to be run with `event.dataTransfer` as the "this" context
	              var nativeGetData = event.dataTransfer.getData.bind(event.dataTransfer);
	              return {
	                types: types,
	                items: items,
	                // return `null` if there is no result, otherwise string
	                getStringData: function getStringData(mediaType) {
	                  // not dragging the requested type
	                  // return `null` (no result)
	                  if (!types.includes(mediaType)) {
	                    return null;
	                  }

	                  // nativeGetData will return `""` when there is no value,
	                  // but at this point we know we will only get explicitly set
	                  // values back as we have checked the `types`.
	                  // `""` can be an explicitly set value.
	                  var value = nativeGetData(mediaType);

	                  // not exposing data for unavailable types
	                  if (!isAnAvailableType({
	                    type: mediaType,
	                    value: value
	                  })) {
	                    return null;
	                  }
	                  return value;
	                }
	              };
	            }
	          }
	        });
	      }
	    });
	  }
	});

	/**
	 * Some events don't make sense for the external adapter
	 *
	 * `onGenerateDragPreview`
	 * The browser creates the drag preview for external drags, so we don't
	 * need an event to generate the preview for _monitors_ or the _dropTarget_
	 *
	 * `onDragStart`
	 * An external drag can never start from in the `window`, so _dropTarget_'s
	 * don't need `onDragStart`
	 */

	function dropTargetForExternal(args) {
	  // not removing unused events, just leaning on the type system
	  return adapter.dropTarget(args);
	}
	(function startup() {
	  // server side rendering check
	  if (typeof window === 'undefined') {
	    return;
	  }

	  // A shared single usage registration as we want to capture
	  // all external drag operations, even if there are no drop targets
	  // on the page yet
	  adapter.registerUsage();
	  // independent of pdnd, we need to keep track of
	  // all drag operations so that we can know if a drag operation
	  // has started locally

	  var idle = {
	    type: 'idle'
	  };
	  var state = idle;
	  function clear() {
	    if (state.type !== 'dragging') {
	      return;
	    }
	    didDragStartLocally = false;
	    state.cleanup();
	    state = idle;
	  }
	  function bindEndEvents() {
	    return dist.bindAll(window, [{
	      type: 'dragend',
	      listener: clear
	    }].concat(_toConsumableArray(getBindingsForBrokenDrags({
	      onDragEnd: clear
	    }))),
	    // we want to make sure we get all the events,
	    // and this helps avoid not seeing events when folks stop
	    // them later on the event path
	    {
	      capture: true
	    });
	  }

	  // we always keep this event listener active
	  dist.bind(window, {
	    type: 'dragstart',
	    listener: function listener() {
	      // something bad has happened if this is true!
	      if (state.type !== 'idle') {
	        return;
	      }
	      // set our global flag
	      didDragStartLocally = true;
	      state = {
	        type: 'dragging',
	        cleanup: bindEndEvents()
	      };
	    },
	    // binding in the capture phase so these listeners are called
	    // before our listeners in the adapters `mount` function
	    options: {
	      capture: true
	    }
	  });
	})();

	/** Common event payload for all events */

	/** A map containing payloads for all events */

	/** Common event payload for all drop target events */

	/** A map containing payloads for all events on drop targets */

	/** Arguments given to all feedback functions (eg `canDrop()`) on a `dropTargetForExternal` */

	/** Arguments given to all monitor feedback functions (eg `canMonitor()`) for a `monitorForExternal` */

	function containsFiles(_ref) {
	  var source = _ref.source;
	  return source.types.includes('Files');
	}

	/** Obtain an array of the dragged `File`s */
	function getFiles(_ref2) {
	  var source = _ref2.source;
	  return source.items
	  // unlike other media types, for files:
	  // item.kind is 'file'
	  // item.type is the type of file eg 'image/jpg'
	  // for other media types, item.type is the mime format
	  .filter(function (item) {
	    return item.kind === 'file';
	  }).map(function (item) {
	    return item.getAsFile();
	  }).filter(function (file) {
	    return file != null;
	  });
	}

	const EditingPanel = () => {
	    useTranslation();

	    const editingTransparentShare = useAppSelector(
	        selectEditingTransparentShare
	    );
	    const shareOfPostId = useAppSelector(selectShareOfPostId);
	    const projectHandle = useAppSelector(selectProjectHandle);
	    const attachmentComposerRef = reactExports.useContext(AttachmentComposerContext);

	    const [isDragging, setIsDragging] = reactExports.useState(false);
	    const containerRef = reactExports.useRef(null);
	    const dispatch = useAppDispatch();

	    reactExports.useEffect(() => {
	        const element = containerRef.current;
	        invariant(element);
	        return dropTargetForExternal({
	            element,
	            canDrop: containsFiles,
	            onDrop({ source, self }) {
	                const files = getFiles({ source });
	                if (files.length === 0) return;

	                setIsDragging(false);

	                dispatch(
	                    insertFile({
	                        file: files[0],
	                        atPosition: 0,
	                    })
	                );
	            },
	            onDrag() {
	                setIsDragging(true);
	            },
	            onDragLeave() {
	                setIsDragging(false);
	            },
	        });
	    }, [dispatch]);

	    return (
	        React$2.createElement('div', { className: "relative", ref: containerRef,}
	            , React$2.createElement('div', {
	                className: `absolute inset-0 flex items-center justify-center
                bg-gray-700 bg-opacity-70 text-notWhite ${
                    isDragging ? "block" : "hidden"
                } z-50
                backdrop-blur-sm`,}
	, "RELEASE TO DROP"

	            )
	            , React$2.createElement('div', { className: "flex flex-col gap-3 py-3"   ,}
	                , editingTransparentShare && shareOfPostId ? (
	                    React$2.createElement(InfoBox, { className: "!m-3 !w-auto" , level: "post-box-info",}
	                        , React$2.createElement('div', { className: tw`co-prose prose prose-sm`,}
	                            , React$2.createElement('p', null, "Shares without content can't have content added after posting. You "

	                                   , React$2.createElement('b', null, "can"), " edit the tags."
	                            )
	                            , React$2.createElement('p', null, "If you want, you can"
	                                    , " "
	                                , React$2.createElement('a', {
	                                    href: sitemap.public.project
	                                        .composePost({
	                                            projectHandle: projectHandle,
	                                            shareOfPostId: shareOfPostId,
	                                        })
	                                        .toString(),
	                                    target: "_blank",
	                                    rel: "noreferrer",}
	, "share this post again"

	                                ), " ", "and add your content there."

	                            )
	                        )
	                    )
	                ) : (
	                    React$2.createElement(React$2.Fragment, null
	                        , React$2.createElement(HeadlineInput, null )
	                        , React$2.createElement(ContentEditor, null )
	                        , React$2.createElement(AttachmentComposer, { ref: attachmentComposerRef,} )
	                    )
	                )
	                , React$2.createElement(TagsInput, null )
	                , React$2.createElement(CwsInput, null )
	            )
	        )
	    );
	};

	const PostComposerPreview = () => {
	    const { blocksForPreview } = useAppSelector(selectRenderedPost);
	    const headline = useAppSelector(selectHeadline);
	    const tags = useAppSelector(selectTags);

	    const tagListRef = reactExports.useRef(null);

	    const [expanded, setExpanded] = reactExports.useState(false);
	    const [hasRunLayout, setHasRunLayout] = reactExports.useState(false);
	    const toggleExpanded = () => setExpanded(!expanded);

	    reactExports.useEffect(() => {
	        if (!hasRunLayout && tagListRef.current) {
	            setExpanded(
	                tagListRef.current.scrollHeight <=
	                    tagListRef.current.clientHeight
	            );
	            setHasRunLayout(true);
	        }
	    }, [hasRunLayout]);

	    const { t } = useTranslation();

	    const hasCohostPlus = useHasCohostPlus();
	    const postAst = useAsync(
	        () =>
	            generatePostAst(blocksForPreview, new Date(), {
	                hasCohostPlus,
	                renderingContext: "post",
	            }),
	        [blocksForPreview, hasCohostPlus]
	    );

	    return (
	        React$2.createElement('div', { 'data-post-composer-preview': true,}
	            , headline ? (
	                React$2.createElement('div', { className: "w-full p-3" ,}
	                    , React$2.createElement('h1', {
	                        className: tw`co-prose prose font-atkinson text-xl font-bold`,}

	                        , headline
	                    )
	                )
	            ) : null
	            , postAst.loading ? (
	                React$2.createElement('div', { className: tw`co-ui-text`,}, "rendering...")
	            ) : postAst.error ? (
	                React$2.createElement('div', { className: tw`co-ui-text`,}, postAst.error.message)
	            ) : (
	                React$2.createElement(PostBody, {
	                    viewModel: {
	                        postId: 0 ,
	                        blocks: blocksForPreview,
	                        astMap: postAst.value,
	                    },
	                    skipCollapse: true,
	                    effectiveDate: undefined,}
	                )
	            )
	            , tags.length ? (
	                React$2.createElement('div', { className: "w-full max-w-full p-3"  ,}
	                    , React$2.createElement('div', {
	                        ref: tagListRef,
	                        className: tw`co-tags relative w-full overflow-y-hidden break-words leading-none ${
                            expanded ? "" : "max-h-10"
                        }`,}

	                        , React$2.createElement('div', null
	                            , tags.map((tag) => (
	                                React$2.createElement('span', {
	                                    className: "mr-2 inline-block text-sm"  ,
	                                    key: tag,}
	, "#"
	                                    , tag
	                                )
	                            ))
	                        )
	                        , !expanded ? (
	                            React$2.createElement('div', { className: "absolute bottom-0 right-2 flex h-5"    ,}
	                                , React$2.createElement('span', { className: "co-from-body inline-block h-full bg-gradient-to-l pl-4"    ,} )
	                                , React$2.createElement('button', {
	                                    onClick: toggleExpanded,
	                                    className: 
	                                        "co-tags co-opaque inline-block cursor-pointer text-sm font-bold hover:underline"
	                                    ,}

	                                    , t(
	                                        "client:post-preview.expand-tags",
	                                        "see all"
	                                    )
	                                )
	                            )
	                        ) : null
	                    )
	                )
	            ) : null
	        )
	    );
	};

	// for now this lives inside the post composer, but as other components move
	// to redux, it should move out into the client toplevel
	const store = configureStore({
	    reducer: {
	        [postComposerSlice.reducerPath]: postComposerSlice.reducer,
	    },
	    middleware: (getDefaultMiddleware) =>
	        getDefaultMiddleware().prepend(listenerMiddleware.middleware),
	});

	 


	const addAppListener = addListener.withTypes();

	const TagRecommendationBox

	 = (props) => {
	    const dynamicTheme = useDynamicTheme();

	    const tags = useAppSelector(selectTags);
	    const dispatch = useAppDispatch();
	    const [storedState, setStoredState] = useLocalStorage(
	        `tag-recommendations/${props.stateId}`,
	        { open: false }
	    );

	    function appendTag(content) {
	        if (
	            tags.findIndex(
	                (existingTag) =>
	                    existingTag.toLowerCase() === content.toLowerCase()
	            ) !== -1
	        ) {
	            // tag already present; do nothing.
	            return;
	        } else {
	            // tag not currently present; add it.
	            dispatch(setTags([...tags, content]));
	        }
	    }

	    return (
	        React$2.createElement('div', {
	            className: tw`co-themed-box w-full`,
	            'data-theme': dynamicTheme.current,}

	            , React$2.createElement(ve$3, { defaultOpen: storedState.open,}
	                , React$2.createElement(ve$3.Button, { className: "co-accordion-header flex w-full max-w-prose flex-row rounded-lg px-3 py-1 ui-open:rounded-b-none"        ,}
	                    , ({ open }) => {
	                        // without the conditional, this leads to an infinite render loop
	                        if (open !== storedState.open) setStoredState({ open });

	                        return (
	                            React$2.createElement(React$2.Fragment, null
	                                , React$2.createElement('span', { className: "flex-1 text-left" ,}
	                                    , props.categoryTitle
	                                )
	                                , React$2.createElement(ForwardRef$12, { className: "h-6 self-center ui-open:rotate-180"  ,} )
	                            )
	                        );
	                    }
	                )
	                , React$2.createElement(ve$3.Panel, { className: "co-accordion-body flex w-full max-w-prose flex-row flex-wrap gap-3 rounded-b-lg p-3"        ,}
	                    , React$2.createElement(React$2.Fragment, null
	                        , props.tags.map((tag) => (
	                            React$2.createElement(TagButton, {
	                                key: tag,
	                                TagIcon: ForwardRef$H,
	                                MouseoverTagIcon: ForwardRef$X,
	                                tagText: tag,
	                                onClick: () => appendTag(tag),}
	                            )
	                        ))
	                    )
	                )
	            )
	        )
	    );
	};

	const PostComposer =
	    React$2.forwardRef((props, ref) => {
	        const {
	            initialAdultContent,
	            project: initialProject,
	            shareOf,
	            cws,
	            tags,
	            initialPost,
	        } = props;
	        const siteConfig = reactExports.useContext(SiteConfigProvider);
	        const hasCohostPlus = useHasCohostPlus();
	        const { activated } = useUserInfo();

	        const hasPosted = useAppSelector(selectHasPosted);
	        const newPostState = useAppSelector(selectNewPostState);
	        const projectHandle = useAppSelector(selectProjectHandle);
	        const dirty = useAppSelector(selectDirty);
	        const postId = useAppSelector(selectPostId);

	        const dispatch = useAppDispatch();

	        // FIXME: this is an island of redux code in an ocean of non-redux
	        // code.  copy our props into redux at mount time and abandon the state
	        // at unmount time.
	        reactExports.useEffect(() => {
	            if (initialPost) {
	                dispatch(
	                    initForEditing({
	                        handle: initialProject.handle,
	                        isActivated: activated,
	                        hasCohostPlus,
	                        siteConfig,
	                        post: initialPost,
	                    })
	                );
	            } else {
	                dispatch(
	                    initForNewPost({
	                        handle: initialProject.handle,
	                        isActivated: activated,
	                        hasCohostPlus,
	                        siteConfig,
	                        shareOf: shareOf ? shareOf.postId : null,
	                        responseToAskId: props.responseToAskId ?? null,
	                        tags,
	                        cws,
	                        adultContent: initialAdultContent,
	                    })
	                );
	            }

	            return () => {
	                dispatch(abandon());
	            };
	            // we deliberately only run this at mount
	            // eslint-disable-next-line react-hooks/exhaustive-deps
	        }, []);

	        useBeforeUnload(() => dirty);

	        reactExports.useImperativeHandle(
	            ref,
	            () => ({
	                attemptClose() {
	                    return !dirty;
	                },
	            }),
	            [dirty]
	        );

	        reactExports.useEffect(() => {
	            if (hasPosted) {
	                if (typeof props.finishedRedirect === "function") {
	                    props.finishedRedirect(postId);
	                    return;
	                } else if (typeof props.finishedRedirect === "string") {
	                    // if we were told somewhere specific to go, go there.
	                    location.replace(props.finishedRedirect);
	                } else if (newPostState === PostState.Unpublished) {
	                    // if it's a draft, go to the drafts page
	                    location.replace(sitemap.public.project.unpublishedPosts());
	                } else {
	                    // otherwise, back to where we came
	                    location.replace(document.referrer);
	                }
	            }
	        }, [
	            props.finishedRedirect,
	            hasPosted,
	            newPostState,
	            projectHandle,
	            props,
	            postId,
	        ]);

	        const postToast = reactExports.useRef();

	        reactExports.useEffect(() => {
	            const unsubscribe = dispatch(
	                addAppListener({
	                    predicate: (_action, state) => {
	                        return (
	                            state.postComposer.state === "uploading" ||
	                            state.postComposer.state === "finished" ||
	                            state.postComposer.state === "failed"
	                        );
	                    },
	                    effect: (action, listenerApi) => {
	                        const state = listenerApi.getState();

	                        if (
	                            state.postComposer.state === "uploading" &&
	                            !postToast.current
	                        ) {
	                            let message = undefined;

	                            switch (newPostState) {
	                                case PostState.Published:
	                                    message = "Posting...";
	                                    break;
	                                case PostState.Unpublished:
	                                    message = "Saving...";
	                                    break;
	                            }

	                            if (message) {
	                                postToast.current = _t$1.loading(message);
	                            }
	                        }

	                        if (state.postComposer.state === "finished") {
	                            // depending on whether newPostState is Published or
	                            // Unpublished, this post is now posted or saved as a draft
	                            let message = undefined;

	                            switch (newPostState) {
	                                case PostState.Published:
	                                    message = "Posted!";
	                                    break;
	                                case PostState.Unpublished:
	                                    message = "Draft saved!";
	                                    break;
	                            }

	                            if (message) {
	                                _t$1.success(message, {
	                                    id: postToast.current,
	                                });
	                            }
	                        }

	                        if (state.postComposer.state === "failed") {
	                            let message = undefined;

	                            switch (newPostState) {
	                                case PostState.Published:
	                                    message = "Couldn't post :(";
	                                    break;
	                                case PostState.Unpublished:
	                                    message = "Couldn't save :(";
	                                    break;
	                            }

	                            if (message) {
	                                _t$1.error(message, {
	                                    id: postToast.current,
	                                });
	                            }
	                        }
	                    },
	                })
	            );

	            return () => {
	                unsubscribe();
	                postToast.current = undefined;
	            };
	        }, [newPostState]);

	        const attachmentComposerRef = reactExports.useRef(null);

	        return activated ? (
	            React$2.createElement(AttachmentComposerContext.Provider, { value: attachmentComposerRef,}
	                , React$2.createElement(PostComposerInner, {
	                    project: initialProject,
	                    isModal: props.isModal,
	                    onClose: props.onClose,}
	                )
	            )
	        ) : (
	            React$2.createElement(UnactivatedPostComposer, { isModal: props.isModal,} )
	        );
	    });
	PostComposer.displayName = "PostComposer";

	const UnactivatedPostComposer =
	    React$2.memo(({ isModal = false }) => {
	        useTranslation();

	        const dispatch = useAppDispatch();
	        const isEditing = useAppSelector(selectIsEditing$2);

	        return (
	            React$2.createElement('div', { className: "cohost-shadow-light dark:cohost-shadow-dark prose mx-auto w-full max-w-full rounded-lg bg-notWhite p-3"        ,}
	                , React$2.createElement('p', null, "Since your account isn't activated yet, you can share this post but can't add anything to it. You can read more about this on"


	                     , " "
	                    , React$2.createElement('a', {
	                        href: "https://help.antisoftware.club/support/solutions/articles/62000224749-details-on-invites-and-the-restrictions-on-un-activated-accounts/",
	                        target: "_blank",
	                        rel: "noreferrer",}
	, "our support site."

	                    )
	                )
	                , React$2.createElement(AuthnButton, {
	                    as: "button",
	                    onClick: () => dispatch(submit()),
	                    disabled: !isEditing,}
	, "share post"

	                )
	            )
	        );
	    });
	UnactivatedPostComposer.displayName = "UnactivatedPostComposer";

	const PostComposerInner



	 = React$2.memo(({ project: initialProject, isModal = false, onClose }) => {
	    const { t } = useTranslation();

	    const hasCohostPlus = useHasCohostPlus();

	    const { projects } = useEditedProjects();
	    const dispatch = useAppDispatch();
	    const hasErrors = useAppSelector(selectHasErrors);
	    const errors = useAppSelector(selectErrors);
	    const isEditing = useAppSelector(selectIsEditing$2);
	    const canCollapseCws = useAppSelector(selectCwsButtonEnabled);
	    const maxAttachmentsChosen = useAppSelector(selectMaxAttachmentsChosen);
	    const newPostState = useAppSelector(selectNewPostState);
	    const projectHandle = useAppSelector(selectProjectHandle);
	    const adultContent = useAppSelector(selectAdultContent);
	    const isTransparentShare = useAppSelector(selectCreatingTransparentShare);
	    const editingTransparentShare = useAppSelector(
	        selectEditingTransparentShare
	    );

	    const currentProject = reactExports.useMemo(() => {
	        const project = projects.find(
	            (project) => project.handle === projectHandle
	        );
	        if (project) {
	            return project;
	        }
	        return initialProject;
	    }, [projectHandle, projects, initialProject]);
	    const pinnedTags = currentProject.frequentlyUsedTags;
	    const recentlyUsedTags = trpc.projects.listRecentlyUsedTags.useQuery({
	        projectId: currentProject.projectId,
	    });

	    const toggleEditingCws = reactExports.useCallback(() => {
	        dispatch(toggleCwsInputOpen());
	    }, [dispatch]);

	    const onChangeNewPostState = reactExports.useCallback(
	        (newPostState) => {
	            dispatch(setNewPostState(newPostState));
	        },
	        [dispatch]
	    );

	    const postStates = [
	        {
	            postState: PostState.Published,
	            string: t("client:post-editor.post-now", "post now"),
	        },
	        {
	            postState: PostState.Unpublished,
	            string: t("client:post-editor.save-as-draft", "save draft"),
	        },
	    ];

	    const dynamicTheme = useDynamicTheme();

	    const onSelectEmoji = reactExports.useCallback(
	        (emoji) => {
	            dispatch(
	                insertNewTextAtSelection(emoji.native ?? emoji.shortcodes)
	            );
	        },
	        [dispatch]
	    );

	    const onKeyDown = reactExports.useCallback(
	        (ev) => {
	            if ((ev.metaKey || ev.ctrlKey) && ev.key === "Enter") {
	                ev.preventDefault();
	                void dispatch(submit());
	            }
	        },
	        [dispatch]
	    );

	    return (
	        // intentionally ignoring this one; just adding a keyboard shortcut for
	        // submitting comments, which is accessible in other ways
	        // eslint-disable-next-line jsx-a11y/no-static-element-interactions
	        React$2.createElement('div', { onKeyDown: onKeyDown,}
	            , React$2.createElement(ErrorBoundary, null
	                , React$2.createElement('div', { className: "mb-6 lg:pl-[5.5rem]" ,}
	                    , React$2.createElement(InfoBox, {
	                        level: "post-box-info",
	                        className: "max-w-prose",
	                        // even though we reset back down to small immediately,
	                        // we need this for the 65ch calculation for max-width
	                        // to be the same as the section below.
	                        textSize: "base",}

	                        , React$2.createElement('div', { className: "co-prose prose prose-sm"  ,}
	                            , React$2.createElement('h4', null, "welcome to the new post editor!"     )
	                            , React$2.createElement('p', null, "the new editor lets you drag and drop images and audio attachments around to arrange your post however you want without needing to use HTML!"



	                            )
	                            , React$2.createElement('p', null, "it's currently in beta, so please let us know if you run into any issues. if you'd like to turn it off, you can do it under the \"preview features\" section in"



	                                  , " "
	                                , React$2.createElement('a', {
	                                    href: sitemap.public
	                                        .userSettings()
	                                        .toString(),}
	, "your settings"

	                                ), "."

	                            )
	                        )
	                    )
	                )
	                , hasErrors ? (
	                    React$2.createElement('div', { className: "mx-auto mb-6 max-w-lg border-2 border-red-700 bg-red-300 p-3 text-notBlack"       ,}
	                        , React$2.createElement('h1', { className: "text-lg font-bold" ,}
	                            , t(
	                                "client:post-editor.validation-errors",
	                                "There were some errors:"
	                            )
	                        )
	                        , React$2.createElement('ul', { className: "list-inside list-disc" ,}
	                            , errors.map((error) => (
	                                React$2.createElement('li', { key: error,}, t(error))
	                            ))
	                        )
	                    )
	                ) : null
	                , React$2.createElement('div', { className: "flex flex-row justify-center gap-6"   ,}
	                    , React$2.createElement(ProjectAvatar, { project: currentProject, noLink: true,} )
	                    , React$2.createElement('div', { className: "flex flex-1 flex-col gap-4"   ,}
	                        /* we use `w-screen` here to force the box to use
	                                as much space as possible, fixing the issue where
	                                it resizes while typing. `max-w-prose` prevents
	                                it from overflowing. */
	                        , React$2.createElement('article', {
	                            className: "co-themed-box co-post-box co-post-composer"  ,
	                            'data-theme': dynamicTheme.current,}

	                            , React$2.createElement('header', { className: "co-thread-header",}
	                                , React$2.createElement('div', { className: "flex flex-row items-center gap-2"   ,}
	                                    , React$2.createElement(ProjectAvatar, {
	                                        project: currentProject,
	                                        hideLock: true,
	                                        className: "h-8 w-8 lg:hidden"  ,
	                                        noLink: true,}
	                                    )
	                                    , React$2.createElement('span', {
	                                        className: tw`co-ui-text relative font-atkinson font-bold`,}

	                                        , React$2.createElement(Ht$1, {
	                                            value: currentProject.handle,
	                                            onChange: (projectHandle) => {
	                                                dispatch(
	                                                    setActiveProject(
	                                                        projectHandle
	                                                    )
	                                                );
	                                            },}

	                                            , React$2.createElement(Ht$1.Button, { className: "font-atkinson font-bold" ,}
	                                                , ({
	                                                    open,
	                                                }

	) => (
	                                                    React$2.createElement(React$2.Fragment, null
	                                                        , currentProject.handle, " "
	                                                        , React$2.createElement(ForwardRef$12, {
	                                                            className: `inline-block h-4 w-4 transition-transform ${
                                                                open
                                                                    ? "rotate-180"
                                                                    : "rotate-0"
                                                            }`,}
	                                                        )
	                                                    )
	                                                )
	                                            )
	                                            , React$2.createElement(Ht$1.Options, { className: "cohost-shadow-light absolute left-0 top-full z-10 mt-1 flex min-w-max flex-col divide-y divide-foreground-400 rounded-lg font-normal leading-none text-notWhite"              ,}
	                                                , projects.map((project) => (
	                                                    React$2.createElement(Ht$1.Option, {
	                                                        key: project.handle,
	                                                        value: project.handle,
	                                                        className: `relative cursor-default select-none bg-foreground py-2 pl-8 pr-2 first:rounded-t-lg last:rounded-b-lg hover:bg-foreground-600`,}

	                                                        , ({
	                                                            selected,
	                                                        }

	) => (
	                                                            React$2.createElement(React$2.Fragment, null
	                                                                , React$2.createElement('span', { className: "block",}
	                                                                    , 
	                                                                        project.handle
	                                                                    
	                                                                )
	                                                                , selected ? (
	                                                                    React$2.createElement('span', { className: "absolute inset-y-0 left-0 flex items-center pl-2"     ,}
	                                                                        , React$2.createElement(ForwardRef$15, { className: "h-4 w-4" ,} )
	                                                                    )
	                                                                ) : null
	                                                            )
	                                                        )
	                                                    )
	                                                ))
	                                            )
	                                        )
	                                    )
	                                )
	                                , React$2.createElement('div', { className: "flex flex-row items-center gap-2"   ,}
	                                    , React$2.createElement('label', { className: "flex flex-row items-center gap-2"   ,}
	                                        , React$2.createElement('span', {
	                                            className: tw`co-ui-text select-none`,}

	                                            , t(
	                                                "client:post-editor.adult-content",
	                                                "18+ content?"
	                                            )
	                                        )
	                                        , React$2.createElement('input', {
	                                            type: "checkbox",
	                                            name: "adultContent",
	                                            className: tw`rounded border-2 disabled:cursor-not-allowed`,
	                                            // visually display false if
	                                            // it's a transparent share,
	                                            // since it will be processed in
	                                            // that direction on the server.
	                                            checked: 
	                                                !isTransparentShare &&
	                                                adultContent
	                                            ,
	                                            onChange: (e) =>
	                                                dispatch(
	                                                    setAdultContent(
	                                                        e.currentTarget.checked
	                                                    )
	                                                )
	                                            ,
	                                            disabled: 
	                                                isTransparentShare || !isEditing
	                                            ,}
	                                        )
	                                    )
	                                    , isModal ? (
	                                        React$2.createElement(ForwardRef$C, {
	                                            className: tw`co-link-button h-6 w-6 cursor-pointer`,
	                                            onClick: onClose,}
	                                        )
	                                    ) : null

	                                    /* <EllipsisHorizontalIcon className="h-6 w-6 text-notBlack" /> */
	                                )
	                            )
	                            , React$2.createElement('hr', { className: "co-hairline",} )
	                            , React$2.createElement(rt$1.Group, null
	                                , React$2.createElement(rt$1.Panels, null
	                                    , React$2.createElement(rt$1.Panel, { unmount: false,}
	                                        , React$2.createElement(EditingPanel, null )
	                                    )
	                                    , React$2.createElement(rt$1.Panel, null
	                                        , React$2.createElement(PostComposerPreview, null )
	                                    )
	                                )
	                                , React$2.createElement('hr', { className: "co-hairline",} )
	                                , React$2.createElement('footer', {
	                                    className: tw`co-thread-footer w-full max-w-full rounded-b-lg p-3`,}

	                                    , React$2.createElement('div', { className: "flex items-center justify-between"  ,}
	                                        , React$2.createElement('div', { className: "flex items-center gap-1 md:gap-2"   ,}
	                                            , React$2.createElement(FilePicker, {
	                                                onFilesPicked: (files) =>
	                                                    dispatch(
	                                                        insertFile({
	                                                            file: files[0],
	                                                            atPosition: -1,
	                                                        })
	                                                    )
	                                                ,}

	                                                , React$2.createElement('button', {
	                                                    disabled: 
	                                                        !isEditing ||
	                                                        maxAttachmentsChosen ||
	                                                        editingTransparentShare
	                                                    ,
	                                                    className: tw`co-link-button disabled:cursor-not-allowed`,
	                                                    title: "attach images or audio"   ,}

	                                                    , React$2.createElement(ForwardRef$13, { className: "inline-block h-6" ,} )
	                                                )
	                                            )
	                                            , React$2.createElement('button', {
	                                                disabled: 
	                                                    isTransparentShare ||
	                                                    !isEditing ||
	                                                    !canCollapseCws
	                                                ,
	                                                onClick: toggleEditingCws,
	                                                className: tw`co-link-button disabled:cursor-not-allowed`,
	                                                title: "add a content warning"   ,}

	                                                , React$2.createElement(ForwardRef$P, { className: "inline-block h-6" ,} )
	                                            )

	                                            , React$2.createElement(EmojiButton, {
	                                                onSelectEmoji: onSelectEmoji,
	                                                disabled: !isEditing,
	                                                hasCohostPlus: !!hasCohostPlus,}
	                                            )
	                                            /* markdown button */
	                                            , React$2.createElement('a', {
	                                                href: sitemap.public
	                                                    .staticContent({
	                                                        slug: "markdown-reference",
	                                                    })
	                                                    .toString(),
	                                                target: "_blank",
	                                                rel: "noreferrer",
	                                                className: tw`co-link-button`,
	                                                title: "markdown reference" ,}

	                                                , React$2.createElement(ForwardRef$V, { className: "inline-block h-6" ,} )
	                                            )
	                                        )
	                                        , React$2.createElement(rt$1.List, {
	                                            className: tw`co-tab-bar flex items-center rounded-lg text-sm leading-none`,}

	                                            , React$2.createElement(rt$1, {
	                                                className: ({ selected }) =>
	                                                    selected
	                                                        ? tw`co-tab-bar co-active rounded-lg px-2 py-2 md:px-3`
	                                                        : `px-2 py-2 md:px-3`
	                                                ,}

	                                                , t(
	                                                    "client:post-editor.compose-tab",
	                                                    "compose"
	                                                )
	                                            )
	                                            , React$2.createElement(rt$1, {
	                                                className: ({ selected }) =>
	                                                    selected
	                                                        ? tw`co-tab-bar co-active rounded-lg px-2 py-2 md:px-3`
	                                                        : `px-2 py-2 md:px-3`
	                                                ,}

	                                                , t(
	                                                    "client:post-editor.preview-tab",
	                                                    "preview"
	                                                )
	                                            )
	                                        )
	                                        , React$2.createElement('div', { className: "relative inline-flex items-stretch rounded-lg text-sm text-text"     ,}
	                                            , React$2.createElement('button', {
	                                                className: tw`co-filled-button rounded-l-lg border-r border-r-gray-500 py-2 pl-2 pr-1 leading-none`,
	                                                onClick: () =>
	                                                    dispatch(submit())
	                                                ,}

	                                                , newPostState ===
	                                                PostState.Published
	                                                    ? t(
	                                                          "client:post-editor.post-now",
	                                                          "post now"
	                                                      )
	                                                    : newPostState ===
	                                                      PostState.Unpublished
	                                                    ? t(
	                                                          "client:post-editor.save-as-draft",
	                                                          "save draft"
	                                                      )
	                                                    : null
	                                            )
	                                            , React$2.createElement(Ht$1, {
	                                                value: newPostState,
	                                                onChange: onChangeNewPostState,}

	                                                , React$2.createElement(Ht$1.Button, null
	                                                    , ({
	                                                        open,
	                                                    }

	) => (
	                                                        React$2.createElement('div', {
	                                                            className: tw`co-filled-button rounded-r-lg py-2 pl-1 pr-2 leading-none`,}

	                                                            , React$2.createElement(ForwardRef$12, {
	                                                                className: `inline-block h-4 w-4 transition-transform ${
                                                                    open
                                                                        ? "rotate-180"
                                                                        : "rotate-0"
                                                                }`,}
	                                                            )
	                                                        )
	                                                    )
	                                                )
	                                                , React$2.createElement(Ht$1.Options, { className: "cohost-shadow-light absolute right-0 top-full mt-1 flex min-w-max flex-col divide-y divide-foreground-400 rounded-lg leading-none"           ,}
	                                                    , postStates.map(
	                                                        ({
	                                                            postState,
	                                                            string,
	                                                        }) => (
	                                                            React$2.createElement(Ht$1.Option, {
	                                                                key: postState,
	                                                                value: 
	                                                                    postState
	                                                                ,
	                                                                className: tw`co-filled-button relative cursor-default select-none py-2 pl-8 pr-2 first:rounded-t-lg last:rounded-b-lg`,}

	                                                                , ({
	                                                                    selected,
	                                                                }

	) => (
	                                                                    React$2.createElement(React$2.Fragment, null
	                                                                        , React$2.createElement('span', { className: "block",}
	                                                                            , 
	                                                                                string
	                                                                            
	                                                                        )
	                                                                        , selected ? (
	                                                                            React$2.createElement('span', { className: "absolute inset-y-0 left-0 flex items-center pl-2"     ,}
	                                                                                , React$2.createElement(ForwardRef$15, { className: "h-4 w-4" ,} )
	                                                                            )
	                                                                        ) : null
	                                                                    )
	                                                                )
	                                                            )
	                                                        )
	                                                    )
	                                                )
	                                            )
	                                        )
	                                    )
	                                )
	                            )
	                        )
	                        , pinnedTags.length > 0 ? (
	                            React$2.createElement(TagRecommendationBox, {
	                                categoryTitle: "pinned tags" ,
	                                stateId: "pinned",
	                                tags: pinnedTags,}
	                            )
	                        ) : null
	                        , recentlyUsedTags.data?.tags ? (
	                            React$2.createElement(TagRecommendationBox, {
	                                categoryTitle: "recently used tags"  ,
	                                stateId: "recently-used",
	                                tags: recentlyUsedTags.data?.tags,}
	                            )
	                        ) : null
	                        , hasCohostPlus ? (
	                            React$2.createElement('p', { className: "max-w-prose",}, "As a cohost Plus! member, your attachment size upload limit is now 10mb! Go crazy, but keep in mind larger attachments might take a while to upload."




	                            )
	                        ) : null
	                    )
	                )
	            )
	        )
	    );
	});
	PostComposerInner.displayName = "PostComposerInner";

	exports.AccessResult = void 0; (function (AccessResult) {
	    const Allowed = "allowed"; AccessResult["Allowed"] = Allowed;
	    const NotAllowed = "not-allowed"; AccessResult["NotAllowed"] = NotAllowed;
	    const LogInFirst = "log-in-first"; AccessResult["LogInFirst"] = LogInFirst;
	    const Blocked = "blocked"; AccessResult["Blocked"] = Blocked;
	})(exports.AccessResult || (exports.AccessResult = {}));

	mod.nativeEnum(exports.AccessResult);

	const commentModuleMachine = createMachine


	(
	    {
	        initial: "launching",
	        strict: true,
	        context: {
	            positionAtCommentId: undefined,
	            error: undefined,
	            clean: true,
	            blockRepliesTo: new Set(),
	            allowEditsOf: new Set(),
	            permissionsPrefilled: false,
	            hostPostId: -99999 ,
	            inReplyToCommentId: undefined,
	            body: "",
	            submitAction: undefined,
	            submitMethod: "POST",
	        },
	        states: {
	            launching: {
	                invoke: {
	                    src: "verifyInitialContext",
	                    onDone: [
	                        {
	                            target: "editing",
	                            cond: (context) =>
	                                context.permissionsPrefilled === true,
	                        },
	                        {
	                            target: "fetchingCommentPermissions",
	                        },
	                    ],
	                    onError: {
	                        target: "unrecoverable",
	                        actions: assign$1(
	                            (_context, result) => {
	                                return {
	                                    error: new Error(result.data),
	                                };
	                            }
	                        ),
	                    },
	                },
	            },
	            unrecoverable: {
	                type: "final",
	            },
	            fetchingCommentPermissions: {
	                invoke: {
	                    src: "fetchCommentPermissions",
	                    onDone: {
	                        target: "editing",
	                        actions: assign$1(
	                            (
	                                _context,
	                                result



	                            ) => {
	                                return {
	                                    blockRepliesTo: result.data.blockRepliesTo,
	                                    allowEditsOf: result.data.allowEditsOf,
	                                };
	                            }
	                        ),
	                    },
	                    onError: {
	                        // default context should be fine if we can't fetch
	                        // actual permissions data, with the drawback that it's
	                        // possible that replies to some comments will fail
	                        target: "editing",
	                    },
	                },
	            },
	            editing: {
	                on: {
	                    REPLY_START: {
	                        target: "editing",
	                        actions: assign$1((_context, event) => {
	                            return {
	                                positionAtCommentId: event.commentId,
	                                inReplyToCommentId: event.commentId,
	                                inReplyToPostId: event.postId,
	                                submitMethod: "POST",
	                                clean: true,
	                            };
	                        }),
	                    },
	                    EDIT_START: {
	                        target: "editing",
	                        actions: assign$1((_context, event) => {
	                            return {
	                                body: event.body,
	                                positionAtCommentId: event.commentId,
	                                submitAction: sitemap.public.apiV1
	                                    .editDeleteComment({
	                                        commentId: event.commentId,
	                                    })
	                                    .toString(),
	                                submitMethod: "PUT",
	                                clean: true,
	                            };
	                        }),
	                    },
	                    DELETE_START: {
	                        target: "confirmingDelete",
	                        actions: assign$1((_context, event) => {
	                            return {
	                                positionAtCommentId: event.commentId,
	                                submitAction: sitemap.public.apiV1
	                                    .editDeleteComment({
	                                        commentId: event.commentId,
	                                    })
	                                    .toString(),
	                                submitMethod: "DELETE",
	                            };
	                        }),
	                    },
	                    COMMENT_INPUT: {
	                        target: "editing",
	                        actions: assign$1((_context, event) => {
	                            return {
	                                body: event.body,
	                                clean: false,
	                            };
	                        }),
	                    },
	                    CANCEL: {
	                        target: "editing",
	                        actions: assign$1((_context, _event) => {
	                            return {
	                                positionAtCommentId: undefined,
	                                inReplyToCommentId: undefined,
	                                inReplyToPostId: undefined,
	                                body: "",
	                                submitAction: undefined,
	                                clean: true,
	                            };
	                        }),
	                    },
	                    SUBMIT: "submitting",
	                },
	            },
	            confirmingDelete: {
	                on: {
	                    SUBMIT: "submitting",
	                    CANCEL: {
	                        target: "editing",
	                        actions: assign$1((_context, _event) => {
	                            return {
	                                positionAtCommentId: undefined,
	                                submitAction: undefined,
	                                submitMethod: undefined,
	                            };
	                        }),
	                    },
	                },
	            },
	            submitting: {
	                invoke: {
	                    src: "submit",
	                    onDone: {
	                        target: "done",
	                    },
	                    onError: {
	                        target: "displayingError",
	                        actions: assign$1((_context, event) => {
	                            return {
	                                error: event.data ,
	                            };
	                        }),
	                    },
	                },
	            },
	            done: {
	                type: "final",
	                entry: ["reload"],
	            },
	            displayingError: {
	                on: {
	                    ACKNOWLEDGE: {
	                        target: "editing",
	                        actions: assign$1({
	                            error: (_context, _event) => undefined,
	                        }),
	                    },
	                },
	            },
	        },
	    },
	    {
	        services: {
	            verifyInitialContext: (context) => {
	                if (context.hostPostId < 0) {
	                    return Promise.reject("missing post ID");
	                }

	                return Promise.resolve();
	            },
	            fetchCommentPermissions: async (context) => {
	                const trpc = getVanillaClient();
	                const res = await trpc.comments.byPost.query({
	                    postId: context.hostPostId,
	                });

	                const blockRepliesTo = new Set();
	                const allowEditsOf = new Set();

	                for (const commentId in res.comments) {
	                    if (
	                        res.comments[commentId ].canEdit ===
	                        exports.AccessResult.Allowed
	                    ) {
	                        allowEditsOf.add(commentId );
	                    }

	                    if (
	                        res.comments[commentId ].canInteract !==
	                        exports.AccessResult.Allowed
	                    ) {
	                        blockRepliesTo.add(commentId );
	                    }
	                }

	                return { blockRepliesTo, allowEditsOf };
	            },
	            submit: async (context) => {
	                const payload = {
	                    // if we're replying to a comment, make sure we're attaching
	                    // it to the correct post ID
	                    postId: context.inReplyToCommentId
	                        ? context.inReplyToPostId
	                        : context.hostPostId,
	                    body: context.body,
	                    inReplyToCommentId: context.inReplyToCommentId,
	                };

	                // if no special submit action is set, use the default
	                // (new comment)
	                const submitAction =
	                    context.submitAction ??
	                    sitemap.public.apiV1.createComment().toString();

	                const res = await fetch(submitAction.toString(), {
	                    credentials: "include",
	                    method: context.submitMethod,
	                    headers: {
	                        "Content-Type": "application/json",
	                    },
	                    body: JSON.stringify(payload),
	                });

	                if (!res.ok) {
	                    throw new Error(res.statusText);
	                }
	            },
	        },
	        actions: {
	            reload: (_context) => {
	                if (typeof location !== "undefined") {
	                    // so this doesn't throw an exception in tests
	                    location.reload();
	                }
	            },
	        },
	    }
	);

	const CommentModuleContext = reactExports.createContext(
	    {} 
	);

	const selectIsLaunching = selectStateMatches("launching");
	const selectIsFetchingCommentPermissions = selectStateMatches(
	    "fetchingCommentPermissions"
	);
	const selectIsEditing$1 = selectStateMatches("editing");
	const selectIsConfirmingDelete = selectStateMatches("confirmingDelete");
	const selectIsSubmitting = selectStateMatches("submitting");
	const selectIsDisplayingError = selectStateMatches("displayingError");
	const selectIsClean = (state) =>
	    state.context.clean;
	const selectIsReply = (state) =>
	    state.context.inReplyToCommentId !== undefined;
	const selectIsEmpty = (state) =>
	    state.context.body.trim() === "";

	const selectPositionAtCommentId$2 = (state) =>
	    state.context.positionAtCommentId;
	const selectBody =
	    (topLevel) => (state) => {
	        // if we're a reply level composer and we exist at all, we can get the body
	        if (!topLevel) return state.context.body;

	        // we're actively in a reply, return an empty string to prevent re-renders
	        if (state.context.positionAtCommentId) return "";

	        return state.context.body;
	    };

	const selectError = (state) => state.context.error;






	const CommentComposer = ({
	    disabled,
	    topLevel,
	}) => {
	    const { t } = useTranslation();
	    const moduleContext = reactExports.useContext(CommentModuleContext);
	    const { send } = moduleContext;

	    const isLaunching = useSelector$1(moduleContext, selectIsLaunching);
	    const isFetchingCommentPermissions = useSelector$1(
	        moduleContext,
	        selectIsFetchingCommentPermissions
	    );
	    const isEditing = useSelector$1(moduleContext, selectIsEditing$1);
	    const isConfirmingDelete = useSelector$1(
	        moduleContext,
	        selectIsConfirmingDelete
	    );
	    const isSubmitting = useSelector$1(moduleContext, selectIsSubmitting);
	    const isDisplayingError = useSelector$1(
	        moduleContext,
	        selectIsDisplayingError
	    );
	    const isClean = useSelector$1(moduleContext, selectIsClean);
	    const isReply = useSelector$1(moduleContext, selectIsReply);
	    const isEmpty = useSelector$1(moduleContext, selectIsEmpty);
	    const canSubmit = reactExports.useMemo(
	        () => !(disabled || isClean || isEmpty),
	        [disabled, isClean, isEmpty]
	    );

	    const positionAtCommentId = useSelector$1(
	        moduleContext,
	        selectPositionAtCommentId$2
	    );

	    const memoizedSelectBody = reactExports.useMemo(() => {
	        return selectBody(topLevel);
	    }, [topLevel]);
	    const body = useSelector$1(moduleContext, memoizedSelectBody);

	    const error = useSelector$1(moduleContext, selectError);

	    const textAreaRef = reactExports.useRef(null);

	    const hasCohostPlus = useHasCohostPlus();

	    const onSelectEmoji = reactExports.useCallback(
	        (emoji) => {
	            if (textAreaRef.current) {
	                const [start, end] = [
	                    textAreaRef.current.selectionStart,
	                    textAreaRef.current.selectionEnd,
	                ];

	                textAreaRef.current.setRangeText(
	                    emoji.native ?? emoji.shortcodes,
	                    start,
	                    end,
	                    "end"
	                );

	                send({
	                    type: "COMMENT_INPUT",
	                    body: textAreaRef.current.value,
	                });
	            }
	        },
	        [send]
	    );

	    let messageAreaText = "";
	    let buttonBar;

	    const onKeyDown = reactExports.useCallback(
	        (ev) => {
	            if (canSubmit && (ev.metaKey || ev.ctrlKey) && ev.key === "Enter") {
	                ev.preventDefault();
	                send({ type: "SUBMIT" });
	            }
	        },
	        [canSubmit, send]
	    );

	    const onClickSubmit = reactExports.useCallback

	(() => {
	        send({ type: "SUBMIT" });
	    }, [send]);
	    const onClickCancel = reactExports.useCallback

	(() => {
	        send({ type: "CANCEL" });
	    }, [send]);

	    switch (true) {
	        case isLaunching:
	        case isFetchingCommentPermissions:
	            buttonBar = (
	                React$2.createElement(React$2.Fragment, null
	                    /* spacer div to prevent layout shifts */
	                    , React$2.createElement('div', { className: "h-9",} )
	                )
	            );

	            break;
	        case disabled:
	        case isEditing:
	            buttonBar = (
	                React$2.createElement(React$2.Fragment, null
	                    , React$2.createElement(EmojiButton, {
	                        onSelectEmoji: onSelectEmoji,
	                        disabled: disabled,
	                        hasCohostPlus: !!hasCohostPlus,}
	                    )
	                    , React$2.createElement('div', { className: "flex-grow",}, " ")
	                    , React$2.createElement('button', {
	                        className: tw`co-outline-button flex items-center justify-center rounded-lg border-2
                            px-[14px] py-[6px] text-sm font-bold`,
	                        onClick: onClickCancel,
	                        // should be able to discard an empty reply, or a clean edit,
	                        // so you can close the reply composer and go back to the
	                        // top-level
	                        disabled: 
	                            disabled ||
	                            (isClean && !isReply && !positionAtCommentId)
	                        ,}

	                        , t("client:new-comment.discard-changes", {
	                            defaultValue: "discard",
	                        })
	                    )
	                    , React$2.createElement('button', {
	                        className: tw`co-filled-button flex items-center justify-center rounded-lg
                            px-4 py-2 text-sm font-bold`,
	                        onClick: onClickSubmit,
	                        disabled: !canSubmit,}

	                        , t("client:new-comment.submit", {
	                            defaultValue: "submit",
	                        })
	                    )
	                )
	            );

	            break;
	        case isConfirmingDelete:
	            messageAreaText = t("client:delete-comment.are-you-sure", {
	                defaultValue:
	                    "⬆️ are you sure you want to delete this comment?",
	            });
	            buttonBar = (
	                React$2.createElement(React$2.Fragment, null
	                    , React$2.createElement('button', {
	                        className: `flex items-center justify-center
    rounded-lg bg-red px-4 py-2 text-sm font-bold
    hover:bg-red-600 active:bg-red-700 disabled:bg-red-200`,
	                        onClick: onClickSubmit,}

	                        , t("client:delete-comment.yes", {
	                            defaultValue: "delete",
	                        })
	                    )
	                    , React$2.createElement('button', {
	                        className: `flex items-center justify-center
                rounded-lg bg-green px-4 py-2 text-sm font-bold
                hover:bg-green-600 active:bg-green-700 disabled:bg-green-200`,
	                        onClick: onClickCancel,}

	                        , t("client:delete-comment.no", {
	                            defaultValue: "do not delete",
	                        })
	                    )
	                )
	            );
	            break;
	        case isSubmitting:
	            messageAreaText = t("client:submitting", {
	                defaultValue: "submitting...",
	            });
	            break;
	        case isDisplayingError:
	            messageAreaText = `error: ${error?.message ?? ""}`;
	            buttonBar = (
	                React$2.createElement('button', {
	                    className: `flex items-center justify-center
            rounded-lg bg-green px-4 py-2 text-sm font-bold
            hover:bg-green-600 active:bg-green-700 disabled:bg-green-200`,
	                    onClick: (e) => {
	                        e.preventDefault();
	                        send({ type: "ACKNOWLEDGE" });
	                    },}

	                    , t("common:ok", { defaultValue: "ok" })
	                )
	            );
	            break;
	    }

	    const onInput = React$2.useCallback

	(
	        ({ currentTarget }) => {
	            send({
	                type: "COMMENT_INPUT",
	                body: currentTarget.value,
	            });
	        },
	        [send]
	    );

	    return (
	        // intentionally ignoring this one; just adding a keyboard shortcut for
	        // submitting comments, which is accessible in other ways
	        // eslint-disable-next-line jsx-a11y/no-static-element-interactions
	        React$2.createElement('div', { className: "flex flex-col gap-4"  , onKeyDown: onKeyDown,}
	            /**
	             * a couple !disabled's scattered around to make sure the root
	             * level display is unaffected here
	             */
	            , !disabled && isConfirmingDelete ? null : (
	                React$2.createElement(ExpandingTextArea, {
	                    className: tw`co-composer-text-box`,
	                    name: "body",
	                    minRows: 2,
	                    placeholder: t("client:new-comment.placeholder", {
	                        defaultValue: "leave a comment...",
	                    }),
	                    onInput: onInput,
	                    disabled: disabled || !isEditing,
	                    value: disabled ? "" : body,
	                    ref: textAreaRef,}
	                )
	            )
	            , !disabled && messageAreaText ? (
	                React$2.createElement('p', { className: tw`co-ui-text text-right`,}, messageAreaText)
	            ) : null

	            , React$2.createElement('div', { className: "flex flex-row items-center justify-end gap-4"    ,}
	                , buttonBar
	            )
	        )
	    );
	};

	function MeatballMenuItem({
	    as: Component = "button",
	    ItemIcon,
	    text,
	    ...props
	}) {
	    return (
	        React$2.createElement(Component, { className: "flex flex-row gap-2 hover:underline"   , ...props,}
	            , React$2.createElement(ItemIcon, { className: "h-6",} )
	            , text
	        )
	    );
	}

	function beatsFormat(dateTime) {
	    return `${dateTime
        .setZone("UTC+1")
        .toLocaleString(DateTime_1.DATE_MED)} ${fromDateTime(dateTime, true)}`;
	}

	/**
	 * Displays a relative timestamp, updated per second until 1 minute has passed,
	 * then updates per minute.
	 *
	 * @component
	 * @example
	 * const dateISO = "2006-10-20T04:20:00-0500";
	 * const link = "https://example.com";
	 * <FriendlyTimestamp dateISO={dateISO} link={link} />
	 */
	const FriendlyTimestamp = ({
	    dateISO,
	    link,
	    ...props
	}) => {
	    const displayPrefs = useDisplayPrefs();
	    const [luxonDT, setLuxonDT] = reactExports.useState(DateTime_1.fromISO(dateISO).toUTC());
	    const [timestampText, setTimestampText] = reactExports.useState(() =>
	        displayPrefs.beatsTimestamps
	            ? beatsFormat(luxonDT)
	            : luxonDT.toLocaleString(DateTime_1.DATETIME_SHORT)
	    );
	    const timerRef = reactExports.useRef();

	    // schedule the timestamp render updates
	    reactExports.useEffect(() => {
	        function updateTimestamp() {
	            setTimestampText(
	                displayPrefs.beatsTimestamps
	                    ? beatsFormat(luxonDT)
	                    : luxonDT.toRelative({ style: "narrow" }) ?? ""
	            );
	            const timeSince = Date.now() - luxonDT.toMillis();
	            let timeout = 60 * 1000; // 1 minute

	            // update every second if we're still under a minute
	            if (timeSince < 60 * 1000) {
	                timeout = 1000;
	            }

	            timerRef.current = setTimeout(updateTimestamp, timeout);
	        }
	        updateTimestamp();
	        return () => {
	            if (timerRef.current) clearTimeout(timerRef.current);
	        };
	    }, [displayPrefs.beatsTimestamps, luxonDT]);

	    // verify we're displaying local time on the client
	    reactExports.useEffect(() => {
	        setLuxonDT((current) => current.toLocal());
	    }, []);

	    // if our props change, update the timestamp
	    reactExports.useEffect(() => {
	        setLuxonDT(DateTime_1.fromISO(dateISO));
	    }, [dateISO]);

	    return (
	        React$2.createElement('time', {
	            dateTime: luxonDT.toISO(),
	            className: 
	                props.className ??
	                "block flex-none text-xs tabular-nums text-gray-500"
	            ,
	            title: luxonDT.toLocaleString(DateTime_1.DATETIME_MED_WITH_WEEKDAY),
	            ...props,}

	            , link ? (
	                React$2.createElement('a', { href: link.toString(), className: "hover:underline",}
	                    , timestampText
	                )
	            ) : (
	                timestampText
	            )
	        )
	    );
	};

	const ProjectReference = ({
	    project,
	    inline = false,
	}) => {
	    return (
	        React$2.createElement(React$2.Fragment, null
	            , React$2.createElement(ProjectAvatar, {
	                project: project,
	                noLink: true,
	                className: `h-8 w-8 ${inline ? "" : "lg:hidden"} inline-block`,
	                hideLock: true,}
	            )

	            , project.displayName ? (
	                React$2.createElement('a', {
	                    rel: "author",
	                    href: sitemap.public.project
	                        .mainAppProfile({
	                            projectHandle: project.handle,
	                        })
	                        .toString(),
	                    className: "co-project-display-name max-w-full flex-shrink truncate font-atkinson font-bold hover:underline"      ,
	                    title: project.displayName,}

	                    , project.displayName
	                )
	            ) : null
	            , project.privacy === exports.ProjectPrivacy.Private ? (
	                React$2.createElement(ForwardRef$i, { className: "co-project-display-name inline-block h-5 w-5"   ,} )
	            ) : null

	            , React$2.createElement('a', {
	                href: sitemap.public.project
	                    .mainAppProfile({
	                        projectHandle: project.handle,
	                    })
	                    .toString(),
	                className: tw`co-project-handle font-atkinson font-normal hover:underline`,}
	, "@"
	                , project.handle
	            )
	        )
	    );
	};

	const selectIsEditing = selectStateMatches("editing");
	const selectAllowEditsOf = (state) =>
	    state.context.allowEditsOf;
	const selectBlockRepliesTo = (state) =>
	    state.context.blockRepliesTo;
	const selectPositionAtCommentId$1 = (state) =>
	    state.context.positionAtCommentId;

	const CommentMeatballMenu = ({
	    rootComment,
	}) => {
	    const commentModuleContext = reactExports.useContext(CommentModuleContext);
	    const allowEditsOf = useSelector$1(commentModuleContext, selectAllowEditsOf);

	    const reportingUIContext = reactExports.useContext(ReportingUIContext);

	    const setHiddenMutation = trpc.comments.setHidden.useMutation({
	        onSettled: () => location.reload(),
	    });

	    const { loggedIn } = useUserInfo();
	    const { isBrowser } = useSSR();

	    const commentAnchor = `comment-${rootComment.comment.commentId}`;
	    const canShare =
	        isBrowser &&
	        !!navigator.canShare && // the share API is not currently in firefox
	        navigator.canShare({ url: `#${commentAnchor}` });

	    return (
	        // explicit height is required to vertically align the
	        // meatballs with the rest of the action buttons
	        React$2.createElement(ot, { as: "div", className: "relative h-6" ,}
	            , React$2.createElement(ot.Button, { className: "co-link-button cursor-pointer text-sm font-bold hover:underline"    ,}
	                , React$2.createElement(ForwardRef$n, { className: "h-6 w-6 transition-transform ui-open:rotate-90"   ,} )
	            )

	            , React$2.createElement(ot.Items, { className: "cohost-shadow-dark absolute right-0 top-8 z-30 flex min-w-max flex-col divide-y rounded-lg bg-notWhite p-3 text-notBlack focus:!outline-none"             ,}
	                , canShare ? (
	                    React$2.createElement('div', { className: "flex flex-col gap-3 pb-1.5"   ,}
	                        , React$2.createElement(ot.Item, null
	                            , React$2.createElement(MeatballMenuItem, {
	                                ItemIcon: ForwardRef$T,
	                                text: "share",
	                                onClick: () =>
	                                    navigator.share({
	                                        url: `#${commentAnchor}`,
	                                    })
	                                ,
	                                disabled: false,}
	                            )
	                        )
	                    )
	                ) : null
	                , React$2.createElement('div', {
	                    className: `flex flex-col gap-3 ${
                        canShare ? "pt-1.5" : ""
                    }`,}

	                    , rootComment.canHide === exports.AccessResult.Allowed ? (
	                        rootComment.comment.hidden ? (
	                            React$2.createElement(ot.Item, null
	                                , React$2.createElement(MeatballMenuItem, {
	                                    disabled: false,
	                                    onClick: () => {
	                                        setHiddenMutation.mutate({
	                                            commentId:
	                                                rootComment.comment.commentId,
	                                            hidden: false,
	                                        });
	                                    },
	                                    ItemIcon: ForwardRef$N,
	                                    text: "unhide",}
	                                )
	                            )
	                        ) : (
	                            React$2.createElement(ot.Item, null
	                                , React$2.createElement(MeatballMenuItem, {
	                                    disabled: false,
	                                    onClick: () => {
	                                        setHiddenMutation.mutate({
	                                            commentId:
	                                                rootComment.comment.commentId,
	                                            hidden: true,
	                                        });
	                                    },
	                                    ItemIcon: ForwardRef$L,
	                                    text: "hide",}
	                                )
	                            )
	                        )
	                    ) : null

	                    , loggedIn ? (
	                        React$2.createElement(ot.Item, null
	                            , React$2.createElement(MeatballMenuItem, {
	                                disabled: false,
	                                onClick: () => {
	                                    reportingUIContext.send({
	                                        type: "START_REPORT",
	                                        commentId:
	                                            rootComment.comment.commentId,
	                                    });
	                                },
	                                ItemIcon: ForwardRef$R,
	                                text: "report",}
	                            )
	                        )
	                    ) : null

	                    , allowEditsOf.has(rootComment.comment.commentId) ? (
	                        React$2.createElement(ot.Item, null
	                            , React$2.createElement(MeatballMenuItem, {
	                                disabled: false,
	                                onClick: () => {
	                                    commentModuleContext.send({
	                                        type: "DELETE_START",
	                                        commentId:
	                                            rootComment.comment.commentId,
	                                    });
	                                },
	                                ItemIcon: ForwardRef$M,
	                                text: "delete",}
	                            )
	                        )
	                    ) : null
	                )
	            )
	        )
	    );
	};

	const CommentContent = (props) => {
	    const { rootComment } = props;

	    const commentModuleContext = reactExports.useContext(CommentModuleContext);
	    const isEditing = useSelector$1(commentModuleContext, selectIsEditing);
	    const allowEditsOf = useSelector$1(commentModuleContext, selectAllowEditsOf);
	    const blockRepliesTo = useSelector$1(
	        commentModuleContext,
	        selectBlockRepliesTo
	    );
	    const positionAtCommentId = useSelector$1(
	        commentModuleContext,
	        selectPositionAtCommentId$1
	    );

	    const displayPrefs = useDisplayPrefs();

	    const { loggedIn } = useUserInfo();
	    const { isBrowser } = useSSR();

	    const commentAnchor = `comment-${rootComment.comment.commentId}`;

	    const renderedComment = reactExports.useMemo(
	        () =>
	            renderMarkdownReactNoHTML(
	                rootComment.comment.body,
	                DateTime_1.fromISO(rootComment.comment.postedAtISO).toJSDate(),
	                {
	                    renderingContext: "comment",
	                    hasCohostPlus: rootComment.comment.hasCohostPlus,
	                    disableEmbeds: displayPrefs.disableEmbeds,
	                    externalLinksInNewTab: displayPrefs.externalLinksInNewTab,
	                }
	            ),
	        [
	            rootComment.comment.body,
	            rootComment.comment.postedAtISO,
	            rootComment.comment.hasCohostPlus,
	            displayPrefs.disableEmbeds,
	            displayPrefs.externalLinksInNewTab,
	        ]
	    );

	    return (
	        React$2.createElement('div', { className: "flex flex-row gap-4"  ,}
	            , rootComment.comment.deleted || !rootComment.poster ? null : (
	                React$2.createElement(ProjectAvatar, {
	                    project: rootComment.poster,
	                    className: "cohost-shadow-light dark:cohost-shadow-dark hidden h-12 w-12 lg:block"     ,}
	                )
	            )
	            , React$2.createElement('div', { className: "flex min-w-0 flex-1 flex-col justify-start gap-2"     ,}
	                /* TODO: change from flex-wrap to something visually better */
	                , React$2.createElement('div', { className: "flex flex-row flex-wrap items-center gap-2"    ,}
	                    , rootComment.comment.deleted || !rootComment.poster ? (
	                        React$2.createElement(React$2.Fragment, null
	                            , React$2.createElement('span', null, "[deleted]")
	                            , React$2.createElement(FriendlyTimestamp, {
	                                dateISO: rootComment.comment.postedAtISO,}
	                            )
	                        )
	                    ) : (
	                        React$2.createElement(React$2.Fragment, null
	                            , React$2.createElement(ProjectReference, { project: rootComment.poster,} )
	                            , React$2.createElement(FriendlyTimestamp, {
	                                dateISO: rootComment.comment.postedAtISO,
	                                link: `#${commentAnchor}`,}
	                            )
	                        )
	                    )
	                )
	                , React$2.createElement('div', { className: tw`co-prose prose overflow-hidden break-words`,}
	                    , renderedComment
	                )
	                , React$2.createElement('div', { className: "flex flex-row items-center gap-2"   ,}
	                    , !loggedIn ? (
	                        React$2.createElement('a', {
	                            className: tw`co-link-button flex cursor-pointer flex-row 
                        items-center gap-1 text-sm font-bold hover:underline`,
	                            href: sitemap.public.login().toString(),}

	                            , React$2.createElement(ForwardRef$x, { className: "h-4 w-4" ,} ), "login to reply"

	                        )
	                    ) : blockRepliesTo.has(rootComment.comment.commentId) ? (
	                        React$2.createElement('span', {
	                            className: tw`co-link-button-disabled flex cursor-not-allowed 
                                flex-row items-center gap-1 text-sm font-bold text-gray-400`,}

	                            , React$2.createElement(ForwardRef$x, { className: "h-4 w-4" ,} ), "replies locked"

	                        )
	                    ) : (
	                        React$2.createElement('button', {
	                            className: tw`co-link-button flex cursor-pointer flex-row 
                                items-center gap-1 text-sm font-bold
                                hover:underline`,
	                            onClick: (e) => {
	                                e.preventDefault();
	                                commentModuleContext.send({
	                                    type: "REPLY_START",
	                                    commentId: rootComment.comment.commentId,
	                                    postId: rootComment.comment.postId,
	                                });
	                            },}

	                            , React$2.createElement(ForwardRef$x, { className: "h-4 w-4" ,} ), "reply"

	                        )
	                    )
	                    , isBrowser &&
	                    allowEditsOf.has(rootComment.comment.commentId) ? (
	                        React$2.createElement(React$2.Fragment, null
	                            , React$2.createElement('button', {
	                                className: tw`co-link-button cursor-pointer text-sm font-bold 
                                    hover:underline`,
	                                onClick: (e) => {
	                                    e.preventDefault();
	                                    commentModuleContext.send({
	                                        type: "EDIT_START",
	                                        commentId:
	                                            rootComment.comment.commentId,
	                                        body: rootComment.comment.body,
	                                    });
	                                },}
	, "edit"

	                            )
	                        )
	                    ) : null
	                    , React$2.createElement(CommentMeatballMenu, { ...props,} )
	                )
	                , positionAtCommentId === rootComment.comment.commentId ? (
	                    React$2.createElement('div', { className: "flex w-full flex-col gap-2"   ,}
	                        , React$2.createElement('div', { className: "flex flex-row gap-2"  ,}
	                            , isEditing ? (
	                                React$2.createElement('p', { className: tw`co-ui-text text-sm font-bold`,}, "replying to @"
	                                      , rootComment.poster?.handle
	                                )
	                            ) : null
	                        )
	                        , React$2.createElement(CommentComposer, { disabled: false, topLevel: false,} )
	                    )
	                ) : null
	            )
	        )
	    );
	};

	const CommentTree = (props) => {
	    const { rootComment, nestingLevel } = props;

	    const [expandHidden, setExpandHidden] = reactExports.useState(false);

	    const commentAnchor = `comment-${rootComment.comment.commentId}`;

	    return (
	        React$2.createElement('div', { className: "flex flex-col gap-4"  ,}
	            , React$2.createElement('article', {
	                className: "relative flex flex-row gap-4"   ,
	                'data-comment-id': rootComment.comment.commentId,}

	                , React$2.createElement('div', { id: commentAnchor, className: "absolute -top-16" ,} )

	                , React$2.createElement('div', { className: "flex min-w-0 flex-1 flex-col"   ,}
	                    , rootComment.comment.hidden ? (
	                        React$2.createElement(InfoBox, {
	                            level: "post-box-info",
	                            className: "mb-4 max-w-full" ,}

	                            , expandHidden ? (
	                                React$2.createElement(React$2.Fragment, null, "The below comment was hidden by the page which made this post."

	                                       , " "
	                                    , React$2.createElement('button', {
	                                        className: tw`co-link-button underline`,
	                                        onClick: () => setExpandHidden(false),}
	, "(hide it again)"

	                                    )
	                                )
	                            ) : (
	                                React$2.createElement(React$2.Fragment, null, "A comment has been hidden by the page which made this post."

	                                      , " "
	                                    , React$2.createElement('button', {
	                                        className: tw`co-link-button underline`,
	                                        onClick: () => setExpandHidden(true),}
	, "(view it anyway)"

	                                    )
	                                )
	                            )
	                        )
	                    ) : null

	                    , expandHidden || !rootComment.comment.hidden ? (
	                        React$2.createElement(CommentContent, { ...props,} )
	                    ) : null
	                )
	            )

	            , (expandHidden || !rootComment.comment.hidden) &&
	            rootComment.comment.children.length > 0 ? (
	                React$2.createElement('div', {
	                    className: tw`co-hairline ml-0 flex flex-col gap-4 border-l pl-6 lg:ml-6 lg:pl-4`,}

	                    , rootComment.comment.children.map((child) => (
	                        React$2.createElement(reactExports.Suspense, { key: child.comment.commentId,}
	                            , React$2.createElement(CommentTree, {
	                                rootComment: child,
	                                nestingLevel: nestingLevel + 1,}
	                            )
	                        )
	                    ))
	                )
	            ) : null
	        )
	    );
	};

	function permissionsFromComments(comments)


	 {
	    let allowEditsOf = [];
	    let blockRepliesTo = [];
	    for (const comment of comments) {
	        if (comment.canEdit === exports.AccessResult.Allowed) {
	            allowEditsOf.push(comment.comment.commentId);
	        }

	        if (comment.canInteract !== exports.AccessResult.Allowed) {
	            blockRepliesTo.push(comment.comment.commentId);
	        }

	        const nested = permissionsFromComments(comment.comment.children);
	        allowEditsOf = allowEditsOf.concat(nested.allowEditsOf);
	        blockRepliesTo = blockRepliesTo.concat(nested.blockRepliesTo);
	    }

	    return {
	        allowEditsOf,
	        blockRepliesTo,
	    };
	}

	const CommentTreeForPost


	 = ({ post, rootComments }) => {
	    const dynamicTheme = useDynamicTheme();

	    const commentNodes = rootComments.map((comment) => (
	        React$2.createElement('div', {
	            key: comment.comment.commentId,
	            'data-theme': dynamicTheme.current,
	            className: "co-themed-box co-comment-box cohost-shadow-light dark:cohost-shadow-dark flex w-full min-w-0 max-w-full flex-col gap-4 rounded-lg p-3 lg:max-w-prose"            ,}

	            , React$2.createElement(reactExports.Suspense, null
	                , React$2.createElement(CommentTree, { rootComment: comment, nestingLevel: 0,} )
	            )
	        )
	    ));

	    return (
	        React$2.createElement('div', { className: "my-3 flex min-w-0 flex-col gap-2"    ,}
	            , React$2.createElement('h4', { className: "px-3 text-bgText lg:px-0"  ,}, "in reply to"
	                  , " "
	                , React$2.createElement('a', {
	                    href: `#post-${post.postId ?? -99999}`,
	                    className: "font-bold text-secondary hover:underline"  ,}
	, "@"
	                    , post.postingProject.handle, "'s post:"
	                )
	            )
	            , commentNodes
	        )
	    );
	};

	const CommentModuleWrapper = (
	    props
	) => {
	    const rootComments = Object.values(props.commentThreads).flat();
	    const permissions = permissionsFromComments(rootComments);
	    const commentModuleService = useInterpret(commentModuleMachine, {
	        context: {
	            permissionsPrefilled:
	                !!permissions.allowEditsOf || !!permissions.blockRepliesTo,
	            allowEditsOf: new Set(permissions.allowEditsOf),
	            blockRepliesTo: new Set(permissions.blockRepliesTo),
	            hostPostId:
	                props.post.transparentShareOfPostId ?? props.post.postId,
	        },
	    });

	    return (
	        React$2.createElement(ErrorBoundary, null
	            , React$2.createElement(CommentModuleContext.Provider, { value: commentModuleService,}
	                , React$2.createElement(CommentModule, { ...props,} )
	            )
	        )
	    );
	};

	const selectPositionAtCommentId = (state) =>
	    state.context.positionAtCommentId;

	const CommentModule = ({
	    post,
	    commentThreads,
	}) => {
	    const userInfo = useUserInfo();
	    const moduleContext = reactExports.useContext(CommentModuleContext);
	    const positionAtCommentId = useSelector$1(
	        moduleContext,
	        selectPositionAtCommentId
	    );
	    const dynamicTheme = useDynamicTheme();

	    let commentComposerBlockedMessage;

	    if (post.commentsLocked) {
	        commentComposerBlockedMessage = "Comments on this post are locked.";
	    } else if (!userInfo.loggedIn) {
	        commentComposerBlockedMessage = "You must log in to comment.";
	    } else if (!userInfo.activated) {
	        commentComposerBlockedMessage =
	            "Your account isn't activated to post yet.";
	    } else if (post.state !== PostState.Published) {
	        commentComposerBlockedMessage = "You can't comment on this post.";
	    }

	    return (
	        React$2.createElement(React$2.Fragment, null
	            , React$2.createElement('div', { id: "comments", className: "relative -top-16" ,} )
	            , React$2.createElement('div', {
	                'data-theme': dynamicTheme.current,
	                className: "co-themed-box co-comment-box cohost-shadow-light dark:cohost-shadow-dark w-full max-w-full rounded-lg p-3 lg:max-w-prose"        ,}

	                , commentComposerBlockedMessage ? (
	                    React$2.createElement(InfoBox, { level: "post-box-info",}
	                        , commentComposerBlockedMessage
	                    )
	                ) : (
	                    React$2.createElement(CommentComposer, {
	                        disabled: positionAtCommentId !== undefined,
	                        topLevel: true,}
	                    )
	                )
	            )
	            , post.shareTree.map((vm) =>
	                commentThreads[vm.postId]?.length ? (
	                    React$2.createElement(CommentTreeForPost, {
	                        key: vm.postId,
	                        post: vm,
	                        rootComments: commentThreads[vm.postId],}
	                    )
	                ) : null
	            )
	            , commentThreads[post.postId]?.length ? (
	                React$2.createElement(CommentTreeForPost, {
	                    key: post.postId,
	                    post: post,
	                    rootComments: commentThreads[post.postId],}
	                )
	            ) : null
	        )
	    );
	};

	const PostCombinedInfoBox

	 = ({ reasons, cws }) => {
	    const { t } = useTranslation();

	    // Adult-only doesn't use PostCombinedInfoBox, so the only cases of default
	    // text size are when it's CWs-only or muffled tags-only
	    const textSize =
	        reasons.hasAdultContent ||
	        (reasons.hasCws && reasons.muffledTagsPresent)
	            ? "text-sm"
	            : "";

	    return (
	        React$2.createElement('div', {
	            className: tw`co-info-box co-warning flex flex-grow flex-row items-center gap-3 rounded-lg 
                    border-[2px] p-3 ${textSize}`,}

	            , React$2.createElement(ForwardRef$R, { className: "h-6 w-6" ,} )

	            , React$2.createElement('div', null
	                , reasons.hasAdultContent ? (
	                    React$2.createElement(React$2.Fragment, null
	                        , React$2.createElement(Trans, { i18nKey: "client:post-preview.adult.combined-content-note",}, "This post contains"
	                              , " "
	                            , React$2.createElement('a', {
	                                href: "https://help.antisoftware.club/a/solutions/articles/62000225024",
	                                target: "_blank",
	                                rel: "noreferrer",
	                                className: "underline",}
	, "18+ content"

	                            ), "."

	                        )
	                        , React$2.createElement('br', null )
	                    )
	                ) : null
	                , reasons.hasCws ? (
	                    React$2.createElement(React$2.Fragment, null
	                        , t(
	                            "client:post-preview.cw.expanded-content-note",
	                            "CWs: "
	                        )
	                        , React$2.createElement('span', { className: "font-bold",}, cws.join(", "), ".")
	                    )
	                ) : null
	                , reasons.muffledTagsPresent ? (
	                    React$2.createElement('div', null
	                        , t(
	                            "client:post-preview.muffled.expanded-content-note",
	                            "Muffled tags: "
	                        )
	                        , React$2.createElement('span', { className: "font-bold",}
	                            , reasons.muffledTagsPresent.join(", "), "."
	                        )
	                    )
	                ) : null
	            )
	        )
	    );
	};

	mod.enum([
	    "draft",
	    "log-in-first",
	    "adult-collapsed",
	    "cw-collapsed",
	    "muffled-tags-collapsed",
	    "unpublished",
	    "deleted",
	]);
	 





	const PostInfoBox

	 = ({ boxType, children }) => {
	    const { t } = useTranslation();
	    const userInfo = useUserInfo();
	    const displayPrefs = useDisplayPrefs();

	    // boxSharedStyle excludes border, background, and text color, which are handled case-by-case
	    const boxSharedStyle = tw`box-border border-[1px] flex flex-row items-center gap-3 self-stretch rounded-lg p-3`;
	    const iconSharedStyle = tw`h-6 w-6 flex-none`;

	    switch (boxType) {
	        case "draft":
	            return (
	                React$2.createElement('div', { className: tw`co-info-box co-info ${boxSharedStyle}`,}
	                    , React$2.createElement(ForwardRef$B, { className: iconSharedStyle,} )
	                    , React$2.createElement('div', null
	                        , React$2.createElement('p', null
	                            , t("client:post-preview.draft.content-note", {
	                                defaultValue:
	                                    "This post is a draft. It's not publicly visible, but you can send people links to it.",
	                            })
	                        )
	                    )
	                )
	            );
	        case "log-in-first":
	            return (
	                React$2.createElement('div', { className: tw`co-info-box co-info ${boxSharedStyle}`,}
	                    , React$2.createElement(ForwardRef$B, { className: iconSharedStyle,} )
	                    , t(
	                        "client:post-preview.post-visible-if-logged-in",
	                        "This page's posts are visible only to users who are logged in."
	                    )
	                )
	            );
	        case "adult-collapsed":
	            return (
	                React$2.createElement('div', { className: tw`co-info-box co-18-plus ${boxSharedStyle}`,}
	                    , React$2.createElement(ForwardRef$B, { className: iconSharedStyle,} )
	                    , !userInfo.loggedIn
	                        ? t(
	                              "client:post-preview.adult.hidden-content-logged-out",
	                              "This post contains 18+ content. You can view it if you're over 18."
	                          )
	                        : displayPrefs.isAdult
	                        ? displayPrefs.explicitlyCollapseAdultContent
	                            ? t(
	                                  "client:post-preview.adult.collapsed-content-note",
	                                  "This post contains 18+ content. We're hiding it according to your content preferences."
	                              )
	                            : t(
	                                  "client:post-preview.adult.18-not-collapsed-note",
	                                  "This post contains 18+ content."
	                              )
	                        : t(
	                              "client:post-preview.adult.grow-up",
	                              "This post contains 18+ content. You can view it when you're older."
	                          )
	                )
	            );
	        case "cw-collapsed":
	            return (
	                React$2.createElement('div', { className: tw`co-info-box co-warning ${boxSharedStyle}`,}
	                    , React$2.createElement(ForwardRef$R, { className: "h-6 w-6" ,} )
	                    , React$2.createElement('div', null
	                        , t(
	                            "client:post-preview.cw.collapsed-content-note",
	                            "This post has content warnings for: "
	                        )
	                        , children
	                    )
	                )
	            );
	        case "muffled-tags-collapsed":
	            return (
	                React$2.createElement('div', { className: tw`co-info-box co-warning ${boxSharedStyle}`,}
	                    , React$2.createElement(ForwardRef$R, { className: "h-6 w-6" ,} )
	                    , React$2.createElement('div', null
	                        , t(
	                            "client:post-preview.cw.muffled-content-note",
	                            "This post has tags you muffled: "
	                        )
	                        , children
	                    )
	                )
	            );
	        case "unpublished":
	            return (
	                React$2.createElement('div', { className: tw`co-info-box co-tombstone ${boxSharedStyle}`,}
	                    , React$2.createElement(ForwardRef$Q, { className: "h-6 w-6" ,} )
	                    , React$2.createElement('div', null
	                        , t(
	                            "client:post-preview.unpublished",
	                            "Sorry!  This post has been unpublished by its original author."
	                        )
	                    )
	                )
	            );
	        case "deleted":
	            return (
	                React$2.createElement('div', { className: tw`co-info-box co-tombstone ${boxSharedStyle}`,}
	                    , React$2.createElement(ForwardRef$Q, { className: "h-6 w-6" ,} )
	                    , React$2.createElement('div', null
	                        , t(
	                            "client:post-preview.deleted",
	                            "Sorry!  This post has been deleted by its original author."
	                        )
	                    )
	                )
	            );
	        default:
	            return null;
	    }
	};

	// NOTE: This typing (based on InfoBox) doesn't actually work, for reasons that
	// seem to be related to the funky props copied from AuthnButton. Both
	// CollapserButton and AuthnButton seem to "any" type all their props for
	// unknown reasons, but we decided this is shippable for now.
	mod.enum(["default", "18-badge"]);
	 







	const BUTTON_TYPE = "button" ;

	const CollapserButton = ({
	    as: Component = BUTTON_TYPE,
	    collapserButtonStyle,
	    children,
	    ...props
	}) => {
	    let buttonClasses = classNames(
	        "flex",
	        "h-10",
	        "items-center",
	        "justify-center",
	        "self-center",
	        "rounded-lg",
	        "bg-foreground",
	        "py-2",
	        "px-3",
	        "leading-none"
	    );

	    if (collapserButtonStyle == "default") {
	        buttonClasses = classNames(
	            tw`co-filled-button tracking-wider whitespace-nowrap`,
	            buttonClasses
	        );
	    } else if (collapserButtonStyle == "18-badge") {
	        buttonClasses = classNames(
	            tw`co-info-box co-18-plus border-[1px] hover-underline`,
	            buttonClasses
	        );
	    }

	    return (
	        React$2.createElement(Component, { ...props, className: buttonClasses,}
	            , children
	        )
	    );
	};

	const usePageType = (



	) => {
	    const isProfilePage = useMatch(patterns.public.project.mainAppProfile);
	    const isSinglePostPage = useMatch(
	        patterns.public.project.singlePost.published
	    );
	    const isTagPage = useMatch(patterns.public.tags);
	    const isProjectTagPage = useMatch(patterns.public.project.tags);
	    const isBookmarkedTagPage = useMatch(patterns.public.bookmarkedTagFeed);

	    if (isProfilePage) {
	        return {
	            pageType: "profile",
	            handle: isProfilePage.params.projectHandle ,
	            tagSlug: undefined,
	        };
	    } else if (isSinglePostPage) {
	        return {
	            pageType: "singlePost",
	            handle: isSinglePostPage.params.projectHandle ,
	            tagSlug: undefined,
	        };
	    } else if (isTagPage) {
	        return {
	            pageType: "tag",
	            handle: undefined,
	            tagSlug: isTagPage.params.tagSlug,
	        };
	    } else if (isProjectTagPage) {
	        return {
	            pageType: "projectTag",
	            handle: isProjectTagPage.params.projectHandle ,
	            tagSlug: isProjectTagPage.params.tagSlug,
	        };
	    } else if (isBookmarkedTagPage) {
	        return {
	            pageType: "bookmarked",
	            handle: undefined,
	            tagSlug: undefined,
	        };
	    }

	    return { pageType: false, handle: undefined, tagSlug: undefined };
	};

	const PostTags = ({
	    tags,
	    highlightedTags,
	}) => {
	    const { t } = useTranslation();

	    const tagListRef = reactExports.useRef(null);

	    // default expanded to `false` so that the max height gets set correctly and
	    // we can actually run layout correctly.
	    const [expanded, setExpanded] = reactExports.useState(false);
	    const hasRunLayout = reactExports.useRef(false);
	    const toggleExpanded = () => setExpanded(!expanded);
	    const page = usePageType();
	    useBookmarkedTags([], page.pageType === "bookmarked").data?.tags ?? [];

	    reactExports.useEffect(() => {
	        if (!hasRunLayout.current && tagListRef.current) {
	            setExpanded(
	                tagListRef.current.scrollHeight <=
	                    tagListRef.current.clientHeight
	            );
	            hasRunLayout.current = true;
	        }
	    }, [tagListRef]);

	    // FIXME: despite our best efforts, it's possible for empty tags to sneak
	    // into the db; until we have a permanent fix, filter out any empty tags
	    // attached to this post and don't attempt to render them, which causes
	    // path-to-regex to choke
	    const filteredTags = tags.filter((tag) => tag != "");

	    return filteredTags.length ? (
	        React$2.createElement('div', { className: "w-full max-w-full p-3"  ,}
	            , React$2.createElement('div', {
	                ref: tagListRef,
	                className: tw`co-tags relative w-full overflow-y-hidden break-words leading-none ${
                    expanded ? "" : "max-h-[60px]" // line-height is 20px, gets us 3 lines
                }`,}

	                , React$2.createElement('div', null
	                    , filteredTags.map((tag) => (
	                        React$2.createElement('a', {
	                            key: tag,
	                            className: `mr-2 inline-block text-sm hover:underline ${
                                // bold bookmarked tags when we're on the feed
                                highlightedTags.includes(tag) ? "font-bold" : ""
                            } ${
                                // bold the current tag if we're on a tag page
                                page.tagSlug === tag ? "font-bold" : ""
                            }`,
	                            href: 
	                                page.handle
	                                    ? sitemap.public.project
	                                          .tags({
	                                              tagSlug: tag,
	                                              projectHandle: page.handle,
	                                          })
	                                          .toString()
	                                    : sitemap.public
	                                          .tags({ tagSlug: tag })
	                                          .toString()
	                            ,}
	, "#"
	                            , tag
	                        )
	                    ))
	                )
	                , !expanded ? (
	                    React$2.createElement('div', { className: "absolute bottom-0 right-2 flex h-5"    ,}
	                        , React$2.createElement('span', { className: "co-from-body inline-block h-full bg-gradient-to-l pl-4"    ,} )
	                        , React$2.createElement('button', {
	                            onClick: toggleExpanded,
	                            className: "co-tags co-opaque inline-block cursor-pointer text-sm font-bold hover:underline"      ,}

	                            , t("client:post-preview.expand-tags", "see all")
	                        )
	                    )
	                ) : null
	            )
	        )
	    ) : null;
	};

	const HeadlineRow = ({
	    viewModel,
	}) => (
	    React$2.createElement('div', { className: "flex w-full flex-row p-3"   ,}
	        , React$2.createElement(HeadlineElement, { viewModel: viewModel,} )
	    )
	);





	const HeadlineElement = ({
	    viewModel,
	}) => {
	    return (
	        React$2.createElement('a', {
	            key: "headline",
	            href: viewModel.singlePostPageUrl.toString(),
	            className: tw`co-prose prose flex-grow self-center break-words hover:underline`,}

	            , React$2.createElement('h3', null, viewModel.headline)
	        )
	    );
	};






























	function potentialCollapseReasons(
	    props,
	    filterableTags,
	    userInfo,
	    displayPrefs
	) {
	    const muffledTagsPresent = filterableTags.filter((tag) =>
	        displayPrefs.collapsedTags.includes(tag)
	    );

	    return {
	        isDeleted: props.viewModel.limitedVisibilityReason === "deleted",
	        isOtherAccountDraft:
	            props.viewModel.limitedVisibilityReason === "unpublished",
	        hasCws: props.viewModel.cws.length > 0,
	        hasAdultContent: props.viewModel.effectiveAdultContent,
	        muffledTagsPresent:
	            muffledTagsPresent.length > 0 ? muffledTagsPresent : null,
	        loggedOutAndNotVisible:
	            !userInfo.loggedIn &&
	            props.viewModel.postingProject.loggedOutPostVisibility === "none",
	    };
	}

	function clickthroughMode(
	    props,
	    reasons,
	    loggedIn,
	    displayPrefs
	) {
	    const ctMode = {
	        canShow: true,
	        canLogIn: false,
	        canAssertAge: false,
	        hasAdultContentAndShouldAutoexpand:
	            reasons.hasAdultContent &&
	            !displayPrefs.explicitlyCollapseAdultContent,
	        hasCwsAndAllShouldAutoexpand:
	            reasons.hasCws &&
	            // the user wants to auto-expand all CW'd posts no matter what OR
	            (displayPrefs.autoExpandAllCws ||
	                // all included CWs are set to auto-expand
	                props.viewModel.cws
	                    .map((cw) => cw.toLowerCase())
	                    .every((cw) => displayPrefs.autoexpandCWs.includes(cw))),
	    };

	    // The conditionals below look for cases where the post shouldn't just collapse
	    // but in fact can't be shown at all, set canShow to false in that case, and
	    // specify any applicable strategies by which the user can gain access to the post
	    if (reasons.hasAdultContent) {
	        if (loggedIn) {
	            if (!displayPrefs.isAdult && !props.viewModel.isEditor) {
	                // logged-in kid; blocking message
	                ctMode.canShow = false;
	                return ctMode;
	            }
	        } else {
	            // adult content, user is logged out; allow the user to log in, or to
	            // assert their age iff the poster's logged-out post visibility is public
	            ctMode.canShow = false;
	            ctMode.canLogIn = true;
	            ctMode.canAssertAge =
	                props.viewModel.postingProject.loggedOutPostVisibility ===
	                "public";
	        }
	    }
	    if (reasons.loggedOutAndNotVisible) {
	        ctMode.canShow = false;
	        ctMode.canLogIn = true;
	    }
	    if (reasons.isDeleted || reasons.isOtherAccountDraft) {
	        ctMode.canShow = false;
	    }

	    return ctMode;
	}

	const collapserBoxColumnStyle = "flex flex-col items-center m-3 gap-3";

	const ExpandedCWAndOrMuffledCollapserBody






	 = ({
	    isDraft,
	    reasons,
	    viewModel,
	    setRelevantClickthroughs,
	    children,
	    effectiveTags,
	    highlightedTags,
	}) => {
	    const { t } = useTranslation();

	    return (
	        React$2.createElement('div', null
	            , React$2.createElement('div', { className: collapserBoxColumnStyle,}
	                , isDraft ? React$2.createElement(PostInfoBox, { boxType: "draft",} ) : null
	                , React$2.createElement('div', { className: "flex flex-row items-center gap-3 self-stretch"    ,}
	                    , React$2.createElement(PostCombinedInfoBox, {
	                        reasons: reasons,
	                        cws: viewModel.cws,}
	                    )
	                    , React$2.createElement(CollapserButton, {
	                        onClick: () => setRelevantClickthroughs(false),
	                        collapserButtonStyle: "default",}

	                        , t("client:post-preview.hide-post", "hide post")
	                    )
	                )
	            )

	            , viewModel.headline ? React$2.createElement(HeadlineRow, { viewModel: viewModel,} ) : null
	            , children
	            , effectiveTags.length > 0 ? (
	                React$2.createElement(PostTags, {
	                    tags: effectiveTags,
	                    highlightedTags: highlightedTags,}
	                )
	            ) : null
	        )
	    );
	};

	const ExpandedAdultCollapserBody




	 = ({
	    isDraft,
	    viewModel,
	    children,
	    effectiveTags,
	    highlightedTags,
	    setRelevantClickthroughs,
	}) => {
	    const { t } = useTranslation();
	    return (
	        React$2.createElement('div', null
	            , React$2.createElement('div', { className: collapserBoxColumnStyle,}
	                , isDraft ? React$2.createElement(PostInfoBox, { boxType: "draft",} ) : null
	                , React$2.createElement('div', { className: "flex flex-row items-start justify-end gap-3 self-stretch p-3"      ,}
	                    , viewModel.headline ? (
	                        React$2.createElement(HeadlineElement, { viewModel: viewModel,} )
	                    ) : null
	                    , React$2.createElement(CollapserButton, {
	                        as: "a",
	                        href: "https://help.antisoftware.club/a/solutions/articles/62000225024",
	                        target: "_blank",
	                        rel: "noreferrer",
	                        collapserButtonStyle: "18-badge",}

	                        , t(
	                            "client:post-preview.adult.expanded-content-note",
	                            "18+"
	                        )
	                    )

	                    , React$2.createElement(CollapserButton, {
	                        onClick: () => setRelevantClickthroughs(false),
	                        collapserButtonStyle: "default",}

	                        , t("client:post-preview.adult.hide-post", "hide post")
	                    )
	                )
	            )

	            , children
	            , effectiveTags.length > 0 ? (
	                React$2.createElement(PostTags, {
	                    tags: effectiveTags,
	                    highlightedTags: highlightedTags,}
	                )
	            ) : null
	        )
	    );
	};

	const NoReasonToCollapseBody



	 = ({ isDraft, viewModel, children, effectiveTags, highlightedTags }) => (
	    React$2.createElement('div', null
	        , isDraft ? (
	            React$2.createElement('div', { className: collapserBoxColumnStyle,}
	                , React$2.createElement(PostInfoBox, { boxType: "draft",} )
	            )
	        ) : null
	        , viewModel.headline ? React$2.createElement(HeadlineRow, { viewModel: viewModel,} ) : null
	        , children
	        , effectiveTags.length > 0 ? (
	            React$2.createElement(PostTags, { tags: effectiveTags, highlightedTags: highlightedTags,} )
	        ) : null
	    )
	);

	const CollapsedBody







	 = ({
	    isDraft,
	    clickthroughMode,
	    reasons,
	    viewModel,
	    effectiveTags,
	    highlightedTags,
	    setRelevantClickthroughs,
	}) => {
	    const { t } = useTranslation();
	    const [loggedOutChild, setLoggedOutChild] = reactExports.useState(false);
	    const currentUrl = useHref(useLocation());

	    const loginParamStr = new URLSearchParams({
	        originalUrl: currentUrl,
	    }).toString();
	    const loginHref = `${patterns.public.login}?${loginParamStr}`;

	    let clickthroughRow = (
	        React$2.createElement('div', { className: "flex flex-row items-center gap-3"   ,}
	            , clickthroughMode.canShow ? (
	                React$2.createElement(CollapserButton, {
	                    onClick: () => setRelevantClickthroughs(true),
	                    collapserButtonStyle: "default",}

	                    , t("client:post-preview.adult.show-post", "show post")
	                )
	            ) : null

	            , clickthroughMode.canLogIn ? (
	                React$2.createElement(CollapserButton, {
	                    as: "a",
	                    href: loginHref,
	                    collapserButtonStyle: "default",}

	                    , t("client:post-preview.adult.log-in", "log in")
	                )
	            ) : null

	            , clickthroughMode.canAssertAge ? (
	                React$2.createElement(React$2.Fragment, null
	                    , React$2.createElement(CollapserButton, {
	                        onClick: () => setRelevantClickthroughs(true),
	                        collapserButtonStyle: "default",}

	                        , t("client:post-preview.adult.i-am-18", "I am 18+")
	                    )
	                    , React$2.createElement(CollapserButton, {
	                        collapserButtonStyle: "default",
	                        onClick: () => setLoggedOutChild(true),}

	                        , t(
	                            "client:post-preview.adult.i-am-not-18",
	                            "I am not 18+"
	                        )
	                    )
	                )
	            ) : null
	        )
	    );

	    let mainClickthroughInfoBox = null;

	    if (viewModel.limitedVisibilityReason !== "none") {
	        let postInfoBoxType = undefined;

	        switch (viewModel.limitedVisibilityReason) {
	            case "log-in-first":
	                postInfoBoxType = "log-in-first";
	                break;
	            case "unpublished":
	                postInfoBoxType = "unpublished";
	                break;
	            case "deleted":
	                postInfoBoxType = "deleted";
	                break;
	            case "blocked":
	                // blocked posts should 404, so this case shouldn't be
	                // accessible to begin with. we want an exhaustive switch
	                // statement here though.
	                break;
	            // catch the case where the post is invisible due to logged-in minor
	            case "adult-content":
	                postInfoBoxType = "adult-collapsed";
	                break;
	        }

	        if (postInfoBoxType !== undefined) {
	            mainClickthroughInfoBox = React$2.createElement(PostInfoBox, { boxType: postInfoBoxType,} );
	        }
	    } else if (reasons.hasAdultContent) {
	        // catch the case where the post has adult content but can still be
	        // expanded
	        mainClickthroughInfoBox = React$2.createElement(PostInfoBox, { boxType: "adult-collapsed",} );
	    }

	    if (reasons.hasAdultContent && loggedOutChild) {
	        clickthroughRow = (
	            React$2.createElement('div', { className: "flex flex-row items-center gap-3 text-cherry"    ,}
	                , t(
	                    "client:post-preview.adult.the-wise-child",
	                    "Thanks for being honest."
	                )
	            )
	        );
	    }

	    return (
	        React$2.createElement('div', null
	            , React$2.createElement('div', { className: collapserBoxColumnStyle,}
	                , isDraft ? React$2.createElement(PostInfoBox, { boxType: "draft",} ) : null
	                , mainClickthroughInfoBox
	                , reasons.hasCws ? (
	                    React$2.createElement(PostInfoBox, { boxType: "cw-collapsed",}
	                        , React$2.createElement('span', { className: "font-bold",}
	                            , viewModel.cws.join(", "), "."
	                        )
	                    )
	                ) : null
	                , reasons.muffledTagsPresent ? (
	                    React$2.createElement(PostInfoBox, { boxType: "muffled-tags-collapsed",}
	                        , React$2.createElement('span', { className: "font-bold",}
	                            , reasons.muffledTagsPresent.join(", "), "."
	                        )
	                    )
	                ) : null
	                , clickthroughRow
	            )

	            , effectiveTags.length > 0 ? (
	                React$2.createElement(PostTags, {
	                    tags: effectiveTags,
	                    highlightedTags: highlightedTags,}
	                )
	            ) : null
	        )
	    );
	};

	const PostCollapser = (props) => {
	    const userInfo = useUserInfo();
	    const { viewModel } = props;
	    const displayPrefs = useDisplayPrefs();
	    /*
	     * we set the tags we filter off of manually since posts up the share tree
	     * have an empty array for `effectiveTags` (since we don't display them).
	     *
	     * we don't just set this to `viewModel.tags` since, if the post we're
	     * displaying is a transparent share, we display that share's tags instead
	     * of the viewModel's tags. while including both arrays might be redundant,
	     * it gives us a complete picture of which tags we actually need to
	     * consider.
	     */
	    const filterableTags = new Set([...props.effectiveTags, ...viewModel.tags]);
	    const reasons = potentialCollapseReasons(
	        props,
	        Array.from(filterableTags),
	        userInfo,
	        displayPrefs
	    );
	    const ctMode = clickthroughMode(
	        props,
	        reasons,
	        userInfo.loggedIn,
	        displayPrefs
	    );

	    // To autoexpand, you must be logged in, and for every reason, that reason
	    // must either be false or able to autoexpand for this post
	    const canAutoexpand =
	        userInfo.loggedIn &&
	        ctMode.canShow &&
	        (!reasons.hasCws || ctMode.hasCwsAndAllShouldAutoexpand) &&
	        (!reasons.hasAdultContent ||
	            ctMode.hasAdultContentAndShouldAutoexpand) &&
	        !reasons.muffledTagsPresent;

	    const [cwClickedThrough, setCWClickedThrough] = reactExports.useState(
	        reasons.hasCws && canAutoexpand
	    );
	    const [adultContentClickedThrough, setAdultContentClickedThrough] =
	        reactExports.useState(reasons.hasAdultContent && canAutoexpand);
	    const [muffledTagsClickedThrough, setMuffledTagsClickedThrough] = reactExports.useState(
	        reasons.muffledTagsPresent && canAutoexpand
	    );
	    const setRelevantClickthroughs = (b) => {
	        if (reasons.hasCws) {
	            setCWClickedThrough(b);
	        }
	        if (reasons.hasAdultContent) {
	            setAdultContentClickedThrough(b);
	        }
	        if (reasons.muffledTagsPresent) {
	            setMuffledTagsClickedThrough(b);
	        }
	    };

	    const isDraft = viewModel.state === PostState.Unpublished;

	    // NOTE: This conditional is order sensitive, as the logic for combined info
	    // boxes is only contained in the top-most relevant condition:
	    //
	    //      ExpandedCWCollapserBody has CW, CW+18, CW+Muffle, CW+18+Muffle
	    //      ExpandedMuffledCollapserBody has Muffle, Muffle+18
	    //
	    // As such, you must test CW, then Muffle, then 18+

	    if (reasons.isDeleted || reasons.isOtherAccountDraft) {
	        // this post is Really invisible (deleted or unpublished)
	        return (
	            React$2.createElement(CollapsedBody, {
	                isDraft: false,
	                setRelevantClickthroughs: setRelevantClickthroughs,
	                clickthroughMode: ctMode,
	                reasons: reasons,
	                displayPrefs: displayPrefs,
	                ...props,}
	            )
	        );
	    } else if (reasons.hasCws) {
	        // there is a CW
	        if (cwClickedThrough) {
	            // there is a CW and we already expanded it
	            return (
	                React$2.createElement(ExpandedCWAndOrMuffledCollapserBody, {
	                    isDraft: isDraft,
	                    setRelevantClickthroughs: setRelevantClickthroughs,
	                    clickthroughMode: ctMode,
	                    reasons: reasons,
	                    ...props,}
	                )
	            );
	        } else {
	            // the CW remains collapsed
	            return (
	                React$2.createElement(CollapsedBody, {
	                    isDraft: isDraft,
	                    setRelevantClickthroughs: setRelevantClickthroughs,
	                    clickthroughMode: ctMode,
	                    reasons: reasons,
	                    displayPrefs: displayPrefs,
	                    ...props,}
	                )
	            );
	        }
	    } else if (reasons.muffledTagsPresent) {
	        // there is a muffled tag that we are collapsing
	        if (muffledTagsClickedThrough) {
	            // the muffled tag has already been click through
	            return (
	                React$2.createElement(ExpandedCWAndOrMuffledCollapserBody, {
	                    isDraft: isDraft,
	                    setRelevantClickthroughs: setRelevantClickthroughs,
	                    clickthroughMode: ctMode,
	                    reasons: reasons,
	                    ...props,}
	                )
	            );
	        } else {
	            // the muffled content remains hidden
	            return (
	                React$2.createElement(CollapsedBody, {
	                    isDraft: isDraft,
	                    setRelevantClickthroughs: setRelevantClickthroughs,
	                    clickthroughMode: ctMode,
	                    reasons: reasons,
	                    displayPrefs: displayPrefs,
	                    ...props,}
	                )
	            );
	        }
	    } else if (reasons.hasAdultContent) {
	        // there is adult content that we are collapsing
	        if (adultContentClickedThrough) {
	            // the adult content has been clicked through
	            return (
	                React$2.createElement(ExpandedAdultCollapserBody, {
	                    isDraft: isDraft,
	                    setRelevantClickthroughs: setRelevantClickthroughs,
	                    ...props,}
	                )
	            );
	        } else {
	            // the adult content remains hidden
	            return (
	                React$2.createElement(CollapsedBody, {
	                    isDraft: isDraft,
	                    setRelevantClickthroughs: setRelevantClickthroughs,
	                    clickthroughMode: ctMode,
	                    reasons: reasons,
	                    displayPrefs: displayPrefs,
	                    ...props,}
	                )
	            );
	        }
	    } else {
	        if (reasons.loggedOutAndNotVisible) {
	            // user isn't logged in, and the post shouldn't be visible to them
	            return (
	                React$2.createElement(CollapsedBody, {
	                    isDraft: isDraft,
	                    setRelevantClickthroughs: setRelevantClickthroughs,
	                    clickthroughMode: ctMode,
	                    reasons: reasons,
	                    displayPrefs: displayPrefs,
	                    ...props,}
	                )
	            );
	        } else {
	            // no CWs, no adult content, public post, let's go
	            return React$2.createElement(NoReasonToCollapseBody, { isDraft: isDraft, ...props,} );
	        }
	    }
	};

	const PostContent = ({
	    viewModel,
	    highlightedTags,
	    skipCollapse = false,
	}) => {
	    return (
	        React$2.createElement('div', null
	            , React$2.createElement(PostCollapser, {
	                viewModel: viewModel,
	                effectiveTags: viewModel.tags,
	                highlightedTags: highlightedTags,}

	                , React$2.createElement(PostBody, {
	                    viewModel: viewModel,
	                    skipCollapse: skipCollapse,
	                    effectiveDate: viewModel.publishedAt,}
	                )
	            )
	        )
	    );
	};

	// https://stackoverflow.com/a/47593316
	function mulberry32(a) {
	    return function () {
	        let t = (a += 0x6d2b79f5);
	        t = Math.imul(t ^ (t >>> 15), t | 1);
	        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
	        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
	    };
	}

	function clamp(x, min, max) {
	    return Math.min(Math.max(x, min), max);
	}

	function lerp(a, b, t) {
	    return a + (b - a) * clamp(t, 0, 1);
	}

	// this will run for 51 hours (midnight EDT on April 1 to 11:59pm PDT on April 2)
	const MAX_SECONDS = (48 + 3) * 60 * 60;

	const APRIL_1 = DateTime_1.now().toUTC().set({ month: 4, day: 1 }).startOf("day");

	const FRACTION_THRESHOLD = 0.02;
	const EXPONENT_THRESHOLD = 0.5;

	const MAX_DECIMAL_PLACES = 5;
	const MAX_EXPONENT = 1.42;

	// Since chaos day features go live at midnight EDT and the clock is tied to
	// midnight UTC, we will already have 4 hours (14400 seconds) on the clock,
	// which gives us a fixed maximum Number of 14,400, which seems healthy. The
	// feature shuts off at 7am UTC on april 3, so the max Number count will be
	// around 200k
	function secondsFromDate(date) {
	    return Math.abs(date.diffNow().as("seconds"));
	}

	function currentOdds() {
	    // we don't use the effective date here since we want the negative odds to
	    // be consistent through the weekend
	    const seconds = secondsFromDate(APRIL_1);
	    const odds = lerp(0.05, 0.6, seconds / MAX_SECONDS);
	    return odds;
	}

	const Numbers

	 = ({ post }) => {
	    const postId = post.transparentShareOfPostId ?? post.postId;
	    const publishDate = reactExports.useMemo(() => {
	        if (post.transparentShareOfPostId) {
	            return (
	                post.shareTree.find(
	                    (vm) => vm.postId === post.transparentShareOfPostId
	                )?.publishedAt ?? post.publishedAt
	            );
	        }

	        return post.publishedAt;
	    }, [post.publishedAt, post.shareTree, post.transparentShareOfPostId]);

	    // use the publish date if it's after april 1 so that numbers don't get as big for posts made
	    // while the feature is live.
	    const effectiveDate = reactExports.useMemo(() => {
	        if (!publishDate) {
	            return APRIL_1;
	        }

	        const publishDateTime = DateTime_1.fromISO(publishDate);
	        return publishDateTime > APRIL_1 ? publishDateTime : APRIL_1;
	    }, [publishDate]);

	    const randFunc = reactExports.useMemo(() => mulberry32(postId), [postId]);
	    const [numberRoll, negativeRoll, fractionRoll, exponentRoll] = reactExports.useMemo

	(() => {
	        return [randFunc(), randFunc(), randFunc(), randFunc()];
	    }, [randFunc]);

	    const [displaySeconds, setDisplaySeconds] = reactExports.useState(
	        secondsFromDate(effectiveDate)
	    );

	    const onClick = reactExports.useCallback(() => {
	        setDisplaySeconds(secondsFromDate(effectiveDate));
	    }, [effectiveDate]);

	    const displayNumber = reactExports.useMemo(() => {
	        let displayNumber = numberRoll * displaySeconds;
	        let decimalPlaces = 0;

	        // fractional Numbers?
	        if (fractionRoll <= FRACTION_THRESHOLD) {
	            const normalizedFraction = fractionRoll / FRACTION_THRESHOLD;
	            // add 1 to the max since we're flooring; makes the effective max
	            // where we want it.
	            decimalPlaces = Math.floor(
	                lerp(1, MAX_DECIMAL_PLACES + 1, normalizedFraction)
	            );
	        }

	        // exponential Numbers growth?
	        if (exponentRoll <= EXPONENT_THRESHOLD) {
	            const normalizedExponent = exponentRoll / EXPONENT_THRESHOLD;
	            const exponent = lerp(1, MAX_EXPONENT, normalizedExponent);
	            displayNumber = Math.pow(displayNumber, exponent);
	        }

	        if (negativeRoll <= currentOdds()) {
	            displayNumber *= -1;
	        }

	        return displayNumber.toLocaleString(undefined, {
	            maximumFractionDigits: decimalPlaces,
	        });
	    }, [displaySeconds, exponentRoll, fractionRoll, negativeRoll, numberRoll]);

	    return (
	        React$2.createElement('button', { onClick: onClick, type: "button",}
	            , displayNumber, " Numbers™"
	        )
	    );
	};

	/**
	 * @deprecated should no longer be used for new development, preferring
	 * SimpleNativeModalDialog
	 */
	const SimpleModalDialog = (
	    props
	) => (
	    React$2.createElement(St$1, { open: props.isOpen, onClose: props.onCancel,}
	        , React$2.createElement(ModalOverlay, null )
	        , React$2.createElement('div', { className: "fixed inset-0 z-10 overflow-y-auto"   ,}
	            , React$2.createElement('div', { className: "flex min-h-full items-center justify-center py-20"    ,}
	                , React$2.createElement(St$1.Panel, {
	                    as: "div",
	                    className: "cohost-shadow-light dark:cohost-shadow-dark relative mx-auto max-w-sm rounded-lg bg-notWhite p-3 text-notBlack"        ,}

	                    , props.title ? (
	                        React$2.createElement(St$1.Title, { className: "text-[1.25rem] font-bold leading-6"  ,}
	                            , props.title
	                        )
	                    ) : null

	                    , React$2.createElement('div', { className: "mt-2",}
	                        , React$2.createElement('p', { className: "text-sm",}, props.body)
	                    )

	                    , props.children && props.children

	                    , React$2.createElement('div', { className: "mt-4 flex flex-row justify-end gap-2"    ,}
	                        , props.cancel ? (
	                            React$2.createElement(BasicButton, {
	                                buttonSize: "regular",
	                                buttonColor: props.cancel.color ?? "stroke",
	                                onClick: props.onCancel,}

	                                , props.cancel.label
	                            )
	                        ) : null
	                        , React$2.createElement(BasicButton, {
	                            buttonSize: "regular",
	                            buttonColor: props.confirm.color ?? "cherry",
	                            onClick: props.onConfirm,}

	                            , props.confirm.label
	                        )
	                    )
	                )
	            )
	        )
	    )
	);

	const SimpleNativeModalDialog

	 = (props) => {
	    const [dialogRef, setDialogRef] = reactExports.useState(null);

	    reactExports.useEffect(() => {
	        if (props.isOpen && dialogRef?.open !== true) {
	            dialogRef?.showModal();
	        } else if (!props.isOpen && dialogRef?.open === true) {
	            dialogRef?.close();
	        }
	    }, [dialogRef, props.isOpen]);

	    return (
	        React$2.createElement('dialog', {
	            ref: setDialogRef,
	            className: "cohost-shadow-light dark:cohost-shadow-dark max-w-sm rounded-lg bg-notWhite p-3 text-notBlack backdrop:bg-notBlack/90"       ,
	            //@ts-expect-error it's real, don't believe their lies
	            onCancel: (e) => {
	                e.preventDefault();
	                props.onCancel();
	            },}

	            , props.title ? (
	                React$2.createElement('h2', { className: "text-[1.25rem] font-bold leading-6"  ,}
	                    , props.title
	                )
	            ) : null
	            , React$2.createElement('div', { className: "mt-2",}
	                , React$2.createElement('p', { className: "text-sm",}, props.body)
	            )

	            , props.children && props.children

	            , React$2.createElement('div', { className: "mt-4 flex flex-row justify-end gap-2"    ,}
	                , props.cancel ? (
	                    React$2.createElement(BasicButton, {
	                        buttonSize: "regular",
	                        buttonColor: props.cancel.color ?? "stroke",
	                        onClick: props.onCancel,}

	                        , props.cancel.label
	                    )
	                ) : null
	                , React$2.createElement(BasicButton, {
	                    buttonSize: "regular",
	                    buttonColor: props.confirm.color ?? "cherry",
	                    onClick: props.onConfirm,}

	                    , props.confirm.label
	                )
	            )
	        )
	    );
	};

	// HACK: this is probably complex enough that we should be using a state machine
	// for it, but colin didn't want to completely rewrite it under time pressure to
	// fix a bug
	const DeletePostButton = ({
	    projectHandle,
	    postId,
	    ...props
	}) => {
	    const [isConfirmOpen, setIsConfirmOpen] = reactExports.useState(false);
	    const [isFinishedOpen, setIsFinishedOpen] = reactExports.useState(false);
	    const [error, setError] = reactExports.useState("");
	    const mutation = trpc.posts.delete.useMutation();

	    async function deletePost() {
	        try {
	            await mutation.mutateAsync({
	                projectHandle,
	                postId,
	            });

	            setError("");
	            setIsFinishedOpen(true);
	        } catch (e) {
	            setError((e ).message);
	        } finally {
	            setIsConfirmOpen(false);
	        }
	    }

	    const { t } = useTranslation();

	    return (
	        React$2.createElement(React$2.Fragment, null
	            , React$2.createElement(SimpleModalDialog, {
	                isOpen: isConfirmOpen,
	                title: t(
	                    "client:delete-post.confirm-title",
	                    "Delete this post"
	                ),
	                body: t(
	                    "client:delete-post.confirm-message",
	                    "Are you sure you want to delete this post? This cannot be undone."
	                ),
	                confirm: {
	                    label: t("common:delete"),
	                    color: "destructive",
	                },
	                cancel: {
	                    label: t("common:cancel"),
	                },
	                onConfirm: deletePost,
	                onCancel: () => setIsConfirmOpen(false),}
	            )
	            , React$2.createElement(SimpleModalDialog, {
	                isOpen: isFinishedOpen,
	                title: t(
	                    "client:delete-post.finished-title",
	                    "Post deleted successfully"
	                ),
	                body: t(
	                    "client:delete-post.finished-message",
	                    "(You may need to manually reload for it to disappear from your screen.)"
	                ),
	                cancel: {
	                    label: t("common:close", "close"),
	                },
	                confirm: {
	                    label: t("common:reload", "reload"),
	                },
	                onConfirm: () => location.reload(),
	                onCancel: () => setIsFinishedOpen(false),}
	            )
	            , React$2.createElement(SimpleModalDialog, {
	                isOpen: error !== "",
	                body: t("client:delete-post.error-message", {
	                    defaultValue: "Error deleting post: {{error}}",
	                    error,
	                }),
	                cancel: {
	                    label: t("common:cancel", "cancel"),
	                },
	                confirm: {
	                    label: t("common:retry", "retry"),
	                },
	                onConfirm: deletePost,
	                onCancel: () => setError(""),}
	            )
	            , React$2.createElement('button', {
	                onClick: () => {
	                    setIsConfirmOpen(true);
	                },
	                ...props,}

	                , React$2.createElement(ForwardRef$M, { className: tw`co-action-button h-6 w-6`,} )
	            )
	        )
	    );
	};

	const LikePostButton = ({
	    post,
	    baseClasses,
	    unlikedClasses,
	    likedClasses,
	}) => {
	    const utils = trpc.useContext();
	    const { data: isLiked } = trpc.posts.isLiked.useQuery(
	        post.transparentShareOfPostId ?? post.postId,
	        { initialData: post.isLiked }
	    );

	    const userInfo = useUserInfo();
	    const currentProject = useCurrentProject();
	    const { t } = useTranslation();

	    const title = isLiked
	        ? t(
	              "server:post-controls.unlike",
	              "unlike this post as {{ activeProjectHandle }}",
	              { activeProjectHandle: currentProject?.handle }
	          )
	        : t(
	              "server:post-controls.like",
	              "like this post as {{ activeProjectHandle }}",
	              { activeProjectHandle: currentProject?.handle }
	          );

	    const createMutationArgs = () => {
	        return {
	            onError: async () => {
	                await utils.posts.isLiked.invalidate(
	                    post.transparentShareOfPostId ?? post.postId
	                );
	            },
	        };
	    };
	    const likeMutation = trpc.relationships.like.useMutation(
	        createMutationArgs()
	    );
	    const unlikeMutation = trpc.relationships.unlike.useMutation(
	        createMutationArgs()
	    );
	    const likePost = reactExports.useCallback(async () => {
	        if (!userInfo.loggedIn) {
	            return;
	        }
	        // assume it will work, revert if it doesn't
	        utils.posts.isLiked.setData(
	            post.transparentShareOfPostId ?? post.postId,
	            (oldIsLiked) => !oldIsLiked
	        );
	        if (isLiked) {
	            await unlikeMutation.mutateAsync({
	                fromProjectId: userInfo.projectId,
	                toPostId: post.transparentShareOfPostId ?? post.postId,
	            });
	        } else {
	            await likeMutation.mutateAsync({
	                fromProjectId: userInfo.projectId,
	                toPostId: post.transparentShareOfPostId ?? post.postId,
	            });
	        }
	    }, [
	        userInfo.loggedIn,
	        userInfo.projectId,
	        utils.posts.isLiked,
	        post.transparentShareOfPostId,
	        post.postId,
	        isLiked,
	        likeMutation,
	        unlikeMutation,
	    ]);

	    if (!userInfo.loggedIn) {
	        return null;
	    }

	    return (
	        React$2.createElement('button', {
	            onClick: likePost,
	            className: `${baseClasses} relative`,
	            title: title,}

	            , React$2.createElement(ForwardRef$m, {
	                className: `${baseClasses} absolute top-0 left-0 ${likedClasses} ${
                    isLiked ? "visible" : "invisible"
                }`,}
	            )
	            , React$2.createElement(ForwardRef$F, {
	                className: `${baseClasses} absolute top-0 left-0 ${unlikedClasses} ${
                    !isLiked ? "visible" : "invisible"
                }`,}
	            )
	        )
	    );
	};

	const PublishPostButton = ({
	    post,
	    className,
	    ...props
	}) => {
	    const changePostState = trpc.posts.changePostState.useMutation();
	    const publishPost = reactExports.useCallback(async () => {
	        try {
	            await changePostState.mutateAsync({
	                projectHandle: post.postingProject.handle,
	                postId: post.postId,
	                operation: "publish",
	            });

	            location.assign(sitemap.public.home());
	        } catch (e) {
	            console.error(e);
	        }
	    }, [changePostState, post.postId, post.postingProject.handle]);
	    const [isConfirmOpen, setIsConfirmOpen] = reactExports.useState(false);

	    return (
	        React$2.createElement(React$2.Fragment, null
	            , React$2.createElement(SimpleModalDialog, {
	                isOpen: isConfirmOpen,
	                title: t$5(
	                    "client:publish-post.confirm-title",
	                    "Publish this draft?"
	                ),
	                body: t$5(
	                    "client:publish-post.confirm-body",
	                    "Are you sure you want to publish this draft?  It will become visible to others."
	                ),
	                confirm: {
	                    label: t$5("common:publish", "publish"),
	                },
	                cancel: {
	                    label: t$5("common:cancel", "cancel"),
	                },
	                onConfirm: publishPost,
	                onCancel: () => setIsConfirmOpen(false),}
	            )
	            , React$2.createElement('button', {
	                onClick: () => setIsConfirmOpen(true),
	                className: `${className ?? ""} relative`,
	                ...props,}

	                , React$2.createElement(ForwardRef$1d, { className: "absolute left-0 top-0"  ,} )
	            )
	        )
	    );
	};

	const SharePostButton

	 = ({ post }) => {
	    const currentProject = useCurrentProject();
	    const { t } = useTranslation();
	    const quickSharePost = trpc.posts.quickShare.useMutation();
	    const utils = trpc.useContext();
	    const displayPrefs = useDisplayPrefs();
	    const { activated } = useUserInfo();

	    const modalPostComposer = useModalPostComposer();

	    const onClick = reactExports.useCallback(
	        (e) => {
	            if (!e.shiftKey) {
	                if (displayPrefs.disableModalPostComposer) {
	                    // user wants this to be a link
	                    return;
	                }
	                if (!activated) {
	                    // FIXME: the modal post composer doesn't support unactivated
	                    // users, and just doesn't show up if you're unactivated.  for
	                    // now, just redirect them to the post composer on its own page.
	                    return;
	                }
	                if (e.ctrlKey || e.metaKey || e.button === 3) {
	                    // ctrl/cmd/middle click: user wants this to open in a new
	                    // tab, treat it as a link.
	                    return;
	                }
	                console.log(modalPostComposer.hasBeenSetup, "hasBeenSetup");
	                if (modalPostComposer.hasBeenSetup) {
	                    // shift key not held down, check if we can pop a modal and
	                    // if so Do It.
	                    e.preventDefault();
	                    // preload data so the modal can open instantly
	                    utils.posts.singlePost.setData(
	                        {
	                            postId: post.postId,
	                            handle: post.postingProject.handle,
	                            skipComments: true,
	                        },
	                        {
	                            comments: {},
	                            post,
	                        }
	                    );
	                    modalPostComposer.activate({
	                        shareOf: {
	                            postId: post.postId,
	                            handle: post.postingProject.handle,
	                        },
	                    });
	                }
	                // can't pop a modal, just let the link do its thing.
	                return;
	            }

	            e.preventDefault();

	            quickSharePost
	                .mutateAsync({ shareOfPostId: post.postId })
	                .then((resp) => console.log("done!", resp.newPostId))
	                .catch((err) => console.error(err));
	        },
	        [
	            displayPrefs.disableModalPostComposer,
	            modalPostComposer,
	            post,
	            quickSharePost,
	            utils.posts.singlePost,
	        ]
	    );

	    if (!currentProject?.handle) {
	        return null;
	    }

	    return (
	        React$2.createElement('a', {
	            onClick: onClick,
	            href: sitemap.public.project
	                .composePost({
	                    projectHandle: currentProject.handle,
	                    shareOfPostId: post.postId,
	                })
	                .toString(),
	            title: t(
	                "server:post-controls.share",
	                "share this post as {{ activeProjectHandle }}",
	                { activeProjectHandle: currentProject.handle }
	            ),}

	            , React$2.createElement(ForwardRef$1h, {
	                className: `h-6 w-6 ${
                    quickSharePost.isSuccess
                        ? "text-green"
                        : quickSharePost.isError
                        ? "text-red"
                        : tw`co-action-button`
                } ${
                    quickSharePost.isLoading
                        ? "motion-safe:animate-spin motion-reduce:animate-pulse"
                        : ""
                }`,}
	            )
	        )
	    );
	};

	const PostControls = ({
	    viewModel,
	}) => {
	    const userInfo = useUserInfo();
	    const { t } = useTranslation();

	    if (userInfo.loggedIn) {
	        const deleteButtonText = t(
	            "client:post-controls.delete",
	            "delete this post"
	        );
	        const publishButtonText = t(
	            "client:post-controls.publish",
	            "publish this post"
	        );
	        const editButtonText = t("client:post-controls.edit", "edit this post");

	        const published = viewModel.state === PostState.Published;

	        return (
	            React$2.createElement('div', { className: "flex items-center justify-end gap-3"   ,}
	                , viewModel.isEditor ? (
	                    React$2.createElement(DeletePostButton, {
	                        postId: viewModel.postId,
	                        projectHandle: viewModel.postingProject.handle,
	                        title: deleteButtonText,}
	                    )
	                ) : null

	                , viewModel.isEditor && !published ? (
	                    React$2.createElement(PublishPostButton, {
	                        post: viewModel,
	                        className: tw`co-action-button h-6 w-6 disabled:cursor-not-allowed`,
	                        disabled: !viewModel.canPublish,
	                        title: publishButtonText,}
	                    )
	                ) : null

	                , viewModel.isEditor ? (
	                    React$2.createElement('a', {
	                        href: viewModel.postEditUrl.toString(),
	                        className: tw`co-action-button h-6 w-6`,
	                        title: editButtonText,}

	                        , React$2.createElement(ForwardRef$$, null )
	                    )
	                ) : null

	                , published ? (
	                    React$2.createElement(React$2.Fragment, null
	                        /* <ChatOutlineIcon className="w-6 h-6 text-notBlack" /> */
	                        , viewModel.canShare === true ? (
	                            React$2.createElement(SharePostButton, { post: viewModel,} )
	                        ) : null
	                        , React$2.createElement(LikePostButton, {
	                            post: viewModel,
	                            baseClasses: "w-6 h-6 pointer"  ,
	                            likedClasses: "text-cherry",
	                            unlikedClasses: tw`co-action-button`,}
	                        )
	                    )
	                ) : null
	            )
	        );
	    } else {
	        return (
	            React$2.createElement('div', { className: "flex justify-end gap-3"  ,}
	                , React$2.createElement('a', {
	                    href: sitemap.public.login().toString(),
	                    className: tw`co-action-button h-6 w-6`,}

	                    , React$2.createElement(ForwardRef$1f, null )
	                )
	            )
	        );
	    }
	};

	const PostFooter


	 = ({ singlePostPageUrl, post }) => {
	    const { t } = useTranslation();
	    const numbersFlag = index_browserExports.useFlag(FeatureFlag.Values["chaos-day-2023"]);
	    const { chaosDay2023_showNumbers } = useDisplayPrefs();
	    const singlePostPageUrlWithComments = reactExports.useMemo(() => {
	        const url = new URL(singlePostPageUrl);
	        url.hash = "#comments";
	        return url.toString();
	    }, [singlePostPageUrl]);

	    return (
	        React$2.createElement(React$2.Fragment, null
	            , React$2.createElement('hr', { className: "co-hairline",} )
	            , React$2.createElement('footer', {
	                className: tw`co-thread-footer w-full max-w-full rounded-b-lg p-3`,}

	                , React$2.createElement('div', { className: "flex justify-between align-middle"  ,}
	                    , React$2.createElement('div', { className: "w-max flex-none" ,}
	                        , React$2.createElement('a', {
	                            href: singlePostPageUrlWithComments,
	                            className: "text-sm hover:underline" ,}

	                            , t("client:post-preview.num-comments", {
	                                count: post.numComments,
	                                defaultValue: "{{numComments}} comment",
	                                numComments: post.numComments,
	                            })
	                            , post.numSharedComments
	                                ? t("client:post-preview.num-shared-comments", {
	                                      defaultValue:
	                                          " + {{numSharedComments}} on shared posts",
	                                      numSharedComments: post.numSharedComments,
	                                  })
	                                : null
	                        )
	                        , numbersFlag && chaosDay2023_showNumbers ? (
	                            /*
	                                i know it's a meme number but in testing 420px
	                                was actually the first safe option with the
	                                longest possible post controls to prevent
	                                overlap.
	                            */
	                            React$2.createElement('span', { className: "text-sm",}
	                                , React$2.createElement('br', { className: "[@media(min-width:420px)]:hidden",} )
	                                , React$2.createElement('span', { className: "[@media(max-width:419px)]:hidden",}, " • "

	                                )
	                                , React$2.createElement(Numbers, { post: post,} )
	                            )
	                        ) : null
	                    )
	                    , React$2.createElement(PostControls, { viewModel: post,} )
	                )
	            )
	        )
	    );
	};

	const SilencePostMenuItem = ({
	    postId,
	}) => {
	    const { loggedIn } = useUserInfo();
	    const utils = trpc.useContext();

	    const { mutate: silencePostMutation } =
	        trpc.relationships.silencePost.useMutation({
	            async onSettled(data, error, variables) {
	                await utils.relationships.isPostSilenced.invalidate({
	                    postId: variables.toPostId,
	                });
	            },
	        });

	    const { mutate: unsilencePostMutation } =
	        trpc.relationships.unsilencePost.useMutation({
	            async onSettled(data, error, variables) {
	                await utils.relationships.isPostSilenced.invalidate({
	                    postId: variables.toPostId,
	                });
	            },
	        });

	    const { data: isSilenced } = trpc.relationships.isPostSilenced.useQuery(
	        {
	            postId,
	        },
	        { enabled: loggedIn }
	    );

	    if (!loggedIn) return null;

	    if (isSilenced) {
	        return (
	            React$2.createElement('button', {
	                className: "flex flex-row gap-2 hover:underline"   ,
	                onClick: () =>
	                    unsilencePostMutation({
	                        toPostId: postId,
	                    })
	                ,}

	                , React$2.createElement(SilenceIcon, { className: "h-6",} ), "unsilence this post"

	            )
	        );
	    } else {
	        return (
	            React$2.createElement('button', {
	                className: "flex flex-row gap-2 hover:underline"   ,
	                onClick: () =>
	                    silencePostMutation({
	                        toPostId: postId,
	                    })
	                ,}

	                , React$2.createElement(SilenceIcon, { className: "h-6",} ), "silence this post"

	            )
	        );
	    }
	};

	const SharedFromHeader = ({
	    viewModel,
	}) => {
	    if (!viewModel.shareTree.length) return null;

	    const { postingProject } =
	        viewModel.shareTree[viewModel.shareTree.length - 1];
	    return (
	        React$2.createElement(React$2.Fragment, null
	            , React$2.createElement(ForwardRef$z, { className: "co-project-display-name h-5 w-5"  ,} )
	            , React$2.createElement(ProjectReference, { project: postingProject,} )
	        )
	    );
	};

	const AskResponsePopover = () => {
	    const { refs, floatingStyles } = useFloating();
	    return (
	        React$2.createElement(Lt, { className: "leading-none",}
	            , React$2.createElement(Lt.Button, { ref: refs.setReference,}
	                , React$2.createElement(ForwardRef$19, {
	                    className: tw`co-action-button h-6 w-6`,}
	                )
	            )
	            , React$2.createElement(Lt.Panel, {
	                ref: refs.setFloating,
	                style: floatingStyles,
	                className: "cohost-shadow-light prose z-20 w-max max-w-full rounded-lg bg-notWhite p-3 text-center text-sm font-normal text-notBlack"           ,}

	                , React$2.createElement('p', null, "This post is a response to an ask."       )
	            )
	        )
	    );
	};

	const PostContentHeader = ({
	    viewModel,
	}) => {
	    return (
	        /* TODO: change from flex-wrap to something visually better */
	        React$2.createElement('div', { className: "co-post-header flex flex-row flex-wrap items-center gap-2 px-3 py-2"       ,}
	            , React$2.createElement(ProjectReference, {
	                project: viewModel.postingProject,
	                inline: true,}
	            )

	            , viewModel.publishedAt ? (
	                React$2.createElement(FriendlyTimestamp, {
	                    dateISO: new Date(viewModel.publishedAt).toISOString(),
	                    link: viewModel.singlePostPageUrl,}
	                )
	            ) : null

	            , viewModel.responseToAskId && React$2.createElement(AskResponsePopover, null )
	        )
	    );
	};

	const PostMeatballMenu


	 = ({ viewModel, dynamicTheme }) => {
	    const { isBrowser } = useSSR();
	    const reportingService = reactExports.useContext(ReportingUIContext);
	    const userInfo = useUserInfo();
	    const { mutate: setPostPinned } = trpc.posts.setPostPinned.useMutation({
	        onSuccess: () => location.reload(),
	    });
	    const { mutate: setPostCommentsLocked } =
	        trpc.posts.setCommentsLocked.useMutation({
	            onSuccess: () => location.reload(),
	        });
	    const { mutate: setPostSharesLocked } =
	        trpc.posts.setSharesLocked.useMutation({
	            onSuccess: () => location.reload(),
	        });

	    const { floatingStyles, refs } = useFloating({
	        placement: "bottom-end",
	        whileElementsMounted: V$3,
	        middleware: [L$4(8)],
	    });

	    const prefersDark = usePrefersDark();
	    let invertToTheme;

	    switch (dynamicTheme.current) {
	        case "dark":
	            invertToTheme = "light";
	            break;
	        case "light":
	            invertToTheme = "dark";
	            break;
	        case "both":
	            invertToTheme = prefersDark ? "light" : "dark";
	            break;
	    }

	    let shareSheetMenuItem = null;
	    if (
	        isBrowser &&
	        !!navigator.canShare && // the share API is not currently in firefox
	        navigator.canShare({ url: viewModel.singlePostPageUrl })
	    ) {
	        shareSheetMenuItem = (
	            React$2.createElement(MeatballMenuItem, {
	                ItemIcon: ForwardRef$T,
	                text: "share post" ,
	                onClick: () =>
	                    navigator.share({ url: viewModel.singlePostPageUrl })
	                ,
	                disabled: false,}
	            )
	        );
	    }

	    // a post is pinnable if it was posted by the viewing project, it's
	    // published, and it isn't a transparent share
	    const canPin =
	        userInfo.projectId === viewModel.postingProject.projectId &&
	        viewModel.state === PostState.Published &&
	        !viewModel.transparentShareOfPostId;
	    let changePinnedMenuItem = null;

	    if (canPin && viewModel.pinned) {
	        // unpin item
	        changePinnedMenuItem = (
	            React$2.createElement('button', {
	                className: "flex flex-row gap-2 hover:underline"   ,
	                onClick: () =>
	                    setPostPinned({ postId: viewModel.postId, pinned: false })
	                ,}

	                , React$2.createElement(PushpinIcon, { className: "h-6",} ), "unpin this post"

	            )
	        );
	    } else if (canPin) {
	        // pin item
	        changePinnedMenuItem = (
	            React$2.createElement('button', {
	                className: "flex flex-row gap-2 hover:underline"   ,
	                onClick: () =>
	                    setPostPinned({ postId: viewModel.postId, pinned: true })
	                ,}

	                , React$2.createElement(PushpinIcon, { className: "h-6",} ), "pin this post"

	            )
	        );
	    } // otherwise, don't offer a pin or unpin item

	    // you can lock and unlock comments on any post you own, as long as it's not
	    // a transparent share.
	    const canLockComments =
	        userInfo.projectId === viewModel.postingProject.projectId &&
	        !viewModel.transparentShareOfPostId;
	    let lockCommentsMenuItem = null;

	    if (canLockComments && viewModel.commentsLocked) {
	        // display unlock comments menu item
	        lockCommentsMenuItem = (
	            React$2.createElement(MeatballMenuItem, {
	                ItemIcon: ForwardRef$1c,
	                text: "unlock comments" ,
	                onClick: () =>
	                    setPostCommentsLocked({
	                        postId: viewModel.postId,
	                        commentsLocked: false,
	                    })
	                ,
	                disabled: false,}
	            )
	        );
	    } else if (canLockComments) {
	        // display lock comments menu item
	        lockCommentsMenuItem = (
	            React$2.createElement(MeatballMenuItem, {
	                ItemIcon: ForwardRef$1e,
	                text: "lock comments" ,
	                onClick: () =>
	                    setPostCommentsLocked({
	                        postId: viewModel.postId,
	                        commentsLocked: true,
	                    })
	                ,
	                disabled: false,}
	            )
	        );
	    } // otherwise display neither

	    // you can lock and unlock shares on any post you own, as long as it's not a
	    // transparent share
	    const canLockShares =
	        userInfo.projectId === viewModel.postingProject.projectId &&
	        !viewModel.transparentShareOfPostId;
	    let lockSharesMenuItem = null;

	    if (canLockShares) {
	        if (viewModel.sharesLocked) {
	            // display unlock menu item
	            lockSharesMenuItem = (
	                React$2.createElement(MeatballMenuItem, {
	                    ItemIcon: ForwardRef$1c,
	                    text: "unlock shares" ,
	                    disabled: false,
	                    onClick: () =>
	                        setPostSharesLocked({
	                            postId: viewModel.postId,
	                            sharesLocked: false,
	                        })
	                    ,}
	                )
	            );
	        } else {
	            // display unlock menu item
	            lockSharesMenuItem = (
	                React$2.createElement(MeatballMenuItem, {
	                    ItemIcon: ForwardRef$1e,
	                    text: "lock shares" ,
	                    disabled: false,
	                    onClick: () =>
	                        setPostSharesLocked({
	                            postId: viewModel.postId,
	                            sharesLocked: true,
	                        })
	                    ,}
	                )
	            );
	        }
	    }

	    return (
	        React$2.createElement(ot, null
	            , React$2.createElement(ot.Button, { ref: refs.setReference,}
	                , React$2.createElement(ForwardRef$S, {
	                    className: tw`co-action-button h-6 w-6 transition-transform ui-open:rotate-90`,}
	                )
	            )

	            , React$2.createElement(ot.Items, {
	                ref: refs.setFloating,
	                style: floatingStyles,
	                className: "cohost-shadow-dark z-30 flex min-w-max flex-col gap-3 rounded-lg bg-notWhite p-3 text-notBlack focus:!outline-none"          ,}

	                , shareSheetMenuItem ? (
	                    React$2.createElement(ot.Item, null, shareSheetMenuItem)
	                ) : null

	                , React$2.createElement(ot.Item, null
	                    , React$2.createElement(MeatballMenuItem, {
	                        ItemIcon: ForwardRef$1g,
	                        text: "invert colors" ,
	                        disabled: false,
	                        onClick: () => dynamicTheme.forceTheme(invertToTheme),}
	                    )
	                )

	                , changePinnedMenuItem ? (
	                    React$2.createElement(ot.Item, null, changePinnedMenuItem)
	                ) : null

	                , lockCommentsMenuItem ? (
	                    React$2.createElement(ot.Item, null, lockCommentsMenuItem)
	                ) : null

	                , lockSharesMenuItem ? (
	                    React$2.createElement(ot.Item, null, lockSharesMenuItem)
	                ) : null

	                , viewModel.state === PostState.Published ? (
	                    React$2.createElement(ot.Item, null
	                        , React$2.createElement(SilencePostMenuItem, {
	                            postId: 
	                                viewModel.transparentShareOfPostId ??
	                                viewModel.postId
	                            ,}
	                        )
	                    )
	                ) : null

	                , React$2.createElement(ot.Item, null
	                    , React$2.createElement(MeatballMenuItem, {
	                        onClick: () =>
	                            reportingService.send({
	                                type: "START_REPORT",
	                                postId:
	                                    viewModel.transparentShareOfPostId ??
	                                    viewModel.postId ??
	                                    (-99999 ),
	                            })
	                        ,
	                        disabled: 
	                            !viewModel.transparentShareOfPostId &&
	                            !viewModel.postId
	                        ,
	                        ItemIcon: ForwardRef$R,
	                        text: "report this post"  ,}
	                    )
	                )
	                , userInfo.modMode ? (
	                    React$2.createElement(React$2.Fragment, null
	                        , React$2.createElement(ot.Item, null
	                            , React$2.createElement('a', {
	                                className: "flex flex-row gap-2 hover:underline"   ,
	                                href: sitemap.public.moderation
	                                    .managePost({
	                                        postId:
	                                            viewModel.transparentShareOfPostId ??
	                                            viewModel.postId,
	                                    })
	                                    .toString(),}

	                                , React$2.createElement(ForwardRef$Y, { className: "h-6",} ), "manage post"

	                            )
	                        )
	                        , viewModel.responseToAskId ? (
	                            React$2.createElement(ot.Item, null
	                                , React$2.createElement('a', {
	                                    className: "flex flex-row gap-2 hover:underline"   ,
	                                    href: sitemap.public.moderation
	                                        .manageAsk({
	                                            askId: viewModel.responseToAskId,
	                                        })
	                                        .toString(),}

	                                    , React$2.createElement(ForwardRef$Y, { className: "h-6",} ), "manage ask"

	                                )
	                            )
	                        ) : null
	                    )
	                ) : null
	            )
	        )
	    );
	};






	const PostContentModule = ({
	    viewModel,
	    highlightedTags,
	    showHeader,
	    skipCollapse,
	    showHairline,
	}) => {
	    return (
	        React$2.createElement('div', null
	            , React$2.createElement('div', {
	                id: `post-${viewModel.postId ?? -99999}`,
	                'data-testid': `post-body-${viewModel.postId ?? -99999}`,
	                className: "relative -top-20" ,}
	            )

	            , showHeader ? React$2.createElement(PostContentHeader, { viewModel: viewModel,} ) : null

	            , React$2.createElement(PostContent, {
	                viewModel: viewModel,
	                skipCollapse: skipCollapse,
	                highlightedTags: highlightedTags,}
	            )

	            , showHairline ? React$2.createElement('hr', { className: "co-hairline",} ) : null
	        )
	    );
	};
	const PostPreview = ({
	    viewModel,
	    highlightedTags,
	    displayPrefs,
	    condensed = false,
	    showFooter = true,
	    showLastPost = true,
	    showMeatballMenu = true,
	    showThreadCollapser = true,
	    skipCollapse = false,
	    commentThreads,
	}) => {
	    const { t } = useTranslation();
	    const [collapseThread, setCollapseThread] = reactExports.useState(
	        displayPrefs.collapseLongThreads
	    );

	    const dynamicTheme = useDynamicTheme();

	    const postContentsToDisplay = [
	        ...viewModel.shareTree.filter(
	            (childViewModel) =>
	                (childViewModel.limitedVisibilityReason !== "none" ||
	                    childViewModel.blocks.length ||
	                    childViewModel.headline.length) &&
	                // skip over deleted transparent shares in rendering; deleted
	                // opaque shares should still be rendered to give readers some idea
	                // that some content was deleted
	                !(
	                    childViewModel.state === PostState.Deleted &&
	                    childViewModel.transparentShareOfPostId
	                )
	        ),
	    ];

	    if (!viewModel.transparentShareOfPostId && showLastPost) {
	        postContentsToDisplay.push(viewModel);
	    }

	    let postContents;

	    const handleCollapserClick = () => {
	        setCollapseThread(!collapseThread);
	    };

	    const sharedWithTagsElement =
	        viewModel.transparentShareOfPostId && viewModel.tags.length ? (
	            React$2.createElement('div', { className: "flex w-full max-w-full flex-col"   ,}
	                , React$2.createElement('hr', { className: "co-hairline mb-3" ,} )
	                , React$2.createElement('div', { className: tw`co-ui-text px-3`,}
	                    , React$2.createElement('span', { className: "min-w-0 truncate" ,}
	                        , React$2.createElement('a', {
	                            href: sitemap.public.project
	                                .mainAppProfile({
	                                    projectHandle:
	                                        viewModel.postingProject.handle,
	                                })
	                                .toString(),
	                            className: "font-bold hover:underline" ,}
	, "@"
	                            , viewModel.postingProject.handle
	                        ), " "
	                        , React$2.createElement('span', null, "shared with:" )
	                    )
	                )
	                , React$2.createElement(PostTags, {
	                    tags: viewModel.tags,
	                    highlightedTags: highlightedTags,}
	                )
	            )
	        ) : null;

	    if (showThreadCollapser && postContentsToDisplay.length > 3) {
	        // the collapser should be shown, and the thread is long enough to
	        // justify it; figure out where it should be, even if we end up
	        // displaying all of the posts.
	        const postAboveTheFold = postContentsToDisplay[0],
	            postsBelowTheFold = collapseThread
	                ? postContentsToDisplay.slice(-2)
	                : postContentsToDisplay.slice(1),
	            nCollapsiblePosts = postContentsToDisplay.length - 3;

	        postContents = (
	            React$2.createElement(React$2.Fragment, null
	                , postAboveTheFold ? (
	                    React$2.createElement(React$2.Fragment, null
	                        , React$2.createElement(PostContentModule, {
	                            key: postAboveTheFold.postId,
	                            viewModel: postAboveTheFold,
	                            highlightedTags: highlightedTags,
	                            displayPrefs: displayPrefs,
	                            showHeader: true,
	                            showHairline: true,}
	                        )

	                        , collapseThread ? (
	                            React$2.createElement(React$2.Fragment, null
	                                , React$2.createElement('button', {
	                                    className: tw`co-link-button w-full cursor-pointer text-center font-bold`,
	                                    onClick: handleCollapserClick,
	                                    type: "button",}

	                                    , React$2.createElement(ForwardRef$A, { className: "mr-1 inline-block w-4"  ,} )

	                                    , t(
	                                        "client:post-preview.thread-collapser-show",
	                                        {
	                                            count: nCollapsiblePosts,
	                                            defaultValue:
	                                                "show {{count}} posts",
	                                        }
	                                    )
	                                )

	                                , React$2.createElement('hr', { className: "co-hairline",} )
	                                , React$2.createElement('hr', { className: "co-hairline my-1" ,} )
	                                , React$2.createElement('hr', { className: "co-hairline",} )
	                            )
	                        ) : (
	                            React$2.createElement(React$2.Fragment, null
	                                , React$2.createElement('button', {
	                                    className: tw`co-link-button w-full cursor-pointer text-center font-bold`,
	                                    onClick: handleCollapserClick,
	                                    type: "button",}

	                                    , React$2.createElement(ForwardRef$y, { className: "mr-1 inline-block w-4"  ,} )

	                                    , t(
	                                        "client:post-preview.thread-collapser-hide",
	                                        {
	                                            count: nCollapsiblePosts,
	                                            defaultValue:
	                                                "hide {{count}} posts",
	                                        }
	                                    )
	                                )

	                                , React$2.createElement('hr', { className: "co-hairline",} )
	                            )
	                        )
	                    )
	                ) : null

	                , postsBelowTheFold.map((embeddedViewModel, i) => {
	                    const last = i === postsBelowTheFold.length - 1;

	                    return (
	                        React$2.createElement(PostContentModule, {
	                            key: embeddedViewModel.postId,
	                            viewModel: embeddedViewModel,
	                            highlightedTags: highlightedTags,
	                            displayPrefs: displayPrefs,
	                            skipCollapse: last ? skipCollapse : undefined,
	                            showHeader: true,
	                            showHairline: !last,}
	                        )
	                    );
	                })
	                , sharedWithTagsElement
	            )
	        );
	    } else {
	        // either the collapser is disabled or the thread is too short to
	        // collapse; don't bother calculating it.
	        postContents = (
	            React$2.createElement(React$2.Fragment, null
	                , postContentsToDisplay.map((embeddedViewModel, i) => {
	                    const last = i === postContentsToDisplay.length - 1;

	                    return (
	                        React$2.createElement(PostContentModule, {
	                            key: embeddedViewModel.postId,
	                            viewModel: embeddedViewModel,
	                            highlightedTags: highlightedTags,
	                            displayPrefs: displayPrefs,
	                            skipCollapse: last ? skipCollapse : undefined,
	                            showHeader: 
	                                postContentsToDisplay.length > 1 ||
	                                !!viewModel.transparentShareOfPostId
	                            ,
	                            showHairline: !last,}
	                        )
	                    );
	                })
	                , sharedWithTagsElement
	            )
	        );
	    }

	    return (
	        React$2.createElement('div', {
	            'data-view': "post-preview",
	            'data-testid': `post-${viewModel.postId}`,
	            'data-postid': viewModel.postId,
	            key: viewModel.postId,
	            className: `grid ${
                condensed ? "" : "lg:grid-cols-[4rem_1fr]"
            } w-full gap-x-6 gap-y-2`,}

	            , condensed ? null : (
	                React$2.createElement(ProjectAvatar, { project: viewModel.postingProject,} )
	            )
	            , React$2.createElement('article', {
	                'data-theme': dynamicTheme.current,
	                className: "co-themed-box co-post-box" ,}

	                , React$2.createElement('header', { className: "co-thread-header",}
	                    , React$2.createElement('div', { className: "flex min-w-0 flex-1 flex-row flex-wrap items-center gap-2 leading-none"       ,}
	                        , viewModel.pinned ? (
	                            React$2.createElement(PushpinIcon, { className: "co-project-display-name h-6" ,} )
	                        ) : null

	                        , React$2.createElement(ProjectReference, { project: viewModel.postingProject,} )

	                        , viewModel.responseToAskId &&
	                            // we only want to show the ask response icon if we
	                            // aren't in a shared post context. when we are, it
	                            // appears in the share attribution line.
	                            viewModel.shareTree.length === 0 && (
	                                React$2.createElement(AskResponsePopover, null )
	                            )

	                        , viewModel.publishedAt ? (
	                            React$2.createElement(FriendlyTimestamp, {
	                                dateISO: new Date(
	                                    viewModel.publishedAt
	                                ).toISOString(),
	                                link: viewModel.singlePostPageUrl,}
	                            )
	                        ) : null

	                        /* FIXME: the share clause here is displayed
	                            incorrectly for shares of deleted posts, pending a
	                            further rewrite of the post history code */
	                        , viewModel.shareTree.length > 0 ? (
	                            React$2.createElement(SharedFromHeader, { viewModel: viewModel,} )
	                        ) : null
	                    )

	                    , showMeatballMenu ? (
	                        React$2.createElement(PostMeatballMenu, {
	                            viewModel: viewModel,
	                            dynamicTheme: dynamicTheme,}
	                        )
	                    ) : null
	                )

	                /* hairline between post header and the first post */
	                , React$2.createElement('hr', { className: "co-hairline",} )

	                , postContents

	                , showFooter ? (
	                    React$2.createElement(PostFooter, {
	                        post: viewModel,
	                        singlePostPageUrl: viewModel.singlePostPageUrl,}
	                    )
	                ) : null
	            )
	            , commentThreads ? (
	                React$2.createElement(CommentModuleWrapper, {
	                    post: viewModel,
	                    commentThreads: commentThreads,}
	                )
	            ) : null
	        )
	    );
	};

	const AskInboxPreview

	 = ({ ask, children }) => {
	    const displayPrefs = useDisplayPrefs();

	    const rendered = reactExports.useMemo(() => {
	        return renderMarkdownReactNoHTML(ask.content, new Date(ask.sentAt), {
	            renderingContext: "ask",
	            disableEmbeds: true,
	            externalLinksInNewTab: displayPrefs.externalLinksInNewTab,
	            hasCohostPlus: false,
	        });
	    }, [ask.content, ask.sentAt, displayPrefs.externalLinksInNewTab]);

	    const showFooter = React$2.Children.count(children) > 0;

	    const blockSenderMutation = trpc.asks.blockSender.useMutation();

	    const reportingService = reactExports.useContext(ReportingUIContext);

	    const blockSender = reactExports.useCallback(() => {
	        n$9
	            .promise(blockSenderMutation.mutateAsync(ask.askId), {
	                loading: "Blocking sender...",
	                success: "Sender blocked!",
	                error: (err) => {
	                    console.error(err);
	                    if (err instanceof TRPCClientError) {
	                        return err.message;
	                    }
	                    return "Failed to block sender";
	                },
	            })
	            .catch((_) => null);
	    }, [ask.askId, blockSenderMutation]);

	    const { current: postBoxTheme, forceTheme: setPostBoxTheme } =
	        useDynamicTheme();

	    return (
	        React$2.createElement('div', {
	            className: `grid ${"lg:grid-cols-[4rem_1fr]"} w-full gap-x-6 gap-y-2`,
	            'data-testid': `ask-${ask.askId}`,}

	            , ask.askingProject ? (
	                React$2.createElement(ProjectAvatar, { project: ask.askingProject, noLink: true,} )
	            ) : (
	                React$2.createElement('img', {
	                    src: sitemap.public.static
	                        .staticAsset({ path: anonBug })
	                        .toString(),
	                    className: "mask mask-squircle cohost-shadow-light dark:cohost-shadow-dark hidden h-16 w-16 lg:block"       ,
	                    alt: "",}
	                )
	            )
	            , React$2.createElement('article', {
	                'data-theme': postBoxTheme,
	                className: "co-themed-box co-post-box" ,}

	                , React$2.createElement('header', { className: "co-thread-header",}
	                    , React$2.createElement('div', { className: "flex min-w-0 flex-1 flex-row items-center gap-2 truncate leading-none"       ,}
	                        , ask.askingProject ? (
	                            React$2.createElement(ProjectReference, { project: ask.askingProject,} )
	                        ) : (
	                            React$2.createElement(React$2.Fragment, null
	                                , React$2.createElement('img', {
	                                    className: "mask mask-squircle inline-block h-8 w-8 lg:hidden"     ,
	                                    src: sitemap.public.static
	                                        .staticAsset({ path: anonBug })
	                                        .toString(),
	                                    alt: "",}
	                                )
	                                , React$2.createElement('span', { className: "co-project-display-name max-w-full flex-shrink truncate font-atkinson font-bold"     ,}
	                                    , ask.loggedIn
	                                        ? "Anonymous User"
	                                        : "Anonymous Guest"
	                                )
	                            )
	                        )
	                        , React$2.createElement(FriendlyTimestamp, {
	                            dateISO: new Date(ask.sentAt).toISOString(),}
	                        )
	                    )

	                    , React$2.createElement(ot, { as: "div", className: "relative h-6 w-6"  ,}
	                        , React$2.createElement(ot.Button, { className: "absolute right-0 top-0"  ,}
	                            , React$2.createElement(ForwardRef$S, {
	                                className: tw`co-action-button h-6 w-6 transition-transform ui-open:rotate-90`,}
	                            )
	                        )

	                        , React$2.createElement(ot.Items, { className: "cohost-shadow-dark absolute right-0 top-8 z-30 flex min-w-max flex-col gap-3 rounded-lg bg-notWhite p-3 text-notBlack focus:!outline-none"             ,}
	                            , React$2.createElement(ot.Item, null
	                                , React$2.createElement(MeatballMenuItem, {
	                                    onClick: blockSender,
	                                    disabled: false,
	                                    ItemIcon: ForwardRef$16,
	                                    text: "block this sender"  ,}
	                                )
	                            )
	                            , React$2.createElement(ot.Item, null
	                                , React$2.createElement(MeatballMenuItem, {
	                                    onClick: () => {
	                                        reportingService.send({
	                                            type: "START_REPORT",
	                                            askId: ask.askId,
	                                        });
	                                    },
	                                    disabled: false,
	                                    ItemIcon: ForwardRef$R,
	                                    text: "report ask" ,}
	                                )
	                            )
	                        )
	                    )
	                )

	                /* hairline between post header and the first post */
	                , React$2.createElement('hr', { className: "co-hairline",} )

	                , React$2.createElement('div', { className: tw`co-prose prose p-3`,}, rendered)
	                , React$2.createElement('hr', { className: "co-hairline",} )
	                , showFooter ? (
	                    React$2.createElement('footer', {
	                        className: tw`co-thread-footer w-full max-w-full rounded-b-lg p-3`,}

	                        , React$2.createElement('div', { className: "flex items-center justify-end gap-3"   ,}
	                            , children
	                        )
	                    )
	                ) : null
	            )
	        )
	    );
	};

	const PostComposerContainer = (
	    props
	) => {
	    const sharedPost = trpc.posts.singlePost.useQuery(
	        {
	            // these overrides exist to appease typescript; they shouldn't ever
	            // be used in practice since the query is enabled based on if
	            // `shareOf` is defined to begin with.
	            handle: props.shareOf?.handle ?? ("" ),
	            postId: props.shareOf?.postId ?? (-99999 ),
	            skipComments: true,
	        },
	        {
	            suspense: true,
	            enabled: !!props.shareOf,
	        }
	    );

	    const ask = trpc.asks.byAskId.useQuery(
	        props.responseToAskId ?? ("" ),
	        {
	            suspense: true,
	            enabled: !!props.responseToAskId,
	        }
	    );

	    const displayPrefs = useDisplayPrefs();

	    const postComposerV2FeatureFlag = index_browserExports.useFlag("attachment-composer-v2");

	    const usePostComposerV2 =
	        postComposerV2FeatureFlag &&
	        displayPrefs.previewFeatures_lexicalPostEditor;

	    return (
	        React$2.createElement(React$2.Fragment, null
	            , props.initialPost && props.initialPost.shareOfPostId ? (
	                React$2.createElement('div', { className: "w-full", 'data-testid': "composer-context",}
	                    , React$2.createElement('h1', { className: "mb-3 text-xl text-bgText"  ,}, "You're editing a reply to this thread:"

	                    )
	                    , React$2.createElement(PostPreview, {
	                        viewModel: props.initialPost,
	                        highlightedTags: [],
	                        showFooter: false,
	                        showLastPost: false,
	                        showMeatballMenu: false,
	                        displayPrefs: displayPrefs,}
	                    )
	                )
	            ) : null

	            , sharedPost.data ? (
	                React$2.createElement('div', { className: "w-full", 'data-testid': "composer-context",}
	                    , React$2.createElement('h1', { className: "mb-3 text-xl text-bgText"  ,}, "You're sharing the following post:"

	                    )
	                    , React$2.createElement(PostPreview, {
	                        viewModel: sharedPost.data.post,
	                        highlightedTags: [],
	                        showFooter: false,
	                        showLastPost: true,
	                        showMeatballMenu: false,
	                        displayPrefs: displayPrefs,}
	                    )
	                )
	            ) : null

	            , ask.data ? (
	                React$2.createElement('div', { className: "w-full", 'data-testid': "composer-context",}
	                    , React$2.createElement('h1', { className: "mb-3 text-xl text-bgText"  ,}, "You're responding to the following ask:"

	                    )
	                    , React$2.createElement(AskInboxPreview, { ask: ask.data,} )
	                )
	            ) : null

	            , usePostComposerV2 ? (
	                // this <Provider> should bubble outward as more of the app
	                // gets reduxified.
	                React$2.createElement(Provider_default, { store: store,}
	                    , React$2.createElement(PostComposer, { ...props,} )
	                )
	            ) : (
	                React$2.createElement(PostComposer$1, { ...props,} )
	            )
	        )
	    );
	};

	const ModalPostComposerButton

	 = ({ hideWhenOpen }) => {
	    const { activate, isOpen, close, hasBeenSetup } = useModalPostComposer();
	    const { activated } = useUserInfo();
	    const currentProject = useCurrentProject();
	    const displayPrefs = useDisplayPrefs();

	    return activated && hasBeenSetup && currentProject?.handle ? (
	        React$2.createElement('div', { className: "fixed bottom-4 right-4 z-20"   ,}
	            , isOpen ? (
	                !hideWhenOpen ? (
	                    React$2.createElement(IconEgg, {
	                        className: "cohost-shadow-light dark:cohost-shadow-dark inline-block h-8 cursor-pointer fill-composeButton text-text hover:fill-text hover:text-composeButton"        ,
	                        onClick: (e) => {
	                            e.preventDefault();
	                            close();
	                        },}

	                        , React$2.createElement(ForwardRef$C, null )
	                    )
	                ) : null
	            ) : (
	                React$2.createElement('a', {
	                    href: sitemap.public.project
	                        .composePost({
	                            projectHandle: currentProject.handle,
	                        })
	                        .toString(),
	                    onClick: (e) => {
	                        console.log(displayPrefs);
	                        if (displayPrefs.disableModalPostComposer) {
	                            return;
	                        }
	                        e.preventDefault();
	                        activate({});
	                    },}

	                    , React$2.createElement(IconEgg, { className: "cohost-shadow-light dark:cohost-shadow-dark inline-block h-8 cursor-pointer fill-composeButton text-text hover:fill-text hover:text-composeButton"        ,}
	                        , React$2.createElement(ForwardRef$10, null )
	                    )
	                )
	            )
	        )
	    ) : null;
	};

	const ModalPostComposer

	 = ({ children }) => {
	    const theme = useDynamicTheme();
	    const [isOpen, setIsOpen] = reactExports.useState(false);
	    const [hasBeenSetup, setHasBeenSetup] = reactExports.useState(false);
	    const { activated } = useUserInfo();
	    const close = reactExports.useCallback(() => {
	        setIsOpen(false);
	    }, []);

	    const onClose = reactExports.useCallback(() => {
	        const attemptClose = composerRef.current?.attemptClose();
	        if (attemptClose === true) {
	            close();
	            return;
	        }
	        setShowDiscardWarning(true);
	    }, [close]);

	    const composerRef = reactExports.useRef(null);
	    const providedOnPost = reactExports.useRef

	(null);

	    const [props, setProps] = reactExports.useState(null);
	    const postComposerSettings = trpc.posts.postComposerSettings.useQuery(
	        {},
	        {
	            enabled: activated,
	            suspense: true,
	        }
	    );

	    const setup = reactExports.useCallback(
	        (props) => {
	            if (hasBeenSetup) {
	                return;
	            }
	            setProps({
	                cws: postComposerSettings.data?.defaultCws ?? [],
	                initialAdultContent:
	                    postComposerSettings.data?.defaultAdultContent ?? false,
	                tags: postComposerSettings.data?.defaultTags ?? [],
	                initialPost: undefined,
	                isModal: true,
	                onClose: close,
	                shareOf: undefined,
	                project: props.project,
	                finishedRedirect: (postId) => {
	                    close();

	                    if (providedOnPost.current) {
	                        providedOnPost.current(postId);
	                    }
	                },
	            });
	            setHasBeenSetup(true);
	        },
	        [close, hasBeenSetup, postComposerSettings.data]
	    );
	    const activate = reactExports.useCallback(
	        (opts) => {
	            if (!props) {
	                console.error("ModalPostComposer: setup hasn't been run");
	                return;
	            }

	            const workingProps = { ...props };
	            workingProps.shareOf = opts.shareOf;
	            workingProps.responseToAskId = opts.responseToAskId;

	            providedOnPost.current = opts.onPost ?? null;

	            setProps(workingProps);

	            setIsOpen(true);
	        },
	        [props]
	    );

	    const [dialogRef, setDialogRef] = reactExports.useState(null);

	    reactExports.useEffect(() => {
	        if (isOpen && dialogRef?.open !== true) {
	            dialogRef?.showModal();
	        } else if (!isOpen && dialogRef?.open === true) {
	            dialogRef?.close();
	        }
	    }, [dialogRef, isOpen]);

	    const [showDiscardWarning, setShowDiscardWarning] = reactExports.useState(false);

	    const onDialogClick = (e) => {
	        if (e.target === e.currentTarget) {
	            onClose();
	        }
	    };

	    return (
	        React$2.createElement(ModalPostComposerContext.Provider, {
	            value: {
	                setup,
	                isOpen,
	                activate,
	                close,
	                hasBeenSetup,
	            },}

	            , children
	            , activated ? (
	                React$2.createElement(React$2.Fragment, null
	                    , React$2.createElement(ModalPostComposerButton, { hideWhenOpen: true,} )
	                    /* necessary to prevent errors here. click handler on the dialog is how we get backdrop click events, which we need for closing the dialog. */
	                    /* eslint-disable-next-line jsx-a11y/click-events-have-key-events, jsx-a11y/no-noninteractive-element-interactions */
	                    , React$2.createElement('dialog', {
	                        ref: setDialogRef,
	                        className: "co-themed-box h-auto max-h-screen max-w-full flex-col items-start justify-stretch gap-6 bg-transparent px-0 py-12 text-inherit backdrop:bg-notBlack/90 open:flex lg:px-6"              ,
	                        onClick: onDialogClick,
	                        //@ts-expect-error it's real, don't believe their lies
	                        onCancel: (e) => {
	                            e.preventDefault();
	                            onClose();
	                        },
	                        'data-theme': theme.current,}

	                        , props ? (
	                            React$2.createElement(reactExports.Suspense, {
	                                fallback: 
	                                    React$2.createElement(Loading, { className: "text-xl text-notWhite" ,} )
	                                ,}

	                                /* fully remove from the tree to get an effective reset on close */
	                                , isOpen ? (
	                                    React$2.createElement(PostComposerContainer, {
	                                        ...props,
	                                        isModal: true,
	                                        onClose: onClose,}
	                                    )
	                                ) : null
	                            )
	                        ) : null
	                    )
	                    , React$2.createElement(DiscardPostDialog, {
	                        onDiscard: () => {
	                            setShowDiscardWarning(false);
	                            close();
	                        },
	                        onCancel: () => {
	                            setShowDiscardWarning(false);
	                        },
	                        isOpen: showDiscardWarning,}
	                    )
	                )
	            ) : null
	        )
	    );
	};

	const DiscardPostDialog



	 = ({ onDiscard, onCancel, isOpen }) => {
	    return (
	        React$2.createElement(SimpleNativeModalDialog, {
	            isOpen: isOpen,
	            title: t$5(
	                "client:post-composer.discard-title",
	                "Discard this post?"
	            ),
	            body: t$5(
	                "client:post-composer.discard-body",
	                "Are you sure you want to discard this post? This cannot be undone."
	            ),
	            confirm: {
	                label: t$5("client:post-composer.discard-button", "discard"),
	                color: "destructive",
	            },
	            cancel: {
	                label: t$5(
	                    "client:post-composer.discard-cancel-button",
	                    "keep working on it"
	                ),
	            },
	            onConfirm: () => onDiscard(),
	            onCancel: () => onCancel(),}
	        )
	    );
	};

	function makeLocalStorageKey$1(projectId) {
	    return `scheduled-delete-acknowledged/project/${projectId}`;
	}

	const QueuedForDeleteHeader = () => {
	    const editedProjects = useEditedProjects();

	    const [unacknowledgedScheduledDeletes, setUnacknowledgedScheduledDeletes] =
	        reactExports.useState(null);

	    reactExports.useEffect(() => {
	        const unacknowledgedDeletes = [];

	        for (const project of editedProjects.projects) {
	            const storedValue = window.localStorage.getItem(
	                makeLocalStorageKey$1(project.projectId)
	            );

	            if (storedValue && !project.deleteAfter) {
	                // a deletion was scheduled, then cancelled; we can clear the
	                // acknowledgement to be a good citizen and not waste localstorage
	                window.localStorage.removeItem(
	                    makeLocalStorageKey$1(project.projectId)
	                );
	            } else if (storedValue && storedValue === project.deleteAfter) ; else if (project.deleteAfter) {
	                // a deletion is scheduled, but has not been acknowledged
	                unacknowledgedDeletes.push(
	                    project 
	                );
	            }
	        }

	        setUnacknowledgedScheduledDeletes(unacknowledgedDeletes);
	    }, [editedProjects]);

	    function onAcknowledge() {
	        if (!unacknowledgedScheduledDeletes) return;

	        // store the acknowledgement to localStorage; store a timestamp so that
	        // we can remove any
	        for (const del of unacknowledgedScheduledDeletes) {
	            window.localStorage.setItem(
	                makeLocalStorageKey$1(del.projectId),
	                del.deleteAfter
	            );
	        }

	        // change the state
	        setUnacknowledgedScheduledDeletes([]);
	    }

	    // display the warning iff we know which deletes haven't been acknowledged
	    // (to prevent an FOUC if the user's acknowledged all their scheduled deletes)
	    // and there's at least one of them
	    if (
	        unacknowledgedScheduledDeletes &&
	        unacknowledgedScheduledDeletes.length > 0
	    ) {
	        const handleList = unacknowledgedScheduledDeletes
	            .map((del) => `@${del.handle}`)
	            .join(", ");
	        const earliestUnacknowledgedDelete = DateTime_1.min(
	            ...unacknowledgedScheduledDeletes.map((del) =>
	                DateTime_1.fromISO(del.deleteAfter)
	            )
	        );
	        const timeLeft = earliestUnacknowledgedDelete.diff(DateTime_1.now());
	        const daysLeft = Math.round(timeLeft.as("days"));

	        return (
	            React$2.createElement(StandardHeader, null
	                , React$2.createElement(React$2.Fragment, null
	                    , React$2.createElement(Trans, {
	                        parent: "div",
	                        className: "prose mx-auto" ,
	                        i18nKey: "client:header-notice.queued-for-delete",}

	                        , React$2.createElement('p', null
	                            , React$2.createElement('strong', null, "Heads up!" ), " One or more pages you edit ("
	                             , { handleList }, ") are scheduled for deletion, starting in "
	                              , { daysLeft }, " days. At that time, that data will be permanently deleted from our servers. If you want to prevent this, please"

	                                  , " "
	                            , React$2.createElement('a', {
	                                href: sitemap.public.project
	                                    .settings()
	                                    .toString(),}
	, "visit the page settings"

	                            ), " ", "and cancel it."

	                        )
	                        , React$2.createElement('p', null, "(If you close this notification, you won't see it again for these pages in this web browser.)"


	                        )
	                    )
	                    , React$2.createElement('button', {
	                        type: "button",
	                        disabled: !unacknowledgedScheduledDeletes,
	                        onClick: onAcknowledge,}

	                        , React$2.createElement(ForwardRef$9, { className: "h-6",} )
	                    )
	                )
	            )
	        );
	    } else return null;
	};

	function makeLocalStorageKey(userId) {
	    return `scheduled-delete-acknowledged/user/${userId}`;
	}

	const UserQueuedForDeleteHeader = () => {
	    const userInfo = useUserInfo();
	    const [unacknowledgedDelete, setUnacknowledgedDelete] = reactExports.useState(false);

	    reactExports.useEffect(() => {
	        if (userInfo.userId) {
	            const storedValue = window.localStorage.getItem(
	                makeLocalStorageKey(userInfo.userId)
	            );

	            if (storedValue && !userInfo.deleteAfter) {
	                // a deletion was scheduled, then cancelled; we can clear the
	                // acknowledgement to be a good citizen and not waste localstorage
	                window.localStorage.removeItem(
	                    makeLocalStorageKey(userInfo.userId)
	                );
	            } else if (
	                storedValue &&
	                storedValue === userInfo.deleteAfter?.toISO()
	            ) ; else if (userInfo.deleteAfter) {
	                // a deletion is scheduled, but has not been acknowledged
	                setUnacknowledgedDelete(true);
	            }
	        }
	    }, [userInfo]);

	    function onAcknowledge() {
	        if (!unacknowledgedDelete || !userInfo.userId || !userInfo.deleteAfter)
	            return;

	        // store the acknowledgement to localStorage; store a timestamp so that
	        // we can remove any
	        window.localStorage.setItem(
	            makeLocalStorageKey(userInfo.userId),
	            userInfo.deleteAfter.toISO()
	        );

	        // change the state
	        setUnacknowledgedDelete(false);
	    }

	    // display the warning iff we know which deletes haven't been acknowledged
	    // (to prevent an FOUC if the user's acknowledged all their scheduled deletes)
	    // and there's at least one of them
	    if (unacknowledgedDelete) {
	        const timeLeft = userInfo.deleteAfter.diff(DateTime_1.now());
	        const daysLeft = Math.round(timeLeft.as("days"));

	        return (
	            React$2.createElement(StandardHeader, null
	                , React$2.createElement(React$2.Fragment, null
	                    , React$2.createElement(Trans, {
	                        parent: "div",
	                        className: "prose mx-auto" ,
	                        i18nKey: "client:header-notice.user-queued-for-delete",}

	                        , React$2.createElement('p', null
	                            , React$2.createElement('strong', null, "Heads up!" ), " Your account is scheduled for deletion, starting in "
	                                , { daysLeft }, " days. At that time, that data will be permanently deleted from our servers. If you want to prevent this, please"


	                            , " "
	                            , React$2.createElement('a', { href: sitemap.public.userSettings().toString(),}, "visit the user settings"

	                            ), " ", "and cancel it."

	                        )
	                        , React$2.createElement('p', null, "(If you close this notification, you won't see it again for this account in this web browser.)"


	                        )
	                    )
	                    , React$2.createElement('button', {
	                        type: "button",
	                        disabled: !unacknowledgedDelete,
	                        onClick: onAcknowledge,}

	                        , React$2.createElement(ForwardRef$9, { className: "h-6",} )
	                    )
	                )
	            )
	        );
	    } else return null;
	};

	const MainLayout = ({ children }) => {
	    return (
	        React$2.createElement(ModalPostComposer, null
	            , React$2.createElement('div', { className: "flex flex-col" ,}
	                , React$2.createElement(CohostToaster, null )
	                , React$2.createElement(Favicons, null )
	                , React$2.createElement(ThemeCSSVars, null )
	                , React$2.createElement(Helmet, { defaultTitle: "cohost!", titleTemplate: "cohost! - %s"  ,} )
	                , React$2.createElement(TopNav, null )
	                , React$2.createElement(Flashes, { className: "cohost-shadow-light absolute left-0 right-0 top-20 z-10 mx-auto max-w-prose"       ,} )
	                , React$2.createElement('div', { className: "flex flex-grow flex-col pb-20"   ,}
	                    , React$2.createElement(EmailVerifyCanceledHeader, null )
	                    , React$2.createElement(UnactivatedHeader, null )
	                    , React$2.createElement(ReadOnlyHeader, null )
	                    , React$2.createElement(UserQueuedForDeleteHeader, null )
	                    , React$2.createElement(QueuedForDeleteHeader, null )
	                    , React$2.createElement(LightboxHost, null
	                        , React$2.createElement(ReportingUIHost, null
	                            , children
	                        )
	                    )
	                    , React$2.createElement(Footer, null )
	                )
	            )
	        )
	    );
	};

	const MainNoFooterLayout = ({
	    children,
	}) => {
	    return (
	        React$2.createElement(ModalPostComposer, null
	            , React$2.createElement('div', { className: "flex flex-col" ,}
	                , React$2.createElement(CohostToaster, null )
	                , React$2.createElement(Favicons, null )
	                , React$2.createElement(ThemeCSSVars, null )
	                , React$2.createElement(Helmet, { defaultTitle: "cohost!", titleTemplate: "cohost! - %s"  ,} )
	                , React$2.createElement(TopNav, null )
	                , React$2.createElement(Flashes, { className: "cohost-shadow-light absolute left-0 right-0 top-20 z-10 mx-auto max-w-prose"       ,} )
	                , React$2.createElement('div', { className: "flex flex-grow flex-col"  ,}
	                    , React$2.createElement(EmailVerifyCanceledHeader, null )
	                    , React$2.createElement(UnactivatedHeader, null )
	                    , React$2.createElement(ReadOnlyHeader, null )
	                    , React$2.createElement(QueuedForDeleteHeader, null )
	                    , React$2.createElement(LightboxHost, null
	                        , React$2.createElement(ReportingUIHost, null
	                            , React$2.createElement(reactExports.Suspense, null, children)
	                        )
	                    )
	                )
	            )
	        )
	    );
	};

	const StaticLayout = ({ children }) => {
	    return (
	        React$2.createElement(MainLayout, null
	            , React$2.createElement('main', { className: "w-full pb-16 pt-16"  ,}
	                , React$2.createElement('div', { className: "container mx-auto grid grid-cols-1 gap-16 md:grid-cols-4"     ,}
	                    , React$2.createElement(SidebarMenu, null )
	                    , React$2.createElement('section', { className: "col-span-1 flex flex-col gap-12 md:col-span-2"    ,}
	                        , React$2.createElement('div', { className: "prose prose-stone rounded-lg bg-notWhite p-3 text-notBlack"     ,}
	                            , children
	                        )
	                    )
	                )
	            )
	        )
	    );
	};

	const StaticNoWrapperLayout = ({
	    children,
	}) => {
	    return (
	        React$2.createElement(MainLayout, null
	            , React$2.createElement('main', { className: "w-full pt-16" ,}
	                , React$2.createElement('div', { className: "container mx-auto grid grid-cols-1 gap-16 md:grid-cols-4"     ,}
	                    , React$2.createElement(SidebarMenu, null )
	                    , React$2.createElement('section', { className: "col-span-1 flex flex-col gap-12 md:col-span-2"    ,}
	                        , children
	                    )
	                )
	            )
	        )
	    );
	};

	const layouts = new Map([
	    ["main", MainLayout],
	    ["mainNoFooter", MainNoFooterLayout],
	    ["iframe", IFrameLayout],
	    ["authn", AuthnLayout],
	    ["error", ErrorLayout],
	    ["static", StaticLayout],
	    ["staticNoWrapper", StaticNoWrapperLayout],
	]);

	const layoutByName = (name) => {
	    const layout = layouts.get(name);
	    return layout ?? MainLayout;
	};

	const SearchPage = loadable$2(() => new Promise(function (resolve, reject) { require(['./search-BMpfkuEp'], resolve, reject); }));
	const ProjectSettingsPage = loadable$2(
	    () => new Promise(function (resolve, reject) { require(['./project-settings-mDhFTqi7'], resolve, reject); })
	);
	const ArtistAlleyPage = loadable$2(
	    () => new Promise(function (resolve, reject) { require(['./artist-alley-DC1Fn39_'], resolve, reject); })
	);
	const ArtistAlleyCreatePage = loadable$2(
	    () => new Promise(function (resolve, reject) { require(['./create-pSSzSoZB'], resolve, reject); })
	);
	const ArtistAlleyPaymentSuccessPage = loadable$2(
	    () => new Promise(function (resolve, reject) { require(['./payment-success-CwiILBPI'], resolve, reject); })
	);
	const ArtistAlleyPaymentCancelledPage = loadable$2(
	    () => new Promise(function (resolve, reject) { require(['./payment-cancelled-CsIYCkxV'], resolve, reject); })
	);
	const ArtistAlleyOwnerListingsPage = loadable$2(
	    () =>
	        new Promise(function (resolve, reject) { require(['./owner-manage-listings-Dnx1_C61'], resolve, reject); })
	);

	const CohostRoutes = ({
	    children,
	}) => {
	    return (
	        React$2.createElement(Routes, null
	            , React$2.createElement(Route, {
	                path: patterns.public.search,
	                element: 
	                    React$2.createElement(MainLayout, null
	                        , React$2.createElement(SearchPage, null )
	                    )
	                ,}
	            )
	            , React$2.createElement(Route, {
	                path: patterns.public.project.settings,
	                element: 
	                    React$2.createElement(MainLayout, null
	                        , React$2.createElement(ProjectSettingsPage, null )
	                    )
	                ,}
	            )
	            /* artist alley */
	            , React$2.createElement(Route, {
	                path: patterns.public.artistAlley.home,
	                element: 
	                    React$2.createElement(MainNoFooterLayout, null
	                        , React$2.createElement(ArtistAlleyPage, null )
	                    )
	                ,}
	            )
	            , React$2.createElement(Route, {
	                path: patterns.public.artistAlley.create,
	                element: 
	                    React$2.createElement(MainLayout, null
	                        , React$2.createElement(ArtistAlleyCreatePage, null )
	                    )
	                ,}
	            )
	            , React$2.createElement(Route, {
	                path: patterns.public.artistAlley.success,
	                element: 
	                    React$2.createElement(StaticNoWrapperLayout, null
	                        , React$2.createElement(ArtistAlleyPaymentSuccessPage, null )
	                    )
	                ,}
	            )
	            , React$2.createElement(Route, {
	                path: patterns.public.artistAlley.cancelled,
	                element: 
	                    React$2.createElement(StaticNoWrapperLayout, null
	                        , React$2.createElement(ArtistAlleyPaymentCancelledPage, null )
	                    )
	                ,}
	            )
	            , React$2.createElement(Route, {
	                path: patterns.public.artistAlley.ownerManage,
	                element: 
	                    React$2.createElement(MainLayout, null
	                        , React$2.createElement(ArtistAlleyOwnerListingsPage, null )
	                    )
	                ,}
	            )
	            , children
	        )
	    );
	};

	const ButtonStyle = mod.enum(["pill", "roundrect", "authn"]);
	 

	const ButtonColor = mod.enum([
	    "cherry",
	    "strawberry",
	    "mango",
	    "not-black",
	    "red",
	    "green",
	    "accent",
	    "secondary",
	    "authn-primary",
	    "authn-other",
	]);
	 

	mod.object({
	    buttonStyle: ButtonStyle,
	    color: ButtonColor,
	    className: mod.string().optional(),
	});
	 

	const baseColors = classNames("bg-notWhite", "hover:text-notWhite");

	// WHY NOT HAVE THESE AS INTERPOLATED CLASS NAMES?
	// tailwind jit doesn't handle interpolated class names!
	// you have to have the full class name written for it to pick up on a string as
	// a class name! so we do this
	const pillClasses = classNames(
	    "font-atkinson",
	    "font-bold",
	    "rounded-full",
	    "border-2"
	);

	const roundrectClasses = classNames("body-2", "rounded-lg");

	const authnStyleClasses = classNames(
	    "flex",
	    "h-12",
	    "items-center",
	    "justify-center",
	    "rounded-lg",
	    "px-6",
	    "text-lg"
	);

	const cherryClasses = classNames(
	    "border-cherry",
	    "hover:bg-cherry",
	    "text-cherry",
	    "active:bg-cherry-600",
	    "active:border-cherry-600",
	    "disabled:text-cherry-300",
	    "disabled:border-cherry-300",
	    "focus:outline-cherry",
	    "focus:ring-cherry",
	    baseColors
	);
	const strawberryClasses = classNames(
	    "border-strawberry",
	    "hover:bg-strawberry",
	    "text-strawberry",
	    "active:bg-strawberry-600",
	    "active:border-strawberry-600",
	    "disabled:text-strawberry-300",
	    "disabled:border-strawberry-300",
	    "focus:outline-strawberry",
	    "focus:ring-strawberry",
	    baseColors
	);

	const redClasses = classNames(
	    "border-red",
	    "hover:bg-red",
	    "text-red",
	    "active:bg-red-600",
	    "active:border-red-600",
	    "disabled:text-red-300",
	    "disabled:border-red-300",
	    "focus:outline-red",
	    baseColors
	);

	const greenClasses = classNames(
	    "border-green",
	    "hover:bg-green",
	    "text-green",
	    "active:bg-green-600",
	    "active:border-green-600",
	    "disabled:text-green-300",
	    "disabled:border-green-300",
	    "focus:outline-green",
	    baseColors
	);
	const mangoClasses = classNames(
	    "border-mango",
	    "hover:bg-mango",
	    "text-mango",
	    "bg-notBlack",
	    "hover:text-notBlack"
	);
	const notBlackClasses = classNames(
	    "border-notBlack",
	    "hover:bg-notBlack",
	    "text-notBlack",
	    "focus:outline-notBlack",
	    "focus:ring-notBlack",
	    baseColors
	);

	const accentClasses = classNames(
	    "border-accent",
	    "text-accent",
	    "bg-foreground",
	    "hover:bg-accent",
	    "hover:text-text"
	);

	const secondaryClasses = classNames(
	    "bg-secondary",
	    "text-notWhite",
	    "dark:text-notBlack",
	    "hover:bg-secondary-600"
	);

	const authnPrimaryColorClasses = classNames(
	    "bg-foreground",
	    "text-text",
	    "hover:bg-foreground-600",
	    "active:bg-foreground-700",
	    "disabled:bg-foreground-200"
	);

	const authnOtherColorClasses = classNames(
	    "border-2",
	    "border-foreground",
	    "text-foreground",
	    "hover:bg-longan-200"
	);

	const sharedClasses = (props) =>
	    classNames(
	        "leading-none",
	        "align-middle",
	        "py-2",
	        "px-4",
	        "no-select",
	        props.className,
	        {
	            [pillClasses]: props.buttonStyle === "pill",
	            [roundrectClasses]: props.buttonStyle === "roundrect",
	            [authnStyleClasses]: props.buttonStyle === "authn",
	            [cherryClasses]: props.color === "cherry",
	            [strawberryClasses]: props.color === "strawberry",
	            [mangoClasses]: props.color === "mango",
	            [notBlackClasses]: props.color === "not-black",
	            [redClasses]: props.color === "red",
	            [accentClasses]: props.color === "accent",
	            [greenClasses]: props.color === "green",
	            [secondaryClasses]: props.color === "secondary",
	            [authnPrimaryColorClasses]: props.color === "authn-primary",
	            [authnOtherColorClasses]: props.color === "authn-other",
	        }
	    );

	const Button




	 = React$2.forwardRef(({ buttonStyle, color, className, ...props }, ref) => {
	    const classes = sharedClasses({
	        buttonStyle,
	        color,
	        className,
	        ...props,
	    });
	    return (
	        React$2.createElement('button', { ...props, className: classes, ref: ref,}
	            , props.children
	        )
	    );
	});
	Button.displayName = "Button";

	const LinkButton




	 = React$2.forwardRef(({ buttonStyle, color, ...props }, ref) => {
	    const classes = sharedClasses({ buttonStyle, color, ...props });
	    return (
	        React$2.createElement('a', { ...props, className: classes, ref: ref,}
	            , props.children
	        )
	    );
	});
	LinkButton.displayName = "LinkButton";

	const UserNote = ({
	    projectId,
	}) => {
	    const { loggedIn } = useUserInfo();
	    const initialContents = trpc.projects.userNote.query.useQuery(
	        { describedProjectId: projectId },
	        {
	            suspense: true,
	            refetchInterval: false,
	            refetchOnMount: false,
	            refetchOnReconnect: false,
	            refetchOnWindowFocus: false,
	            enabled: loggedIn,
	        }
	    ).data?.contents;

	    const userNoteMutation = trpc.projects.userNote.mutate.useMutation();
	    const onSubmit = reactExports.useCallback(
	        async ({ contents }) => {
	            await userNoteMutation.mutateAsync({
	                describedProjectId: projectId,
	                contents: contents,
	            });
	        },
	        [projectId, userNoteMutation]
	    );

	    const { handleSubmit, control } = useForm({
	        defaultValues: {
	            contents: initialContents || "",
	        },
	        mode: "all",
	    });

	    if (!loggedIn) {
	        return null;
	    }

	    return (
	        React$2.createElement('div', { className: "cohost-shadow-light dark:cohost-shadow-dark flex flex-col divide-y divide-gray-300 rounded-lg bg-white lg:max-w-sm"        ,}
	            , React$2.createElement('div', { className: "flex flex-row items-center rounded-t-lg bg-longan p-3 uppercase text-notBlack"       ,}, "Private Note"

	            )
	            , React$2.createElement('div', { className: "flex flex-col gap-2 px-3 py-2 text-notBlack"     ,}
	                , React$2.createElement('div', null
	                    , React$2.createElement('em', null, "Only you can see this"    )
	                )
	                , React$2.createElement('form', {
	                    className: "flex flex-col gap-3"  ,
	                    onSubmit: handleSubmit(onSubmit),}

	                    , React$2.createElement(Controller, {
	                        control: control,
	                        name: "contents",
	                        render: ({ field: { ref, onChange, ...field } }) => (
	                            React$2.createElement(ExpandingTextArea, {
	                                ...field,
	                                className: "border-cherry",
	                                onInput: onChange,
	                                ref: ref,
	                                minRows: 1,
	                                autoComplete: "off",
	                                placeholder: t$5(
	                                    "client:private-note.placeholder",
	                                    {
	                                        defaultValue: "add note",
	                                    }
	                                ),}
	                            )
	                        ),}
	                    )
	                    , React$2.createElement('div', { className: "flex w-full flex-row items-center justify-end gap-4"     ,}
	                        , userNoteMutation.isSuccess ? (
	                            React$2.createElement('p', { className: "font-bold text-green" ,}, "Note saved!" )
	                        ) : null
	                        , userNoteMutation.isError ? (
	                            React$2.createElement('p', { className: "text-red",}, `Sorry, we couldn't save your note. ${userNoteMutation.error.message}`)
	                        ) : null
	                        , React$2.createElement('button', {
	                            className: `rounded-lg bg-cherry py-2 px-4 text-sm font-bold text-notWhite
                        hover:bg-cherry-600 active:bg-cherry-700 disabled:bg-cherry-200`,}

	                            , t$5("client:new-comment.save", {
	                                defaultValue: "save",
	                            })
	                        )
	                    )
	                )
	            )
	        )
	    );
	};

	// actual values don't matter, but higher-numbered following states cover up
	// lower-numbered ones
	var FollowingState; (function (FollowingState) {
	    const NotFollowing = 0; FollowingState[FollowingState["NotFollowing"] = NotFollowing] = "NotFollowing";
	    const FollowRequested = 1; FollowingState[FollowingState["FollowRequested"] = FollowRequested] = "FollowRequested";
	    const Following = 2; FollowingState[FollowingState["Following"] = Following] = "Following";
	})(FollowingState || (FollowingState = {}));

	mod.nativeEnum(FollowingState);

	const FollowButton = (props) => {
	    return (
	        React$2.createElement(reactExports.Suspense, null
	            , React$2.createElement(FollowButtonInner, { ...props,} )
	        )
	    );
	};

	const FollowButtonInner = ({
	    project,
	    onFollow,
	    color,
	}) => {
	    const userInfo = useUserInfo();
	    const utils = trpc.useContext();
	    const followingStateQuery = trpc.projects.followingState.useQuery(
	        { projectHandle: project.handle },
	        { suspense: true }
	    );
	    const reqStore = useReqMutableStore();
	    const ssrUrl = reqStore.get("ssrUrl");

	    // big ol boilerplate to generate the optimistic update callbacks. this can
	    // _probably_ be cleaned up somewhat, but doing so would require a bunch of
	    // type finangaling that likely isn't worth doing in a component we never
	    // actually touch.
	    const createMutationCallbacks = reactExports.useCallback(
	        (
	            optimisticState
	        













	) => {
	            return {
	                onMutate: async () => {
	                    // cancel any pending requests so they don't overwrite our
	                    // optimistic update
	                    await utils.projects.followingState.cancel({
	                        projectHandle: project.handle,
	                    });

	                    // snapshot the previous value
	                    const previousState = utils.projects.followingState.getData(
	                        {
	                            projectHandle: project.handle,
	                        }
	                    );

	                    // optimistic update
	                    // cancel follow request -> not following
	                    utils.projects.followingState.setData(
	                        { projectHandle: project.handle },
	                        {
	                            readerToProject: optimisticState,
	                        }
	                    );

	                    return { previousState };
	                },
	                onError: (err, params, context) => {
	                    // mutation failed, reset back to the previous state
	                    utils.projects.followingState.setData(
	                        { projectHandle: project.handle },
	                        context?.previousState
	                    );
	                },
	                onSettled: async () => {
	                    // refetch so we know we're For Sure accurate
	                    await utils.projects.followingState.invalidate({
	                        projectHandle: project.handle,
	                    });
	                },
	                onSuccess: (result) => {
	                    if (onFollow) {
	                        onFollow(result.followingState);
	                    }
	                },
	            };
	        },
	        [onFollow, project.handle, utils.projects.followingState]
	    );

	    const followRequestMutation =
	        trpc.relationships.createFollowRequest.useMutation({
	            ...createMutationCallbacks(
	                project.privacy === exports.ProjectPrivacy.Private
	                    ? FollowingState.FollowRequested
	                    : FollowingState.Following
	            ),
	        });
	    const unfollowMutation = trpc.relationships.unfollow.useMutation({
	        ...createMutationCallbacks(FollowingState.NotFollowing),
	    });
	    const cancelFollowRequestMutation =
	        trpc.relationships.declineOrCancelFollowRequest.useMutation({
	            ...createMutationCallbacks(FollowingState.NotFollowing),
	        });

	    const { t } = useTranslation();
	    const followingState = followingStateQuery.data?.readerToProject ?? null;

	    const [isConfirmOpen, setIsConfirmOpen] = reactExports.useState(false);

	    const onClickFollow = reactExports.useCallback(async () => {
	        if (!userInfo.projectId) return;
	        const mutateArgs = {
	            fromProjectId: userInfo.projectId,
	            toProjectId: project.projectId,
	        };

	        switch (followingState) {
	            case FollowingState.FollowRequested:
	                // pending request; cancel follow request
	                await cancelFollowRequestMutation.mutateAsync(mutateArgs);
	                break;
	            case FollowingState.NotFollowing:
	                // not following; follow
	                await followRequestMutation.mutateAsync(mutateArgs);
	                break;
	            case FollowingState.Following:
	                // following; unfollow.  this causes a confirmation dialog box.
	                setIsConfirmOpen(true);
	                break;
	            case null:
	                // following state is only null when we don't know what we're
	                // doing or user is logged out. just exit out.
	                return;
	        }
	    }, [
	        cancelFollowRequestMutation,
	        followRequestMutation,
	        followingState,
	        project.projectId,
	        userInfo.projectId,
	    ]);

	    const onConfirmUnfollow = reactExports.useCallback(async () => {
	        if (!userInfo.projectId) return;
	        const mutateArgs = {
	            fromProjectId: userInfo.projectId,
	            toProjectId: project.projectId,
	        };

	        await unfollowMutation.mutateAsync(mutateArgs);
	        setIsConfirmOpen(false);
	    }, [project.projectId, userInfo.projectId, unfollowMutation]);

	    let followButtonText = "unknown";

	    if (!userInfo.loggedIn) {
	        followButtonText = t("common:login");
	    } else if (followingState === FollowingState.Following) {
	        followButtonText = t("client:page.unfollow-button", "unfollow");
	    } else if (followingState === FollowingState.NotFollowing) {
	        if (project.privacy === exports.ProjectPrivacy.Private) {
	            followButtonText = t(
	                "client:page.follow-request-button",
	                "send follow request"
	            );
	        } else {
	            followButtonText = t("client:page.follow-button", "follow");
	        }
	    } else if (followingState === FollowingState.FollowRequested) {
	        followButtonText = t(
	            "client:page.cancel-follow-request-button",
	            "cancel follow request"
	        );
	    } else {
	        return null;
	    }

	    if (!userInfo.loggedIn) {
	        return (
	            React$2.createElement(LinkButton, {
	                buttonStyle: "pill",
	                color: color,
	                href: sitemap.public.login({ originalUrl: ssrUrl }).toString(),}

	                , followButtonText
	            )
	        );
	    }

	    return (
	        React$2.createElement(React$2.Fragment, null
	            , React$2.createElement(SimpleModalDialog, {
	                isOpen: isConfirmOpen,
	                title: t(
	                    "client:unfollow-page.confirm-title",
	                    "Unfollow this page?"
	                ),
	                body: t(
	                    "client:unfollow-page.confirm-body",
	                    "Are you sure you want to unfollow this page?"
	                ),
	                confirm: { label: t("common:unfollow", "unfollow") },
	                cancel: { label: t("common:cancel", "cancel") },
	                onConfirm: onConfirmUnfollow,
	                onCancel: () => setIsConfirmOpen(false),}
	            )
	            , React$2.createElement(Button, { buttonStyle: "pill", color: color, onClick: onClickFollow,}
	                , followButtonText
	            )
	        )
	    );
	};

	function validateUrl(urlString) {
	    let urlObj;

	    try {
	        urlObj = new URL(urlString);
	    } catch (e) {
	        return { valid: false };
	    }

	    if (urlObj.protocol !== "https:" && urlObj.protocol !== "http:") {
	        return { valid: false };
	    }

	    return {
	        valid: true,
	        url: urlObj.toString(),
	    };
	}

	function displayURL$1(url) {
	    return url.toString().split("://")[1];
	}

	const ContactCardValue

	 = ({ value }) => {
	    const validationResult = validateUrl(value);

	    if (validationResult.valid) {
	        // turn it into a link
	        return (
	            React$2.createElement('a', {
	                href: value,
	                className: "text-mango",
	                rel: "me nofollow noopener"  ,
	                target: "_blank",}

	                , displayURL$1(new URL(validationResult.url))
	            )
	        );
	    } else {
	        // just spew out the text
	        return React$2.createElement('div', null, value);
	    }
	};

	const ContactInfoCard



	 = ({ project }) => {
	    const [privateInfoOpen, setPrivateInfoOpen] = reactExports.useState(false);

	    const [publicRows, privateRows] = reactExports.useMemo(
	        () =>
	            _$5.partition(
	                project.contactCard,
	                (row) => row.visibility !== "follows"
	            ),
	        [project.contactCard]
	    );

	    const privateInfoSection = reactExports.useMemo(() => {
	        if (privateRows.length > 0) {
	            if (privateInfoOpen) {
	                return (
	                    React$2.createElement(React$2.Fragment, null
	                        , React$2.createElement('button', {
	                            className: "mt-3 flex w-full flex-row text-notWhite"    ,
	                            onClick: (e) => {
	                                e.stopPropagation();
	                                setPrivateInfoOpen(false);
	                            },
	                            type: "button",}

	                            , React$2.createElement('div', { className: "flex-1 text-left font-bold"  ,}, "hide private contact info"

	                            )
	                            , React$2.createElement(ForwardRef$q, { className: "h-6",} )
	                        )

	                        , privateRows.map((row) => (
	                            React$2.createElement('div', {
	                                className: "mt-3 flex flex-col self-start"   ,
	                                key: `${row.service}-${row.value}`,}

	                                , React$2.createElement('div', { className: "font-bold",}, row.service)
	                                , React$2.createElement(ContactCardValue, { value: row.value,} )
	                            )
	                        ))

	                        , React$2.createElement('hr', { className: "mt-3 w-full border-[1px] border-mango"   ,} )
	                    )
	                );
	            } else {
	                return (
	                    React$2.createElement(React$2.Fragment, null
	                        , React$2.createElement('button', {
	                            className: "mt-3 flex w-full flex-row"   ,
	                            onClick: (e) => {
	                                e.stopPropagation();
	                                setPrivateInfoOpen(true);
	                            },
	                            type: "button",}

	                            , React$2.createElement('div', { className: "flex-1 text-left font-bold"  ,}, "show private contact info"

	                            )
	                            , React$2.createElement(ForwardRef$t, { className: "h-6",} )
	                        )

	                        , React$2.createElement('hr', { className: "mt-3 w-full border-[1px] border-mango"   ,} )
	                    )
	                );
	            }
	        } else return null; // no private rows
	    }, [privateInfoOpen, privateRows]);

	    return (
	        React$2.createElement(React$2.Fragment, null
	            , publicRows.length > 0 || privateRows.length > 0 ? (
	                React$2.createElement('hr', { className: "mt-8 w-full border-[1px] border-mango"   ,} )
	            ) : null

	            , publicRows.map((row) => (
	                React$2.createElement('div', {
	                    className: "mt-3 flex flex-col self-start"   ,
	                    key: `${row.service}-${row.value}`,}

	                    , React$2.createElement('div', { className: "font-bold",}, row.service)
	                    , React$2.createElement(ContactCardValue, { value: row.value,} )
	                )
	            ))

	            , privateInfoSection
	        )
	    );
	};

	function displayURL(url) {
	    return url.toString().split("://")[1];
	}

	 





	const ErrorBox

	 = ({ header, body, children }) => (
	    React$2.createElement('div', { className: "cohost-shadow-light mt-4 rounded-lg bg-foreground p-3"    ,}
	        , React$2.createElement('h1', { className: "text-xl font-bold" ,}, header)

	        , React$2.createElement('p', null, body)
	        , children
	    )
	);

	const ProfileView

	 = ({ project, canAccessPermissions, previewMode = false, children }) => {
	    const { t } = useTranslation();
	    const displayPrefs = useDisplayPrefs();
	    const animate = previewMode || !displayPrefs.pauseProfileGifs;
	    let postFeed;

	    const { data: isReaderMuting } = trpc.projects.isReaderMuting.useQuery(
	        {
	            projectHandle: project.handle,
	        },
	        { suspense: true }
	    );

	    const { data: isReaderBlocking } = trpc.projects.isReaderBlocking.useQuery(
	        {
	            projectHandle: project.handle,
	        },
	        { suspense: true }
	    );

	    const userInfo = useUserInfo();
	    const activeProjectId = userInfo.loggedIn ? userInfo.projectId : null;
	    const [mutedCollapsed, setMutedCollapsed] = reactExports.useState(true);
	    const shouldMuteCollapse = isReaderMuting && mutedCollapsed;
	    const [blockedCollapsed, setBlockedCollapsed] = reactExports.useState(true);
	    const shouldBlockCollapse = isReaderBlocking && blockedCollapsed;

	    // modal post composer setup
	    const currentProject = useCurrentProject();
	    const modalPostComposer = useModalPostComposer();
	    reactExports.useEffect(() => {
	        if (currentProject) {
	            modalPostComposer.setup({
	                project: currentProject,
	            });
	        }
	    }, [currentProject, modalPostComposer]);

	    const flags = reactExports.useMemo(
	        () => new Set(project.flags),
	        [project.flags]
	    );

	    const renderedDescription = reactExports.useMemo(
	        () =>
	            renderMarkdownReactNoHTML(project.description, new Date(), {
	                renderingContext: "profile",
	                hasCohostPlus: false,
	                disableEmbeds: false,
	                externalLinksInNewTab: displayPrefs.externalLinksInNewTab,
	            }),
	        [displayPrefs.externalLinksInNewTab, project.description]
	    );

	    const reportingUIContext = reactExports.useContext(ReportingUIContext);

	    const utils = trpc.useContext();

	    const silencingMutationArgs = {
	        onSettled: async () => {
	            return Promise.all([
	                utils.posts.profilePosts.invalidate(),
	                utils.projects.isReaderMuting.invalidate({
	                    projectHandle: project.handle,
	                }),
	            ]);
	        },
	    };
	    const silenceProjectMutation = trpc.relationships.mute.useMutation(
	        silencingMutationArgs
	    );
	    const unsilenceProjectMutation = trpc.relationships.unmute.useMutation(
	        silencingMutationArgs
	    );

	    const [silenceConfirmOpen, setSilenceConfirmOpen] = reactExports.useState(false);

	    const onClickSilencing = reactExports.useCallback(async () => {
	        if (!userInfo.loggedIn) {
	            throw new Error("Not logged in");
	        }

	        const mutateArgs = {
	            fromProjectId: userInfo.projectId,
	            toProjectId: project.projectId,
	        };
	        if (isReaderMuting)
	            await unsilenceProjectMutation.mutateAsync(mutateArgs);
	        else setSilenceConfirmOpen(true);
	    }, [
	        isReaderMuting,
	        project.projectId,
	        unsilenceProjectMutation,
	        userInfo.loggedIn,
	        userInfo.projectId,
	    ]);

	    const onConfirmSilencing = reactExports.useCallback(async () => {
	        if (!userInfo.loggedIn) {
	            throw new Error("Not logged in");
	        }

	        const mutateArgs = {
	            fromProjectId: userInfo.projectId,
	            toProjectId: project.projectId,
	        };

	        await silenceProjectMutation.mutateAsync(mutateArgs);
	        setSilenceConfirmOpen(false);
	    }, [
	        project.projectId,
	        silenceProjectMutation,
	        userInfo.loggedIn,
	        userInfo.projectId,
	    ]);

	    const [blockConfirmOpen, setBlockConfirmOpen] = reactExports.useState(false);

	    const blockingMutationArgs = {
	        onSettled: async () => {
	            return Promise.all([
	                utils.posts.profilePosts.invalidate(),
	                utils.projects.isReaderBlocking.invalidate({
	                    projectHandle: project.handle,
	                }),
	            ]);
	        },
	    };
	    const blockProjectMutation =
	        trpc.relationships.block.useMutation(blockingMutationArgs);
	    const unblockProjectMutation =
	        trpc.relationships.unblock.useMutation(blockingMutationArgs);

	    const onClickBlocking = reactExports.useCallback(async () => {
	        if (!userInfo.loggedIn) {
	            throw new Error("Not logged in");
	        }

	        const mutateArgs = {
	            fromProjectId: userInfo.projectId,
	            toProjectId: project.projectId,
	        };
	        if (isReaderBlocking)
	            await unblockProjectMutation.mutateAsync(mutateArgs);
	        else setBlockConfirmOpen(true);
	    }, [
	        isReaderBlocking,
	        project.projectId,
	        unblockProjectMutation,
	        userInfo.loggedIn,
	        userInfo.projectId,
	    ]);

	    const onConfirmBlocking = reactExports.useCallback(async () => {
	        if (!userInfo.loggedIn) {
	            throw new Error("Not logged in");
	        }

	        const mutateArgs = {
	            fromProjectId: userInfo.projectId,
	            toProjectId: project.projectId,
	        };

	        await blockProjectMutation.mutateAsync(mutateArgs);
	        setBlockConfirmOpen(false);
	    }, [
	        blockProjectMutation,
	        project.projectId,
	        userInfo.loggedIn,
	        userInfo.projectId,
	    ]);

	    if (canAccessPermissions.canRead === exports.AccessResult.Blocked) {
	        postFeed = (
	            React$2.createElement(ErrorBox, {
	                header: t(
	                    "server:project-page.blocked-headline",
	                    "you're blocked by this page"
	                ),
	                body: t(
	                    "server:project-page.blocked-detail-text",
	                    "they don't want you reading any of their posts"
	                ),}
	            )
	        );
	    } else if (canAccessPermissions.canRead === exports.AccessResult.LogInFirst) {
	        if (project.loggedOutPostVisibility === "none") {
	            postFeed = (
	                React$2.createElement(ErrorBox, {
	                    header: t(
	                        "server:project-page.none-logged-out-headline",
	                        "this page is not viewable by logged-out users"
	                    ),
	                    body: t(
	                        "server:project-page.none-logged-out-detail-text",
	                        "you can view it if you're logged in"
	                    ),}
	                )
	            );
	        }
	    } else if (canAccessPermissions.canRead === exports.AccessResult.NotAllowed) {
	        if (project.privacy === exports.ProjectPrivacy.Private) {
	            if (userInfo.loggedIn) {
	                postFeed = (
	                    React$2.createElement(ErrorBox, {
	                        header: t(
	                            "server:project-page.private-headline",
	                            "this page is private"
	                        ),
	                        body: t(
	                            "server:project-page.unfollowed-private-detail-text",
	                            "you can only see posts from them if you follow them"
	                        ),}
	                    )
	                );
	            } else {
	                postFeed = (
	                    React$2.createElement(ErrorBox, {
	                        header: t(
	                            "server:project-page.private-headline",
	                            "this page is private"
	                        ),
	                        body: t(
	                            "server:project-page.log-in-private-detail-text",
	                            "you might be able to see posts from them if you log in"
	                        ),}
	                    )
	                );
	            }
	        }
	    } else if (canAccessPermissions.canRead === exports.AccessResult.Allowed) {
	        // explicitly verify we can read to avoid issues if new states get added
	        if (flags.has("suspended")) {
	            postFeed = (
	                React$2.createElement('div', null
	                    , React$2.createElement(ErrorBox, {
	                        header: t(
	                            "client:project-page.user-banned-headline",
	                            "this page has been banned from cohost"
	                        ),
	                        body: t(
	                            "client:project-page.user-banned-body",
	                            "due to community guidelines violations, we have banned this page and its operator."
	                        ),}
	                    )
	                )
	            );
	        } else if (shouldMuteCollapse && shouldBlockCollapse) {
	            postFeed = (
	                React$2.createElement('div', null
	                    , React$2.createElement(ErrorBox, {
	                        header: t(
	                            "client:project-page.muted-and-blocked-headline",
	                            "this page is silenced AND blocked"
	                        ),
	                        body: t(
	                            "client:project-page.muted-and-blocked-body",
	                            "if you really want to, you can view their posts temporarily"
	                        ),}

	                        , React$2.createElement('div', { className: "mt-4 flex flex-row justify-center"   ,}
	                            , React$2.createElement(Button, {
	                                buttonStyle: "pill",
	                                color: "accent",
	                                onClick: () => {
	                                    setMutedCollapsed(false);
	                                    setBlockedCollapsed(false);
	                                },}

	                                , t(
	                                    "client:project-page.muted-temporary-view",
	                                    "view temporarily"
	                                )
	                            )
	                        )
	                    )
	                )
	            );
	        } else if (shouldMuteCollapse) {
	            postFeed = (
	                React$2.createElement('div', null
	                    , React$2.createElement(ErrorBox, {
	                        header: t(
	                            "client:project-page.muted-headline",
	                            "this page is silenced"
	                        ),
	                        body: t(
	                            "client:project-page.muted-body",
	                            "you can either unsilence them or view their posts temporarily"
	                        ),}

	                        , React$2.createElement('div', { className: "mt-4 flex flex-row justify-center"   ,}
	                            , React$2.createElement(Button, {
	                                buttonStyle: "pill",
	                                color: "accent",
	                                onClick: () => setMutedCollapsed(false),}

	                                , t(
	                                    "client:project-page.muted-temporary-view",
	                                    "view temporarily"
	                                )
	                            )
	                        )
	                    )
	                )
	            );
	        } else if (shouldBlockCollapse) {
	            postFeed = (
	                React$2.createElement('div', null
	                    , React$2.createElement(ErrorBox, {
	                        header: t(
	                            "client:project-page.reader-blocking-headline",
	                            "this page is blocked"
	                        ),
	                        body: t(
	                            "client:project-page.reader-blocking-body",
	                            "you can either unblock them or view their posts temporarily"
	                        ),}

	                        , React$2.createElement('div', { className: "mt-4 flex flex-row justify-center"   ,}
	                            , React$2.createElement(Button, {
	                                buttonStyle: "pill",
	                                color: "accent",
	                                onClick: () => setBlockedCollapsed(false),}

	                                , t(
	                                    "client:project-page.muted-temporary-view",
	                                    "view temporarily"
	                                )
	                            )
	                        )
	                    )
	                )
	            );
	        } else {
	            postFeed = React$2.createElement(reactExports.Suspense, null, children);
	        }
	    } else {
	        postFeed = (
	            React$2.createElement('div', null, "unknown permission state: "   , canAccessPermissions.canRead)
	        );
	    }
	    return (
	        React$2.createElement(React$2.Fragment, null
	            , React$2.createElement(SimpleModalDialog, {
	                isOpen: silenceConfirmOpen,
	                title: t("client:silence-page.confirm-title", {
	                    defaultValue: "Silence this page?",
	                }),
	                body: t("client:silence-page.confirm-body", {
	                    defaultValue: "Are you sure you want to silence this page?",
	                }),
	                confirm: {
	                    label: t("common:silence", "silence"),
	                },
	                cancel: {
	                    label: t("common:cancel", "cancel"),
	                },
	                onConfirm: onConfirmSilencing,
	                onCancel: () => setSilenceConfirmOpen(false),}
	            )
	            , React$2.createElement(SimpleModalDialog, {
	                isOpen: blockConfirmOpen,
	                title: t("client:block-page.confirm-title", {
	                    defaultValue: "Block this page?",
	                }),
	                body: t("client:block-page.confirm-body", {
	                    defaultValue: "Are you sure you want to block this page?",
	                }),
	                confirm: {
	                    label: t("common:block", "block"),
	                    color: "destructive",
	                },
	                cancel: {
	                    label: t("common:cancel", "cancel"),
	                },
	                onConfirm: onConfirmBlocking,
	                onCancel: () => setBlockConfirmOpen(false),}
	            )
	            , project.headerURL ? (
	                React$2.createElement('img', {
	                    src: 
	                        animate ? project.headerURL : project.headerPreviewURL
	                    ,
	                    className: "aspect-[44/9] w-full object-cover"  ,
	                    alt: "",}
	                )
	            ) : null
	            , React$2.createElement('div', { className: "grid w-full min-w-0 flex-grow grid-cols-1 gap-6 lg:grid-cols-4"      ,}
	                /* PROFILE SIDEBAR */
	                , React$2.createElement('div', { className: "relative col-span-1 flex w-full min-w-0 flex-col break-words bg-foreground p-3 pt-0 lg:items-center"          ,}
	                    , React$2.createElement('div', { className: "relative flex w-full min-w-0 flex-wrap gap-2 break-words lg:items-center lg:gap-0"        ,}
	                        , React$2.createElement('div', { className: "lg:w-full lg:flex-grow" ,}
	                            , React$2.createElement(ProjectAvatar, {
	                                noLink: true,
	                                project: project,
	                                className: `cohost-shadow-light dark:cohost-shadow-dark mx-auto h-20 w-20 lg:h-36 lg:w-36 ${
                                    project.headerURL
                                        ? "-mt-8 lg:-mt-20"
                                        : "mt-4"
                                }`,
	                                forceAnimate: previewMode,}
	                            )
	                        )
	                        , React$2.createElement('div', { className: "flex min-w-0 flex-col break-words lg:flex-grow"    ,}
	                            , React$2.createElement('div', { className: "flex flex-col gap-2 break-words lg:gap-0"    ,}
	                                , React$2.createElement('h1', { className: "min-w-0 break-words font-atkinson text-2xl font-bold text-text lg:relative lg:mt-4 lg:text-center"        ,}
	                                    , flags.has("parody") ? (
	                                        React$2.createElement('div', { className: "group  inline"  ,}
	                                            , React$2.createElement(ForwardRef$u, { className: "mr-2 inline h-6 w-6 -scale-y-100"    ,} )
	                                            , React$2.createElement('div', { className: "cohost-shadow-light prose invisible absolute left-0 top-8 z-20 w-max max-w-full rounded-lg bg-notWhite p-3 text-center text-sm font-normal text-notBlack group-hover:visible lg:bottom-8 lg:top-auto"                  ,}
	                                                , React$2.createElement('p', null, "cohost staff has verified that this account is"

	                                                       , " "
	                                                    , React$2.createElement('b', null, "not"), " an official representative of the entity in its display name."


	                                                )
	                                            )
	                                        )
	                                    ) : null

	                                    , React$2.createElement('a', {
	                                        href: sitemap.public.project
	                                            .mainAppProfile({
	                                                projectHandle: project.handle,
	                                            })
	                                            .toString(),
	                                        className: "hover:underline",}

	                                        , project.displayName
	                                    )
	                                )
	                                , React$2.createElement('h2', { className: "font-atkinson text-text lg:min-w-full lg:text-center"   ,}
	                                    , React$2.createElement('a', {
	                                        href: sitemap.public.project
	                                            .mainAppProfile({
	                                                projectHandle: project.handle,
	                                            })
	                                            .toString(),
	                                        className: "hover:underline",}
	, "@"
	                                        , project.handle
	                                    )
	                                )
	                            )
	                            , React$2.createElement('h3', { className: "font-atkinson text-text lg:text-center"  ,}
	                                , project.dek
	                            )
	                        )
	                    )
	                    , userInfo.loggedIn &&
	                    userInfo.projectId !== project.projectId ? (
	                        React$2.createElement('div', { className: "absolute right-4 top-4"  ,}
	                            , React$2.createElement(ot, { as: "div", className: "relative",}
	                                , React$2.createElement(ot.Button, { className: "absolute right-0 top-0"  ,}
	                                    , React$2.createElement(ForwardRef$n, { className: "h-6 w-6 text-text transition-transform ui-open:rotate-90"    ,} )
	                                )
	                                , React$2.createElement(ot.Items, { className: "cohost-shadow-dark absolute right-0 top-8 z-30 flex min-w-max flex-col gap-3 rounded-lg bg-notWhite p-3 text-notBlack focus:!outline-none"             ,}
	                                    , React$2.createElement(ot.Item, null
	                                        , React$2.createElement('button', {
	                                            className: "flex flex-row gap-2 hover:underline"   ,
	                                            onClick: onClickSilencing,}

	                                            , React$2.createElement(SilenceIcon, { className: "h-6",} )
	                                            , isReaderMuting
	                                                ? t(
	                                                      "client:unsilence-handle-button",
	                                                      {
	                                                          defaultValue:
	                                                              "unsilence @{{projectHandle}}",
	                                                          projectHandle:
	                                                              project.handle,
	                                                      }
	                                                  )
	                                                : t(
	                                                      "client:silence-handle-button",
	                                                      {
	                                                          defaultValue:
	                                                              "silence @{{projectHandle}}",
	                                                          projectHandle:
	                                                              project.handle,
	                                                      }
	                                                  )
	                                        )
	                                    )
	                                    , React$2.createElement(ot.Item, null
	                                        , React$2.createElement('button', {
	                                            className: "flex flex-row gap-2 hover:underline"   ,
	                                            onClick: onClickBlocking,}

	                                            , React$2.createElement(ForwardRef$16, { className: "h-6 scale-x-[-1]" ,} )
	                                            , isReaderBlocking
	                                                ? t(
	                                                      "client:unblock-handle-button",
	                                                      {
	                                                          defaultValue:
	                                                              "unblock @{{projectHandle}}",
	                                                          projectHandle:
	                                                              project.handle,
	                                                      }
	                                                  )
	                                                : t(
	                                                      "client:block-handle-button",
	                                                      {
	                                                          defaultValue:
	                                                              "block @{{projectHandle}}",
	                                                          projectHandle:
	                                                              project.handle,
	                                                      }
	                                                  )
	                                        )
	                                    )
	                                    , React$2.createElement(ot.Item, null
	                                        , React$2.createElement('button', {
	                                            className: "flex flex-row gap-2 hover:underline"   ,
	                                            onClick: (e) => {
	                                                e.preventDefault();
	                                                reportingUIContext.send({
	                                                    type: "START_REPORT",
	                                                    projectId:
	                                                        project.projectId,
	                                                });
	                                            },}

	                                            , React$2.createElement(ForwardRef$R, { className: "h-6",} )
	                                            , t("client:report-handle-button", {
	                                                defaultValue:
	                                                    "report @{{projectHandle}}",
	                                                projectHandle: project.handle,
	                                            })
	                                        )
	                                    )
	                                    , userInfo.modMode ? (
	                                        React$2.createElement(ot.Item, null
	                                            , React$2.createElement('a', {
	                                                className: "flex flex-row gap-2 hover:underline"   ,
	                                                href: sitemap.public.moderation
	                                                    .manageProject({
	                                                        projectHandle:
	                                                            project.handle,
	                                                    })
	                                                    .toString(),}

	                                                , React$2.createElement(ForwardRef$4, { className: "h-6",} ), "manage project"

	                                            )
	                                        )
	                                    ) : null
	                                )
	                            )
	                        )
	                    ) : null
	                    , project.pronouns || project.url ? (
	                        React$2.createElement('ul', { className: "break-word mb-2 mt-2 flex min-w-0 flex-col justify-around gap-4 text-sm lg:flex-row"         ,}
	                            , project.pronouns ? (
	                                React$2.createElement('li', null
	                                    , React$2.createElement(ForwardRef$c, { className: "inline-block h-4 text-accent"  ,} ), " "
	                                    , project.pronouns
	                                )
	                            ) : null
	                            , project.url ? (
	                                React$2.createElement('li', null
	                                    , React$2.createElement(ForwardRef$j, { className: "inline-block h-4 text-accent"  ,} ), " "
	                                    /* it's complaining about the possibility that href="#"; since this is in a profile preview, I'm marking this wontfix for now */
	                                    /* eslint-disable-next-line jsx-a11y/anchor-is-valid */
	                                    , React$2.createElement('a', {
	                                        href: 
	                                            previewMode
	                                                ? "#"
	                                                : new URL(
	                                                      project.url
	                                                  ).toString()
	                                        ,
	                                        rel: "me nofollow noopener"  ,
	                                        target: "_blank",
	                                        className: "break-all text-accent hover:underline"  ,}

	                                        , previewMode
	                                            ? project.url
	                                            : displayURL(new URL(project.url))
	                                    )
	                                )
	                            ) : null
	                        )
	                    ) : null
	                    , React$2.createElement('div', { className: "prose-invert prose-stone min-w-0 max-w-full overflow-hidden break-words prose-a:text-accent lg:text-center"       ,}
	                        , renderedDescription
	                    )
	                    , React$2.createElement('div', { className: "mt-4 flex flex-row items-center gap-4"    ,}
	                        , canAccessPermissions.canRead !==
	                            exports.AccessResult.Blocked &&
	                        activeProjectId !== project.projectId ? (
	                            React$2.createElement(FollowButton, { project: project, color: "accent",} )
	                        ) : null

	                        , activeProjectId === project.projectId &&
	                        !previewMode ? (
	                            React$2.createElement(React$2.Fragment, null
	                                , React$2.createElement(LinkButton, {
	                                    buttonStyle: "pill",
	                                    color: "accent",
	                                    href: sitemap.public.project
	                                        .profileEdit()
	                                        .toString(),}

	                                    , t(
	                                        "client:profile-page.edit-profile-button",
	                                        "Edit profile"
	                                    )
	                                )
	                                , React$2.createElement(LinkButton, {
	                                    buttonStyle: "pill",
	                                    color: "accent",
	                                    href: sitemap.public.project
	                                        .settings()
	                                        .toString(),}

	                                    , React$2.createElement(ForwardRef$4, { className: "h-4",} )
	                                )
	                            )
	                        ) : null
	                        , project.askSettings.enabled ? (
	                            React$2.createElement(LinkButton, {
	                                buttonStyle: "pill",
	                                color: "accent",
	                                href: sitemap.public.project
	                                    .ask({ projectHandle: project.handle })
	                                    .toString(),}
	, "ask"

	                            )
	                        ) : null
	                    )

	                    , React$2.createElement(ContactInfoCard, { project: project,} )
	                )
	                , React$2.createElement('div', { className: "order-3 col-span-1 mb-16 lg:order-none lg:col-span-2"    ,}
	                    , postFeed
	                )
	                /* frequently used tags */
	                , React$2.createElement('div', { className: "order-2 col-span-1 mt-4 w-full lg:order-none lg:mb-16"     ,}
	                    , React$2.createElement('div', { className: "flex flex-col gap-5"  ,}
	                        , project.frequentlyUsedTags.length ? (
	                            React$2.createElement('div', { className: "cohost-shadow-light dark:cohost-shadow-dark flex flex-col divide-y divide-gray-300 rounded-lg bg-white lg:max-w-sm"        ,}
	                                , React$2.createElement('div', { className: "flex flex-row items-center rounded-t-lg bg-longan p-3 uppercase text-notBlack"       ,}, "Pinned Tags"

	                                )
	                                , React$2.createElement('ul', { className: "flex flex-row flex-wrap items-center gap-x-2.5 gap-y-3 p-3"      ,}
	                                    , project.frequentlyUsedTags.map((tag) => (
	                                        React$2.createElement('li', {
	                                            key: tag,
	                                            className: "cursor-pointer select-none" ,}

	                                            , React$2.createElement('a', {
	                                                href: sitemap.public.project
	                                                    .tags({
	                                                        tagSlug: tag,
	                                                        projectHandle:
	                                                            project.handle,
	                                                    })
	                                                    .toString(),
	                                                className: "flex items-center justify-start gap-1 rounded-full bg-foreground px-2 py-1 leading-none text-text hover:bg-foreground-700"          ,}

	                                                , React$2.createElement(ForwardRef$2, { className: "inline-block h-3.5" ,} )
	                                                , React$2.createElement('span', { className: "block",}
	                                                    , tag
	                                                )
	                                            )
	                                        )
	                                    ))
	                                )
	                            )
	                        ) : null
	                        , userInfo.loggedIn &&
	                        userInfo.projectId !== project.projectId ? (
	                            React$2.createElement(UserNote, { projectId: project.projectId,} )
	                        ) : null
	                    )
	                )
	            )
	        )
	    );
	};

	/**
	 * Needed to get around helmet still not supporting react fragmets for some reason.
	 *
	 * See: https://github.com/nfl/react-helmet/issues/342#issuecomment-432537982
	 * for prior art.
	 * @param fragment a fragment containing child vnodes. any non-vnodes are in the output!
	 * @returns an array of vnodes, which helmet is fine with.
	 */
	function renderFragment(
	    { props: { children } },
	    key
	) {
	    return React$2.Children.toArray(children)
	        .filter(reactExports.isValidElement)
	        .map((child, childIndex) =>
	            reactExports.cloneElement(child, {
	                key: `${key}-${childIndex}`,
	            })
	        );
	}

	const PostOpenGraph

	 = ({ viewModel: initialViewModel }) => {
	    const viewModel = reactExports.useMemo(() => {
	        if (!initialViewModel.transparentShareOfPostId) return initialViewModel;

	        // if it's a transparent share, get the opaque post
	        return (
	            initialViewModel.shareTree.find(
	                (vm) => vm.postId === initialViewModel.transparentShareOfPostId
	                // this shouldn't happen but in the event we don't have a share
	                // tree, return the initial view model as fallback.
	            ) ?? initialViewModel
	        );
	    }, [initialViewModel]);

	    const attachmentBlocks = reactExports.useMemo(
	        () => getAttachmentViewBlocks(viewModel.blocks),
	        [viewModel.blocks]
	    );

	    const siteTitle = `${
        viewModel.postingProject.displayName
            ? viewModel.postingProject.displayName
            : `@${viewModel.postingProject.handle}`
    } on cohost`;

	    return (
	        React$2.createElement(Helmet, null
	            /* opengraph */
	            , React$2.createElement('meta', { property: "og:site_name", content: siteTitle,} )
	            , viewModel.headline ? (
	                React$2.createElement('meta', { property: "og:title", content: viewModel.headline,} )
	            ) : (
	                React$2.createElement('meta', { property: "og:title", content: siteTitle,} )
	            )
	            , React$2.createElement('meta', {
	                property: "og:description",
	                content: renderPostSummary(viewModel, {
	                    myPost: false,
	                    skipHeadline: true,
	                }),}
	            )
	            , React$2.createElement('meta', { property: "og:type", content: "article",} )
	            , React$2.createElement('meta', {
	                property: "article:published_time",
	                content: viewModel.publishedAt,}
	            )
	            , React$2.createElement('meta', {
	                property: "article:author",
	                content: sitemap.public.project
	                    .mainAppProfile({
	                        projectHandle: viewModel.postingProject.handle,
	                    })
	                    .toString(),}
	            )
	            , React$2.createElement('meta', {
	                property: "og:url",
	                // we still want to link to the initial view model's single post
	                // page in the event of a transparent share, as that's what the
	                // user would have actually pasted in.
	                content: initialViewModel.singlePostPageUrl.toString(),}
	            )
	            , React$2.createElement('link', {
	                href: initialViewModel.singlePostPageUrl.toString(),
	                rel: "alternate",
	                type: "application/activity+json",}
	            )
	            , viewModel.tags.map((tag) => (
	                React$2.createElement('meta', { property: "article:tag", content: tag, key: tag,} )
	            ))

	            /* hide image previews if the post is 18+ or has any content warnings */
	            , !viewModel.effectiveAdultContent && viewModel.cws.length === 0
	                ? attachmentBlocks.map((attachment) => {
	                      switch (attachment.attachment.kind) {
	                          case "image":
	                              return (
	                                  React$2.createElement('meta', {
	                                      key: attachment.attachment.attachmentId,
	                                      property: "og:image",
	                                      content: attachment.attachment.fileURL,}
	                                  )
	                              );
	                          case "audio":
	                              return (
	                                  React$2.createElement('meta', {
	                                      key: attachment.attachment.attachmentId,
	                                      property: "og:audio",
	                                      content: attachment.attachment.fileURL,}
	                                  )
	                              );
	                      }
	                  })
	                : null

	            /* if we don't have any attachments, render the page's avatar */
	            , !attachmentBlocks.length ? (
	                renderFragment(
	                    React$2.createElement(React$2.Fragment, null
	                        , React$2.createElement('meta', {
	                            property: "og:image",
	                            content: viewModel.postingProject.avatarURL,}
	                        )
	                        , React$2.createElement('meta', {
	                            property: "og:image:alt",
	                            content: viewModel.postingProject.handle,}
	                        )
	                        , React$2.createElement('meta', { property: "og:image:width", content: "128",} )
	                        , React$2.createElement('meta', { property: "og:image:height", content: "128",} )
	                        , React$2.createElement('meta', { property: "twitter:card", content: "summary",} )
	                    ),
	                    "avatar"
	                )
	            ) : (
	                React$2.createElement('meta', { property: "twitter:card", content: "summary_large_image",} )
	            )
	        )
	    );
	};

	const SinglePostFeed



	 = ({ handle, postId, nonce }) => {
	    const displayPrefs = useDisplayPrefs();

	    const fetchedPost = trpc.posts.singlePost.useQuery(
	        {
	            handle,
	            postId,
	            nonce,
	        },
	        {
	            suspense: true,
	        }
	    );

	    const pageTitle = reactExports.useMemo(() => {
	        if (fetchedPost.data?.post.headline) {
	            return `"${fetchedPost.data.post.headline}"`;
	        }

	        return `post from @${
            fetchedPost.data?.post.postingProject.handle ?? "unknown"
        }`;
	    }, [
	        fetchedPost.data?.post.headline,
	        fetchedPost.data?.post.postingProject.handle,
	    ]);

	    if (!fetchedPost.data) {
	        return null;
	    }

	    return (
	        React$2.createElement(React$2.Fragment, null
	            , React$2.createElement(Helmet, { title: pageTitle,} )
	            , React$2.createElement('div', { className: "mt-4 flex flex-col gap-4"   ,}
	                , React$2.createElement(PostOpenGraph, { viewModel: fetchedPost.data.post,} )
	                , React$2.createElement(PostPreview, {
	                    viewModel: fetchedPost.data.post,
	                    highlightedTags: [],
	                    condensed: true,
	                    skipCollapse: true,
	                    showThreadCollapser: false,
	                    displayPrefs: displayPrefs,
	                    commentThreads: fetchedPost.data.comments,}
	                )
	            )
	        )
	    );
	};

	const SinglePostView = ({
	    project,
	    postId,
	    nonce,
	}) => {
	    return (
	        React$2.createElement('div', { className: "container mx-auto flex flex-grow flex-col"    ,}
	            , React$2.createElement(ProfileView, {
	                project: project,
	                canAccessPermissions: {
	                    // these get overwritten by the post view model's access
	                    // flags, so don't worry if they're less restrictive than
	                    // they look like they should be
	                    canRead: exports.AccessResult.Allowed,
	                    canEdit: exports.AccessResult.NotAllowed,
	                    canShare: exports.AccessResult.Allowed,
	                    canInteract: exports.AccessResult.Allowed,
	                },}

	                , React$2.createElement(SinglePostFeed, {
	                    postId: postId,
	                    nonce: nonce,
	                    handle: project.handle,}
	                )
	            )
	        )
	    );
	};
	SinglePostView.displayName = "single-post-view";

	axios$1.defaults.withCredentials = true;
	                const AsyncPage = SinglePostView;
	                loadable$2(
	    (props) =>
	        (() => {
	if (props.page === "single-post-view") {return Promise.resolve(SinglePostView);}
	throw new Error('unknown page: ' + props.page)
	})() 

	,
	    {
	        cacheKey: (props) => props.page,
	    }
	);

	const setupApp = async () => {
	    const appEl = document.getElementById("app");
	    if (!appEl) {
	        console.info(
	            "Couldn't find app EL, probably not loaded that far yet. trying again in 20ms"
	        );
	        setTimeout(setupApp, 20);
	        return;
	    }
	    const state = loadJSONFromID(
	        ClientStateID$1.COHOST_LOADER_STATE
	    );
	    const Layout = layoutByName(
	        loadJSONFromID(ClientStateID$1.COHOST_LAYOUT)
	    );

	    const envVars = loadJSONFromID(
	        ClientStateID$1.ENV_VARS
	    );

	    env.setEnv(envVars);

	    await new Promise(function (resolve, reject) { require(['./i18n-Ddu9HOeh'], resolve, reject); }); // load after env so the version is available (needed for cache busting)

	    client.hydrateRoot(
	        appEl,
	        React$2.createElement(App, null
	            , React$2.createElement(BrowserRouter, null
	                , React$2.createElement(CohostRoutes, null
	                    , React$2.createElement(Route, {
	                        path: "*",
	                        element: 
	                            React$2.createElement(Layout, null
	                                , Object.keys(state).map((name) => (
	                                    React$2.createElement(AsyncPage, {
	                                        key: name,
	                                        page: name,
	                                        ...state[name],}
	                                    )
	                                ))
	                            )
	                        ,}
	)
	                )
	            )
	        )
	    );
	};

	void setupApp();

	const rewriteDataNode = document.getElementById('__cohost_dl_rewrite_data');
	window.cohostDL = {
	    rewriteData: rewriteDataNode ? JSON.parse(rewriteDataNode.innerHTML) : null,
	};

	exports.ArtistAlleyAdId = ArtistAlleyAdId;
	exports.AuthnButton = AuthnButton;
	exports.BasicButton = BasicButton;
	exports.Button = Button;
	exports.ControllableExpandingTextArea = ControllableExpandingTextArea;
	exports.Controller = Controller;
	exports.DateTime_1 = DateTime_1;
	exports.DropZone = DropZone;
	exports.FeatureFlag = FeatureFlag;
	exports.FilePicker = FilePicker;
	exports.FollowButton = FollowButton;
	exports.ForwardRef = ForwardRef$2;
	exports.ForwardRef$1 = ForwardRef$t;
	exports.ForwardRef$10 = ForwardRef$1;
	exports.ForwardRef$11 = ForwardRef$n;
	exports.ForwardRef$12 = ForwardRef$R;
	exports.ForwardRef$2 = ForwardRef$6;
	exports.ForwardRef$3 = ForwardRef$H;
	exports.ForwardRef$4 = ForwardRef$8;
	exports.ForwardRef$5 = ForwardRef$C;
	exports.ForwardRef$6 = ForwardRef$15;
	exports.ForwardRef$7 = ForwardRef$5;
	exports.ForwardRef$8 = ForwardRef$7;
	exports.ForwardRef$9 = ForwardRef;
	exports.Helmet = Helmet;
	exports.ISODateString = ISODateString;
	exports.InfoBox = InfoBox;
	exports.LazyDnD = LazyDnD;
	exports.MeatballMenuItem = MeatballMenuItem;
	exports.PlayPauseButton = PlayPauseButton;
	exports.ProfileView = ProfileView;
	exports.ProjectAvatar = ProjectAvatar;
	exports.ProjectId = ProjectId;
	exports.ProjectReference = ProjectReference;
	exports.React = React$2;
	exports.ReportingUIContext = ReportingUIContext;
	exports.SidebarMenu = SidebarMenu;
	exports.SimpleModalDialog = SimpleModalDialog;
	exports.TokenInput = TokenInput;
	exports.UserId = UserId;
	exports.WireProjectModel = WireProjectModel;
	exports._ = _$5;
	exports.axios = axios$1;
	exports.classNames = classNames;
	exports.commonjsGlobal = commonjsGlobal;
	exports.env = env;
	exports.fromDateTime = fromDateTime;
	exports.getDefaultExportFromCjs = getDefaultExportFromCjs;
	exports.getVanillaClient = getVanillaClient;
	exports.index_browserExports = index_browserExports;
	exports.instance = instance;
	exports.isDefined = isDefined;
	exports.isValidAttachmentContentType = isValidAttachmentContentType;
	exports.mod = mod;
	exports.n = n$9;
	exports.ot = ot;
	exports.reactExports = reactExports;
	exports.renderMarkdownReactNoHTML = renderMarkdownReactNoHTML;
	exports.setDefaults = setDefaults;
	exports.setI18n = setI18n;
	exports.sitemap = sitemap;
	exports.t = t$5;
	exports.trpc = trpc;
	exports.tw = tw;
	exports.useController = useController;
	exports.useCurrentProject = useCurrentProject;
	exports.useDisplayPrefs = useDisplayPrefs;
	exports.useDynamicTheme = useDynamicTheme;
	exports.useForm = useForm;
	exports.useHasCohostPlus = useHasCohostPlus;
	exports.useImageOptimizer = useImageOptimizer;
	exports.useMedia = useMedia;
	exports.useParams = useParams;
	exports.useProjectSearch = useProjectSearch;
	exports.useRequiresLogin = useRequiresLogin;
	exports.useSearchParams = useSearchParams;
	exports.useSiteConfig = useSiteConfig;
	exports.useTagSearch = useTagSearch;
	exports.useTranslation = useTranslation;
	exports.useUserInfo = useUserInfo;
	exports.validateUrl = validateUrl;
	exports.ve = ve$3;

}));