diff --git a/package-lock.json b/package-lock.json index 9567869..f9d2f7f 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "flowos", - "version": "2.2.0", + "version": "2.3.0", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "flowos", - "version": "2.2.0", + "version": "2.3.0", "license": "MIT", "dependencies": { "ansi-to-html": "^0.7.2", diff --git a/package.json b/package.json index eb150a6..3b89076 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "flowos", - "version": "2.2.0", + "version": "2.3.0", "description": "The most aesthetic webOS.", "main": "src/bootloader.ts", "scripts": { diff --git a/public/uv-sw.js b/public/uv-sw.js index 6b70648..3f93bda 100644 --- a/public/uv-sw.js +++ b/public/uv-sw.js @@ -1,9 +1,21 @@ -// @ts-nocheck +/*global UVServiceWorker,__uv$config*/ +/* + * Stock service worker script. + * Users can provide their own sw.js if they need to extend the functionality of the service worker. + * Ideally, this will be registered under the scope in uv.config.js so it will not need to be modified. + * However, if a user changes the location of uv.bundle.js/uv.config.js or sw.js is not relative to them, they will need to modify this script locally. + */ -importScripts('/uv/uv.sw.js'); + +importScripts(`uv.config.js`); const params = new URL(self.location.href).searchParams const serverURL = atob(params.get('url')); -const sw = new UVServiceWorker(serverURL); +self.__uv$config.bare = `${serverURL}/bare/` -self.addEventListener('fetch', event => event.respondWith(sw.fetch(event))); \ No newline at end of file +importScripts('uv.bundle.js'); +importScripts(__uv$config.sw || 'uv.sw.js'); + +const sw = new UVServiceWorker(); + +self.addEventListener('fetch', (event) => event.respondWith(sw.fetch(event))); diff --git a/public/uv.bundle.js b/public/uv.bundle.js new file mode 100644 index 0000000..0c8f47a --- /dev/null +++ b/public/uv.bundle.js @@ -0,0 +1,39014 @@ +(() => { + var __create = Object.create; + var __defProp = Object.defineProperty; + var __getOwnPropDesc = Object.getOwnPropertyDescriptor; + var __getOwnPropNames = Object.getOwnPropertyNames; + var __getProtoOf = Object.getPrototypeOf; + var __hasOwnProp = Object.prototype.hasOwnProperty; + var __commonJS = (cb, mod) => function __require() { + return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; + }; + var __export = (target, all) => { + for (var name42 in all) + __defProp(target, name42, { get: all[name42], enumerable: true }); + }; + var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; + }; + var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( + // If the importer is in node compatibility mode or this is not an ESM + // file that has been converted to a CommonJS file using a Babel- + // compatible transform (i.e. "__esModule" has not been set), then set + // "default" to the CommonJS "module.exports" for node compatibility. + isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, + mod + )); + + // node_modules/events/events.js + var require_events = __commonJS({ + "node_modules/events/events.js"(exports, module) { + "use strict"; + var R4 = typeof Reflect === "object" ? Reflect : null; + var ReflectApply = R4 && typeof R4.apply === "function" ? R4.apply : function ReflectApply2(target, receiver, args) { + return Function.prototype.apply.call(target, receiver, args); + }; + var ReflectOwnKeys; + if (R4 && typeof R4.ownKeys === "function") { + ReflectOwnKeys = R4.ownKeys; + } else if (Object.getOwnPropertySymbols) { + ReflectOwnKeys = function ReflectOwnKeys2(target) { + return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target)); + }; + } else { + ReflectOwnKeys = function ReflectOwnKeys2(target) { + return Object.getOwnPropertyNames(target); + }; + } + function ProcessEmitWarning(warning) { + if (console && console.warn) + console.warn(warning); + } + var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) { + return value !== value; + }; + function EventEmitter5() { + EventEmitter5.init.call(this); + } + module.exports = EventEmitter5; + module.exports.once = once; + EventEmitter5.EventEmitter = EventEmitter5; + EventEmitter5.prototype._events = void 0; + EventEmitter5.prototype._eventsCount = 0; + EventEmitter5.prototype._maxListeners = void 0; + var defaultMaxListeners = 10; + function checkListener(listener) { + if (typeof listener !== "function") { + throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener); + } + } + Object.defineProperty(EventEmitter5, "defaultMaxListeners", { + enumerable: true, + get: function() { + return defaultMaxListeners; + }, + set: function(arg) { + if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) { + throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + "."); + } + defaultMaxListeners = arg; + } + }); + EventEmitter5.init = function() { + if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) { + this._events = /* @__PURE__ */ Object.create(null); + this._eventsCount = 0; + } + this._maxListeners = this._maxListeners || void 0; + }; + EventEmitter5.prototype.setMaxListeners = function setMaxListeners(n) { + if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) { + throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + "."); + } + this._maxListeners = n; + return this; + }; + function _getMaxListeners(that) { + if (that._maxListeners === void 0) + return EventEmitter5.defaultMaxListeners; + return that._maxListeners; + } + EventEmitter5.prototype.getMaxListeners = function getMaxListeners() { + return _getMaxListeners(this); + }; + EventEmitter5.prototype.emit = function emit(type) { + var args = []; + for (var i = 1; i < arguments.length; i++) + args.push(arguments[i]); + var doError = type === "error"; + var events = this._events; + if (events !== void 0) + doError = doError && events.error === void 0; + else if (!doError) + return false; + if (doError) { + var er; + if (args.length > 0) + er = args[0]; + if (er instanceof Error) { + throw er; + } + var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : "")); + err.context = er; + throw err; + } + var handler = events[type]; + if (handler === void 0) + return false; + if (typeof handler === "function") { + ReflectApply(handler, this, args); + } else { + var len = handler.length; + var listeners = arrayClone(handler, len); + for (var i = 0; i < len; ++i) + ReflectApply(listeners[i], this, args); + } + return true; + }; + function _addListener(target, type, listener, prepend) { + var m; + var events; + var existing; + checkListener(listener); + events = target._events; + if (events === void 0) { + events = target._events = /* @__PURE__ */ Object.create(null); + target._eventsCount = 0; + } else { + if (events.newListener !== void 0) { + target.emit( + "newListener", + type, + listener.listener ? listener.listener : listener + ); + events = target._events; + } + existing = events[type]; + } + if (existing === void 0) { + existing = events[type] = listener; + ++target._eventsCount; + } else { + if (typeof existing === "function") { + existing = events[type] = prepend ? [listener, existing] : [existing, listener]; + } else if (prepend) { + existing.unshift(listener); + } else { + existing.push(listener); + } + m = _getMaxListeners(target); + if (m > 0 && existing.length > m && !existing.warned) { + existing.warned = true; + var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit"); + w.name = "MaxListenersExceededWarning"; + w.emitter = target; + w.type = type; + w.count = existing.length; + ProcessEmitWarning(w); + } + } + return target; + } + EventEmitter5.prototype.addListener = function addListener(type, listener) { + return _addListener(this, type, listener, false); + }; + EventEmitter5.prototype.on = EventEmitter5.prototype.addListener; + EventEmitter5.prototype.prependListener = function prependListener(type, listener) { + return _addListener(this, type, listener, true); + }; + function onceWrapper() { + if (!this.fired) { + this.target.removeListener(this.type, this.wrapFn); + this.fired = true; + if (arguments.length === 0) + return this.listener.call(this.target); + return this.listener.apply(this.target, arguments); + } + } + function _onceWrap(target, type, listener) { + var state = { fired: false, wrapFn: void 0, target, type, listener }; + var wrapped = onceWrapper.bind(state); + wrapped.listener = listener; + state.wrapFn = wrapped; + return wrapped; + } + EventEmitter5.prototype.once = function once2(type, listener) { + checkListener(listener); + this.on(type, _onceWrap(this, type, listener)); + return this; + }; + EventEmitter5.prototype.prependOnceListener = function prependOnceListener(type, listener) { + checkListener(listener); + this.prependListener(type, _onceWrap(this, type, listener)); + return this; + }; + EventEmitter5.prototype.removeListener = function removeListener(type, listener) { + var list, events, position, i, originalListener; + checkListener(listener); + events = this._events; + if (events === void 0) + return this; + list = events[type]; + if (list === void 0) + return this; + if (list === listener || list.listener === listener) { + if (--this._eventsCount === 0) + this._events = /* @__PURE__ */ Object.create(null); + else { + delete events[type]; + if (events.removeListener) + this.emit("removeListener", type, list.listener || listener); + } + } else if (typeof list !== "function") { + position = -1; + for (i = list.length - 1; i >= 0; i--) { + if (list[i] === listener || list[i].listener === listener) { + originalListener = list[i].listener; + position = i; + break; + } + } + if (position < 0) + return this; + if (position === 0) + list.shift(); + else { + spliceOne(list, position); + } + if (list.length === 1) + events[type] = list[0]; + if (events.removeListener !== void 0) + this.emit("removeListener", type, originalListener || listener); + } + return this; + }; + EventEmitter5.prototype.off = EventEmitter5.prototype.removeListener; + EventEmitter5.prototype.removeAllListeners = function removeAllListeners(type) { + var listeners, events, i; + events = this._events; + if (events === void 0) + return this; + if (events.removeListener === void 0) { + if (arguments.length === 0) { + this._events = /* @__PURE__ */ Object.create(null); + this._eventsCount = 0; + } else if (events[type] !== void 0) { + if (--this._eventsCount === 0) + this._events = /* @__PURE__ */ Object.create(null); + else + delete events[type]; + } + return this; + } + if (arguments.length === 0) { + var keys = Object.keys(events); + var key; + for (i = 0; i < keys.length; ++i) { + key = keys[i]; + if (key === "removeListener") + continue; + this.removeAllListeners(key); + } + this.removeAllListeners("removeListener"); + this._events = /* @__PURE__ */ Object.create(null); + this._eventsCount = 0; + return this; + } + listeners = events[type]; + if (typeof listeners === "function") { + this.removeListener(type, listeners); + } else if (listeners !== void 0) { + for (i = listeners.length - 1; i >= 0; i--) { + this.removeListener(type, listeners[i]); + } + } + return this; + }; + function _listeners(target, type, unwrap3) { + var events = target._events; + if (events === void 0) + return []; + var evlistener = events[type]; + if (evlistener === void 0) + return []; + if (typeof evlistener === "function") + return unwrap3 ? [evlistener.listener || evlistener] : [evlistener]; + return unwrap3 ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length); + } + EventEmitter5.prototype.listeners = function listeners(type) { + return _listeners(this, type, true); + }; + EventEmitter5.prototype.rawListeners = function rawListeners(type) { + return _listeners(this, type, false); + }; + EventEmitter5.listenerCount = function(emitter, type) { + if (typeof emitter.listenerCount === "function") { + return emitter.listenerCount(type); + } else { + return listenerCount.call(emitter, type); + } + }; + EventEmitter5.prototype.listenerCount = listenerCount; + function listenerCount(type) { + var events = this._events; + if (events !== void 0) { + var evlistener = events[type]; + if (typeof evlistener === "function") { + return 1; + } else if (evlistener !== void 0) { + return evlistener.length; + } + } + return 0; + } + EventEmitter5.prototype.eventNames = function eventNames() { + return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : []; + }; + function arrayClone(arr, n) { + var copy = new Array(n); + for (var i = 0; i < n; ++i) + copy[i] = arr[i]; + return copy; + } + function spliceOne(list, index) { + for (; index + 1 < list.length; index++) + list[index] = list[index + 1]; + list.pop(); + } + function unwrapListeners(arr) { + var ret = new Array(arr.length); + for (var i = 0; i < ret.length; ++i) { + ret[i] = arr[i].listener || arr[i]; + } + return ret; + } + function once(emitter, name42) { + return new Promise(function(resolve, reject) { + function errorListener(err) { + emitter.removeListener(name42, resolver); + reject(err); + } + function resolver() { + if (typeof emitter.removeListener === "function") { + emitter.removeListener("error", errorListener); + } + resolve([].slice.call(arguments)); + } + ; + eventTargetAgnosticAddListener(emitter, name42, resolver, { once: true }); + if (name42 !== "error") { + addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true }); + } + }); + } + function addErrorHandlerIfEventEmitter(emitter, handler, flags) { + if (typeof emitter.on === "function") { + eventTargetAgnosticAddListener(emitter, "error", handler, flags); + } + } + function eventTargetAgnosticAddListener(emitter, name42, listener, flags) { + if (typeof emitter.on === "function") { + if (flags.once) { + emitter.once(name42, listener); + } else { + emitter.on(name42, listener); + } + } else if (typeof emitter.addEventListener === "function") { + emitter.addEventListener(name42, function wrapListener(arg) { + if (flags.once) { + emitter.removeEventListener(name42, wrapListener); + } + listener(arg); + }); + } else { + throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter); + } + } + } + }); + + // node_modules/source-map-js/lib/base64.js + var require_base64 = __commonJS({ + "node_modules/source-map-js/lib/base64.js"(exports) { + var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split(""); + exports.encode = function(number2) { + if (0 <= number2 && number2 < intToCharMap.length) { + return intToCharMap[number2]; + } + throw new TypeError("Must be between 0 and 63: " + number2); + }; + exports.decode = function(charCode) { + var bigA = 65; + var bigZ = 90; + var littleA = 97; + var littleZ = 122; + var zero2 = 48; + var nine = 57; + var plus = 43; + var slash = 47; + var littleOffset = 26; + var numberOffset = 52; + if (bigA <= charCode && charCode <= bigZ) { + return charCode - bigA; + } + if (littleA <= charCode && charCode <= littleZ) { + return charCode - littleA + littleOffset; + } + if (zero2 <= charCode && charCode <= nine) { + return charCode - zero2 + numberOffset; + } + if (charCode == plus) { + return 62; + } + if (charCode == slash) { + return 63; + } + return -1; + }; + } + }); + + // node_modules/source-map-js/lib/base64-vlq.js + var require_base64_vlq = __commonJS({ + "node_modules/source-map-js/lib/base64-vlq.js"(exports) { + var base642 = require_base64(); + var VLQ_BASE_SHIFT = 5; + var VLQ_BASE = 1 << VLQ_BASE_SHIFT; + var VLQ_BASE_MASK = VLQ_BASE - 1; + var VLQ_CONTINUATION_BIT = VLQ_BASE; + function toVLQSigned(aValue) { + return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0; + } + function fromVLQSigned(aValue) { + var isNegative = (aValue & 1) === 1; + var shifted = aValue >> 1; + return isNegative ? -shifted : shifted; + } + exports.encode = function base64VLQ_encode(aValue) { + var encoded = ""; + var digit; + var vlq = toVLQSigned(aValue); + do { + digit = vlq & VLQ_BASE_MASK; + vlq >>>= VLQ_BASE_SHIFT; + if (vlq > 0) { + digit |= VLQ_CONTINUATION_BIT; + } + encoded += base642.encode(digit); + } while (vlq > 0); + return encoded; + }; + exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) { + var strLen = aStr.length; + var result = 0; + var shift = 0; + var continuation, digit; + do { + if (aIndex >= strLen) { + throw new Error("Expected more digits in base 64 VLQ value."); + } + digit = base642.decode(aStr.charCodeAt(aIndex++)); + if (digit === -1) { + throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1)); + } + continuation = !!(digit & VLQ_CONTINUATION_BIT); + digit &= VLQ_BASE_MASK; + result = result + (digit << shift); + shift += VLQ_BASE_SHIFT; + } while (continuation); + aOutParam.value = fromVLQSigned(result); + aOutParam.rest = aIndex; + }; + } + }); + + // node_modules/source-map-js/lib/util.js + var require_util = __commonJS({ + "node_modules/source-map-js/lib/util.js"(exports) { + function getArg(aArgs, aName, aDefaultValue) { + if (aName in aArgs) { + return aArgs[aName]; + } else if (arguments.length === 3) { + return aDefaultValue; + } else { + throw new Error('"' + aName + '" is a required argument.'); + } + } + exports.getArg = getArg; + var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/; + var dataUrlRegexp = /^data:.+\,.+$/; + function urlParse(aUrl) { + var match = aUrl.match(urlRegexp); + if (!match) { + return null; + } + return { + scheme: match[1], + auth: match[2], + host: match[3], + port: match[4], + path: match[5] + }; + } + exports.urlParse = urlParse; + function urlGenerate(aParsedUrl) { + var url2 = ""; + if (aParsedUrl.scheme) { + url2 += aParsedUrl.scheme + ":"; + } + url2 += "//"; + if (aParsedUrl.auth) { + url2 += aParsedUrl.auth + "@"; + } + if (aParsedUrl.host) { + url2 += aParsedUrl.host; + } + if (aParsedUrl.port) { + url2 += ":" + aParsedUrl.port; + } + if (aParsedUrl.path) { + url2 += aParsedUrl.path; + } + return url2; + } + exports.urlGenerate = urlGenerate; + var MAX_CACHED_INPUTS = 32; + function lruMemoize(f) { + var cache = []; + return function(input) { + for (var i = 0; i < cache.length; i++) { + if (cache[i].input === input) { + var temp = cache[0]; + cache[0] = cache[i]; + cache[i] = temp; + return cache[0].result; + } + } + var result = f(input); + cache.unshift({ + input, + result + }); + if (cache.length > MAX_CACHED_INPUTS) { + cache.pop(); + } + return result; + }; + } + var normalize = lruMemoize(function normalize2(aPath) { + var path = aPath; + var url2 = urlParse(aPath); + if (url2) { + if (!url2.path) { + return aPath; + } + path = url2.path; + } + var isAbsolute = exports.isAbsolute(path); + var parts = []; + var start = 0; + var i = 0; + while (true) { + start = i; + i = path.indexOf("/", start); + if (i === -1) { + parts.push(path.slice(start)); + break; + } else { + parts.push(path.slice(start, i)); + while (i < path.length && path[i] === "/") { + i++; + } + } + } + for (var part, up = 0, i = parts.length - 1; i >= 0; i--) { + part = parts[i]; + if (part === ".") { + parts.splice(i, 1); + } else if (part === "..") { + up++; + } else if (up > 0) { + if (part === "") { + parts.splice(i + 1, up); + up = 0; + } else { + parts.splice(i, 2); + up--; + } + } + } + path = parts.join("/"); + if (path === "") { + path = isAbsolute ? "/" : "."; + } + if (url2) { + url2.path = path; + return urlGenerate(url2); + } + return path; + }); + exports.normalize = normalize; + function join(aRoot, aPath) { + if (aRoot === "") { + aRoot = "."; + } + if (aPath === "") { + aPath = "."; + } + var aPathUrl = urlParse(aPath); + var aRootUrl = urlParse(aRoot); + if (aRootUrl) { + aRoot = aRootUrl.path || "/"; + } + if (aPathUrl && !aPathUrl.scheme) { + if (aRootUrl) { + aPathUrl.scheme = aRootUrl.scheme; + } + return urlGenerate(aPathUrl); + } + if (aPathUrl || aPath.match(dataUrlRegexp)) { + return aPath; + } + if (aRootUrl && !aRootUrl.host && !aRootUrl.path) { + aRootUrl.host = aPath; + return urlGenerate(aRootUrl); + } + var joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath); + if (aRootUrl) { + aRootUrl.path = joined; + return urlGenerate(aRootUrl); + } + return joined; + } + exports.join = join; + exports.isAbsolute = function(aPath) { + return aPath.charAt(0) === "/" || urlRegexp.test(aPath); + }; + function relative(aRoot, aPath) { + if (aRoot === "") { + aRoot = "."; + } + aRoot = aRoot.replace(/\/$/, ""); + var level = 0; + while (aPath.indexOf(aRoot + "/") !== 0) { + var index = aRoot.lastIndexOf("/"); + if (index < 0) { + return aPath; + } + aRoot = aRoot.slice(0, index); + if (aRoot.match(/^([^\/]+:\/)?\/*$/)) { + return aPath; + } + ++level; + } + return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1); + } + exports.relative = relative; + var supportsNullProto = function() { + var obj = /* @__PURE__ */ Object.create(null); + return !("__proto__" in obj); + }(); + function identity(s) { + return s; + } + function toSetString(aStr) { + if (isProtoString(aStr)) { + return "$" + aStr; + } + return aStr; + } + exports.toSetString = supportsNullProto ? identity : toSetString; + function fromSetString(aStr) { + if (isProtoString(aStr)) { + return aStr.slice(1); + } + return aStr; + } + exports.fromSetString = supportsNullProto ? identity : fromSetString; + function isProtoString(s) { + if (!s) { + return false; + } + var length2 = s.length; + if (length2 < 9) { + return false; + } + if (s.charCodeAt(length2 - 1) !== 95 || s.charCodeAt(length2 - 2) !== 95 || s.charCodeAt(length2 - 3) !== 111 || s.charCodeAt(length2 - 4) !== 116 || s.charCodeAt(length2 - 5) !== 111 || s.charCodeAt(length2 - 6) !== 114 || s.charCodeAt(length2 - 7) !== 112 || s.charCodeAt(length2 - 8) !== 95 || s.charCodeAt(length2 - 9) !== 95) { + return false; + } + for (var i = length2 - 10; i >= 0; i--) { + if (s.charCodeAt(i) !== 36) { + return false; + } + } + return true; + } + function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) { + var cmp = strcmp(mappingA.source, mappingB.source); + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.originalLine - mappingB.originalLine; + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.originalColumn - mappingB.originalColumn; + if (cmp !== 0 || onlyCompareOriginal) { + return cmp; + } + cmp = mappingA.generatedColumn - mappingB.generatedColumn; + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.generatedLine - mappingB.generatedLine; + if (cmp !== 0) { + return cmp; + } + return strcmp(mappingA.name, mappingB.name); + } + exports.compareByOriginalPositions = compareByOriginalPositions; + function compareByOriginalPositionsNoSource(mappingA, mappingB, onlyCompareOriginal) { + var cmp; + cmp = mappingA.originalLine - mappingB.originalLine; + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.originalColumn - mappingB.originalColumn; + if (cmp !== 0 || onlyCompareOriginal) { + return cmp; + } + cmp = mappingA.generatedColumn - mappingB.generatedColumn; + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.generatedLine - mappingB.generatedLine; + if (cmp !== 0) { + return cmp; + } + return strcmp(mappingA.name, mappingB.name); + } + exports.compareByOriginalPositionsNoSource = compareByOriginalPositionsNoSource; + function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) { + var cmp = mappingA.generatedLine - mappingB.generatedLine; + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.generatedColumn - mappingB.generatedColumn; + if (cmp !== 0 || onlyCompareGenerated) { + return cmp; + } + cmp = strcmp(mappingA.source, mappingB.source); + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.originalLine - mappingB.originalLine; + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.originalColumn - mappingB.originalColumn; + if (cmp !== 0) { + return cmp; + } + return strcmp(mappingA.name, mappingB.name); + } + exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated; + function compareByGeneratedPositionsDeflatedNoLine(mappingA, mappingB, onlyCompareGenerated) { + var cmp = mappingA.generatedColumn - mappingB.generatedColumn; + if (cmp !== 0 || onlyCompareGenerated) { + return cmp; + } + cmp = strcmp(mappingA.source, mappingB.source); + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.originalLine - mappingB.originalLine; + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.originalColumn - mappingB.originalColumn; + if (cmp !== 0) { + return cmp; + } + return strcmp(mappingA.name, mappingB.name); + } + exports.compareByGeneratedPositionsDeflatedNoLine = compareByGeneratedPositionsDeflatedNoLine; + function strcmp(aStr1, aStr2) { + if (aStr1 === aStr2) { + return 0; + } + if (aStr1 === null) { + return 1; + } + if (aStr2 === null) { + return -1; + } + if (aStr1 > aStr2) { + return 1; + } + return -1; + } + function compareByGeneratedPositionsInflated(mappingA, mappingB) { + var cmp = mappingA.generatedLine - mappingB.generatedLine; + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.generatedColumn - mappingB.generatedColumn; + if (cmp !== 0) { + return cmp; + } + cmp = strcmp(mappingA.source, mappingB.source); + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.originalLine - mappingB.originalLine; + if (cmp !== 0) { + return cmp; + } + cmp = mappingA.originalColumn - mappingB.originalColumn; + if (cmp !== 0) { + return cmp; + } + return strcmp(mappingA.name, mappingB.name); + } + exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated; + function parseSourceMapInput(str) { + return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, "")); + } + exports.parseSourceMapInput = parseSourceMapInput; + function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) { + sourceURL = sourceURL || ""; + if (sourceRoot) { + if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") { + sourceRoot += "/"; + } + sourceURL = sourceRoot + sourceURL; + } + if (sourceMapURL) { + var parsed = urlParse(sourceMapURL); + if (!parsed) { + throw new Error("sourceMapURL could not be parsed"); + } + if (parsed.path) { + var index = parsed.path.lastIndexOf("/"); + if (index >= 0) { + parsed.path = parsed.path.substring(0, index + 1); + } + } + sourceURL = join(urlGenerate(parsed), sourceURL); + } + return normalize(sourceURL); + } + exports.computeSourceURL = computeSourceURL; + } + }); + + // node_modules/source-map-js/lib/array-set.js + var require_array_set = __commonJS({ + "node_modules/source-map-js/lib/array-set.js"(exports) { + var util = require_util(); + var has = Object.prototype.hasOwnProperty; + var hasNativeMap = typeof Map !== "undefined"; + function ArraySet() { + this._array = []; + this._set = hasNativeMap ? /* @__PURE__ */ new Map() : /* @__PURE__ */ Object.create(null); + } + ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) { + var set = new ArraySet(); + for (var i = 0, len = aArray.length; i < len; i++) { + set.add(aArray[i], aAllowDuplicates); + } + return set; + }; + ArraySet.prototype.size = function ArraySet_size() { + return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length; + }; + ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) { + var sStr = hasNativeMap ? aStr : util.toSetString(aStr); + var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr); + var idx = this._array.length; + if (!isDuplicate || aAllowDuplicates) { + this._array.push(aStr); + } + if (!isDuplicate) { + if (hasNativeMap) { + this._set.set(aStr, idx); + } else { + this._set[sStr] = idx; + } + } + }; + ArraySet.prototype.has = function ArraySet_has(aStr) { + if (hasNativeMap) { + return this._set.has(aStr); + } else { + var sStr = util.toSetString(aStr); + return has.call(this._set, sStr); + } + }; + ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) { + if (hasNativeMap) { + var idx = this._set.get(aStr); + if (idx >= 0) { + return idx; + } + } else { + var sStr = util.toSetString(aStr); + if (has.call(this._set, sStr)) { + return this._set[sStr]; + } + } + throw new Error('"' + aStr + '" is not in the set.'); + }; + ArraySet.prototype.at = function ArraySet_at(aIdx) { + if (aIdx >= 0 && aIdx < this._array.length) { + return this._array[aIdx]; + } + throw new Error("No element indexed by " + aIdx); + }; + ArraySet.prototype.toArray = function ArraySet_toArray() { + return this._array.slice(); + }; + exports.ArraySet = ArraySet; + } + }); + + // node_modules/source-map-js/lib/mapping-list.js + var require_mapping_list = __commonJS({ + "node_modules/source-map-js/lib/mapping-list.js"(exports) { + var util = require_util(); + function generatedPositionAfter(mappingA, mappingB) { + var lineA = mappingA.generatedLine; + var lineB = mappingB.generatedLine; + var columnA = mappingA.generatedColumn; + var columnB = mappingB.generatedColumn; + return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0; + } + function MappingList() { + this._array = []; + this._sorted = true; + this._last = { generatedLine: -1, generatedColumn: 0 }; + } + MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) { + this._array.forEach(aCallback, aThisArg); + }; + MappingList.prototype.add = function MappingList_add(aMapping) { + if (generatedPositionAfter(this._last, aMapping)) { + this._last = aMapping; + this._array.push(aMapping); + } else { + this._sorted = false; + this._array.push(aMapping); + } + }; + MappingList.prototype.toArray = function MappingList_toArray() { + if (!this._sorted) { + this._array.sort(util.compareByGeneratedPositionsInflated); + this._sorted = true; + } + return this._array; + }; + exports.MappingList = MappingList; + } + }); + + // node_modules/source-map-js/lib/source-map-generator.js + var require_source_map_generator = __commonJS({ + "node_modules/source-map-js/lib/source-map-generator.js"(exports) { + var base64VLQ = require_base64_vlq(); + var util = require_util(); + var ArraySet = require_array_set().ArraySet; + var MappingList = require_mapping_list().MappingList; + function SourceMapGenerator2(aArgs) { + if (!aArgs) { + aArgs = {}; + } + this._file = util.getArg(aArgs, "file", null); + this._sourceRoot = util.getArg(aArgs, "sourceRoot", null); + this._skipValidation = util.getArg(aArgs, "skipValidation", false); + this._sources = new ArraySet(); + this._names = new ArraySet(); + this._mappings = new MappingList(); + this._sourcesContents = null; + } + SourceMapGenerator2.prototype._version = 3; + SourceMapGenerator2.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) { + var sourceRoot = aSourceMapConsumer.sourceRoot; + var generator = new SourceMapGenerator2({ + file: aSourceMapConsumer.file, + sourceRoot + }); + aSourceMapConsumer.eachMapping(function(mapping) { + var newMapping = { + generated: { + line: mapping.generatedLine, + column: mapping.generatedColumn + } + }; + if (mapping.source != null) { + newMapping.source = mapping.source; + if (sourceRoot != null) { + newMapping.source = util.relative(sourceRoot, newMapping.source); + } + newMapping.original = { + line: mapping.originalLine, + column: mapping.originalColumn + }; + if (mapping.name != null) { + newMapping.name = mapping.name; + } + } + generator.addMapping(newMapping); + }); + aSourceMapConsumer.sources.forEach(function(sourceFile) { + var sourceRelative = sourceFile; + if (sourceRoot !== null) { + sourceRelative = util.relative(sourceRoot, sourceFile); + } + if (!generator._sources.has(sourceRelative)) { + generator._sources.add(sourceRelative); + } + var content = aSourceMapConsumer.sourceContentFor(sourceFile); + if (content != null) { + generator.setSourceContent(sourceFile, content); + } + }); + return generator; + }; + SourceMapGenerator2.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) { + var generated = util.getArg(aArgs, "generated"); + var original = util.getArg(aArgs, "original", null); + var source = util.getArg(aArgs, "source", null); + var name42 = util.getArg(aArgs, "name", null); + if (!this._skipValidation) { + this._validateMapping(generated, original, source, name42); + } + if (source != null) { + source = String(source); + if (!this._sources.has(source)) { + this._sources.add(source); + } + } + if (name42 != null) { + name42 = String(name42); + if (!this._names.has(name42)) { + this._names.add(name42); + } + } + this._mappings.add({ + generatedLine: generated.line, + generatedColumn: generated.column, + originalLine: original != null && original.line, + originalColumn: original != null && original.column, + source, + name: name42 + }); + }; + SourceMapGenerator2.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) { + var source = aSourceFile; + if (this._sourceRoot != null) { + source = util.relative(this._sourceRoot, source); + } + if (aSourceContent != null) { + if (!this._sourcesContents) { + this._sourcesContents = /* @__PURE__ */ Object.create(null); + } + this._sourcesContents[util.toSetString(source)] = aSourceContent; + } else if (this._sourcesContents) { + delete this._sourcesContents[util.toSetString(source)]; + if (Object.keys(this._sourcesContents).length === 0) { + this._sourcesContents = null; + } + } + }; + SourceMapGenerator2.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) { + var sourceFile = aSourceFile; + if (aSourceFile == null) { + if (aSourceMapConsumer.file == null) { + throw new Error( + `SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map's "file" property. Both were omitted.` + ); + } + sourceFile = aSourceMapConsumer.file; + } + var sourceRoot = this._sourceRoot; + if (sourceRoot != null) { + sourceFile = util.relative(sourceRoot, sourceFile); + } + var newSources = new ArraySet(); + var newNames = new ArraySet(); + this._mappings.unsortedForEach(function(mapping) { + if (mapping.source === sourceFile && mapping.originalLine != null) { + var original = aSourceMapConsumer.originalPositionFor({ + line: mapping.originalLine, + column: mapping.originalColumn + }); + if (original.source != null) { + mapping.source = original.source; + if (aSourceMapPath != null) { + mapping.source = util.join(aSourceMapPath, mapping.source); + } + if (sourceRoot != null) { + mapping.source = util.relative(sourceRoot, mapping.source); + } + mapping.originalLine = original.line; + mapping.originalColumn = original.column; + if (original.name != null) { + mapping.name = original.name; + } + } + } + var source = mapping.source; + if (source != null && !newSources.has(source)) { + newSources.add(source); + } + var name42 = mapping.name; + if (name42 != null && !newNames.has(name42)) { + newNames.add(name42); + } + }, this); + this._sources = newSources; + this._names = newNames; + aSourceMapConsumer.sources.forEach(function(sourceFile2) { + var content = aSourceMapConsumer.sourceContentFor(sourceFile2); + if (content != null) { + if (aSourceMapPath != null) { + sourceFile2 = util.join(aSourceMapPath, sourceFile2); + } + if (sourceRoot != null) { + sourceFile2 = util.relative(sourceRoot, sourceFile2); + } + this.setSourceContent(sourceFile2, content); + } + }, this); + }; + SourceMapGenerator2.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) { + if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") { + throw new Error( + "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 (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) { + return; + } else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) { + return; + } else { + throw new Error("Invalid mapping: " + JSON.stringify({ + generated: aGenerated, + source: aSource, + original: aOriginal, + name: aName + })); + } + }; + SourceMapGenerator2.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() { + var previousGeneratedColumn = 0; + var previousGeneratedLine = 1; + var previousOriginalColumn = 0; + var previousOriginalLine = 0; + var previousName = 0; + var previousSource = 0; + var result = ""; + var next; + var mapping; + var nameIdx; + var sourceIdx; + var mappings = this._mappings.toArray(); + for (var i = 0, len = mappings.length; i < len; i++) { + mapping = mappings[i]; + next = ""; + if (mapping.generatedLine !== previousGeneratedLine) { + previousGeneratedColumn = 0; + while (mapping.generatedLine !== previousGeneratedLine) { + next += ";"; + previousGeneratedLine++; + } + } else { + if (i > 0) { + if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) { + continue; + } + next += ","; + } + } + next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn); + previousGeneratedColumn = mapping.generatedColumn; + if (mapping.source != null) { + sourceIdx = this._sources.indexOf(mapping.source); + next += base64VLQ.encode(sourceIdx - previousSource); + previousSource = sourceIdx; + next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine); + previousOriginalLine = mapping.originalLine - 1; + next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn); + previousOriginalColumn = mapping.originalColumn; + if (mapping.name != null) { + nameIdx = this._names.indexOf(mapping.name); + next += base64VLQ.encode(nameIdx - previousName); + previousName = nameIdx; + } + } + result += next; + } + return result; + }; + SourceMapGenerator2.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) { + return aSources.map(function(source) { + if (!this._sourcesContents) { + return null; + } + if (aSourceRoot != null) { + source = util.relative(aSourceRoot, source); + } + var key = util.toSetString(source); + return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null; + }, this); + }; + SourceMapGenerator2.prototype.toJSON = function SourceMapGenerator_toJSON() { + var map = { + version: this._version, + sources: this._sources.toArray(), + names: this._names.toArray(), + mappings: this._serializeMappings() + }; + if (this._file != null) { + map.file = this._file; + } + if (this._sourceRoot != null) { + map.sourceRoot = this._sourceRoot; + } + if (this._sourcesContents) { + map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot); + } + return map; + }; + SourceMapGenerator2.prototype.toString = function SourceMapGenerator_toString() { + return JSON.stringify(this.toJSON()); + }; + exports.SourceMapGenerator = SourceMapGenerator2; + } + }); + + // node_modules/esotope-hammerhead/esotope.js + var require_esotope = __commonJS({ + "node_modules/esotope-hammerhead/esotope.js"(exports) { + "use strict"; + var isArray; + var json; + var renumber; + var hexadecimal; + var quotes; + var escapeless; + var parentheses2; + var semicolons; + var safeConcatenation; + var directive; + var extra; + var parse45; + var Syntax2 = { + AssignmentExpression: "AssignmentExpression", + AssignmentPattern: "AssignmentPattern", + ArrayExpression: "ArrayExpression", + ArrayPattern: "ArrayPattern", + ArrowFunctionExpression: "ArrowFunctionExpression", + AwaitExpression: "AwaitExpression", + BlockStatement: "BlockStatement", + BinaryExpression: "BinaryExpression", + BreakStatement: "BreakStatement", + CallExpression: "CallExpression", + CatchClause: "CatchClause", + ClassBody: "ClassBody", + ClassDeclaration: "ClassDeclaration", + ClassExpression: "ClassExpression", + ComprehensionBlock: "ComprehensionBlock", + ComprehensionExpression: "ComprehensionExpression", + ConditionalExpression: "ConditionalExpression", + ContinueStatement: "ContinueStatement", + DirectiveStatement: "DirectiveStatement", + DoWhileStatement: "DoWhileStatement", + DebuggerStatement: "DebuggerStatement", + EmptyStatement: "EmptyStatement", + ExportAllDeclaration: "ExportAllDeclaration", + ExportBatchSpecifier: "ExportBatchSpecifier", + ExportDeclaration: "ExportDeclaration", + ExportNamedDeclaration: "ExportNamedDeclaration", + ExportSpecifier: "ExportSpecifier", + ExpressionStatement: "ExpressionStatement", + ForStatement: "ForStatement", + ForInStatement: "ForInStatement", + ForOfStatement: "ForOfStatement", + FunctionDeclaration: "FunctionDeclaration", + FunctionExpression: "FunctionExpression", + GeneratorExpression: "GeneratorExpression", + Identifier: "Identifier", + IfStatement: "IfStatement", + ImportExpression: "ImportExpression", + ImportSpecifier: "ImportSpecifier", + ImportDeclaration: "ImportDeclaration", + ChainExpression: "ChainExpression", + Literal: "Literal", + LabeledStatement: "LabeledStatement", + LogicalExpression: "LogicalExpression", + MemberExpression: "MemberExpression", + MetaProperty: "MetaProperty", + MethodDefinition: "MethodDefinition", + ModuleDeclaration: "ModuleDeclaration", + NewExpression: "NewExpression", + ObjectExpression: "ObjectExpression", + ObjectPattern: "ObjectPattern", + PrivateIdentifier: "PrivateIdentifier", + Program: "Program", + Property: "Property", + PropertyDefinition: "PropertyDefinition", + RestElement: "RestElement", + ReturnStatement: "ReturnStatement", + SequenceExpression: "SequenceExpression", + SpreadElement: "SpreadElement", + Super: "Super", + SwitchStatement: "SwitchStatement", + SwitchCase: "SwitchCase", + TaggedTemplateExpression: "TaggedTemplateExpression", + TemplateElement: "TemplateElement", + TemplateLiteral: "TemplateLiteral", + ThisExpression: "ThisExpression", + ThrowStatement: "ThrowStatement", + TryStatement: "TryStatement", + UnaryExpression: "UnaryExpression", + UpdateExpression: "UpdateExpression", + VariableDeclaration: "VariableDeclaration", + VariableDeclarator: "VariableDeclarator", + WhileStatement: "WhileStatement", + WithStatement: "WithStatement", + YieldExpression: "YieldExpression" + }; + exports.Syntax = Syntax2; + var Precedence = { + Sequence: 0, + Yield: 1, + Assignment: 1, + Conditional: 2, + ArrowFunction: 2, + Coalesce: 3, + LogicalOR: 3, + LogicalAND: 4, + BitwiseOR: 5, + BitwiseXOR: 6, + BitwiseAND: 7, + Equality: 8, + Relational: 9, + BitwiseSHIFT: 10, + Additive: 11, + Multiplicative: 12, + Unary: 13, + Exponentiation: 14, + Postfix: 14, + Await: 14, + Call: 15, + New: 16, + TaggedTemplate: 17, + OptionalChaining: 17, + Member: 18, + Primary: 19 + }; + var BinaryPrecedence = { + "||": Precedence.LogicalOR, + "&&": Precedence.LogicalAND, + "|": Precedence.BitwiseOR, + "^": Precedence.BitwiseXOR, + "&": Precedence.BitwiseAND, + "==": Precedence.Equality, + "!=": Precedence.Equality, + "===": Precedence.Equality, + "!==": Precedence.Equality, + "is": Precedence.Equality, + "isnt": Precedence.Equality, + "<": Precedence.Relational, + ">": Precedence.Relational, + "<=": Precedence.Relational, + ">=": Precedence.Relational, + "in": Precedence.Relational, + "instanceof": Precedence.Relational, + "<<": Precedence.BitwiseSHIFT, + ">>": Precedence.BitwiseSHIFT, + ">>>": Precedence.BitwiseSHIFT, + "+": Precedence.Additive, + "-": Precedence.Additive, + "*": Precedence.Multiplicative, + "%": Precedence.Multiplicative, + "/": Precedence.Multiplicative, + "??": Precedence.Coalesce, + "**": Precedence.Exponentiation + }; + function getDefaultOptions() { + return { + indent: null, + base: null, + parse: null, + format: { + indent: { + style: " ", + base: 0 + }, + newline: "\n", + space: " ", + json: false, + renumber: false, + hexadecimal: false, + quotes: "single", + escapeless: false, + compact: false, + parentheses: true, + semicolons: true, + safeConcatenation: false + }, + directive: false, + raw: true, + verbatim: null + }; + } + var NON_ASCII_WHITESPACES = [ + 5760, + 6158, + 8192, + 8193, + 8194, + 8195, + 8196, + 8197, + 8198, + 8199, + 8200, + 8201, + 8202, + 8239, + 8287, + 12288, + 65279 + ]; + var NON_ASCII_IDENTIFIER_CHARACTERS_REGEXP = new RegExp( + "[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0\u08A2-\u08AC\u08E4-\u08FE\u0900-\u0963\u0966-\u096F\u0971-\u0977\u0979-\u097F\u0981-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C01-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C82\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D02\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F0\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191C\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1D00-\u1DE6\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA697\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A\uAA7B\uAA80-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE26\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]" + ); + function isIdentifierCh(cp) { + if (cp < 128) { + return cp >= 97 && cp <= 122 || // a..z + cp >= 65 && cp <= 90 || // A..Z + cp >= 48 && cp <= 57 || // 0..9 + cp === 36 || cp === 95 || // $ (dollar) and _ (underscore) + cp === 92; + } + var ch = String.fromCharCode(cp); + return NON_ASCII_IDENTIFIER_CHARACTERS_REGEXP.test(ch); + } + function isLineTerminator(cp) { + return cp === 10 || cp === 13 || cp === 8232 || cp === 8233; + } + function isWhitespace2(cp) { + return cp === 32 || cp === 9 || isLineTerminator(cp) || cp === 11 || cp === 12 || cp === 160 || cp >= 5760 && NON_ASCII_WHITESPACES.indexOf(cp) >= 0; + } + function isDecimalDigit(cp) { + return cp >= 48 && cp <= 57; + } + function stringRepeat(str, num) { + var result = ""; + for (num |= 0; num > 0; num >>>= 1, str += str) { + if (num & 1) { + result += str; + } + } + return result; + } + isArray = Array.isArray; + if (!isArray) { + isArray = function isArray2(array) { + return Object.prototype.toString.call(array) === "[object Array]"; + }; + } + function updateDeeply(target, override) { + var key, val; + function isHashObject(target2) { + return typeof target2 === "object" && target2 instanceof Object && !(target2 instanceof RegExp); + } + for (key in override) { + if (override.hasOwnProperty(key)) { + val = override[key]; + if (isHashObject(val)) { + if (isHashObject(target[key])) { + updateDeeply(target[key], val); + } else { + target[key] = updateDeeply({}, val); + } + } else { + target[key] = val; + } + } + } + return target; + } + function generateNumber(value) { + var result, point, temp, exponent, pos; + if (value === 1 / 0) { + return json ? "null" : renumber ? "1e400" : "1e+400"; + } + result = "" + value; + if (!renumber || result.length < 3) { + return result; + } + point = result.indexOf("."); + if (!json && result.charCodeAt(0) === 48 && point === 1) { + point = 0; + result = result.slice(1); + } + temp = result; + result = result.replace("e+", "e"); + exponent = 0; + if ((pos = temp.indexOf("e")) > 0) { + exponent = +temp.slice(pos + 1); + temp = temp.slice(0, pos); + } + if (point >= 0) { + exponent -= temp.length - point - 1; + temp = +(temp.slice(0, point) + temp.slice(point + 1)) + ""; + } + pos = 0; + while (temp.charCodeAt(temp.length + pos - 1) === 48) { + --pos; + } + if (pos !== 0) { + exponent -= pos; + temp = temp.slice(0, pos); + } + if (exponent !== 0) { + temp += "e" + exponent; + } + if ((temp.length < result.length || hexadecimal && value > 1e12 && Math.floor(value) === value && (temp = "0x" + value.toString(16)).length < result.length) && +temp === value) { + result = temp; + } + return result; + } + function escapeRegExpCharacter(ch, previousIsBackslash) { + if ((ch & ~1) === 8232) { + return (previousIsBackslash ? "u" : "\\u") + (ch === 8232 ? "2028" : "2029"); + } else if (ch === 10 || ch === 13) { + return (previousIsBackslash ? "" : "\\") + (ch === 10 ? "n" : "r"); + } + return String.fromCharCode(ch); + } + function generateRegExp(reg) { + var match, result, flags, i, iz, ch, characterInBrack, previousIsBackslash; + result = reg.toString(); + if (reg.source) { + match = result.match(/\/([^/]*)$/); + if (!match) { + return result; + } + flags = match[1]; + result = ""; + characterInBrack = false; + previousIsBackslash = false; + for (i = 0, iz = reg.source.length; i < iz; ++i) { + ch = reg.source.charCodeAt(i); + if (!previousIsBackslash) { + if (characterInBrack) { + if (ch === 93) { + characterInBrack = false; + } + } else { + if (ch === 47) { + result += "\\"; + } else if (ch === 91) { + characterInBrack = true; + } + } + result += escapeRegExpCharacter(ch, previousIsBackslash); + previousIsBackslash = ch === 92; + } else { + result += escapeRegExpCharacter(ch, previousIsBackslash); + previousIsBackslash = false; + } + } + return "/" + result + "/" + flags; + } + return result; + } + function escapeAllowedCharacter(code2, next) { + var hex, result = "\\"; + switch (code2) { + case 8: + result += "b"; + break; + case 12: + result += "f"; + break; + case 9: + result += "t"; + break; + default: + hex = code2.toString(16).toUpperCase(); + if (json || code2 > 255) { + result += "u" + "0000".slice(hex.length) + hex; + } else if (code2 === 0 && !isDecimalDigit(next)) { + result += "0"; + } else if (code2 === 11) { + result += "x0B"; + } else { + result += "x" + "00".slice(hex.length) + hex; + } + break; + } + return result; + } + function escapeDisallowedCharacter(code2) { + var result = "\\"; + switch (code2) { + case 92: + result += "\\"; + break; + case 10: + result += "n"; + break; + case 13: + result += "r"; + break; + case 8232: + result += "u2028"; + break; + case 8233: + result += "u2029"; + break; + } + return result; + } + function escapeDirective(str) { + var i, iz, code2, quote; + quote = quotes === "double" ? '"' : "'"; + for (i = 0, iz = str.length; i < iz; ++i) { + code2 = str.charCodeAt(i); + if (code2 === 39) { + quote = '"'; + break; + } else if (code2 === 34) { + quote = "'"; + break; + } else if (code2 === 92) { + ++i; + } + } + return quote + str + quote; + } + function escapeString(str) { + var result = "", i, len, code2, singleQuotes = 0, doubleQuotes = 0, single, quote; + for (i = 0, len = str.length; i < len; ++i) { + code2 = str.charCodeAt(i); + if (code2 === 39) { + ++singleQuotes; + } else if (code2 === 34) { + ++doubleQuotes; + } else if (code2 === 47 && json) { + result += "\\"; + } else if (isLineTerminator(code2) || code2 === 92) { + result += escapeDisallowedCharacter(code2); + continue; + } else if (json && code2 < 32 || // SP + !(json || escapeless || code2 >= 32 && code2 <= 126)) { + result += escapeAllowedCharacter(code2, str.charCodeAt(i + 1)); + continue; + } + result += String.fromCharCode(code2); + } + single = !(quotes === "double" || quotes === "auto" && doubleQuotes < singleQuotes); + quote = single ? "'" : '"'; + if (!(single ? singleQuotes : doubleQuotes)) { + return quote + result + quote; + } + str = result; + result = quote; + for (i = 0, len = str.length; i < len; ++i) { + code2 = str.charCodeAt(i); + if (code2 === 39 && single || code2 === 34 && !single) { + result += "\\"; + } + result += String.fromCharCode(code2); + } + return result + quote; + } + function join(l, r) { + if (!l.length) + return r; + if (!r.length) + return l; + var lCp = l.charCodeAt(l.length - 1), rCp = r.charCodeAt(0); + if (isIdentifierCh(lCp) && isIdentifierCh(rCp) || lCp === rCp && (lCp === 43 || lCp === 45) || // + +, - - + lCp === 47 && rCp === 105) { + return l + _.space + r; + } else if (isWhitespace2(lCp) || isWhitespace2(rCp)) + return l + r; + return l + _.optSpace + r; + } + function shiftIndent() { + var prevIndent = _.indent; + _.indent += _.indentUnit; + return prevIndent; + } + function adoptionPrefix($stmt) { + if ($stmt.type === Syntax2.BlockStatement) + return _.optSpace; + if ($stmt.type === Syntax2.EmptyStatement) + return ""; + return _.newline + _.indent + _.indentUnit; + } + function adoptionSuffix($stmt) { + if ($stmt.type === Syntax2.BlockStatement) + return _.optSpace; + return _.newline + _.indent; + } + function generateVerbatim($expr, settings2) { + var verbatim = $expr[extra.verbatim], strVerbatim = typeof verbatim === "string", precedence = !strVerbatim && verbatim.precedence !== void 0 ? verbatim.precedence : Precedence.Sequence, parenthesize = precedence < settings2.precedence, content = strVerbatim ? verbatim : verbatim.content, chunks = content.split(/\r\n|\n/), chunkCount = chunks.length; + if (parenthesize) + _.js += "("; + _.js += chunks[0]; + for (var i = 1; i < chunkCount; i++) + _.js += _.newline + _.indent + chunks[i]; + if (parenthesize) + _.js += ")"; + } + function generateFunctionParams($node) { + var $params = $node.params, paramCount = $params.length, lastParamIdx = paramCount - 1, arrowFuncWithoutParentheses = $node.type === Syntax2.ArrowFunctionExpression && paramCount === 1 && $params[0].type === Syntax2.Identifier; + if (arrowFuncWithoutParentheses) + _.js += $params[0].name; + else { + _.js += "("; + for (var i = 0; i < paramCount; ++i) { + var $param = $params[i]; + if ($params[i].type === Syntax2.Identifier) + _.js += $param.name; + else + ExprGen[$param.type]($param, Preset.e4); + if (i !== lastParamIdx) + _.js += "," + _.optSpace; + } + _.js += ")"; + } + } + function generateFunctionBody($node) { + var $body = $node.body; + generateFunctionParams($node); + if ($node.type === Syntax2.ArrowFunctionExpression) + _.js += _.optSpace + "=>"; + if ($node.expression) { + _.js += _.optSpace; + var exprJs = exprToJs($body, Preset.e4); + if (exprJs.charAt(0) === "{") + exprJs = "(" + exprJs + ")"; + _.js += exprJs; + } else { + _.js += adoptionPrefix($body); + StmtGen[$body.type]($body, Preset.s8); + } + } + var Preset = { + e1: function(allowIn) { + return { + precedence: Precedence.Assignment, + allowIn, + allowCall: true, + allowUnparenthesizedNew: true + }; + }, + e2: function(allowIn) { + return { + precedence: Precedence.LogicalOR, + allowIn, + allowCall: true, + allowUnparenthesizedNew: true + }; + }, + e3: { + precedence: Precedence.Call, + allowIn: true, + allowCall: true, + allowUnparenthesizedNew: false + }, + e4: { + precedence: Precedence.Assignment, + allowIn: true, + allowCall: true, + allowUnparenthesizedNew: true + }, + e5: { + precedence: Precedence.Sequence, + allowIn: true, + allowCall: true, + allowUnparenthesizedNew: true + }, + e6: function(allowUnparenthesizedNew) { + return { + precedence: Precedence.New, + allowIn: true, + allowCall: false, + allowUnparenthesizedNew + }; + }, + e7: { + precedence: Precedence.Unary, + allowIn: true, + allowCall: true, + allowUnparenthesizedNew: true + }, + e8: { + precedence: Precedence.Postfix, + allowIn: true, + allowCall: true, + allowUnparenthesizedNew: true + }, + e9: { + precedence: void 0, + allowIn: true, + allowCall: true, + allowUnparenthesizedNew: true + }, + e10: { + precedence: Precedence.Call, + allowIn: true, + allowCall: true, + allowUnparenthesizedNew: true + }, + e11: function(allowCall) { + return { + precedence: Precedence.Call, + allowIn: true, + allowCall, + allowUnparenthesizedNew: false + }; + }, + e12: { + precedence: Precedence.Primary, + allowIn: false, + allowCall: false, + allowUnparenthesizedNew: true + }, + e13: { + precedence: Precedence.Primary, + allowIn: true, + allowCall: true, + allowUnparenthesizedNew: true + }, + e14: { + precedence: Precedence.Sequence, + allowIn: false, + allowCall: true, + allowUnparenthesizedNew: true + }, + e15: function(allowCall) { + return { + precedence: Precedence.Sequence, + allowIn: true, + allowCall, + allowUnparenthesizedNew: true + }; + }, + e16: function(precedence, allowIn) { + return { + precedence, + allowIn, + allowCall: true, + allowUnparenthesizedNew: true + }; + }, + e17: function(allowIn) { + return { + precedence: Precedence.Call, + allowIn, + allowCall: true, + allowUnparenthesizedNew: true + }; + }, + e18: function(allowIn) { + return { + precedence: Precedence.Assignment, + allowIn, + allowCall: true, + allowUnparenthesizedNew: true + }; + }, + e19: { + precedence: Precedence.Sequence, + allowIn: true, + allowCall: true, + semicolonOptional: false + }, + e20: { + precedence: Precedence.Await, + allowCall: true + }, + s1: function(functionBody, semicolonOptional) { + return { + allowIn: true, + functionBody: false, + directiveContext: functionBody, + semicolonOptional + }; + }, + s2: { + allowIn: true, + functionBody: false, + directiveContext: false, + semicolonOptional: true + }, + s3: function(allowIn) { + return { + allowIn, + functionBody: false, + directiveContext: false, + semicolonOptional: false + }; + }, + s4: function(semicolonOptional) { + return { + allowIn: true, + functionBody: false, + directiveContext: false, + semicolonOptional + }; + }, + s5: function(semicolonOptional) { + return { + allowIn: true, + functionBody: false, + directiveContext: true, + semicolonOptional + }; + }, + s6: { + allowIn: false, + functionBody: false, + directiveContext: false, + semicolonOptional: false + }, + s7: { + allowIn: true, + functionBody: false, + directiveContext: false, + semicolonOptional: false + }, + s8: { + allowIn: true, + functionBody: true, + directiveContext: false, + semicolonOptional: false + } + }; + var FLOATING_OR_OCTAL_REGEXP = /[.eExX]|^0[0-9]+/; + var LAST_DECIMAL_DIGIT_REGEXP = /[0-9]$/; + function isLogicalExpression(node) { + if (!node) + return false; + return node.type === Syntax2.LogicalExpression; + } + function needParensForLogicalExpression(node, parent) { + switch (node.operator) { + case "||": + if (!isLogicalExpression(parent)) + return false; + return parent.operator === "??" || parent.operator === "&&"; + case "&&": + return isLogicalExpression(parent, { + operator: "??" + }); + case "??": + return isLogicalExpression(parent) && parent.operator !== "??"; + } + } + function generateLogicalOrBinaryExpression($expr, settings2, $parent) { + var op = $expr.operator, precedence = BinaryPrecedence[$expr.operator], parenthesize = precedence < settings2.precedence, allowIn = settings2.allowIn || parenthesize, operandGenSettings = Preset.e16(precedence, allowIn), exprJs = exprToJs($expr.left, operandGenSettings, $expr); + parenthesize |= op === "in" && !allowIn; + var needParens = needParensForLogicalExpression($expr, $parent); + if (parenthesize || needParens) + _.js += "("; + if (exprJs.charCodeAt(exprJs.length - 1) === 47 && isIdentifierCh(op.charCodeAt(0))) + exprJs = exprJs + _.space + op; + else + exprJs = join(exprJs, op); + operandGenSettings.precedence++; + var rightJs = exprToJs($expr.right, operandGenSettings, $expr); + if (op === "/" && rightJs.charAt(0) === "/" || op.slice(-1) === "<" && rightJs.slice(0, 3) === "!--") + exprJs += _.space + rightJs; + else + exprJs = join(exprJs, rightJs); + _.js += exprJs; + if (parenthesize || needParens) + _.js += ")"; + } + function generateArrayPatternOrExpression($expr) { + var $elems = $expr.elements, elemCount = $elems.length; + if (elemCount) { + var lastElemIdx = elemCount - 1, multiline = elemCount > 1, prevIndent = shiftIndent(), itemPrefix = _.newline + _.indent; + _.js += "["; + for (var i = 0; i < elemCount; i++) { + var $elem = $elems[i]; + if (multiline) + _.js += itemPrefix; + if ($elem) + ExprGen[$elem.type]($elem, Preset.e4); + if (i !== lastElemIdx || !$elem) + _.js += ","; + } + _.indent = prevIndent; + if (multiline) + _.js += _.newline + _.indent; + _.js += "]"; + } else + _.js += "[]"; + } + function generateGeneratorOrComprehensionExpression($expr) { + var $blocks = $expr.blocks, $filter = $expr.filter, isGenerator = $expr.type === Syntax2.GeneratorExpression, exprJs = isGenerator ? "(" : "[", bodyJs = exprToJs($expr.body, Preset.e4); + if ($blocks) { + var prevIndent = shiftIndent(), blockCount = $blocks.length; + for (var i = 0; i < blockCount; ++i) { + var blockJs = exprToJs($blocks[i], Preset.e5); + exprJs = i > 0 ? join(exprJs, blockJs) : exprJs + blockJs; + } + _.indent = prevIndent; + } + if ($filter) { + var filterJs = exprToJs($filter, Preset.e5); + exprJs = join(exprJs, "if" + _.optSpace); + exprJs = join(exprJs, "(" + filterJs + ")"); + } + exprJs = join(exprJs, bodyJs); + exprJs += isGenerator ? ")" : "]"; + _.js += exprJs; + } + var ExprRawGen = { + SequenceExpression: function generateSequenceExpression($expr, settings2) { + var $children = $expr.expressions, childrenCount = $children.length, lastChildIdx = childrenCount - 1, parenthesize = Precedence.Sequence < settings2.precedence, exprGenSettings = Preset.e1(settings2.allowIn || parenthesize); + if (parenthesize) + _.js += "("; + for (var i = 0; i < childrenCount; i++) { + var $child = $children[i]; + ExprGen[$child.type]($child, exprGenSettings); + if (i !== lastChildIdx) + _.js += "," + _.optSpace; + } + if (parenthesize) + _.js += ")"; + }, + AssignmentExpression: function generateAssignmentExpression($expr, settings2) { + var $left = $expr.left, $right = $expr.right, parenthesize = Precedence.Assignment < settings2.precedence, allowIn = settings2.allowIn || parenthesize; + if (parenthesize) + _.js += "("; + ExprGen[$left.type]($left, Preset.e17(allowIn)); + _.js += _.optSpace + $expr.operator + _.optSpace; + ExprGen[$right.type]($right, Preset.e18(allowIn)); + if (parenthesize) + _.js += ")"; + }, + AssignmentPattern: function generateAssignmentPattern($node) { + var $fakeAssign = { + left: $node.left, + right: $node.right, + operator: "=" + }; + ExprGen.AssignmentExpression($fakeAssign, Preset.e4); + }, + ArrowFunctionExpression: function generateArrowFunctionExpression($expr, settings2) { + var parenthesize = Precedence.ArrowFunction < settings2.precedence; + if (parenthesize) + _.js += "("; + if ($expr.async) + _.js += "async "; + generateFunctionBody($expr); + if (parenthesize) + _.js += ")"; + }, + AwaitExpression: function generateAwaitExpression($expr, settings2) { + var parenthesize = Precedence.Await < settings2.precedence; + if (parenthesize) + _.js += "("; + _.js += $expr.all ? "await* " : "await "; + ExprGen[$expr.argument.type]($expr.argument, Preset.e20); + if (parenthesize) + _.js += ")"; + }, + ConditionalExpression: function generateConditionalExpression($expr, settings2) { + var $test = $expr.test, $conseq = $expr.consequent, $alt = $expr.alternate, parenthesize = Precedence.Conditional < settings2.precedence, allowIn = settings2.allowIn || parenthesize, testGenSettings = Preset.e2(allowIn), branchGenSettings = Preset.e1(allowIn); + if (parenthesize) + _.js += "("; + ExprGen[$test.type]($test, testGenSettings); + _.js += _.optSpace + "?" + _.optSpace; + ExprGen[$conseq.type]($conseq, branchGenSettings); + _.js += _.optSpace + ":" + _.optSpace; + ExprGen[$alt.type]($alt, branchGenSettings); + if (parenthesize) + _.js += ")"; + }, + LogicalExpression: generateLogicalOrBinaryExpression, + BinaryExpression: generateLogicalOrBinaryExpression, + CallExpression: function generateCallExpression($expr, settings2) { + var $callee = $expr.callee, $args = $expr["arguments"], argCount = $args.length, lastArgIdx = argCount - 1, parenthesize = !settings2.allowCall || Precedence.Call < settings2.precedence; + if (parenthesize) + _.js += "("; + ExprGen[$callee.type]($callee, Preset.e3); + if ($expr.optional) + _.js += "?."; + _.js += "("; + for (var i = 0; i < argCount; ++i) { + var $arg = $args[i]; + ExprGen[$arg.type]($arg, Preset.e4); + if (i !== lastArgIdx) + _.js += "," + _.optSpace; + } + _.js += ")"; + if (parenthesize) + _.js += ")"; + }, + NewExpression: function generateNewExpression($expr, settings2) { + var $args = $expr["arguments"], parenthesize = Precedence.New < settings2.precedence, argCount = $args.length, lastArgIdx = argCount - 1, withCall = !settings2.allowUnparenthesizedNew || parentheses2 || argCount > 0, calleeJs = exprToJs($expr.callee, Preset.e6(!withCall)); + if (parenthesize) + _.js += "("; + _.js += join("new", calleeJs); + if (withCall) { + _.js += "("; + for (var i = 0; i < argCount; ++i) { + var $arg = $args[i]; + ExprGen[$arg.type]($arg, Preset.e4); + if (i !== lastArgIdx) + _.js += "," + _.optSpace; + } + _.js += ")"; + } + if (parenthesize) + _.js += ")"; + }, + MemberExpression: function generateMemberExpression($expr, settings2) { + var $obj = $expr.object, $prop = $expr.property, parenthesize = Precedence.Member < settings2.precedence, isNumObj = !$expr.computed && $obj.type === Syntax2.Literal && typeof $obj.value === "number"; + if (parenthesize) + _.js += "("; + if (isNumObj) { + var numJs = exprToJs($obj, Preset.e11(settings2.allowCall)), withPoint = LAST_DECIMAL_DIGIT_REGEXP.test(numJs) && !FLOATING_OR_OCTAL_REGEXP.test(numJs); + _.js += withPoint ? numJs + "." : numJs; + } else + ExprGen[$obj.type]($obj, Preset.e11(settings2.allowCall)); + if ($expr.computed) { + if ($expr.optional) + _.js += "?."; + _.js += "["; + ExprGen[$prop.type]($prop, Preset.e15(settings2.allowCall)); + _.js += "]"; + } else + _.js += ($expr.optional ? "?." : ".") + $prop.name; + if (parenthesize) + _.js += ")"; + }, + UnaryExpression: function generateUnaryExpression($expr, settings2) { + var parenthesize = Precedence.Unary < settings2.precedence, op = $expr.operator, argJs = exprToJs($expr.argument, Preset.e7); + if (parenthesize) + _.js += "("; + if (_.optSpace === "" || op.length > 2) + _.js += join(op, argJs); + else { + _.js += op; + var leftCp = op.charCodeAt(op.length - 1), rightCp = argJs.charCodeAt(0); + if (leftCp === rightCp && (leftCp === 43 || leftCp === 45) || isIdentifierCh(leftCp) && isIdentifierCh(rightCp)) { + _.js += _.space; + } + _.js += argJs; + } + if (parenthesize) + _.js += ")"; + }, + YieldExpression: function generateYieldExpression($expr, settings2) { + var $arg = $expr.argument, js = $expr.delegate ? "yield*" : "yield", parenthesize = Precedence.Yield < settings2.precedence; + if (parenthesize) + _.js += "("; + if ($arg) { + var argJs = exprToJs($arg, Preset.e4); + js = join(js, argJs); + } + _.js += js; + if (parenthesize) + _.js += ")"; + }, + UpdateExpression: function generateUpdateExpression($expr, settings2) { + var $arg = $expr.argument, $op = $expr.operator, prefix = $expr.prefix, precedence = prefix ? Precedence.Unary : Precedence.Postfix, parenthesize = precedence < settings2.precedence; + if (parenthesize) + _.js += "("; + if (prefix) { + _.js += $op; + ExprGen[$arg.type]($arg, Preset.e8); + } else { + ExprGen[$arg.type]($arg, Preset.e8); + _.js += $op; + } + if (parenthesize) + _.js += ")"; + }, + FunctionExpression: function generateFunctionExpression($expr) { + var isGenerator = !!$expr.generator; + if ($expr.async) + _.js += "async "; + _.js += isGenerator ? "function*" : "function"; + if ($expr.id) { + _.js += isGenerator ? _.optSpace : _.space; + _.js += $expr.id.name; + } else + _.js += _.optSpace; + generateFunctionBody($expr); + }, + ExportBatchSpecifier: function generateExportBatchSpecifier() { + _.js += "*"; + }, + ArrayPattern: generateArrayPatternOrExpression, + ArrayExpression: generateArrayPatternOrExpression, + ClassExpression: function generateClassExpression($expr) { + var $id = $expr.id, $super = $expr.superClass, $body = $expr.body, exprJs = "class"; + if ($id) { + var idJs = exprToJs($id, Preset.e9); + exprJs = join(exprJs, idJs); + } + if ($super) { + var superJs = exprToJs($super, Preset.e4); + superJs = join("extends", superJs); + exprJs = join(exprJs, superJs); + } + _.js += exprJs + _.optSpace; + StmtGen[$body.type]($body, Preset.s2); + }, + MetaProperty: function generateMetaProperty($expr, settings2) { + var $meta = $expr.meta, $property = $expr.property, parenthesize = Precedence.Member < settings2.precedence; + if (parenthesize) + _.js += "("; + _.js += (typeof $meta === "string" ? $meta : $meta.name) + "." + (typeof $property === "string" ? $property : $property.name); + if (parenthesize) + _.js += ")"; + }, + MethodDefinition: function generateMethodDefinition($expr) { + var exprJs = $expr["static"] ? "static" + _.optSpace : "", keyJs = exprToJs($expr.key, Preset.e5); + if ($expr.computed) + keyJs = "[" + keyJs + "]"; + if ($expr.kind === "get" || $expr.kind === "set") { + keyJs = join($expr.kind, keyJs); + _.js += join(exprJs, keyJs); + } else { + if ($expr.value.generator) + _.js += exprJs + "*" + keyJs; + else if ($expr.value.async) + _.js += exprJs + "async " + keyJs; + else + _.js += join(exprJs, keyJs); + } + generateFunctionBody($expr.value); + }, + Property: function generateProperty($expr) { + var $val = $expr.value, $kind = $expr.kind, keyJs = exprToJs($expr.key, Preset.e4); + if ($expr.computed) + keyJs = "[" + keyJs + "]"; + if ($kind === "get" || $kind === "set") { + _.js += $kind + _.space + keyJs; + generateFunctionBody($val); + } else { + if ($expr.shorthand) + _.js += keyJs; + else if ($expr.method) { + if ($val.generator) + keyJs = "*" + keyJs; + else if ($val.async) + keyJs = "async " + keyJs; + _.js += keyJs; + generateFunctionBody($val); + } else { + _.js += keyJs + ":" + _.optSpace; + ExprGen[$val.type]($val, Preset.e4); + } + } + }, + PropertyDefinition: function generatePropertyDefinition($expr) { + var $val = $expr.value, exprJs = $expr["static"] ? "static" + _.optSpace : "", keyJs = exprToJs($expr.key, Preset.e4); + if ($expr.computed) + keyJs = "[" + keyJs + "]"; + _.js += exprJs + keyJs + "=" + _.optSpace; + ExprGen[$val.type]($val, Preset.e4); + if (semicolons || !settings.semicolonOptional) + _.js += ";"; + }, + ObjectExpression: function generateObjectExpression($expr) { + var $props = $expr.properties, propCount = $props.length; + if (propCount) { + var lastPropIdx = propCount - 1, prevIndent = shiftIndent(); + _.js += "{"; + for (var i = 0; i < propCount; i++) { + var $prop = $props[i], propType = $prop.type || Syntax2.Property; + _.js += _.newline + _.indent; + ExprGen[propType]($prop, Preset.e5); + if (i !== lastPropIdx) + _.js += ","; + } + _.indent = prevIndent; + _.js += _.newline + _.indent + "}"; + } else + _.js += "{}"; + }, + ObjectPattern: function generateObjectPattern($expr) { + var $props = $expr.properties, propCount = $props.length; + if (propCount) { + var lastPropIdx = propCount - 1, multiline = false; + if (propCount === 1) + multiline = $props[0].value.type !== Syntax2.Identifier; + else { + for (var i = 0; i < propCount; i++) { + if (!$props[i].shorthand) { + multiline = true; + break; + } + } + } + _.js += multiline ? "{" + _.newline : "{"; + var prevIndent = shiftIndent(), propSuffix = "," + (multiline ? _.newline : _.optSpace); + for (var i = 0; i < propCount; i++) { + var $prop = $props[i]; + if (multiline) + _.js += _.indent; + ExprGen[$prop.type]($prop, Preset.e5); + if (i !== lastPropIdx) + _.js += propSuffix; + } + _.indent = prevIndent; + _.js += multiline ? _.newline + _.indent + "}" : "}"; + } else + _.js += "{}"; + }, + ThisExpression: function generateThisExpression() { + _.js += "this"; + }, + Identifier: function generateIdentifier($expr, precedence, flag) { + _.js += $expr.name; + }, + PrivateIdentifier: function generatePrivateIdentifier($expr, precedence, flag) { + _.js += "#" + $expr.name; + }, + ImportExpression: function generateImportExpression($expr, settings2) { + var parenthesize = Precedence.Call < settings2.precedence; + var $source = $expr.source; + if (parenthesize) + _.js += "("; + _.js += "import("; + ExprGen[$source.type]($source, Preset.e4); + _.js += ")"; + if (parenthesize) + _.js += ")"; + }, + ImportSpecifier: function generateImportSpecifier($expr) { + _.js += $expr.imported.name; + if ($expr.local) + _.js += _.space + "as" + _.space + $expr.local.name; + }, + ExportSpecifier: function generateImportOrExportSpecifier($expr) { + _.js += $expr.local.name; + if ($expr.exported) + _.js += _.space + "as" + _.space + $expr.exported.name; + }, + ChainExpression: function generateChainExpression($expr, settings2) { + var parenthesize = Precedence.OptionalChaining < settings2.precedence; + var $expression = $expr.expression; + settings2 = settings2 || {}; + var newSettings = { + precedence: Precedence.OptionalChaining, + allowIn: settings2.allowIn, + allowCall: settings2.allowCall, + allowUnparenthesizedNew: settings2.allowUnparenthesizedNew + }; + if (parenthesize) { + newSettings.allowCall = true; + _.js += "("; + } + ExprGen[$expression.type]($expression, newSettings); + if (parenthesize) + _.js += ")"; + }, + Literal: function generateLiteral($expr) { + if (extra.raw && $expr.raw !== void 0) + _.js += $expr.raw; + else if ($expr.value === null) + _.js += "null"; + else { + var valueType = typeof $expr.value; + if (valueType === "string") + _.js += escapeString($expr.value); + else if (valueType === "number") + _.js += generateNumber($expr.value); + else if (valueType === "boolean") + _.js += $expr.value ? "true" : "false"; + else + _.js += generateRegExp($expr.value); + } + }, + GeneratorExpression: generateGeneratorOrComprehensionExpression, + ComprehensionExpression: generateGeneratorOrComprehensionExpression, + ComprehensionBlock: function generateComprehensionBlock($expr) { + var $left = $expr.left, leftJs = void 0, rightJs = exprToJs($expr.right, Preset.e5); + if ($left.type === Syntax2.VariableDeclaration) + leftJs = $left.kind + _.space + stmtToJs($left.declarations[0], Preset.s6); + else + leftJs = exprToJs($left, Preset.e10); + leftJs = join(leftJs, $expr.of ? "of" : "in"); + _.js += "for" + _.optSpace + "(" + join(leftJs, rightJs) + ")"; + }, + RestElement: function generateRestElement($node) { + _.js += "..." + $node.argument.name; + }, + SpreadElement: function generateSpreadElement($expr) { + var $arg = $expr.argument; + _.js += "..."; + ExprGen[$arg.type]($arg, Preset.e4); + }, + TaggedTemplateExpression: function generateTaggedTemplateExpression($expr, settings2) { + var $tag = $expr.tag, $quasi = $expr.quasi, parenthesize = Precedence.TaggedTemplate < settings2.precedence; + if (parenthesize) + _.js += "("; + ExprGen[$tag.type]($tag, Preset.e11(settings2.allowCall)); + ExprGen[$quasi.type]($quasi, Preset.e12); + if (parenthesize) + _.js += ")"; + }, + TemplateElement: function generateTemplateElement($expr) { + _.js += $expr.value.raw; + }, + TemplateLiteral: function generateTemplateLiteral($expr) { + var $quasis = $expr.quasis, $childExprs = $expr.expressions, quasiCount = $quasis.length, lastQuasiIdx = quasiCount - 1; + _.js += "`"; + for (var i = 0; i < quasiCount; ++i) { + var $quasi = $quasis[i]; + ExprGen[$quasi.type]($quasi, Preset.e13); + if (i !== lastQuasiIdx) { + var $childExpr = $childExprs[i]; + _.js += "${" + _.optSpace; + ExprGen[$childExpr.type]($childExpr, Preset.e5); + _.js += _.optSpace + "}"; + } + } + _.js += "`"; + }, + Super: function generateSuper() { + _.js += "super"; + } + }; + var EXPR_STMT_UNALLOWED_EXPR_REGEXP = /^{|^class(?:\s|{)|^(async )?function(?:\s|\*|\()/; + function generateTryStatementHandlers(stmtJs, $finalizer, handlers) { + var handlerCount = handlers.length, lastHandlerIdx = handlerCount - 1; + for (var i = 0; i < handlerCount; ++i) { + var handlerJs = stmtToJs(handlers[i], Preset.s7); + stmtJs = join(stmtJs, handlerJs); + if ($finalizer || i !== lastHandlerIdx) + stmtJs += adoptionSuffix(handlers[i].body); + } + return stmtJs; + } + function generateForStatementIterator($op, $stmt, settings2) { + var $body = $stmt.body, $left = $stmt.left, bodySemicolonOptional = !semicolons && settings2.semicolonOptional, prevIndent1 = shiftIndent(), awaitStr = $stmt.await ? " await" : "", stmtJs = "for" + awaitStr + _.optSpace + "("; + if ($left.type === Syntax2.VariableDeclaration) { + var prevIndent2 = shiftIndent(); + stmtJs += $left.kind + _.space + stmtToJs($left.declarations[0], Preset.s6); + _.indent = prevIndent2; + } else + stmtJs += exprToJs($left, Preset.e10); + stmtJs = join(stmtJs, $op); + var rightJs = exprToJs($stmt.right, Preset.e4); + stmtJs = join(stmtJs, rightJs) + ")"; + _.indent = prevIndent1; + _.js += stmtJs + adoptionPrefix($body); + StmtGen[$body.type]($body, Preset.s4(bodySemicolonOptional)); + } + var StmtRawGen = { + BlockStatement: function generateBlockStatement($stmt, settings2) { + var $body = $stmt.body, len = $body.length, lastIdx = len - 1, prevIndent = shiftIndent(); + _.js += "{" + _.newline; + for (var i = 0; i < len; i++) { + var $item = $body[i]; + _.js += _.indent; + StmtGen[$item.type]($item, Preset.s1(settings2.functionBody, i === lastIdx)); + _.js += _.newline; + } + _.indent = prevIndent; + _.js += _.indent + "}"; + }, + BreakStatement: function generateBreakStatement($stmt, settings2) { + if ($stmt.label) + _.js += "break " + $stmt.label.name; + else + _.js += "break"; + if (semicolons || !settings2.semicolonOptional) + _.js += ";"; + }, + ContinueStatement: function generateContinueStatement($stmt, settings2) { + if ($stmt.label) + _.js += "continue " + $stmt.label.name; + else + _.js += "continue"; + if (semicolons || !settings2.semicolonOptional) + _.js += ";"; + }, + ClassBody: function generateClassBody($stmt) { + var $body = $stmt.body, itemCount = $body.length, lastItemIdx = itemCount - 1, prevIndent = shiftIndent(); + _.js += "{" + _.newline; + for (var i = 0; i < itemCount; i++) { + var $item = $body[i], itemType = $item.type || Syntax2.Property; + _.js += _.indent; + ExprGen[itemType]($item, Preset.e5); + if (i !== lastItemIdx) + _.js += _.newline; + } + _.indent = prevIndent; + _.js += _.newline + _.indent + "}"; + }, + ClassDeclaration: function generateClassDeclaration($stmt) { + var $body = $stmt.body, $super = $stmt.superClass, js = "class " + $stmt.id.name; + if ($super) { + var superJs = exprToJs($super, Preset.e4); + js += _.space + join("extends", superJs); + } + _.js += js + _.optSpace; + StmtGen[$body.type]($body, Preset.s2); + }, + DirectiveStatement: function generateDirectiveStatement($stmt, settings2) { + if (extra.raw && $stmt.raw) + _.js += $stmt.raw; + else + _.js += escapeDirective($stmt.directive); + if (semicolons || !settings2.semicolonOptional) + _.js += ";"; + }, + DoWhileStatement: function generateDoWhileStatement($stmt, settings2) { + var $body = $stmt.body, $test = $stmt.test, bodyJs = adoptionPrefix($body) + stmtToJs($body, Preset.s7) + adoptionSuffix($body); + var stmtJs = join("do", bodyJs); + _.js += join(stmtJs, "while" + _.optSpace + "("); + ExprGen[$test.type]($test, Preset.e5); + _.js += ")"; + if (semicolons || !settings2.semicolonOptional) + _.js += ";"; + }, + CatchClause: function generateCatchClause($stmt) { + var $param = $stmt.param, $guard = $stmt.guard, $body = $stmt.body, prevIndent = shiftIndent(); + _.js += "catch" + _.optSpace; + if ($param) { + _.js += "("; + ExprGen[$param.type]($param, Preset.e5); + } + if ($guard) { + _.js += " if "; + ExprGen[$guard.type]($guard, Preset.e5); + } + _.indent = prevIndent; + if ($param) { + _.js += ")"; + } + _.js += adoptionPrefix($body); + StmtGen[$body.type]($body, Preset.s7); + }, + DebuggerStatement: function generateDebuggerStatement($stmt, settings2) { + _.js += "debugger"; + if (semicolons || !settings2.semicolonOptional) + _.js += ";"; + }, + EmptyStatement: function generateEmptyStatement() { + _.js += ";"; + }, + ExportAllDeclaration: function($stmt, settings2) { + StmtRawGen.ExportDeclaration($stmt, settings2, true); + }, + ExportDeclaration: function generateExportDeclaration($stmt, settings2, exportAll) { + var $specs = $stmt.specifiers, $decl = $stmt.declaration, withSemicolon = semicolons || !settings2.semicolonOptional; + if ($stmt["default"]) { + var declJs = exprToJs($decl, Preset.e4); + _.js += join("export default", declJs); + if (withSemicolon) + _.js += ";"; + } else if ($specs || exportAll) { + var stmtJs = "export"; + if (exportAll) + stmtJs += _.optSpace + "*"; + else if ($specs.length === 0) + stmtJs += _.optSpace + "{" + _.optSpace + "}"; + else if ($specs[0].type === Syntax2.ExportBatchSpecifier) { + var specJs = exprToJs($specs[0], Preset.e5); + stmtJs = join(stmtJs, specJs); + } else { + var prevIndent = shiftIndent(), specCount = $specs.length, lastSpecIdx = specCount - 1; + stmtJs += _.optSpace + "{"; + for (var i = 0; i < specCount; ++i) { + stmtJs += _.newline + _.indent; + stmtJs += exprToJs($specs[i], Preset.e5); + if (i !== lastSpecIdx) + stmtJs += ","; + } + _.indent = prevIndent; + stmtJs += _.newline + _.indent + "}"; + } + if ($stmt.source) { + _.js += join(stmtJs, "from" + _.optSpace); + ExprGen.Literal($stmt.source); + } else + _.js += stmtJs; + if (withSemicolon) + _.js += ";"; + } else if ($decl) { + var declJs = stmtToJs($decl, Preset.s4(!withSemicolon)); + _.js += join("export", declJs); + } + }, + ExportNamedDeclaration: function($stmt, settings2) { + StmtRawGen.ExportDeclaration($stmt, settings2); + }, + ExpressionStatement: function generateExpressionStatement($stmt, settings2) { + var exprJs = exprToJs($stmt.expression, Preset.e5), parenthesize = EXPR_STMT_UNALLOWED_EXPR_REGEXP.test(exprJs) || directive && settings2.directiveContext && $stmt.expression.type === Syntax2.Literal && typeof $stmt.expression.value === "string"; + if (parenthesize) + _.js += "(" + exprJs + ")"; + else + _.js += exprJs; + if (semicolons || !settings2.semicolonOptional) + _.js += ";"; + }, + ImportDeclaration: function generateImportDeclaration($stmt, settings2) { + var $specs = $stmt.specifiers, stmtJs = "import", specCount = $specs.length; + if (specCount) { + var hasBinding = !!$specs[0]["default"], firstNamedIdx = hasBinding ? 1 : 0, lastSpecIdx = specCount - 1; + if (hasBinding) + stmtJs = join(stmtJs, $specs[0].id.name); + if (firstNamedIdx < specCount) { + if (hasBinding) + stmtJs += ","; + stmtJs += _.optSpace + "{"; + if (firstNamedIdx === lastSpecIdx) + stmtJs += _.optSpace + exprToJs($specs[firstNamedIdx], Preset.e5) + _.optSpace; + else { + var prevIndent = shiftIndent(); + for (var i = firstNamedIdx; i < specCount; i++) { + stmtJs += _.newline + _.indent + exprToJs($specs[i], Preset.e5); + if (i !== lastSpecIdx) + stmtJs += ","; + } + _.indent = prevIndent; + stmtJs += _.newline + _.indent; + } + stmtJs += "}" + _.optSpace; + } + stmtJs = join(stmtJs, "from"); + } + _.js += stmtJs + _.optSpace; + ExprGen.Literal($stmt.source); + if (semicolons || !settings2.semicolonOptional) + _.js += ";"; + }, + VariableDeclarator: function generateVariableDeclarator($stmt, settings2) { + var $id = $stmt.id, $init = $stmt.init, genSettings = Preset.e1(settings2.allowIn); + if ($init) { + ExprGen[$id.type]($id, genSettings); + _.js += _.optSpace + "=" + _.optSpace; + ExprGen[$init.type]($init, genSettings, $stmt); + } else { + if ($id.type === Syntax2.Identifier) + _.js += $id.name; + else + ExprGen[$id.type]($id, genSettings); + } + }, + VariableDeclaration: function generateVariableDeclaration($stmt, settings2) { + var $decls = $stmt.declarations, len = $decls.length, prevIndent = len > 1 ? shiftIndent() : _.indent, declGenSettings = Preset.s3(settings2.allowIn); + _.js += $stmt.kind; + for (var i = 0; i < len; i++) { + var $decl = $decls[i]; + _.js += i === 0 ? _.space : "," + _.optSpace; + StmtGen[$decl.type]($decl, declGenSettings); + } + if (semicolons || !settings2.semicolonOptional) + _.js += ";"; + _.indent = prevIndent; + }, + ThrowStatement: function generateThrowStatement($stmt, settings2) { + var argJs = exprToJs($stmt.argument, Preset.e5); + _.js += join("throw", argJs); + if (semicolons || !settings2.semicolonOptional) + _.js += ";"; + }, + TryStatement: function generateTryStatement($stmt) { + var $block = $stmt.block, $finalizer = $stmt.finalizer, stmtJs = "try" + adoptionPrefix($block) + stmtToJs($block, Preset.s7) + adoptionSuffix($block); + var $handlers = $stmt.handlers || $stmt.guardedHandlers; + if ($handlers) + stmtJs = generateTryStatementHandlers(stmtJs, $finalizer, $handlers); + if ($stmt.handler) { + $handlers = isArray($stmt.handler) ? $stmt.handler : [$stmt.handler]; + stmtJs = generateTryStatementHandlers(stmtJs, $finalizer, $handlers); + } + if ($finalizer) { + stmtJs = join(stmtJs, "finally" + adoptionPrefix($finalizer)); + stmtJs += stmtToJs($finalizer, Preset.s7); + } + _.js += stmtJs; + }, + SwitchStatement: function generateSwitchStatement($stmt) { + var $cases = $stmt.cases, $discr = $stmt.discriminant, prevIndent = shiftIndent(); + _.js += "switch" + _.optSpace + "("; + ExprGen[$discr.type]($discr, Preset.e5); + _.js += ")" + _.optSpace + "{" + _.newline; + _.indent = prevIndent; + if ($cases) { + var caseCount = $cases.length, lastCaseIdx = caseCount - 1; + for (var i = 0; i < caseCount; i++) { + var $case = $cases[i]; + _.js += _.indent; + StmtGen[$case.type]($case, Preset.s4(i === lastCaseIdx)); + _.js += _.newline; + } + } + _.js += _.indent + "}"; + }, + SwitchCase: function generateSwitchCase($stmt, settings2) { + var $conseqs = $stmt.consequent, $firstConseq = $conseqs[0], $test = $stmt.test, i = 0, conseqSemicolonOptional = !semicolons && settings2.semicolonOptional, conseqCount = $conseqs.length, lastConseqIdx = conseqCount - 1, prevIndent = shiftIndent(); + if ($test) { + var testJs = exprToJs($test, Preset.e5); + _.js += join("case", testJs) + ":"; + } else + _.js += "default:"; + if (conseqCount && $firstConseq.type === Syntax2.BlockStatement) { + i++; + _.js += adoptionPrefix($firstConseq); + StmtGen[$firstConseq.type]($firstConseq, Preset.s7); + } + for (; i < conseqCount; i++) { + var $conseq = $conseqs[i], semicolonOptional = i === lastConseqIdx && conseqSemicolonOptional; + _.js += _.newline + _.indent; + StmtGen[$conseq.type]($conseq, Preset.s4(semicolonOptional)); + } + _.indent = prevIndent; + }, + IfStatement: function generateIfStatement($stmt, settings2) { + var $conseq = $stmt.consequent, $test = $stmt.test, prevIndent = shiftIndent(), semicolonOptional = !semicolons && settings2.semicolonOptional; + _.js += "if" + _.optSpace + "("; + ExprGen[$test.type]($test, Preset.e5); + _.js += ")"; + _.indent = prevIndent; + _.js += adoptionPrefix($conseq); + if ($stmt.alternate) { + var conseq = stmtToJs($conseq, Preset.s7) + adoptionSuffix($conseq), alt = stmtToJs($stmt.alternate, Preset.s4(semicolonOptional)); + if ($stmt.alternate.type === Syntax2.IfStatement) + alt = "else " + alt; + else + alt = join("else", adoptionPrefix($stmt.alternate) + alt); + _.js += join(conseq, alt); + } else + StmtGen[$conseq.type]($conseq, Preset.s4(semicolonOptional)); + }, + ForStatement: function generateForStatement($stmt, settings2) { + var $init = $stmt.init, $test = $stmt.test, $body = $stmt.body, $update = $stmt.update, bodySemicolonOptional = !semicolons && settings2.semicolonOptional, prevIndent = shiftIndent(); + _.js += "for" + _.optSpace + "("; + if ($init) { + if ($init.type === Syntax2.VariableDeclaration) + StmtGen[$init.type]($init, Preset.s6); + else { + ExprGen[$init.type]($init, Preset.e14); + _.js += ";"; + } + } else + _.js += ";"; + if ($test) { + _.js += _.optSpace; + ExprGen[$test.type]($test, Preset.e5); + } + _.js += ";"; + if ($update) { + _.js += _.optSpace; + ExprGen[$update.type]($update, Preset.e5); + } + _.js += ")"; + _.indent = prevIndent; + _.js += adoptionPrefix($body); + StmtGen[$body.type]($body, Preset.s4(bodySemicolonOptional)); + }, + ForInStatement: function generateForInStatement($stmt, settings2) { + generateForStatementIterator("in", $stmt, settings2); + }, + ForOfStatement: function generateForOfStatement($stmt, settings2) { + generateForStatementIterator("of", $stmt, settings2); + }, + LabeledStatement: function generateLabeledStatement($stmt, settings2) { + var $body = $stmt.body, bodySemicolonOptional = !semicolons && settings2.semicolonOptional, prevIndent = _.indent; + _.js += $stmt.label.name + ":" + adoptionPrefix($body); + if ($body.type !== Syntax2.BlockStatement) + prevIndent = shiftIndent(); + StmtGen[$body.type]($body, Preset.s4(bodySemicolonOptional)); + _.indent = prevIndent; + }, + ModuleDeclaration: function generateModuleDeclaration($stmt, settings2) { + _.js += "module" + _.space + $stmt.id.name + _.space + "from" + _.optSpace; + ExprGen.Literal($stmt.source); + if (semicolons || !settings2.semicolonOptional) + _.js += ";"; + }, + Program: function generateProgram($stmt) { + var $body = $stmt.body, len = $body.length, lastIdx = len - 1; + if (safeConcatenation && len > 0) + _.js += "\n"; + for (var i = 0; i < len; i++) { + var $item = $body[i]; + _.js += _.indent; + StmtGen[$item.type]($item, Preset.s5(!safeConcatenation && i === lastIdx)); + if (i !== lastIdx) + _.js += _.newline; + } + }, + FunctionDeclaration: function generateFunctionDeclaration($stmt) { + var isGenerator = !!$stmt.generator; + if ($stmt.async) + _.js += "async "; + _.js += isGenerator ? "function*" + _.optSpace : "function" + _.space; + _.js += $stmt.id.name; + generateFunctionBody($stmt); + }, + ReturnStatement: function generateReturnStatement($stmt, settings2) { + var $arg = $stmt.argument; + if ($arg) { + var argJs = exprToJs($arg, Preset.e5); + _.js += join("return", argJs); + } else + _.js += "return"; + if (semicolons || !settings2.semicolonOptional) + _.js += ";"; + }, + WhileStatement: function generateWhileStatement($stmt, settings2) { + var $body = $stmt.body, $test = $stmt.test, bodySemicolonOptional = !semicolons && settings2.semicolonOptional, prevIndent = shiftIndent(); + _.js += "while" + _.optSpace + "("; + ExprGen[$test.type]($test, Preset.e5); + _.js += ")"; + _.indent = prevIndent; + _.js += adoptionPrefix($body); + StmtGen[$body.type]($body, Preset.s4(bodySemicolonOptional)); + }, + WithStatement: function generateWithStatement($stmt, settings2) { + var $body = $stmt.body, $obj = $stmt.object, bodySemicolonOptional = !semicolons && settings2.semicolonOptional, prevIndent = shiftIndent(); + _.js += "with" + _.optSpace + "("; + ExprGen[$obj.type]($obj, Preset.e5); + _.js += ")"; + _.indent = prevIndent; + _.js += adoptionPrefix($body); + StmtGen[$body.type]($body, Preset.s4(bodySemicolonOptional)); + } + }; + function exprToJs($expr, settings2, $parent) { + var savedJs = _.js; + _.js = ""; + ExprGen[$expr.type]($expr, settings2, $parent); + var src = _.js; + _.js = savedJs; + return src; + } + function stmtToJs($stmt, settings2) { + var savedJs = _.js; + _.js = ""; + StmtGen[$stmt.type]($stmt, settings2); + var src = _.js; + _.js = savedJs; + return src; + } + function run($node) { + _.js = ""; + if (StmtGen[$node.type]) + StmtGen[$node.type]($node, Preset.s7); + else + ExprGen[$node.type]($node, Preset.e19); + return _.js; + } + function wrapExprGen(gen) { + return function($expr, settings2) { + if (extra.verbatim && $expr.hasOwnProperty(extra.verbatim)) + generateVerbatim($expr, settings2); + else + gen($expr, settings2); + }; + } + function createExprGenWithExtras() { + var gens = {}; + for (var key in ExprRawGen) { + if (ExprRawGen.hasOwnProperty(key)) + gens[key] = wrapExprGen(ExprRawGen[key]); + } + return gens; + } + var _ = { + js: "", + newline: "\n", + optSpace: " ", + space: " ", + indentUnit: " ", + indent: "" + }; + var ExprGen = void 0; + var StmtGen = StmtRawGen; + exports.generate = function($node, options) { + var defaultOptions = getDefaultOptions(), result, pair; + if (options != null) { + if (typeof options.indent === "string") { + defaultOptions.format.indent.style = options.indent; + } + if (typeof options.base === "number") { + defaultOptions.format.indent.base = options.base; + } + options = updateDeeply(defaultOptions, options); + _.indentUnit = options.format.indent.style; + if (typeof options.base === "string") { + _.indent = options.base; + } else { + _.indent = stringRepeat(_.indentUnit, options.format.indent.base); + } + } else { + options = defaultOptions; + _.indentUnit = options.format.indent.style; + _.indent = stringRepeat(_.indentUnit, options.format.indent.base); + } + json = options.format.json; + renumber = options.format.renumber; + hexadecimal = json ? false : options.format.hexadecimal; + quotes = json ? "double" : options.format.quotes; + escapeless = options.format.escapeless; + _.newline = options.format.newline; + _.optSpace = options.format.space; + if (options.format.compact) + _.newline = _.optSpace = _.indentUnit = _.indent = ""; + _.space = _.optSpace ? _.optSpace : " "; + parentheses2 = options.format.parentheses; + semicolons = options.format.semicolons; + safeConcatenation = options.format.safeConcatenation; + directive = options.directive; + parse45 = json ? null : options.parse; + extra = options; + if (extra.verbatim) + ExprGen = createExprGenWithExtras(); + else + ExprGen = ExprRawGen; + return run($node); + }; + } + }); + + // node_modules/set-cookie-parser/lib/set-cookie.js + var require_set_cookie = __commonJS({ + "node_modules/set-cookie-parser/lib/set-cookie.js"(exports, module) { + "use strict"; + var defaultParseOptions = { + decodeValues: true, + map: false, + silent: false + }; + function isNonEmptyString(str) { + return typeof str === "string" && !!str.trim(); + } + function parseString(setCookieValue, options) { + var parts = setCookieValue.split(";").filter(isNonEmptyString); + var nameValuePairStr = parts.shift(); + var parsed = parseNameValuePair(nameValuePairStr); + var name42 = parsed.name; + var value = parsed.value; + options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions; + try { + value = options.decodeValues ? decodeURIComponent(value) : value; + } catch (e) { + console.error( + "set-cookie-parser encountered an error while decoding a cookie with value '" + value + "'. Set options.decodeValues to false to disable this feature.", + e + ); + } + var cookie = { + name: name42, + value + }; + parts.forEach(function(part) { + var sides = part.split("="); + var key = sides.shift().trimLeft().toLowerCase(); + var value2 = sides.join("="); + if (key === "expires") { + cookie.expires = new Date(value2); + } else if (key === "max-age") { + cookie.maxAge = parseInt(value2, 10); + } else if (key === "secure") { + cookie.secure = true; + } else if (key === "httponly") { + cookie.httpOnly = true; + } else if (key === "samesite") { + cookie.sameSite = value2; + } else { + cookie[key] = value2; + } + }); + return cookie; + } + function parseNameValuePair(nameValuePairStr) { + var name42 = ""; + var value = ""; + var nameValueArr = nameValuePairStr.split("="); + if (nameValueArr.length > 1) { + name42 = nameValueArr.shift(); + value = nameValueArr.join("="); + } else { + value = nameValuePairStr; + } + return { name: name42, value }; + } + function parse45(input, options) { + options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions; + if (!input) { + if (!options.map) { + return []; + } else { + return {}; + } + } + if (input.headers) { + if (typeof input.headers.getSetCookie === "function") { + input = input.headers.getSetCookie(); + } else if (input.headers["set-cookie"]) { + input = input.headers["set-cookie"]; + } else { + var sch = input.headers[Object.keys(input.headers).find(function(key) { + return key.toLowerCase() === "set-cookie"; + })]; + if (!sch && input.headers.cookie && !options.silent) { + console.warn( + "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning." + ); + } + input = sch; + } + } + if (!Array.isArray(input)) { + input = [input]; + } + options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions; + if (!options.map) { + return input.filter(isNonEmptyString).map(function(str) { + return parseString(str, options); + }); + } else { + var cookies = {}; + return input.filter(isNonEmptyString).reduce(function(cookies2, str) { + var cookie = parseString(str, options); + cookies2[cookie.name] = cookie; + return cookies2; + }, cookies); + } + } + function splitCookiesString(cookiesString) { + if (Array.isArray(cookiesString)) { + return cookiesString; + } + if (typeof cookiesString !== "string") { + return []; + } + var cookiesStrings = []; + var pos = 0; + var start; + var ch; + var lastComma; + var nextStart; + var cookiesSeparatorFound; + function skipWhitespace() { + while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) { + pos += 1; + } + return pos < cookiesString.length; + } + function notSpecialChar() { + ch = cookiesString.charAt(pos); + return ch !== "=" && ch !== ";" && ch !== ","; + } + while (pos < cookiesString.length) { + start = pos; + cookiesSeparatorFound = false; + while (skipWhitespace()) { + ch = cookiesString.charAt(pos); + if (ch === ",") { + lastComma = pos; + pos += 1; + skipWhitespace(); + nextStart = pos; + while (pos < cookiesString.length && notSpecialChar()) { + pos += 1; + } + if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") { + cookiesSeparatorFound = true; + pos = nextStart; + cookiesStrings.push(cookiesString.substring(start, lastComma)); + start = pos; + } else { + pos = lastComma + 1; + } + } else { + pos += 1; + } + } + if (!cookiesSeparatorFound || pos >= cookiesString.length) { + cookiesStrings.push(cookiesString.substring(start, cookiesString.length)); + } + } + return cookiesStrings; + } + module.exports = parse45; + module.exports.parse = parse45; + module.exports.parseString = parseString; + module.exports.splitCookiesString = splitCookiesString; + } + }); + + // node_modules/mime-db/db.json + var require_db = __commonJS({ + "node_modules/mime-db/db.json"(exports, module) { + module.exports = { + "application/1d-interleaved-parityfec": { + source: "iana" + }, + "application/3gpdash-qoe-report+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/3gpp-ims+xml": { + source: "iana", + compressible: true + }, + "application/3gpphal+json": { + source: "iana", + compressible: true + }, + "application/3gpphalforms+json": { + source: "iana", + compressible: true + }, + "application/a2l": { + source: "iana" + }, + "application/ace+cbor": { + source: "iana" + }, + "application/activemessage": { + source: "iana" + }, + "application/activity+json": { + source: "iana", + compressible: true + }, + "application/alto-costmap+json": { + source: "iana", + compressible: true + }, + "application/alto-costmapfilter+json": { + source: "iana", + compressible: true + }, + "application/alto-directory+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointcost+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointcostparams+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointprop+json": { + source: "iana", + compressible: true + }, + "application/alto-endpointpropparams+json": { + source: "iana", + compressible: true + }, + "application/alto-error+json": { + source: "iana", + compressible: true + }, + "application/alto-networkmap+json": { + source: "iana", + compressible: true + }, + "application/alto-networkmapfilter+json": { + source: "iana", + compressible: true + }, + "application/alto-updatestreamcontrol+json": { + source: "iana", + compressible: true + }, + "application/alto-updatestreamparams+json": { + source: "iana", + compressible: true + }, + "application/aml": { + source: "iana" + }, + "application/andrew-inset": { + source: "iana", + extensions: ["ez"] + }, + "application/applefile": { + source: "iana" + }, + "application/applixware": { + source: "apache", + extensions: ["aw"] + }, + "application/at+jwt": { + source: "iana" + }, + "application/atf": { + source: "iana" + }, + "application/atfx": { + source: "iana" + }, + "application/atom+xml": { + source: "iana", + compressible: true, + extensions: ["atom"] + }, + "application/atomcat+xml": { + source: "iana", + compressible: true, + extensions: ["atomcat"] + }, + "application/atomdeleted+xml": { + source: "iana", + compressible: true, + extensions: ["atomdeleted"] + }, + "application/atomicmail": { + source: "iana" + }, + "application/atomsvc+xml": { + source: "iana", + compressible: true, + extensions: ["atomsvc"] + }, + "application/atsc-dwd+xml": { + source: "iana", + compressible: true, + extensions: ["dwd"] + }, + "application/atsc-dynamic-event-message": { + source: "iana" + }, + "application/atsc-held+xml": { + source: "iana", + compressible: true, + extensions: ["held"] + }, + "application/atsc-rdt+json": { + source: "iana", + compressible: true + }, + "application/atsc-rsat+xml": { + source: "iana", + compressible: true, + extensions: ["rsat"] + }, + "application/atxml": { + source: "iana" + }, + "application/auth-policy+xml": { + source: "iana", + compressible: true + }, + "application/bacnet-xdd+zip": { + source: "iana", + compressible: false + }, + "application/batch-smtp": { + source: "iana" + }, + "application/bdoc": { + compressible: false, + extensions: ["bdoc"] + }, + "application/beep+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/calendar+json": { + source: "iana", + compressible: true + }, + "application/calendar+xml": { + source: "iana", + compressible: true, + extensions: ["xcs"] + }, + "application/call-completion": { + source: "iana" + }, + "application/cals-1840": { + source: "iana" + }, + "application/captive+json": { + source: "iana", + compressible: true + }, + "application/cbor": { + source: "iana" + }, + "application/cbor-seq": { + source: "iana" + }, + "application/cccex": { + source: "iana" + }, + "application/ccmp+xml": { + source: "iana", + compressible: true + }, + "application/ccxml+xml": { + source: "iana", + compressible: true, + extensions: ["ccxml"] + }, + "application/cdfx+xml": { + source: "iana", + compressible: true, + extensions: ["cdfx"] + }, + "application/cdmi-capability": { + source: "iana", + extensions: ["cdmia"] + }, + "application/cdmi-container": { + source: "iana", + extensions: ["cdmic"] + }, + "application/cdmi-domain": { + source: "iana", + extensions: ["cdmid"] + }, + "application/cdmi-object": { + source: "iana", + extensions: ["cdmio"] + }, + "application/cdmi-queue": { + source: "iana", + extensions: ["cdmiq"] + }, + "application/cdni": { + source: "iana" + }, + "application/cea": { + source: "iana" + }, + "application/cea-2018+xml": { + source: "iana", + compressible: true + }, + "application/cellml+xml": { + source: "iana", + compressible: true + }, + "application/cfw": { + source: "iana" + }, + "application/city+json": { + source: "iana", + compressible: true + }, + "application/clr": { + source: "iana" + }, + "application/clue+xml": { + source: "iana", + compressible: true + }, + "application/clue_info+xml": { + source: "iana", + compressible: true + }, + "application/cms": { + source: "iana" + }, + "application/cnrp+xml": { + source: "iana", + compressible: true + }, + "application/coap-group+json": { + source: "iana", + compressible: true + }, + "application/coap-payload": { + source: "iana" + }, + "application/commonground": { + source: "iana" + }, + "application/conference-info+xml": { + source: "iana", + compressible: true + }, + "application/cose": { + source: "iana" + }, + "application/cose-key": { + source: "iana" + }, + "application/cose-key-set": { + source: "iana" + }, + "application/cpl+xml": { + source: "iana", + compressible: true, + extensions: ["cpl"] + }, + "application/csrattrs": { + source: "iana" + }, + "application/csta+xml": { + source: "iana", + compressible: true + }, + "application/cstadata+xml": { + source: "iana", + compressible: true + }, + "application/csvm+json": { + source: "iana", + compressible: true + }, + "application/cu-seeme": { + source: "apache", + extensions: ["cu"] + }, + "application/cwt": { + source: "iana" + }, + "application/cybercash": { + source: "iana" + }, + "application/dart": { + compressible: true + }, + "application/dash+xml": { + source: "iana", + compressible: true, + extensions: ["mpd"] + }, + "application/dash-patch+xml": { + source: "iana", + compressible: true, + extensions: ["mpp"] + }, + "application/dashdelta": { + source: "iana" + }, + "application/davmount+xml": { + source: "iana", + compressible: true, + extensions: ["davmount"] + }, + "application/dca-rft": { + source: "iana" + }, + "application/dcd": { + source: "iana" + }, + "application/dec-dx": { + source: "iana" + }, + "application/dialog-info+xml": { + source: "iana", + compressible: true + }, + "application/dicom": { + source: "iana" + }, + "application/dicom+json": { + source: "iana", + compressible: true + }, + "application/dicom+xml": { + source: "iana", + compressible: true + }, + "application/dii": { + source: "iana" + }, + "application/dit": { + source: "iana" + }, + "application/dns": { + source: "iana" + }, + "application/dns+json": { + source: "iana", + compressible: true + }, + "application/dns-message": { + source: "iana" + }, + "application/docbook+xml": { + source: "apache", + compressible: true, + extensions: ["dbk"] + }, + "application/dots+cbor": { + source: "iana" + }, + "application/dskpp+xml": { + source: "iana", + compressible: true + }, + "application/dssc+der": { + source: "iana", + extensions: ["dssc"] + }, + "application/dssc+xml": { + source: "iana", + compressible: true, + extensions: ["xdssc"] + }, + "application/dvcs": { + source: "iana" + }, + "application/ecmascript": { + source: "iana", + compressible: true, + extensions: ["es", "ecma"] + }, + "application/edi-consent": { + source: "iana" + }, + "application/edi-x12": { + source: "iana", + compressible: false + }, + "application/edifact": { + source: "iana", + compressible: false + }, + "application/efi": { + source: "iana" + }, + "application/elm+json": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/elm+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.cap+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/emergencycalldata.comment+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.control+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.deviceinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.ecall.msd": { + source: "iana" + }, + "application/emergencycalldata.providerinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.serviceinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.subscriberinfo+xml": { + source: "iana", + compressible: true + }, + "application/emergencycalldata.veds+xml": { + source: "iana", + compressible: true + }, + "application/emma+xml": { + source: "iana", + compressible: true, + extensions: ["emma"] + }, + "application/emotionml+xml": { + source: "iana", + compressible: true, + extensions: ["emotionml"] + }, + "application/encaprtp": { + source: "iana" + }, + "application/epp+xml": { + source: "iana", + compressible: true + }, + "application/epub+zip": { + source: "iana", + compressible: false, + extensions: ["epub"] + }, + "application/eshop": { + source: "iana" + }, + "application/exi": { + source: "iana", + extensions: ["exi"] + }, + "application/expect-ct-report+json": { + source: "iana", + compressible: true + }, + "application/express": { + source: "iana", + extensions: ["exp"] + }, + "application/fastinfoset": { + source: "iana" + }, + "application/fastsoap": { + source: "iana" + }, + "application/fdt+xml": { + source: "iana", + compressible: true, + extensions: ["fdt"] + }, + "application/fhir+json": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/fhir+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/fido.trusted-apps+json": { + compressible: true + }, + "application/fits": { + source: "iana" + }, + "application/flexfec": { + source: "iana" + }, + "application/font-sfnt": { + source: "iana" + }, + "application/font-tdpfr": { + source: "iana", + extensions: ["pfr"] + }, + "application/font-woff": { + source: "iana", + compressible: false + }, + "application/framework-attributes+xml": { + source: "iana", + compressible: true + }, + "application/geo+json": { + source: "iana", + compressible: true, + extensions: ["geojson"] + }, + "application/geo+json-seq": { + source: "iana" + }, + "application/geopackage+sqlite3": { + source: "iana" + }, + "application/geoxacml+xml": { + source: "iana", + compressible: true + }, + "application/gltf-buffer": { + source: "iana" + }, + "application/gml+xml": { + source: "iana", + compressible: true, + extensions: ["gml"] + }, + "application/gpx+xml": { + source: "apache", + compressible: true, + extensions: ["gpx"] + }, + "application/gxf": { + source: "apache", + extensions: ["gxf"] + }, + "application/gzip": { + source: "iana", + compressible: false, + extensions: ["gz"] + }, + "application/h224": { + source: "iana" + }, + "application/held+xml": { + source: "iana", + compressible: true + }, + "application/hjson": { + extensions: ["hjson"] + }, + "application/http": { + source: "iana" + }, + "application/hyperstudio": { + source: "iana", + extensions: ["stk"] + }, + "application/ibe-key-request+xml": { + source: "iana", + compressible: true + }, + "application/ibe-pkg-reply+xml": { + source: "iana", + compressible: true + }, + "application/ibe-pp-data": { + source: "iana" + }, + "application/iges": { + source: "iana" + }, + "application/im-iscomposing+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/index": { + source: "iana" + }, + "application/index.cmd": { + source: "iana" + }, + "application/index.obj": { + source: "iana" + }, + "application/index.response": { + source: "iana" + }, + "application/index.vnd": { + source: "iana" + }, + "application/inkml+xml": { + source: "iana", + compressible: true, + extensions: ["ink", "inkml"] + }, + "application/iotp": { + source: "iana" + }, + "application/ipfix": { + source: "iana", + extensions: ["ipfix"] + }, + "application/ipp": { + source: "iana" + }, + "application/isup": { + source: "iana" + }, + "application/its+xml": { + source: "iana", + compressible: true, + extensions: ["its"] + }, + "application/java-archive": { + source: "apache", + compressible: false, + extensions: ["jar", "war", "ear"] + }, + "application/java-serialized-object": { + source: "apache", + compressible: false, + extensions: ["ser"] + }, + "application/java-vm": { + source: "apache", + compressible: false, + extensions: ["class"] + }, + "application/javascript": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["js", "mjs"] + }, + "application/jf2feed+json": { + source: "iana", + compressible: true + }, + "application/jose": { + source: "iana" + }, + "application/jose+json": { + source: "iana", + compressible: true + }, + "application/jrd+json": { + source: "iana", + compressible: true + }, + "application/jscalendar+json": { + source: "iana", + compressible: true + }, + "application/json": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["json", "map"] + }, + "application/json-patch+json": { + source: "iana", + compressible: true + }, + "application/json-seq": { + source: "iana" + }, + "application/json5": { + extensions: ["json5"] + }, + "application/jsonml+json": { + source: "apache", + compressible: true, + extensions: ["jsonml"] + }, + "application/jwk+json": { + source: "iana", + compressible: true + }, + "application/jwk-set+json": { + source: "iana", + compressible: true + }, + "application/jwt": { + source: "iana" + }, + "application/kpml-request+xml": { + source: "iana", + compressible: true + }, + "application/kpml-response+xml": { + source: "iana", + compressible: true + }, + "application/ld+json": { + source: "iana", + compressible: true, + extensions: ["jsonld"] + }, + "application/lgr+xml": { + source: "iana", + compressible: true, + extensions: ["lgr"] + }, + "application/link-format": { + source: "iana" + }, + "application/load-control+xml": { + source: "iana", + compressible: true + }, + "application/lost+xml": { + source: "iana", + compressible: true, + extensions: ["lostxml"] + }, + "application/lostsync+xml": { + source: "iana", + compressible: true + }, + "application/lpf+zip": { + source: "iana", + compressible: false + }, + "application/lxf": { + source: "iana" + }, + "application/mac-binhex40": { + source: "iana", + extensions: ["hqx"] + }, + "application/mac-compactpro": { + source: "apache", + extensions: ["cpt"] + }, + "application/macwriteii": { + source: "iana" + }, + "application/mads+xml": { + source: "iana", + compressible: true, + extensions: ["mads"] + }, + "application/manifest+json": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["webmanifest"] + }, + "application/marc": { + source: "iana", + extensions: ["mrc"] + }, + "application/marcxml+xml": { + source: "iana", + compressible: true, + extensions: ["mrcx"] + }, + "application/mathematica": { + source: "iana", + extensions: ["ma", "nb", "mb"] + }, + "application/mathml+xml": { + source: "iana", + compressible: true, + extensions: ["mathml"] + }, + "application/mathml-content+xml": { + source: "iana", + compressible: true + }, + "application/mathml-presentation+xml": { + source: "iana", + compressible: true + }, + "application/mbms-associated-procedure-description+xml": { + source: "iana", + compressible: true + }, + "application/mbms-deregister+xml": { + source: "iana", + compressible: true + }, + "application/mbms-envelope+xml": { + source: "iana", + compressible: true + }, + "application/mbms-msk+xml": { + source: "iana", + compressible: true + }, + "application/mbms-msk-response+xml": { + source: "iana", + compressible: true + }, + "application/mbms-protection-description+xml": { + source: "iana", + compressible: true + }, + "application/mbms-reception-report+xml": { + source: "iana", + compressible: true + }, + "application/mbms-register+xml": { + source: "iana", + compressible: true + }, + "application/mbms-register-response+xml": { + source: "iana", + compressible: true + }, + "application/mbms-schedule+xml": { + source: "iana", + compressible: true + }, + "application/mbms-user-service-description+xml": { + source: "iana", + compressible: true + }, + "application/mbox": { + source: "iana", + extensions: ["mbox"] + }, + "application/media-policy-dataset+xml": { + source: "iana", + compressible: true, + extensions: ["mpf"] + }, + "application/media_control+xml": { + source: "iana", + compressible: true + }, + "application/mediaservercontrol+xml": { + source: "iana", + compressible: true, + extensions: ["mscml"] + }, + "application/merge-patch+json": { + source: "iana", + compressible: true + }, + "application/metalink+xml": { + source: "apache", + compressible: true, + extensions: ["metalink"] + }, + "application/metalink4+xml": { + source: "iana", + compressible: true, + extensions: ["meta4"] + }, + "application/mets+xml": { + source: "iana", + compressible: true, + extensions: ["mets"] + }, + "application/mf4": { + source: "iana" + }, + "application/mikey": { + source: "iana" + }, + "application/mipc": { + source: "iana" + }, + "application/missing-blocks+cbor-seq": { + source: "iana" + }, + "application/mmt-aei+xml": { + source: "iana", + compressible: true, + extensions: ["maei"] + }, + "application/mmt-usd+xml": { + source: "iana", + compressible: true, + extensions: ["musd"] + }, + "application/mods+xml": { + source: "iana", + compressible: true, + extensions: ["mods"] + }, + "application/moss-keys": { + source: "iana" + }, + "application/moss-signature": { + source: "iana" + }, + "application/mosskey-data": { + source: "iana" + }, + "application/mosskey-request": { + source: "iana" + }, + "application/mp21": { + source: "iana", + extensions: ["m21", "mp21"] + }, + "application/mp4": { + source: "iana", + extensions: ["mp4s", "m4p"] + }, + "application/mpeg4-generic": { + source: "iana" + }, + "application/mpeg4-iod": { + source: "iana" + }, + "application/mpeg4-iod-xmt": { + source: "iana" + }, + "application/mrb-consumer+xml": { + source: "iana", + compressible: true + }, + "application/mrb-publish+xml": { + source: "iana", + compressible: true + }, + "application/msc-ivr+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/msc-mixer+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/msword": { + source: "iana", + compressible: false, + extensions: ["doc", "dot"] + }, + "application/mud+json": { + source: "iana", + compressible: true + }, + "application/multipart-core": { + source: "iana" + }, + "application/mxf": { + source: "iana", + extensions: ["mxf"] + }, + "application/n-quads": { + source: "iana", + extensions: ["nq"] + }, + "application/n-triples": { + source: "iana", + extensions: ["nt"] + }, + "application/nasdata": { + source: "iana" + }, + "application/news-checkgroups": { + source: "iana", + charset: "US-ASCII" + }, + "application/news-groupinfo": { + source: "iana", + charset: "US-ASCII" + }, + "application/news-transmission": { + source: "iana" + }, + "application/nlsml+xml": { + source: "iana", + compressible: true + }, + "application/node": { + source: "iana", + extensions: ["cjs"] + }, + "application/nss": { + source: "iana" + }, + "application/oauth-authz-req+jwt": { + source: "iana" + }, + "application/oblivious-dns-message": { + source: "iana" + }, + "application/ocsp-request": { + source: "iana" + }, + "application/ocsp-response": { + source: "iana" + }, + "application/octet-stream": { + source: "iana", + compressible: false, + extensions: ["bin", "dms", "lrf", "mar", "so", "dist", "distz", "pkg", "bpk", "dump", "elc", "deploy", "exe", "dll", "deb", "dmg", "iso", "img", "msi", "msp", "msm", "buffer"] + }, + "application/oda": { + source: "iana", + extensions: ["oda"] + }, + "application/odm+xml": { + source: "iana", + compressible: true + }, + "application/odx": { + source: "iana" + }, + "application/oebps-package+xml": { + source: "iana", + compressible: true, + extensions: ["opf"] + }, + "application/ogg": { + source: "iana", + compressible: false, + extensions: ["ogx"] + }, + "application/omdoc+xml": { + source: "apache", + compressible: true, + extensions: ["omdoc"] + }, + "application/onenote": { + source: "apache", + extensions: ["onetoc", "onetoc2", "onetmp", "onepkg"] + }, + "application/opc-nodeset+xml": { + source: "iana", + compressible: true + }, + "application/oscore": { + source: "iana" + }, + "application/oxps": { + source: "iana", + extensions: ["oxps"] + }, + "application/p21": { + source: "iana" + }, + "application/p21+zip": { + source: "iana", + compressible: false + }, + "application/p2p-overlay+xml": { + source: "iana", + compressible: true, + extensions: ["relo"] + }, + "application/parityfec": { + source: "iana" + }, + "application/passport": { + source: "iana" + }, + "application/patch-ops-error+xml": { + source: "iana", + compressible: true, + extensions: ["xer"] + }, + "application/pdf": { + source: "iana", + compressible: false, + extensions: ["pdf"] + }, + "application/pdx": { + source: "iana" + }, + "application/pem-certificate-chain": { + source: "iana" + }, + "application/pgp-encrypted": { + source: "iana", + compressible: false, + extensions: ["pgp"] + }, + "application/pgp-keys": { + source: "iana", + extensions: ["asc"] + }, + "application/pgp-signature": { + source: "iana", + extensions: ["asc", "sig"] + }, + "application/pics-rules": { + source: "apache", + extensions: ["prf"] + }, + "application/pidf+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/pidf-diff+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/pkcs10": { + source: "iana", + extensions: ["p10"] + }, + "application/pkcs12": { + source: "iana" + }, + "application/pkcs7-mime": { + source: "iana", + extensions: ["p7m", "p7c"] + }, + "application/pkcs7-signature": { + source: "iana", + extensions: ["p7s"] + }, + "application/pkcs8": { + source: "iana", + extensions: ["p8"] + }, + "application/pkcs8-encrypted": { + source: "iana" + }, + "application/pkix-attr-cert": { + source: "iana", + extensions: ["ac"] + }, + "application/pkix-cert": { + source: "iana", + extensions: ["cer"] + }, + "application/pkix-crl": { + source: "iana", + extensions: ["crl"] + }, + "application/pkix-pkipath": { + source: "iana", + extensions: ["pkipath"] + }, + "application/pkixcmp": { + source: "iana", + extensions: ["pki"] + }, + "application/pls+xml": { + source: "iana", + compressible: true, + extensions: ["pls"] + }, + "application/poc-settings+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/postscript": { + source: "iana", + compressible: true, + extensions: ["ai", "eps", "ps"] + }, + "application/ppsp-tracker+json": { + source: "iana", + compressible: true + }, + "application/problem+json": { + source: "iana", + compressible: true + }, + "application/problem+xml": { + source: "iana", + compressible: true + }, + "application/provenance+xml": { + source: "iana", + compressible: true, + extensions: ["provx"] + }, + "application/prs.alvestrand.titrax-sheet": { + source: "iana" + }, + "application/prs.cww": { + source: "iana", + extensions: ["cww"] + }, + "application/prs.cyn": { + source: "iana", + charset: "7-BIT" + }, + "application/prs.hpub+zip": { + source: "iana", + compressible: false + }, + "application/prs.nprend": { + source: "iana" + }, + "application/prs.plucker": { + source: "iana" + }, + "application/prs.rdf-xml-crypt": { + source: "iana" + }, + "application/prs.xsf+xml": { + source: "iana", + compressible: true + }, + "application/pskc+xml": { + source: "iana", + compressible: true, + extensions: ["pskcxml"] + }, + "application/pvd+json": { + source: "iana", + compressible: true + }, + "application/qsig": { + source: "iana" + }, + "application/raml+yaml": { + compressible: true, + extensions: ["raml"] + }, + "application/raptorfec": { + source: "iana" + }, + "application/rdap+json": { + source: "iana", + compressible: true + }, + "application/rdf+xml": { + source: "iana", + compressible: true, + extensions: ["rdf", "owl"] + }, + "application/reginfo+xml": { + source: "iana", + compressible: true, + extensions: ["rif"] + }, + "application/relax-ng-compact-syntax": { + source: "iana", + extensions: ["rnc"] + }, + "application/remote-printing": { + source: "iana" + }, + "application/reputon+json": { + source: "iana", + compressible: true + }, + "application/resource-lists+xml": { + source: "iana", + compressible: true, + extensions: ["rl"] + }, + "application/resource-lists-diff+xml": { + source: "iana", + compressible: true, + extensions: ["rld"] + }, + "application/rfc+xml": { + source: "iana", + compressible: true + }, + "application/riscos": { + source: "iana" + }, + "application/rlmi+xml": { + source: "iana", + compressible: true + }, + "application/rls-services+xml": { + source: "iana", + compressible: true, + extensions: ["rs"] + }, + "application/route-apd+xml": { + source: "iana", + compressible: true, + extensions: ["rapd"] + }, + "application/route-s-tsid+xml": { + source: "iana", + compressible: true, + extensions: ["sls"] + }, + "application/route-usd+xml": { + source: "iana", + compressible: true, + extensions: ["rusd"] + }, + "application/rpki-ghostbusters": { + source: "iana", + extensions: ["gbr"] + }, + "application/rpki-manifest": { + source: "iana", + extensions: ["mft"] + }, + "application/rpki-publication": { + source: "iana" + }, + "application/rpki-roa": { + source: "iana", + extensions: ["roa"] + }, + "application/rpki-updown": { + source: "iana" + }, + "application/rsd+xml": { + source: "apache", + compressible: true, + extensions: ["rsd"] + }, + "application/rss+xml": { + source: "apache", + compressible: true, + extensions: ["rss"] + }, + "application/rtf": { + source: "iana", + compressible: true, + extensions: ["rtf"] + }, + "application/rtploopback": { + source: "iana" + }, + "application/rtx": { + source: "iana" + }, + "application/samlassertion+xml": { + source: "iana", + compressible: true + }, + "application/samlmetadata+xml": { + source: "iana", + compressible: true + }, + "application/sarif+json": { + source: "iana", + compressible: true + }, + "application/sarif-external-properties+json": { + source: "iana", + compressible: true + }, + "application/sbe": { + source: "iana" + }, + "application/sbml+xml": { + source: "iana", + compressible: true, + extensions: ["sbml"] + }, + "application/scaip+xml": { + source: "iana", + compressible: true + }, + "application/scim+json": { + source: "iana", + compressible: true + }, + "application/scvp-cv-request": { + source: "iana", + extensions: ["scq"] + }, + "application/scvp-cv-response": { + source: "iana", + extensions: ["scs"] + }, + "application/scvp-vp-request": { + source: "iana", + extensions: ["spq"] + }, + "application/scvp-vp-response": { + source: "iana", + extensions: ["spp"] + }, + "application/sdp": { + source: "iana", + extensions: ["sdp"] + }, + "application/secevent+jwt": { + source: "iana" + }, + "application/senml+cbor": { + source: "iana" + }, + "application/senml+json": { + source: "iana", + compressible: true + }, + "application/senml+xml": { + source: "iana", + compressible: true, + extensions: ["senmlx"] + }, + "application/senml-etch+cbor": { + source: "iana" + }, + "application/senml-etch+json": { + source: "iana", + compressible: true + }, + "application/senml-exi": { + source: "iana" + }, + "application/sensml+cbor": { + source: "iana" + }, + "application/sensml+json": { + source: "iana", + compressible: true + }, + "application/sensml+xml": { + source: "iana", + compressible: true, + extensions: ["sensmlx"] + }, + "application/sensml-exi": { + source: "iana" + }, + "application/sep+xml": { + source: "iana", + compressible: true + }, + "application/sep-exi": { + source: "iana" + }, + "application/session-info": { + source: "iana" + }, + "application/set-payment": { + source: "iana" + }, + "application/set-payment-initiation": { + source: "iana", + extensions: ["setpay"] + }, + "application/set-registration": { + source: "iana" + }, + "application/set-registration-initiation": { + source: "iana", + extensions: ["setreg"] + }, + "application/sgml": { + source: "iana" + }, + "application/sgml-open-catalog": { + source: "iana" + }, + "application/shf+xml": { + source: "iana", + compressible: true, + extensions: ["shf"] + }, + "application/sieve": { + source: "iana", + extensions: ["siv", "sieve"] + }, + "application/simple-filter+xml": { + source: "iana", + compressible: true + }, + "application/simple-message-summary": { + source: "iana" + }, + "application/simplesymbolcontainer": { + source: "iana" + }, + "application/sipc": { + source: "iana" + }, + "application/slate": { + source: "iana" + }, + "application/smil": { + source: "iana" + }, + "application/smil+xml": { + source: "iana", + compressible: true, + extensions: ["smi", "smil"] + }, + "application/smpte336m": { + source: "iana" + }, + "application/soap+fastinfoset": { + source: "iana" + }, + "application/soap+xml": { + source: "iana", + compressible: true + }, + "application/sparql-query": { + source: "iana", + extensions: ["rq"] + }, + "application/sparql-results+xml": { + source: "iana", + compressible: true, + extensions: ["srx"] + }, + "application/spdx+json": { + source: "iana", + compressible: true + }, + "application/spirits-event+xml": { + source: "iana", + compressible: true + }, + "application/sql": { + source: "iana" + }, + "application/srgs": { + source: "iana", + extensions: ["gram"] + }, + "application/srgs+xml": { + source: "iana", + compressible: true, + extensions: ["grxml"] + }, + "application/sru+xml": { + source: "iana", + compressible: true, + extensions: ["sru"] + }, + "application/ssdl+xml": { + source: "apache", + compressible: true, + extensions: ["ssdl"] + }, + "application/ssml+xml": { + source: "iana", + compressible: true, + extensions: ["ssml"] + }, + "application/stix+json": { + source: "iana", + compressible: true + }, + "application/swid+xml": { + source: "iana", + compressible: true, + extensions: ["swidtag"] + }, + "application/tamp-apex-update": { + source: "iana" + }, + "application/tamp-apex-update-confirm": { + source: "iana" + }, + "application/tamp-community-update": { + source: "iana" + }, + "application/tamp-community-update-confirm": { + source: "iana" + }, + "application/tamp-error": { + source: "iana" + }, + "application/tamp-sequence-adjust": { + source: "iana" + }, + "application/tamp-sequence-adjust-confirm": { + source: "iana" + }, + "application/tamp-status-query": { + source: "iana" + }, + "application/tamp-status-response": { + source: "iana" + }, + "application/tamp-update": { + source: "iana" + }, + "application/tamp-update-confirm": { + source: "iana" + }, + "application/tar": { + compressible: true + }, + "application/taxii+json": { + source: "iana", + compressible: true + }, + "application/td+json": { + source: "iana", + compressible: true + }, + "application/tei+xml": { + source: "iana", + compressible: true, + extensions: ["tei", "teicorpus"] + }, + "application/tetra_isi": { + source: "iana" + }, + "application/thraud+xml": { + source: "iana", + compressible: true, + extensions: ["tfi"] + }, + "application/timestamp-query": { + source: "iana" + }, + "application/timestamp-reply": { + source: "iana" + }, + "application/timestamped-data": { + source: "iana", + extensions: ["tsd"] + }, + "application/tlsrpt+gzip": { + source: "iana" + }, + "application/tlsrpt+json": { + source: "iana", + compressible: true + }, + "application/tnauthlist": { + source: "iana" + }, + "application/token-introspection+jwt": { + source: "iana" + }, + "application/toml": { + compressible: true, + extensions: ["toml"] + }, + "application/trickle-ice-sdpfrag": { + source: "iana" + }, + "application/trig": { + source: "iana", + extensions: ["trig"] + }, + "application/ttml+xml": { + source: "iana", + compressible: true, + extensions: ["ttml"] + }, + "application/tve-trigger": { + source: "iana" + }, + "application/tzif": { + source: "iana" + }, + "application/tzif-leap": { + source: "iana" + }, + "application/ubjson": { + compressible: false, + extensions: ["ubj"] + }, + "application/ulpfec": { + source: "iana" + }, + "application/urc-grpsheet+xml": { + source: "iana", + compressible: true + }, + "application/urc-ressheet+xml": { + source: "iana", + compressible: true, + extensions: ["rsheet"] + }, + "application/urc-targetdesc+xml": { + source: "iana", + compressible: true, + extensions: ["td"] + }, + "application/urc-uisocketdesc+xml": { + source: "iana", + compressible: true + }, + "application/vcard+json": { + source: "iana", + compressible: true + }, + "application/vcard+xml": { + source: "iana", + compressible: true + }, + "application/vemmi": { + source: "iana" + }, + "application/vividence.scriptfile": { + source: "apache" + }, + "application/vnd.1000minds.decision-model+xml": { + source: "iana", + compressible: true, + extensions: ["1km"] + }, + "application/vnd.3gpp-prose+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-prose-pc3ch+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp-v2x-local-service-information": { + source: "iana" + }, + "application/vnd.3gpp.5gnas": { + source: "iana" + }, + "application/vnd.3gpp.access-transfer-events+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.bsf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.gmop+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.gtpc": { + source: "iana" + }, + "application/vnd.3gpp.interworking-data": { + source: "iana" + }, + "application/vnd.3gpp.lpp": { + source: "iana" + }, + "application/vnd.3gpp.mc-signalling-ear": { + source: "iana" + }, + "application/vnd.3gpp.mcdata-affiliation-command+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-payload": { + source: "iana" + }, + "application/vnd.3gpp.mcdata-service-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-signalling": { + source: "iana" + }, + "application/vnd.3gpp.mcdata-ue-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcdata-user-profile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-affiliation-command+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-floor-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-location-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-mbms-usage-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-service-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-signed+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-ue-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-ue-init-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcptt-user-profile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-affiliation-command+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-affiliation-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-location-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-mbms-usage-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-service-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-transmission-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-ue-config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mcvideo-user-profile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.mid-call+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.ngap": { + source: "iana" + }, + "application/vnd.3gpp.pfcp": { + source: "iana" + }, + "application/vnd.3gpp.pic-bw-large": { + source: "iana", + extensions: ["plb"] + }, + "application/vnd.3gpp.pic-bw-small": { + source: "iana", + extensions: ["psb"] + }, + "application/vnd.3gpp.pic-bw-var": { + source: "iana", + extensions: ["pvb"] + }, + "application/vnd.3gpp.s1ap": { + source: "iana" + }, + "application/vnd.3gpp.sms": { + source: "iana" + }, + "application/vnd.3gpp.sms+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.srvcc-ext+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.srvcc-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.state-and-event-info+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp.ussd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp2.bcmcsinfo+xml": { + source: "iana", + compressible: true + }, + "application/vnd.3gpp2.sms": { + source: "iana" + }, + "application/vnd.3gpp2.tcap": { + source: "iana", + extensions: ["tcap"] + }, + "application/vnd.3lightssoftware.imagescal": { + source: "iana" + }, + "application/vnd.3m.post-it-notes": { + source: "iana", + extensions: ["pwn"] + }, + "application/vnd.accpac.simply.aso": { + source: "iana", + extensions: ["aso"] + }, + "application/vnd.accpac.simply.imp": { + source: "iana", + extensions: ["imp"] + }, + "application/vnd.acucobol": { + source: "iana", + extensions: ["acu"] + }, + "application/vnd.acucorp": { + source: "iana", + extensions: ["atc", "acutc"] + }, + "application/vnd.adobe.air-application-installer-package+zip": { + source: "apache", + compressible: false, + extensions: ["air"] + }, + "application/vnd.adobe.flash.movie": { + source: "iana" + }, + "application/vnd.adobe.formscentral.fcdt": { + source: "iana", + extensions: ["fcdt"] + }, + "application/vnd.adobe.fxp": { + source: "iana", + extensions: ["fxp", "fxpl"] + }, + "application/vnd.adobe.partial-upload": { + source: "iana" + }, + "application/vnd.adobe.xdp+xml": { + source: "iana", + compressible: true, + extensions: ["xdp"] + }, + "application/vnd.adobe.xfdf": { + source: "iana", + extensions: ["xfdf"] + }, + "application/vnd.aether.imp": { + source: "iana" + }, + "application/vnd.afpc.afplinedata": { + source: "iana" + }, + "application/vnd.afpc.afplinedata-pagedef": { + source: "iana" + }, + "application/vnd.afpc.cmoca-cmresource": { + source: "iana" + }, + "application/vnd.afpc.foca-charset": { + source: "iana" + }, + "application/vnd.afpc.foca-codedfont": { + source: "iana" + }, + "application/vnd.afpc.foca-codepage": { + source: "iana" + }, + "application/vnd.afpc.modca": { + source: "iana" + }, + "application/vnd.afpc.modca-cmtable": { + source: "iana" + }, + "application/vnd.afpc.modca-formdef": { + source: "iana" + }, + "application/vnd.afpc.modca-mediummap": { + source: "iana" + }, + "application/vnd.afpc.modca-objectcontainer": { + source: "iana" + }, + "application/vnd.afpc.modca-overlay": { + source: "iana" + }, + "application/vnd.afpc.modca-pagesegment": { + source: "iana" + }, + "application/vnd.age": { + source: "iana", + extensions: ["age"] + }, + "application/vnd.ah-barcode": { + source: "iana" + }, + "application/vnd.ahead.space": { + source: "iana", + extensions: ["ahead"] + }, + "application/vnd.airzip.filesecure.azf": { + source: "iana", + extensions: ["azf"] + }, + "application/vnd.airzip.filesecure.azs": { + source: "iana", + extensions: ["azs"] + }, + "application/vnd.amadeus+json": { + source: "iana", + compressible: true + }, + "application/vnd.amazon.ebook": { + source: "apache", + extensions: ["azw"] + }, + "application/vnd.amazon.mobi8-ebook": { + source: "iana" + }, + "application/vnd.americandynamics.acc": { + source: "iana", + extensions: ["acc"] + }, + "application/vnd.amiga.ami": { + source: "iana", + extensions: ["ami"] + }, + "application/vnd.amundsen.maze+xml": { + source: "iana", + compressible: true + }, + "application/vnd.android.ota": { + source: "iana" + }, + "application/vnd.android.package-archive": { + source: "apache", + compressible: false, + extensions: ["apk"] + }, + "application/vnd.anki": { + source: "iana" + }, + "application/vnd.anser-web-certificate-issue-initiation": { + source: "iana", + extensions: ["cii"] + }, + "application/vnd.anser-web-funds-transfer-initiation": { + source: "apache", + extensions: ["fti"] + }, + "application/vnd.antix.game-component": { + source: "iana", + extensions: ["atx"] + }, + "application/vnd.apache.arrow.file": { + source: "iana" + }, + "application/vnd.apache.arrow.stream": { + source: "iana" + }, + "application/vnd.apache.thrift.binary": { + source: "iana" + }, + "application/vnd.apache.thrift.compact": { + source: "iana" + }, + "application/vnd.apache.thrift.json": { + source: "iana" + }, + "application/vnd.api+json": { + source: "iana", + compressible: true + }, + "application/vnd.aplextor.warrp+json": { + source: "iana", + compressible: true + }, + "application/vnd.apothekende.reservation+json": { + source: "iana", + compressible: true + }, + "application/vnd.apple.installer+xml": { + source: "iana", + compressible: true, + extensions: ["mpkg"] + }, + "application/vnd.apple.keynote": { + source: "iana", + extensions: ["key"] + }, + "application/vnd.apple.mpegurl": { + source: "iana", + extensions: ["m3u8"] + }, + "application/vnd.apple.numbers": { + source: "iana", + extensions: ["numbers"] + }, + "application/vnd.apple.pages": { + source: "iana", + extensions: ["pages"] + }, + "application/vnd.apple.pkpass": { + compressible: false, + extensions: ["pkpass"] + }, + "application/vnd.arastra.swi": { + source: "iana" + }, + "application/vnd.aristanetworks.swi": { + source: "iana", + extensions: ["swi"] + }, + "application/vnd.artisan+json": { + source: "iana", + compressible: true + }, + "application/vnd.artsquare": { + source: "iana" + }, + "application/vnd.astraea-software.iota": { + source: "iana", + extensions: ["iota"] + }, + "application/vnd.audiograph": { + source: "iana", + extensions: ["aep"] + }, + "application/vnd.autopackage": { + source: "iana" + }, + "application/vnd.avalon+json": { + source: "iana", + compressible: true + }, + "application/vnd.avistar+xml": { + source: "iana", + compressible: true + }, + "application/vnd.balsamiq.bmml+xml": { + source: "iana", + compressible: true, + extensions: ["bmml"] + }, + "application/vnd.balsamiq.bmpr": { + source: "iana" + }, + "application/vnd.banana-accounting": { + source: "iana" + }, + "application/vnd.bbf.usp.error": { + source: "iana" + }, + "application/vnd.bbf.usp.msg": { + source: "iana" + }, + "application/vnd.bbf.usp.msg+json": { + source: "iana", + compressible: true + }, + "application/vnd.bekitzur-stech+json": { + source: "iana", + compressible: true + }, + "application/vnd.bint.med-content": { + source: "iana" + }, + "application/vnd.biopax.rdf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.blink-idb-value-wrapper": { + source: "iana" + }, + "application/vnd.blueice.multipass": { + source: "iana", + extensions: ["mpm"] + }, + "application/vnd.bluetooth.ep.oob": { + source: "iana" + }, + "application/vnd.bluetooth.le.oob": { + source: "iana" + }, + "application/vnd.bmi": { + source: "iana", + extensions: ["bmi"] + }, + "application/vnd.bpf": { + source: "iana" + }, + "application/vnd.bpf3": { + source: "iana" + }, + "application/vnd.businessobjects": { + source: "iana", + extensions: ["rep"] + }, + "application/vnd.byu.uapi+json": { + source: "iana", + compressible: true + }, + "application/vnd.cab-jscript": { + source: "iana" + }, + "application/vnd.canon-cpdl": { + source: "iana" + }, + "application/vnd.canon-lips": { + source: "iana" + }, + "application/vnd.capasystems-pg+json": { + source: "iana", + compressible: true + }, + "application/vnd.cendio.thinlinc.clientconf": { + source: "iana" + }, + "application/vnd.century-systems.tcp_stream": { + source: "iana" + }, + "application/vnd.chemdraw+xml": { + source: "iana", + compressible: true, + extensions: ["cdxml"] + }, + "application/vnd.chess-pgn": { + source: "iana" + }, + "application/vnd.chipnuts.karaoke-mmd": { + source: "iana", + extensions: ["mmd"] + }, + "application/vnd.ciedi": { + source: "iana" + }, + "application/vnd.cinderella": { + source: "iana", + extensions: ["cdy"] + }, + "application/vnd.cirpack.isdn-ext": { + source: "iana" + }, + "application/vnd.citationstyles.style+xml": { + source: "iana", + compressible: true, + extensions: ["csl"] + }, + "application/vnd.claymore": { + source: "iana", + extensions: ["cla"] + }, + "application/vnd.cloanto.rp9": { + source: "iana", + extensions: ["rp9"] + }, + "application/vnd.clonk.c4group": { + source: "iana", + extensions: ["c4g", "c4d", "c4f", "c4p", "c4u"] + }, + "application/vnd.cluetrust.cartomobile-config": { + source: "iana", + extensions: ["c11amc"] + }, + "application/vnd.cluetrust.cartomobile-config-pkg": { + source: "iana", + extensions: ["c11amz"] + }, + "application/vnd.coffeescript": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.document": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.document-template": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.presentation": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.presentation-template": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.spreadsheet": { + source: "iana" + }, + "application/vnd.collabio.xodocuments.spreadsheet-template": { + source: "iana" + }, + "application/vnd.collection+json": { + source: "iana", + compressible: true + }, + "application/vnd.collection.doc+json": { + source: "iana", + compressible: true + }, + "application/vnd.collection.next+json": { + source: "iana", + compressible: true + }, + "application/vnd.comicbook+zip": { + source: "iana", + compressible: false + }, + "application/vnd.comicbook-rar": { + source: "iana" + }, + "application/vnd.commerce-battelle": { + source: "iana" + }, + "application/vnd.commonspace": { + source: "iana", + extensions: ["csp"] + }, + "application/vnd.contact.cmsg": { + source: "iana", + extensions: ["cdbcmsg"] + }, + "application/vnd.coreos.ignition+json": { + source: "iana", + compressible: true + }, + "application/vnd.cosmocaller": { + source: "iana", + extensions: ["cmc"] + }, + "application/vnd.crick.clicker": { + source: "iana", + extensions: ["clkx"] + }, + "application/vnd.crick.clicker.keyboard": { + source: "iana", + extensions: ["clkk"] + }, + "application/vnd.crick.clicker.palette": { + source: "iana", + extensions: ["clkp"] + }, + "application/vnd.crick.clicker.template": { + source: "iana", + extensions: ["clkt"] + }, + "application/vnd.crick.clicker.wordbank": { + source: "iana", + extensions: ["clkw"] + }, + "application/vnd.criticaltools.wbs+xml": { + source: "iana", + compressible: true, + extensions: ["wbs"] + }, + "application/vnd.cryptii.pipe+json": { + source: "iana", + compressible: true + }, + "application/vnd.crypto-shade-file": { + source: "iana" + }, + "application/vnd.cryptomator.encrypted": { + source: "iana" + }, + "application/vnd.cryptomator.vault": { + source: "iana" + }, + "application/vnd.ctc-posml": { + source: "iana", + extensions: ["pml"] + }, + "application/vnd.ctct.ws+xml": { + source: "iana", + compressible: true + }, + "application/vnd.cups-pdf": { + source: "iana" + }, + "application/vnd.cups-postscript": { + source: "iana" + }, + "application/vnd.cups-ppd": { + source: "iana", + extensions: ["ppd"] + }, + "application/vnd.cups-raster": { + source: "iana" + }, + "application/vnd.cups-raw": { + source: "iana" + }, + "application/vnd.curl": { + source: "iana" + }, + "application/vnd.curl.car": { + source: "apache", + extensions: ["car"] + }, + "application/vnd.curl.pcurl": { + source: "apache", + extensions: ["pcurl"] + }, + "application/vnd.cyan.dean.root+xml": { + source: "iana", + compressible: true + }, + "application/vnd.cybank": { + source: "iana" + }, + "application/vnd.cyclonedx+json": { + source: "iana", + compressible: true + }, + "application/vnd.cyclonedx+xml": { + source: "iana", + compressible: true + }, + "application/vnd.d2l.coursepackage1p0+zip": { + source: "iana", + compressible: false + }, + "application/vnd.d3m-dataset": { + source: "iana" + }, + "application/vnd.d3m-problem": { + source: "iana" + }, + "application/vnd.dart": { + source: "iana", + compressible: true, + extensions: ["dart"] + }, + "application/vnd.data-vision.rdz": { + source: "iana", + extensions: ["rdz"] + }, + "application/vnd.datapackage+json": { + source: "iana", + compressible: true + }, + "application/vnd.dataresource+json": { + source: "iana", + compressible: true + }, + "application/vnd.dbf": { + source: "iana", + extensions: ["dbf"] + }, + "application/vnd.debian.binary-package": { + source: "iana" + }, + "application/vnd.dece.data": { + source: "iana", + extensions: ["uvf", "uvvf", "uvd", "uvvd"] + }, + "application/vnd.dece.ttml+xml": { + source: "iana", + compressible: true, + extensions: ["uvt", "uvvt"] + }, + "application/vnd.dece.unspecified": { + source: "iana", + extensions: ["uvx", "uvvx"] + }, + "application/vnd.dece.zip": { + source: "iana", + extensions: ["uvz", "uvvz"] + }, + "application/vnd.denovo.fcselayout-link": { + source: "iana", + extensions: ["fe_launch"] + }, + "application/vnd.desmume.movie": { + source: "iana" + }, + "application/vnd.dir-bi.plate-dl-nosuffix": { + source: "iana" + }, + "application/vnd.dm.delegation+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dna": { + source: "iana", + extensions: ["dna"] + }, + "application/vnd.document+json": { + source: "iana", + compressible: true + }, + "application/vnd.dolby.mlp": { + source: "apache", + extensions: ["mlp"] + }, + "application/vnd.dolby.mobile.1": { + source: "iana" + }, + "application/vnd.dolby.mobile.2": { + source: "iana" + }, + "application/vnd.doremir.scorecloud-binary-document": { + source: "iana" + }, + "application/vnd.dpgraph": { + source: "iana", + extensions: ["dpg"] + }, + "application/vnd.dreamfactory": { + source: "iana", + extensions: ["dfac"] + }, + "application/vnd.drive+json": { + source: "iana", + compressible: true + }, + "application/vnd.ds-keypoint": { + source: "apache", + extensions: ["kpxx"] + }, + "application/vnd.dtg.local": { + source: "iana" + }, + "application/vnd.dtg.local.flash": { + source: "iana" + }, + "application/vnd.dtg.local.html": { + source: "iana" + }, + "application/vnd.dvb.ait": { + source: "iana", + extensions: ["ait"] + }, + "application/vnd.dvb.dvbisl+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.dvbj": { + source: "iana" + }, + "application/vnd.dvb.esgcontainer": { + source: "iana" + }, + "application/vnd.dvb.ipdcdftnotifaccess": { + source: "iana" + }, + "application/vnd.dvb.ipdcesgaccess": { + source: "iana" + }, + "application/vnd.dvb.ipdcesgaccess2": { + source: "iana" + }, + "application/vnd.dvb.ipdcesgpdd": { + source: "iana" + }, + "application/vnd.dvb.ipdcroaming": { + source: "iana" + }, + "application/vnd.dvb.iptv.alfec-base": { + source: "iana" + }, + "application/vnd.dvb.iptv.alfec-enhancement": { + source: "iana" + }, + "application/vnd.dvb.notif-aggregate-root+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-container+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-generic+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-ia-msglist+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-ia-registration-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-ia-registration-response+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.notif-init+xml": { + source: "iana", + compressible: true + }, + "application/vnd.dvb.pfr": { + source: "iana" + }, + "application/vnd.dvb.service": { + source: "iana", + extensions: ["svc"] + }, + "application/vnd.dxr": { + source: "iana" + }, + "application/vnd.dynageo": { + source: "iana", + extensions: ["geo"] + }, + "application/vnd.dzr": { + source: "iana" + }, + "application/vnd.easykaraoke.cdgdownload": { + source: "iana" + }, + "application/vnd.ecdis-update": { + source: "iana" + }, + "application/vnd.ecip.rlp": { + source: "iana" + }, + "application/vnd.eclipse.ditto+json": { + source: "iana", + compressible: true + }, + "application/vnd.ecowin.chart": { + source: "iana", + extensions: ["mag"] + }, + "application/vnd.ecowin.filerequest": { + source: "iana" + }, + "application/vnd.ecowin.fileupdate": { + source: "iana" + }, + "application/vnd.ecowin.series": { + source: "iana" + }, + "application/vnd.ecowin.seriesrequest": { + source: "iana" + }, + "application/vnd.ecowin.seriesupdate": { + source: "iana" + }, + "application/vnd.efi.img": { + source: "iana" + }, + "application/vnd.efi.iso": { + source: "iana" + }, + "application/vnd.emclient.accessrequest+xml": { + source: "iana", + compressible: true + }, + "application/vnd.enliven": { + source: "iana", + extensions: ["nml"] + }, + "application/vnd.enphase.envoy": { + source: "iana" + }, + "application/vnd.eprints.data+xml": { + source: "iana", + compressible: true + }, + "application/vnd.epson.esf": { + source: "iana", + extensions: ["esf"] + }, + "application/vnd.epson.msf": { + source: "iana", + extensions: ["msf"] + }, + "application/vnd.epson.quickanime": { + source: "iana", + extensions: ["qam"] + }, + "application/vnd.epson.salt": { + source: "iana", + extensions: ["slt"] + }, + "application/vnd.epson.ssf": { + source: "iana", + extensions: ["ssf"] + }, + "application/vnd.ericsson.quickcall": { + source: "iana" + }, + "application/vnd.espass-espass+zip": { + source: "iana", + compressible: false + }, + "application/vnd.eszigno3+xml": { + source: "iana", + compressible: true, + extensions: ["es3", "et3"] + }, + "application/vnd.etsi.aoc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.asic-e+zip": { + source: "iana", + compressible: false + }, + "application/vnd.etsi.asic-s+zip": { + source: "iana", + compressible: false + }, + "application/vnd.etsi.cug+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvcommand+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvdiscovery+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsad-bc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsad-cod+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsad-npvr+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvservice+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvsync+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.iptvueprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.mcid+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.mheg5": { + source: "iana" + }, + "application/vnd.etsi.overload-control-policy-dataset+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.pstn+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.sci+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.simservs+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.timestamp-token": { + source: "iana" + }, + "application/vnd.etsi.tsl+xml": { + source: "iana", + compressible: true + }, + "application/vnd.etsi.tsl.der": { + source: "iana" + }, + "application/vnd.eu.kasparian.car+json": { + source: "iana", + compressible: true + }, + "application/vnd.eudora.data": { + source: "iana" + }, + "application/vnd.evolv.ecig.profile": { + source: "iana" + }, + "application/vnd.evolv.ecig.settings": { + source: "iana" + }, + "application/vnd.evolv.ecig.theme": { + source: "iana" + }, + "application/vnd.exstream-empower+zip": { + source: "iana", + compressible: false + }, + "application/vnd.exstream-package": { + source: "iana" + }, + "application/vnd.ezpix-album": { + source: "iana", + extensions: ["ez2"] + }, + "application/vnd.ezpix-package": { + source: "iana", + extensions: ["ez3"] + }, + "application/vnd.f-secure.mobile": { + source: "iana" + }, + "application/vnd.familysearch.gedcom+zip": { + source: "iana", + compressible: false + }, + "application/vnd.fastcopy-disk-image": { + source: "iana" + }, + "application/vnd.fdf": { + source: "iana", + extensions: ["fdf"] + }, + "application/vnd.fdsn.mseed": { + source: "iana", + extensions: ["mseed"] + }, + "application/vnd.fdsn.seed": { + source: "iana", + extensions: ["seed", "dataless"] + }, + "application/vnd.ffsns": { + source: "iana" + }, + "application/vnd.ficlab.flb+zip": { + source: "iana", + compressible: false + }, + "application/vnd.filmit.zfc": { + source: "iana" + }, + "application/vnd.fints": { + source: "iana" + }, + "application/vnd.firemonkeys.cloudcell": { + source: "iana" + }, + "application/vnd.flographit": { + source: "iana", + extensions: ["gph"] + }, + "application/vnd.fluxtime.clip": { + source: "iana", + extensions: ["ftc"] + }, + "application/vnd.font-fontforge-sfd": { + source: "iana" + }, + "application/vnd.framemaker": { + source: "iana", + extensions: ["fm", "frame", "maker", "book"] + }, + "application/vnd.frogans.fnc": { + source: "iana", + extensions: ["fnc"] + }, + "application/vnd.frogans.ltf": { + source: "iana", + extensions: ["ltf"] + }, + "application/vnd.fsc.weblaunch": { + source: "iana", + extensions: ["fsc"] + }, + "application/vnd.fujifilm.fb.docuworks": { + source: "iana" + }, + "application/vnd.fujifilm.fb.docuworks.binder": { + source: "iana" + }, + "application/vnd.fujifilm.fb.docuworks.container": { + source: "iana" + }, + "application/vnd.fujifilm.fb.jfi+xml": { + source: "iana", + compressible: true + }, + "application/vnd.fujitsu.oasys": { + source: "iana", + extensions: ["oas"] + }, + "application/vnd.fujitsu.oasys2": { + source: "iana", + extensions: ["oa2"] + }, + "application/vnd.fujitsu.oasys3": { + source: "iana", + extensions: ["oa3"] + }, + "application/vnd.fujitsu.oasysgp": { + source: "iana", + extensions: ["fg5"] + }, + "application/vnd.fujitsu.oasysprs": { + source: "iana", + extensions: ["bh2"] + }, + "application/vnd.fujixerox.art-ex": { + source: "iana" + }, + "application/vnd.fujixerox.art4": { + source: "iana" + }, + "application/vnd.fujixerox.ddd": { + source: "iana", + extensions: ["ddd"] + }, + "application/vnd.fujixerox.docuworks": { + source: "iana", + extensions: ["xdw"] + }, + "application/vnd.fujixerox.docuworks.binder": { + source: "iana", + extensions: ["xbd"] + }, + "application/vnd.fujixerox.docuworks.container": { + source: "iana" + }, + "application/vnd.fujixerox.hbpl": { + source: "iana" + }, + "application/vnd.fut-misnet": { + source: "iana" + }, + "application/vnd.futoin+cbor": { + source: "iana" + }, + "application/vnd.futoin+json": { + source: "iana", + compressible: true + }, + "application/vnd.fuzzysheet": { + source: "iana", + extensions: ["fzs"] + }, + "application/vnd.genomatix.tuxedo": { + source: "iana", + extensions: ["txd"] + }, + "application/vnd.gentics.grd+json": { + source: "iana", + compressible: true + }, + "application/vnd.geo+json": { + source: "iana", + compressible: true + }, + "application/vnd.geocube+xml": { + source: "iana", + compressible: true + }, + "application/vnd.geogebra.file": { + source: "iana", + extensions: ["ggb"] + }, + "application/vnd.geogebra.slides": { + source: "iana" + }, + "application/vnd.geogebra.tool": { + source: "iana", + extensions: ["ggt"] + }, + "application/vnd.geometry-explorer": { + source: "iana", + extensions: ["gex", "gre"] + }, + "application/vnd.geonext": { + source: "iana", + extensions: ["gxt"] + }, + "application/vnd.geoplan": { + source: "iana", + extensions: ["g2w"] + }, + "application/vnd.geospace": { + source: "iana", + extensions: ["g3w"] + }, + "application/vnd.gerber": { + source: "iana" + }, + "application/vnd.globalplatform.card-content-mgt": { + source: "iana" + }, + "application/vnd.globalplatform.card-content-mgt-response": { + source: "iana" + }, + "application/vnd.gmx": { + source: "iana", + extensions: ["gmx"] + }, + "application/vnd.google-apps.document": { + compressible: false, + extensions: ["gdoc"] + }, + "application/vnd.google-apps.presentation": { + compressible: false, + extensions: ["gslides"] + }, + "application/vnd.google-apps.spreadsheet": { + compressible: false, + extensions: ["gsheet"] + }, + "application/vnd.google-earth.kml+xml": { + source: "iana", + compressible: true, + extensions: ["kml"] + }, + "application/vnd.google-earth.kmz": { + source: "iana", + compressible: false, + extensions: ["kmz"] + }, + "application/vnd.gov.sk.e-form+xml": { + source: "iana", + compressible: true + }, + "application/vnd.gov.sk.e-form+zip": { + source: "iana", + compressible: false + }, + "application/vnd.gov.sk.xmldatacontainer+xml": { + source: "iana", + compressible: true + }, + "application/vnd.grafeq": { + source: "iana", + extensions: ["gqf", "gqs"] + }, + "application/vnd.gridmp": { + source: "iana" + }, + "application/vnd.groove-account": { + source: "iana", + extensions: ["gac"] + }, + "application/vnd.groove-help": { + source: "iana", + extensions: ["ghf"] + }, + "application/vnd.groove-identity-message": { + source: "iana", + extensions: ["gim"] + }, + "application/vnd.groove-injector": { + source: "iana", + extensions: ["grv"] + }, + "application/vnd.groove-tool-message": { + source: "iana", + extensions: ["gtm"] + }, + "application/vnd.groove-tool-template": { + source: "iana", + extensions: ["tpl"] + }, + "application/vnd.groove-vcard": { + source: "iana", + extensions: ["vcg"] + }, + "application/vnd.hal+json": { + source: "iana", + compressible: true + }, + "application/vnd.hal+xml": { + source: "iana", + compressible: true, + extensions: ["hal"] + }, + "application/vnd.handheld-entertainment+xml": { + source: "iana", + compressible: true, + extensions: ["zmm"] + }, + "application/vnd.hbci": { + source: "iana", + extensions: ["hbci"] + }, + "application/vnd.hc+json": { + source: "iana", + compressible: true + }, + "application/vnd.hcl-bireports": { + source: "iana" + }, + "application/vnd.hdt": { + source: "iana" + }, + "application/vnd.heroku+json": { + source: "iana", + compressible: true + }, + "application/vnd.hhe.lesson-player": { + source: "iana", + extensions: ["les"] + }, + "application/vnd.hl7cda+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.hl7v2+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.hp-hpgl": { + source: "iana", + extensions: ["hpgl"] + }, + "application/vnd.hp-hpid": { + source: "iana", + extensions: ["hpid"] + }, + "application/vnd.hp-hps": { + source: "iana", + extensions: ["hps"] + }, + "application/vnd.hp-jlyt": { + source: "iana", + extensions: ["jlt"] + }, + "application/vnd.hp-pcl": { + source: "iana", + extensions: ["pcl"] + }, + "application/vnd.hp-pclxl": { + source: "iana", + extensions: ["pclxl"] + }, + "application/vnd.httphone": { + source: "iana" + }, + "application/vnd.hydrostatix.sof-data": { + source: "iana", + extensions: ["sfd-hdstx"] + }, + "application/vnd.hyper+json": { + source: "iana", + compressible: true + }, + "application/vnd.hyper-item+json": { + source: "iana", + compressible: true + }, + "application/vnd.hyperdrive+json": { + source: "iana", + compressible: true + }, + "application/vnd.hzn-3d-crossword": { + source: "iana" + }, + "application/vnd.ibm.afplinedata": { + source: "iana" + }, + "application/vnd.ibm.electronic-media": { + source: "iana" + }, + "application/vnd.ibm.minipay": { + source: "iana", + extensions: ["mpy"] + }, + "application/vnd.ibm.modcap": { + source: "iana", + extensions: ["afp", "listafp", "list3820"] + }, + "application/vnd.ibm.rights-management": { + source: "iana", + extensions: ["irm"] + }, + "application/vnd.ibm.secure-container": { + source: "iana", + extensions: ["sc"] + }, + "application/vnd.iccprofile": { + source: "iana", + extensions: ["icc", "icm"] + }, + "application/vnd.ieee.1905": { + source: "iana" + }, + "application/vnd.igloader": { + source: "iana", + extensions: ["igl"] + }, + "application/vnd.imagemeter.folder+zip": { + source: "iana", + compressible: false + }, + "application/vnd.imagemeter.image+zip": { + source: "iana", + compressible: false + }, + "application/vnd.immervision-ivp": { + source: "iana", + extensions: ["ivp"] + }, + "application/vnd.immervision-ivu": { + source: "iana", + extensions: ["ivu"] + }, + "application/vnd.ims.imsccv1p1": { + source: "iana" + }, + "application/vnd.ims.imsccv1p2": { + source: "iana" + }, + "application/vnd.ims.imsccv1p3": { + source: "iana" + }, + "application/vnd.ims.lis.v2.result+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolconsumerprofile+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolproxy+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolproxy.id+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolsettings+json": { + source: "iana", + compressible: true + }, + "application/vnd.ims.lti.v2.toolsettings.simple+json": { + source: "iana", + compressible: true + }, + "application/vnd.informedcontrol.rms+xml": { + source: "iana", + compressible: true + }, + "application/vnd.informix-visionary": { + source: "iana" + }, + "application/vnd.infotech.project": { + source: "iana" + }, + "application/vnd.infotech.project+xml": { + source: "iana", + compressible: true + }, + "application/vnd.innopath.wamp.notification": { + source: "iana" + }, + "application/vnd.insors.igm": { + source: "iana", + extensions: ["igm"] + }, + "application/vnd.intercon.formnet": { + source: "iana", + extensions: ["xpw", "xpx"] + }, + "application/vnd.intergeo": { + source: "iana", + extensions: ["i2g"] + }, + "application/vnd.intertrust.digibox": { + source: "iana" + }, + "application/vnd.intertrust.nncp": { + source: "iana" + }, + "application/vnd.intu.qbo": { + source: "iana", + extensions: ["qbo"] + }, + "application/vnd.intu.qfx": { + source: "iana", + extensions: ["qfx"] + }, + "application/vnd.iptc.g2.catalogitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.conceptitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.knowledgeitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.newsitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.newsmessage+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.packageitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.iptc.g2.planningitem+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ipunplugged.rcprofile": { + source: "iana", + extensions: ["rcprofile"] + }, + "application/vnd.irepository.package+xml": { + source: "iana", + compressible: true, + extensions: ["irp"] + }, + "application/vnd.is-xpr": { + source: "iana", + extensions: ["xpr"] + }, + "application/vnd.isac.fcs": { + source: "iana", + extensions: ["fcs"] + }, + "application/vnd.iso11783-10+zip": { + source: "iana", + compressible: false + }, + "application/vnd.jam": { + source: "iana", + extensions: ["jam"] + }, + "application/vnd.japannet-directory-service": { + source: "iana" + }, + "application/vnd.japannet-jpnstore-wakeup": { + source: "iana" + }, + "application/vnd.japannet-payment-wakeup": { + source: "iana" + }, + "application/vnd.japannet-registration": { + source: "iana" + }, + "application/vnd.japannet-registration-wakeup": { + source: "iana" + }, + "application/vnd.japannet-setstore-wakeup": { + source: "iana" + }, + "application/vnd.japannet-verification": { + source: "iana" + }, + "application/vnd.japannet-verification-wakeup": { + source: "iana" + }, + "application/vnd.jcp.javame.midlet-rms": { + source: "iana", + extensions: ["rms"] + }, + "application/vnd.jisp": { + source: "iana", + extensions: ["jisp"] + }, + "application/vnd.joost.joda-archive": { + source: "iana", + extensions: ["joda"] + }, + "application/vnd.jsk.isdn-ngn": { + source: "iana" + }, + "application/vnd.kahootz": { + source: "iana", + extensions: ["ktz", "ktr"] + }, + "application/vnd.kde.karbon": { + source: "iana", + extensions: ["karbon"] + }, + "application/vnd.kde.kchart": { + source: "iana", + extensions: ["chrt"] + }, + "application/vnd.kde.kformula": { + source: "iana", + extensions: ["kfo"] + }, + "application/vnd.kde.kivio": { + source: "iana", + extensions: ["flw"] + }, + "application/vnd.kde.kontour": { + source: "iana", + extensions: ["kon"] + }, + "application/vnd.kde.kpresenter": { + source: "iana", + extensions: ["kpr", "kpt"] + }, + "application/vnd.kde.kspread": { + source: "iana", + extensions: ["ksp"] + }, + "application/vnd.kde.kword": { + source: "iana", + extensions: ["kwd", "kwt"] + }, + "application/vnd.kenameaapp": { + source: "iana", + extensions: ["htke"] + }, + "application/vnd.kidspiration": { + source: "iana", + extensions: ["kia"] + }, + "application/vnd.kinar": { + source: "iana", + extensions: ["kne", "knp"] + }, + "application/vnd.koan": { + source: "iana", + extensions: ["skp", "skd", "skt", "skm"] + }, + "application/vnd.kodak-descriptor": { + source: "iana", + extensions: ["sse"] + }, + "application/vnd.las": { + source: "iana" + }, + "application/vnd.las.las+json": { + source: "iana", + compressible: true + }, + "application/vnd.las.las+xml": { + source: "iana", + compressible: true, + extensions: ["lasxml"] + }, + "application/vnd.laszip": { + source: "iana" + }, + "application/vnd.leap+json": { + source: "iana", + compressible: true + }, + "application/vnd.liberty-request+xml": { + source: "iana", + compressible: true + }, + "application/vnd.llamagraphics.life-balance.desktop": { + source: "iana", + extensions: ["lbd"] + }, + "application/vnd.llamagraphics.life-balance.exchange+xml": { + source: "iana", + compressible: true, + extensions: ["lbe"] + }, + "application/vnd.logipipe.circuit+zip": { + source: "iana", + compressible: false + }, + "application/vnd.loom": { + source: "iana" + }, + "application/vnd.lotus-1-2-3": { + source: "iana", + extensions: ["123"] + }, + "application/vnd.lotus-approach": { + source: "iana", + extensions: ["apr"] + }, + "application/vnd.lotus-freelance": { + source: "iana", + extensions: ["pre"] + }, + "application/vnd.lotus-notes": { + source: "iana", + extensions: ["nsf"] + }, + "application/vnd.lotus-organizer": { + source: "iana", + extensions: ["org"] + }, + "application/vnd.lotus-screencam": { + source: "iana", + extensions: ["scm"] + }, + "application/vnd.lotus-wordpro": { + source: "iana", + extensions: ["lwp"] + }, + "application/vnd.macports.portpkg": { + source: "iana", + extensions: ["portpkg"] + }, + "application/vnd.mapbox-vector-tile": { + source: "iana", + extensions: ["mvt"] + }, + "application/vnd.marlin.drm.actiontoken+xml": { + source: "iana", + compressible: true + }, + "application/vnd.marlin.drm.conftoken+xml": { + source: "iana", + compressible: true + }, + "application/vnd.marlin.drm.license+xml": { + source: "iana", + compressible: true + }, + "application/vnd.marlin.drm.mdcf": { + source: "iana" + }, + "application/vnd.mason+json": { + source: "iana", + compressible: true + }, + "application/vnd.maxar.archive.3tz+zip": { + source: "iana", + compressible: false + }, + "application/vnd.maxmind.maxmind-db": { + source: "iana" + }, + "application/vnd.mcd": { + source: "iana", + extensions: ["mcd"] + }, + "application/vnd.medcalcdata": { + source: "iana", + extensions: ["mc1"] + }, + "application/vnd.mediastation.cdkey": { + source: "iana", + extensions: ["cdkey"] + }, + "application/vnd.meridian-slingshot": { + source: "iana" + }, + "application/vnd.mfer": { + source: "iana", + extensions: ["mwf"] + }, + "application/vnd.mfmp": { + source: "iana", + extensions: ["mfm"] + }, + "application/vnd.micro+json": { + source: "iana", + compressible: true + }, + "application/vnd.micrografx.flo": { + source: "iana", + extensions: ["flo"] + }, + "application/vnd.micrografx.igx": { + source: "iana", + extensions: ["igx"] + }, + "application/vnd.microsoft.portable-executable": { + source: "iana" + }, + "application/vnd.microsoft.windows.thumbnail-cache": { + source: "iana" + }, + "application/vnd.miele+json": { + source: "iana", + compressible: true + }, + "application/vnd.mif": { + source: "iana", + extensions: ["mif"] + }, + "application/vnd.minisoft-hp3000-save": { + source: "iana" + }, + "application/vnd.mitsubishi.misty-guard.trustweb": { + source: "iana" + }, + "application/vnd.mobius.daf": { + source: "iana", + extensions: ["daf"] + }, + "application/vnd.mobius.dis": { + source: "iana", + extensions: ["dis"] + }, + "application/vnd.mobius.mbk": { + source: "iana", + extensions: ["mbk"] + }, + "application/vnd.mobius.mqy": { + source: "iana", + extensions: ["mqy"] + }, + "application/vnd.mobius.msl": { + source: "iana", + extensions: ["msl"] + }, + "application/vnd.mobius.plc": { + source: "iana", + extensions: ["plc"] + }, + "application/vnd.mobius.txf": { + source: "iana", + extensions: ["txf"] + }, + "application/vnd.mophun.application": { + source: "iana", + extensions: ["mpn"] + }, + "application/vnd.mophun.certificate": { + source: "iana", + extensions: ["mpc"] + }, + "application/vnd.motorola.flexsuite": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.adsi": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.fis": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.gotap": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.kmr": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.ttc": { + source: "iana" + }, + "application/vnd.motorola.flexsuite.wem": { + source: "iana" + }, + "application/vnd.motorola.iprm": { + source: "iana" + }, + "application/vnd.mozilla.xul+xml": { + source: "iana", + compressible: true, + extensions: ["xul"] + }, + "application/vnd.ms-3mfdocument": { + source: "iana" + }, + "application/vnd.ms-artgalry": { + source: "iana", + extensions: ["cil"] + }, + "application/vnd.ms-asf": { + source: "iana" + }, + "application/vnd.ms-cab-compressed": { + source: "iana", + extensions: ["cab"] + }, + "application/vnd.ms-color.iccprofile": { + source: "apache" + }, + "application/vnd.ms-excel": { + source: "iana", + compressible: false, + extensions: ["xls", "xlm", "xla", "xlc", "xlt", "xlw"] + }, + "application/vnd.ms-excel.addin.macroenabled.12": { + source: "iana", + extensions: ["xlam"] + }, + "application/vnd.ms-excel.sheet.binary.macroenabled.12": { + source: "iana", + extensions: ["xlsb"] + }, + "application/vnd.ms-excel.sheet.macroenabled.12": { + source: "iana", + extensions: ["xlsm"] + }, + "application/vnd.ms-excel.template.macroenabled.12": { + source: "iana", + extensions: ["xltm"] + }, + "application/vnd.ms-fontobject": { + source: "iana", + compressible: true, + extensions: ["eot"] + }, + "application/vnd.ms-htmlhelp": { + source: "iana", + extensions: ["chm"] + }, + "application/vnd.ms-ims": { + source: "iana", + extensions: ["ims"] + }, + "application/vnd.ms-lrm": { + source: "iana", + extensions: ["lrm"] + }, + "application/vnd.ms-office.activex+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-officetheme": { + source: "iana", + extensions: ["thmx"] + }, + "application/vnd.ms-opentype": { + source: "apache", + compressible: true + }, + "application/vnd.ms-outlook": { + compressible: false, + extensions: ["msg"] + }, + "application/vnd.ms-package.obfuscated-opentype": { + source: "apache" + }, + "application/vnd.ms-pki.seccat": { + source: "apache", + extensions: ["cat"] + }, + "application/vnd.ms-pki.stl": { + source: "apache", + extensions: ["stl"] + }, + "application/vnd.ms-playready.initiator+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-powerpoint": { + source: "iana", + compressible: false, + extensions: ["ppt", "pps", "pot"] + }, + "application/vnd.ms-powerpoint.addin.macroenabled.12": { + source: "iana", + extensions: ["ppam"] + }, + "application/vnd.ms-powerpoint.presentation.macroenabled.12": { + source: "iana", + extensions: ["pptm"] + }, + "application/vnd.ms-powerpoint.slide.macroenabled.12": { + source: "iana", + extensions: ["sldm"] + }, + "application/vnd.ms-powerpoint.slideshow.macroenabled.12": { + source: "iana", + extensions: ["ppsm"] + }, + "application/vnd.ms-powerpoint.template.macroenabled.12": { + source: "iana", + extensions: ["potm"] + }, + "application/vnd.ms-printdevicecapabilities+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-printing.printticket+xml": { + source: "apache", + compressible: true + }, + "application/vnd.ms-printschematicket+xml": { + source: "iana", + compressible: true + }, + "application/vnd.ms-project": { + source: "iana", + extensions: ["mpp", "mpt"] + }, + "application/vnd.ms-tnef": { + source: "iana" + }, + "application/vnd.ms-windows.devicepairing": { + source: "iana" + }, + "application/vnd.ms-windows.nwprinting.oob": { + source: "iana" + }, + "application/vnd.ms-windows.printerpairing": { + source: "iana" + }, + "application/vnd.ms-windows.wsd.oob": { + source: "iana" + }, + "application/vnd.ms-wmdrm.lic-chlg-req": { + source: "iana" + }, + "application/vnd.ms-wmdrm.lic-resp": { + source: "iana" + }, + "application/vnd.ms-wmdrm.meter-chlg-req": { + source: "iana" + }, + "application/vnd.ms-wmdrm.meter-resp": { + source: "iana" + }, + "application/vnd.ms-word.document.macroenabled.12": { + source: "iana", + extensions: ["docm"] + }, + "application/vnd.ms-word.template.macroenabled.12": { + source: "iana", + extensions: ["dotm"] + }, + "application/vnd.ms-works": { + source: "iana", + extensions: ["wps", "wks", "wcm", "wdb"] + }, + "application/vnd.ms-wpl": { + source: "iana", + extensions: ["wpl"] + }, + "application/vnd.ms-xpsdocument": { + source: "iana", + compressible: false, + extensions: ["xps"] + }, + "application/vnd.msa-disk-image": { + source: "iana" + }, + "application/vnd.mseq": { + source: "iana", + extensions: ["mseq"] + }, + "application/vnd.msign": { + source: "iana" + }, + "application/vnd.multiad.creator": { + source: "iana" + }, + "application/vnd.multiad.creator.cif": { + source: "iana" + }, + "application/vnd.music-niff": { + source: "iana" + }, + "application/vnd.musician": { + source: "iana", + extensions: ["mus"] + }, + "application/vnd.muvee.style": { + source: "iana", + extensions: ["msty"] + }, + "application/vnd.mynfc": { + source: "iana", + extensions: ["taglet"] + }, + "application/vnd.nacamar.ybrid+json": { + source: "iana", + compressible: true + }, + "application/vnd.ncd.control": { + source: "iana" + }, + "application/vnd.ncd.reference": { + source: "iana" + }, + "application/vnd.nearst.inv+json": { + source: "iana", + compressible: true + }, + "application/vnd.nebumind.line": { + source: "iana" + }, + "application/vnd.nervana": { + source: "iana" + }, + "application/vnd.netfpx": { + source: "iana" + }, + "application/vnd.neurolanguage.nlu": { + source: "iana", + extensions: ["nlu"] + }, + "application/vnd.nimn": { + source: "iana" + }, + "application/vnd.nintendo.nitro.rom": { + source: "iana" + }, + "application/vnd.nintendo.snes.rom": { + source: "iana" + }, + "application/vnd.nitf": { + source: "iana", + extensions: ["ntf", "nitf"] + }, + "application/vnd.noblenet-directory": { + source: "iana", + extensions: ["nnd"] + }, + "application/vnd.noblenet-sealer": { + source: "iana", + extensions: ["nns"] + }, + "application/vnd.noblenet-web": { + source: "iana", + extensions: ["nnw"] + }, + "application/vnd.nokia.catalogs": { + source: "iana" + }, + "application/vnd.nokia.conml+wbxml": { + source: "iana" + }, + "application/vnd.nokia.conml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.iptv.config+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.isds-radio-presets": { + source: "iana" + }, + "application/vnd.nokia.landmark+wbxml": { + source: "iana" + }, + "application/vnd.nokia.landmark+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.landmarkcollection+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.n-gage.ac+xml": { + source: "iana", + compressible: true, + extensions: ["ac"] + }, + "application/vnd.nokia.n-gage.data": { + source: "iana", + extensions: ["ngdat"] + }, + "application/vnd.nokia.n-gage.symbian.install": { + source: "iana", + extensions: ["n-gage"] + }, + "application/vnd.nokia.ncd": { + source: "iana" + }, + "application/vnd.nokia.pcd+wbxml": { + source: "iana" + }, + "application/vnd.nokia.pcd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.nokia.radio-preset": { + source: "iana", + extensions: ["rpst"] + }, + "application/vnd.nokia.radio-presets": { + source: "iana", + extensions: ["rpss"] + }, + "application/vnd.novadigm.edm": { + source: "iana", + extensions: ["edm"] + }, + "application/vnd.novadigm.edx": { + source: "iana", + extensions: ["edx"] + }, + "application/vnd.novadigm.ext": { + source: "iana", + extensions: ["ext"] + }, + "application/vnd.ntt-local.content-share": { + source: "iana" + }, + "application/vnd.ntt-local.file-transfer": { + source: "iana" + }, + "application/vnd.ntt-local.ogw_remote-access": { + source: "iana" + }, + "application/vnd.ntt-local.sip-ta_remote": { + source: "iana" + }, + "application/vnd.ntt-local.sip-ta_tcp_stream": { + source: "iana" + }, + "application/vnd.oasis.opendocument.chart": { + source: "iana", + extensions: ["odc"] + }, + "application/vnd.oasis.opendocument.chart-template": { + source: "iana", + extensions: ["otc"] + }, + "application/vnd.oasis.opendocument.database": { + source: "iana", + extensions: ["odb"] + }, + "application/vnd.oasis.opendocument.formula": { + source: "iana", + extensions: ["odf"] + }, + "application/vnd.oasis.opendocument.formula-template": { + source: "iana", + extensions: ["odft"] + }, + "application/vnd.oasis.opendocument.graphics": { + source: "iana", + compressible: false, + extensions: ["odg"] + }, + "application/vnd.oasis.opendocument.graphics-template": { + source: "iana", + extensions: ["otg"] + }, + "application/vnd.oasis.opendocument.image": { + source: "iana", + extensions: ["odi"] + }, + "application/vnd.oasis.opendocument.image-template": { + source: "iana", + extensions: ["oti"] + }, + "application/vnd.oasis.opendocument.presentation": { + source: "iana", + compressible: false, + extensions: ["odp"] + }, + "application/vnd.oasis.opendocument.presentation-template": { + source: "iana", + extensions: ["otp"] + }, + "application/vnd.oasis.opendocument.spreadsheet": { + source: "iana", + compressible: false, + extensions: ["ods"] + }, + "application/vnd.oasis.opendocument.spreadsheet-template": { + source: "iana", + extensions: ["ots"] + }, + "application/vnd.oasis.opendocument.text": { + source: "iana", + compressible: false, + extensions: ["odt"] + }, + "application/vnd.oasis.opendocument.text-master": { + source: "iana", + extensions: ["odm"] + }, + "application/vnd.oasis.opendocument.text-template": { + source: "iana", + extensions: ["ott"] + }, + "application/vnd.oasis.opendocument.text-web": { + source: "iana", + extensions: ["oth"] + }, + "application/vnd.obn": { + source: "iana" + }, + "application/vnd.ocf+cbor": { + source: "iana" + }, + "application/vnd.oci.image.manifest.v1+json": { + source: "iana", + compressible: true + }, + "application/vnd.oftn.l10n+json": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.contentaccessdownload+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.contentaccessstreaming+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.cspg-hexbinary": { + source: "iana" + }, + "application/vnd.oipf.dae.svg+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.dae.xhtml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.mippvcontrolmessage+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.pae.gem": { + source: "iana" + }, + "application/vnd.oipf.spdiscovery+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.spdlist+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.ueprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oipf.userprofile+xml": { + source: "iana", + compressible: true + }, + "application/vnd.olpc-sugar": { + source: "iana", + extensions: ["xo"] + }, + "application/vnd.oma-scws-config": { + source: "iana" + }, + "application/vnd.oma-scws-http-request": { + source: "iana" + }, + "application/vnd.oma-scws-http-response": { + source: "iana" + }, + "application/vnd.oma.bcast.associated-procedure-parameter+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.drm-trigger+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.imd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.ltkm": { + source: "iana" + }, + "application/vnd.oma.bcast.notification+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.provisioningtrigger": { + source: "iana" + }, + "application/vnd.oma.bcast.sgboot": { + source: "iana" + }, + "application/vnd.oma.bcast.sgdd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.sgdu": { + source: "iana" + }, + "application/vnd.oma.bcast.simple-symbol-container": { + source: "iana" + }, + "application/vnd.oma.bcast.smartcard-trigger+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.sprov+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.bcast.stkm": { + source: "iana" + }, + "application/vnd.oma.cab-address-book+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-feature-handler+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-pcc+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-subs-invite+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.cab-user-prefs+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.dcd": { + source: "iana" + }, + "application/vnd.oma.dcdc": { + source: "iana" + }, + "application/vnd.oma.dd2+xml": { + source: "iana", + compressible: true, + extensions: ["dd2"] + }, + "application/vnd.oma.drm.risd+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.group-usage-list+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.lwm2m+cbor": { + source: "iana" + }, + "application/vnd.oma.lwm2m+json": { + source: "iana", + compressible: true + }, + "application/vnd.oma.lwm2m+tlv": { + source: "iana" + }, + "application/vnd.oma.pal+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.detailed-progress-report+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.final-report+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.groups+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.invocation-descriptor+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.poc.optimized-progress-report+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.push": { + source: "iana" + }, + "application/vnd.oma.scidm.messages+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oma.xcap-directory+xml": { + source: "iana", + compressible: true + }, + "application/vnd.omads-email+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.omads-file+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.omads-folder+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.omaloc-supl-init": { + source: "iana" + }, + "application/vnd.onepager": { + source: "iana" + }, + "application/vnd.onepagertamp": { + source: "iana" + }, + "application/vnd.onepagertamx": { + source: "iana" + }, + "application/vnd.onepagertat": { + source: "iana" + }, + "application/vnd.onepagertatp": { + source: "iana" + }, + "application/vnd.onepagertatx": { + source: "iana" + }, + "application/vnd.openblox.game+xml": { + source: "iana", + compressible: true, + extensions: ["obgx"] + }, + "application/vnd.openblox.game-binary": { + source: "iana" + }, + "application/vnd.openeye.oeb": { + source: "iana" + }, + "application/vnd.openofficeorg.extension": { + source: "apache", + extensions: ["oxt"] + }, + "application/vnd.openstreetmap.data+xml": { + source: "iana", + compressible: true, + extensions: ["osm"] + }, + "application/vnd.opentimestamps.ots": { + source: "iana" + }, + "application/vnd.openxmlformats-officedocument.custom-properties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.customxmlproperties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawing+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.chart+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.extended-properties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.comments+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.presentation": { + source: "iana", + compressible: false, + extensions: ["pptx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.presprops+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slide": { + source: "iana", + extensions: ["sldx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.slide+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slideshow": { + source: "iana", + extensions: ["ppsx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.tags+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.template": { + source: "iana", + extensions: ["potx"] + }, + "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": { + source: "iana", + compressible: false, + extensions: ["xlsx"] + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.template": { + source: "iana", + extensions: ["xltx"] + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.theme+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.themeoverride+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.vmldrawing": { + source: "iana" + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.document": { + source: "iana", + compressible: false, + extensions: ["docx"] + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.template": { + source: "iana", + extensions: ["dotx"] + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-package.core-properties+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml": { + source: "iana", + compressible: true + }, + "application/vnd.openxmlformats-package.relationships+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oracle.resource+json": { + source: "iana", + compressible: true + }, + "application/vnd.orange.indata": { + source: "iana" + }, + "application/vnd.osa.netdeploy": { + source: "iana" + }, + "application/vnd.osgeo.mapguide.package": { + source: "iana", + extensions: ["mgp"] + }, + "application/vnd.osgi.bundle": { + source: "iana" + }, + "application/vnd.osgi.dp": { + source: "iana", + extensions: ["dp"] + }, + "application/vnd.osgi.subsystem": { + source: "iana", + extensions: ["esa"] + }, + "application/vnd.otps.ct-kip+xml": { + source: "iana", + compressible: true + }, + "application/vnd.oxli.countgraph": { + source: "iana" + }, + "application/vnd.pagerduty+json": { + source: "iana", + compressible: true + }, + "application/vnd.palm": { + source: "iana", + extensions: ["pdb", "pqa", "oprc"] + }, + "application/vnd.panoply": { + source: "iana" + }, + "application/vnd.paos.xml": { + source: "iana" + }, + "application/vnd.patentdive": { + source: "iana" + }, + "application/vnd.patientecommsdoc": { + source: "iana" + }, + "application/vnd.pawaafile": { + source: "iana", + extensions: ["paw"] + }, + "application/vnd.pcos": { + source: "iana" + }, + "application/vnd.pg.format": { + source: "iana", + extensions: ["str"] + }, + "application/vnd.pg.osasli": { + source: "iana", + extensions: ["ei6"] + }, + "application/vnd.piaccess.application-licence": { + source: "iana" + }, + "application/vnd.picsel": { + source: "iana", + extensions: ["efif"] + }, + "application/vnd.pmi.widget": { + source: "iana", + extensions: ["wg"] + }, + "application/vnd.poc.group-advertisement+xml": { + source: "iana", + compressible: true + }, + "application/vnd.pocketlearn": { + source: "iana", + extensions: ["plf"] + }, + "application/vnd.powerbuilder6": { + source: "iana", + extensions: ["pbd"] + }, + "application/vnd.powerbuilder6-s": { + source: "iana" + }, + "application/vnd.powerbuilder7": { + source: "iana" + }, + "application/vnd.powerbuilder7-s": { + source: "iana" + }, + "application/vnd.powerbuilder75": { + source: "iana" + }, + "application/vnd.powerbuilder75-s": { + source: "iana" + }, + "application/vnd.preminet": { + source: "iana" + }, + "application/vnd.previewsystems.box": { + source: "iana", + extensions: ["box"] + }, + "application/vnd.proteus.magazine": { + source: "iana", + extensions: ["mgz"] + }, + "application/vnd.psfs": { + source: "iana" + }, + "application/vnd.publishare-delta-tree": { + source: "iana", + extensions: ["qps"] + }, + "application/vnd.pvi.ptid1": { + source: "iana", + extensions: ["ptid"] + }, + "application/vnd.pwg-multiplexed": { + source: "iana" + }, + "application/vnd.pwg-xhtml-print+xml": { + source: "iana", + compressible: true + }, + "application/vnd.qualcomm.brew-app-res": { + source: "iana" + }, + "application/vnd.quarantainenet": { + source: "iana" + }, + "application/vnd.quark.quarkxpress": { + source: "iana", + extensions: ["qxd", "qxt", "qwd", "qwt", "qxl", "qxb"] + }, + "application/vnd.quobject-quoxdocument": { + source: "iana" + }, + "application/vnd.radisys.moml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-conf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-conn+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-dialog+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-audit-stream+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-conf+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-base+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-fax-detect+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-fax-sendrecv+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-group+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-speech+xml": { + source: "iana", + compressible: true + }, + "application/vnd.radisys.msml-dialog-transform+xml": { + source: "iana", + compressible: true + }, + "application/vnd.rainstor.data": { + source: "iana" + }, + "application/vnd.rapid": { + source: "iana" + }, + "application/vnd.rar": { + source: "iana", + extensions: ["rar"] + }, + "application/vnd.realvnc.bed": { + source: "iana", + extensions: ["bed"] + }, + "application/vnd.recordare.musicxml": { + source: "iana", + extensions: ["mxl"] + }, + "application/vnd.recordare.musicxml+xml": { + source: "iana", + compressible: true, + extensions: ["musicxml"] + }, + "application/vnd.renlearn.rlprint": { + source: "iana" + }, + "application/vnd.resilient.logic": { + source: "iana" + }, + "application/vnd.restful+json": { + source: "iana", + compressible: true + }, + "application/vnd.rig.cryptonote": { + source: "iana", + extensions: ["cryptonote"] + }, + "application/vnd.rim.cod": { + source: "apache", + extensions: ["cod"] + }, + "application/vnd.rn-realmedia": { + source: "apache", + extensions: ["rm"] + }, + "application/vnd.rn-realmedia-vbr": { + source: "apache", + extensions: ["rmvb"] + }, + "application/vnd.route66.link66+xml": { + source: "iana", + compressible: true, + extensions: ["link66"] + }, + "application/vnd.rs-274x": { + source: "iana" + }, + "application/vnd.ruckus.download": { + source: "iana" + }, + "application/vnd.s3sms": { + source: "iana" + }, + "application/vnd.sailingtracker.track": { + source: "iana", + extensions: ["st"] + }, + "application/vnd.sar": { + source: "iana" + }, + "application/vnd.sbm.cid": { + source: "iana" + }, + "application/vnd.sbm.mid2": { + source: "iana" + }, + "application/vnd.scribus": { + source: "iana" + }, + "application/vnd.sealed.3df": { + source: "iana" + }, + "application/vnd.sealed.csf": { + source: "iana" + }, + "application/vnd.sealed.doc": { + source: "iana" + }, + "application/vnd.sealed.eml": { + source: "iana" + }, + "application/vnd.sealed.mht": { + source: "iana" + }, + "application/vnd.sealed.net": { + source: "iana" + }, + "application/vnd.sealed.ppt": { + source: "iana" + }, + "application/vnd.sealed.tiff": { + source: "iana" + }, + "application/vnd.sealed.xls": { + source: "iana" + }, + "application/vnd.sealedmedia.softseal.html": { + source: "iana" + }, + "application/vnd.sealedmedia.softseal.pdf": { + source: "iana" + }, + "application/vnd.seemail": { + source: "iana", + extensions: ["see"] + }, + "application/vnd.seis+json": { + source: "iana", + compressible: true + }, + "application/vnd.sema": { + source: "iana", + extensions: ["sema"] + }, + "application/vnd.semd": { + source: "iana", + extensions: ["semd"] + }, + "application/vnd.semf": { + source: "iana", + extensions: ["semf"] + }, + "application/vnd.shade-save-file": { + source: "iana" + }, + "application/vnd.shana.informed.formdata": { + source: "iana", + extensions: ["ifm"] + }, + "application/vnd.shana.informed.formtemplate": { + source: "iana", + extensions: ["itp"] + }, + "application/vnd.shana.informed.interchange": { + source: "iana", + extensions: ["iif"] + }, + "application/vnd.shana.informed.package": { + source: "iana", + extensions: ["ipk"] + }, + "application/vnd.shootproof+json": { + source: "iana", + compressible: true + }, + "application/vnd.shopkick+json": { + source: "iana", + compressible: true + }, + "application/vnd.shp": { + source: "iana" + }, + "application/vnd.shx": { + source: "iana" + }, + "application/vnd.sigrok.session": { + source: "iana" + }, + "application/vnd.simtech-mindmapper": { + source: "iana", + extensions: ["twd", "twds"] + }, + "application/vnd.siren+json": { + source: "iana", + compressible: true + }, + "application/vnd.smaf": { + source: "iana", + extensions: ["mmf"] + }, + "application/vnd.smart.notebook": { + source: "iana" + }, + "application/vnd.smart.teacher": { + source: "iana", + extensions: ["teacher"] + }, + "application/vnd.snesdev-page-table": { + source: "iana" + }, + "application/vnd.software602.filler.form+xml": { + source: "iana", + compressible: true, + extensions: ["fo"] + }, + "application/vnd.software602.filler.form-xml-zip": { + source: "iana" + }, + "application/vnd.solent.sdkm+xml": { + source: "iana", + compressible: true, + extensions: ["sdkm", "sdkd"] + }, + "application/vnd.spotfire.dxp": { + source: "iana", + extensions: ["dxp"] + }, + "application/vnd.spotfire.sfs": { + source: "iana", + extensions: ["sfs"] + }, + "application/vnd.sqlite3": { + source: "iana" + }, + "application/vnd.sss-cod": { + source: "iana" + }, + "application/vnd.sss-dtf": { + source: "iana" + }, + "application/vnd.sss-ntf": { + source: "iana" + }, + "application/vnd.stardivision.calc": { + source: "apache", + extensions: ["sdc"] + }, + "application/vnd.stardivision.draw": { + source: "apache", + extensions: ["sda"] + }, + "application/vnd.stardivision.impress": { + source: "apache", + extensions: ["sdd"] + }, + "application/vnd.stardivision.math": { + source: "apache", + extensions: ["smf"] + }, + "application/vnd.stardivision.writer": { + source: "apache", + extensions: ["sdw", "vor"] + }, + "application/vnd.stardivision.writer-global": { + source: "apache", + extensions: ["sgl"] + }, + "application/vnd.stepmania.package": { + source: "iana", + extensions: ["smzip"] + }, + "application/vnd.stepmania.stepchart": { + source: "iana", + extensions: ["sm"] + }, + "application/vnd.street-stream": { + source: "iana" + }, + "application/vnd.sun.wadl+xml": { + source: "iana", + compressible: true, + extensions: ["wadl"] + }, + "application/vnd.sun.xml.calc": { + source: "apache", + extensions: ["sxc"] + }, + "application/vnd.sun.xml.calc.template": { + source: "apache", + extensions: ["stc"] + }, + "application/vnd.sun.xml.draw": { + source: "apache", + extensions: ["sxd"] + }, + "application/vnd.sun.xml.draw.template": { + source: "apache", + extensions: ["std"] + }, + "application/vnd.sun.xml.impress": { + source: "apache", + extensions: ["sxi"] + }, + "application/vnd.sun.xml.impress.template": { + source: "apache", + extensions: ["sti"] + }, + "application/vnd.sun.xml.math": { + source: "apache", + extensions: ["sxm"] + }, + "application/vnd.sun.xml.writer": { + source: "apache", + extensions: ["sxw"] + }, + "application/vnd.sun.xml.writer.global": { + source: "apache", + extensions: ["sxg"] + }, + "application/vnd.sun.xml.writer.template": { + source: "apache", + extensions: ["stw"] + }, + "application/vnd.sus-calendar": { + source: "iana", + extensions: ["sus", "susp"] + }, + "application/vnd.svd": { + source: "iana", + extensions: ["svd"] + }, + "application/vnd.swiftview-ics": { + source: "iana" + }, + "application/vnd.sycle+xml": { + source: "iana", + compressible: true + }, + "application/vnd.syft+json": { + source: "iana", + compressible: true + }, + "application/vnd.symbian.install": { + source: "apache", + extensions: ["sis", "sisx"] + }, + "application/vnd.syncml+xml": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["xsm"] + }, + "application/vnd.syncml.dm+wbxml": { + source: "iana", + charset: "UTF-8", + extensions: ["bdm"] + }, + "application/vnd.syncml.dm+xml": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["xdm"] + }, + "application/vnd.syncml.dm.notification": { + source: "iana" + }, + "application/vnd.syncml.dmddf+wbxml": { + source: "iana" + }, + "application/vnd.syncml.dmddf+xml": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["ddf"] + }, + "application/vnd.syncml.dmtnds+wbxml": { + source: "iana" + }, + "application/vnd.syncml.dmtnds+xml": { + source: "iana", + charset: "UTF-8", + compressible: true + }, + "application/vnd.syncml.ds.notification": { + source: "iana" + }, + "application/vnd.tableschema+json": { + source: "iana", + compressible: true + }, + "application/vnd.tao.intent-module-archive": { + source: "iana", + extensions: ["tao"] + }, + "application/vnd.tcpdump.pcap": { + source: "iana", + extensions: ["pcap", "cap", "dmp"] + }, + "application/vnd.think-cell.ppttc+json": { + source: "iana", + compressible: true + }, + "application/vnd.tmd.mediaflex.api+xml": { + source: "iana", + compressible: true + }, + "application/vnd.tml": { + source: "iana" + }, + "application/vnd.tmobile-livetv": { + source: "iana", + extensions: ["tmo"] + }, + "application/vnd.tri.onesource": { + source: "iana" + }, + "application/vnd.trid.tpt": { + source: "iana", + extensions: ["tpt"] + }, + "application/vnd.triscape.mxs": { + source: "iana", + extensions: ["mxs"] + }, + "application/vnd.trueapp": { + source: "iana", + extensions: ["tra"] + }, + "application/vnd.truedoc": { + source: "iana" + }, + "application/vnd.ubisoft.webplayer": { + source: "iana" + }, + "application/vnd.ufdl": { + source: "iana", + extensions: ["ufd", "ufdl"] + }, + "application/vnd.uiq.theme": { + source: "iana", + extensions: ["utz"] + }, + "application/vnd.umajin": { + source: "iana", + extensions: ["umj"] + }, + "application/vnd.unity": { + source: "iana", + extensions: ["unityweb"] + }, + "application/vnd.uoml+xml": { + source: "iana", + compressible: true, + extensions: ["uoml"] + }, + "application/vnd.uplanet.alert": { + source: "iana" + }, + "application/vnd.uplanet.alert-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.bearer-choice": { + source: "iana" + }, + "application/vnd.uplanet.bearer-choice-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.cacheop": { + source: "iana" + }, + "application/vnd.uplanet.cacheop-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.channel": { + source: "iana" + }, + "application/vnd.uplanet.channel-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.list": { + source: "iana" + }, + "application/vnd.uplanet.list-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.listcmd": { + source: "iana" + }, + "application/vnd.uplanet.listcmd-wbxml": { + source: "iana" + }, + "application/vnd.uplanet.signal": { + source: "iana" + }, + "application/vnd.uri-map": { + source: "iana" + }, + "application/vnd.valve.source.material": { + source: "iana" + }, + "application/vnd.vcx": { + source: "iana", + extensions: ["vcx"] + }, + "application/vnd.vd-study": { + source: "iana" + }, + "application/vnd.vectorworks": { + source: "iana" + }, + "application/vnd.vel+json": { + source: "iana", + compressible: true + }, + "application/vnd.verimatrix.vcas": { + source: "iana" + }, + "application/vnd.veritone.aion+json": { + source: "iana", + compressible: true + }, + "application/vnd.veryant.thin": { + source: "iana" + }, + "application/vnd.ves.encrypted": { + source: "iana" + }, + "application/vnd.vidsoft.vidconference": { + source: "iana" + }, + "application/vnd.visio": { + source: "iana", + extensions: ["vsd", "vst", "vss", "vsw"] + }, + "application/vnd.visionary": { + source: "iana", + extensions: ["vis"] + }, + "application/vnd.vividence.scriptfile": { + source: "iana" + }, + "application/vnd.vsf": { + source: "iana", + extensions: ["vsf"] + }, + "application/vnd.wap.sic": { + source: "iana" + }, + "application/vnd.wap.slc": { + source: "iana" + }, + "application/vnd.wap.wbxml": { + source: "iana", + charset: "UTF-8", + extensions: ["wbxml"] + }, + "application/vnd.wap.wmlc": { + source: "iana", + extensions: ["wmlc"] + }, + "application/vnd.wap.wmlscriptc": { + source: "iana", + extensions: ["wmlsc"] + }, + "application/vnd.webturbo": { + source: "iana", + extensions: ["wtb"] + }, + "application/vnd.wfa.dpp": { + source: "iana" + }, + "application/vnd.wfa.p2p": { + source: "iana" + }, + "application/vnd.wfa.wsc": { + source: "iana" + }, + "application/vnd.windows.devicepairing": { + source: "iana" + }, + "application/vnd.wmc": { + source: "iana" + }, + "application/vnd.wmf.bootstrap": { + source: "iana" + }, + "application/vnd.wolfram.mathematica": { + source: "iana" + }, + "application/vnd.wolfram.mathematica.package": { + source: "iana" + }, + "application/vnd.wolfram.player": { + source: "iana", + extensions: ["nbp"] + }, + "application/vnd.wordperfect": { + source: "iana", + extensions: ["wpd"] + }, + "application/vnd.wqd": { + source: "iana", + extensions: ["wqd"] + }, + "application/vnd.wrq-hp3000-labelled": { + source: "iana" + }, + "application/vnd.wt.stf": { + source: "iana", + extensions: ["stf"] + }, + "application/vnd.wv.csp+wbxml": { + source: "iana" + }, + "application/vnd.wv.csp+xml": { + source: "iana", + compressible: true + }, + "application/vnd.wv.ssp+xml": { + source: "iana", + compressible: true + }, + "application/vnd.xacml+json": { + source: "iana", + compressible: true + }, + "application/vnd.xara": { + source: "iana", + extensions: ["xar"] + }, + "application/vnd.xfdl": { + source: "iana", + extensions: ["xfdl"] + }, + "application/vnd.xfdl.webform": { + source: "iana" + }, + "application/vnd.xmi+xml": { + source: "iana", + compressible: true + }, + "application/vnd.xmpie.cpkg": { + source: "iana" + }, + "application/vnd.xmpie.dpkg": { + source: "iana" + }, + "application/vnd.xmpie.plan": { + source: "iana" + }, + "application/vnd.xmpie.ppkg": { + source: "iana" + }, + "application/vnd.xmpie.xlim": { + source: "iana" + }, + "application/vnd.yamaha.hv-dic": { + source: "iana", + extensions: ["hvd"] + }, + "application/vnd.yamaha.hv-script": { + source: "iana", + extensions: ["hvs"] + }, + "application/vnd.yamaha.hv-voice": { + source: "iana", + extensions: ["hvp"] + }, + "application/vnd.yamaha.openscoreformat": { + source: "iana", + extensions: ["osf"] + }, + "application/vnd.yamaha.openscoreformat.osfpvg+xml": { + source: "iana", + compressible: true, + extensions: ["osfpvg"] + }, + "application/vnd.yamaha.remote-setup": { + source: "iana" + }, + "application/vnd.yamaha.smaf-audio": { + source: "iana", + extensions: ["saf"] + }, + "application/vnd.yamaha.smaf-phrase": { + source: "iana", + extensions: ["spf"] + }, + "application/vnd.yamaha.through-ngn": { + source: "iana" + }, + "application/vnd.yamaha.tunnel-udpencap": { + source: "iana" + }, + "application/vnd.yaoweme": { + source: "iana" + }, + "application/vnd.yellowriver-custom-menu": { + source: "iana", + extensions: ["cmp"] + }, + "application/vnd.youtube.yt": { + source: "iana" + }, + "application/vnd.zul": { + source: "iana", + extensions: ["zir", "zirz"] + }, + "application/vnd.zzazz.deck+xml": { + source: "iana", + compressible: true, + extensions: ["zaz"] + }, + "application/voicexml+xml": { + source: "iana", + compressible: true, + extensions: ["vxml"] + }, + "application/voucher-cms+json": { + source: "iana", + compressible: true + }, + "application/vq-rtcpxr": { + source: "iana" + }, + "application/wasm": { + source: "iana", + compressible: true, + extensions: ["wasm"] + }, + "application/watcherinfo+xml": { + source: "iana", + compressible: true, + extensions: ["wif"] + }, + "application/webpush-options+json": { + source: "iana", + compressible: true + }, + "application/whoispp-query": { + source: "iana" + }, + "application/whoispp-response": { + source: "iana" + }, + "application/widget": { + source: "iana", + extensions: ["wgt"] + }, + "application/winhlp": { + source: "apache", + extensions: ["hlp"] + }, + "application/wita": { + source: "iana" + }, + "application/wordperfect5.1": { + source: "iana" + }, + "application/wsdl+xml": { + source: "iana", + compressible: true, + extensions: ["wsdl"] + }, + "application/wspolicy+xml": { + source: "iana", + compressible: true, + extensions: ["wspolicy"] + }, + "application/x-7z-compressed": { + source: "apache", + compressible: false, + extensions: ["7z"] + }, + "application/x-abiword": { + source: "apache", + extensions: ["abw"] + }, + "application/x-ace-compressed": { + source: "apache", + extensions: ["ace"] + }, + "application/x-amf": { + source: "apache" + }, + "application/x-apple-diskimage": { + source: "apache", + extensions: ["dmg"] + }, + "application/x-arj": { + compressible: false, + extensions: ["arj"] + }, + "application/x-authorware-bin": { + source: "apache", + extensions: ["aab", "x32", "u32", "vox"] + }, + "application/x-authorware-map": { + source: "apache", + extensions: ["aam"] + }, + "application/x-authorware-seg": { + source: "apache", + extensions: ["aas"] + }, + "application/x-bcpio": { + source: "apache", + extensions: ["bcpio"] + }, + "application/x-bdoc": { + compressible: false, + extensions: ["bdoc"] + }, + "application/x-bittorrent": { + source: "apache", + extensions: ["torrent"] + }, + "application/x-blorb": { + source: "apache", + extensions: ["blb", "blorb"] + }, + "application/x-bzip": { + source: "apache", + compressible: false, + extensions: ["bz"] + }, + "application/x-bzip2": { + source: "apache", + compressible: false, + extensions: ["bz2", "boz"] + }, + "application/x-cbr": { + source: "apache", + extensions: ["cbr", "cba", "cbt", "cbz", "cb7"] + }, + "application/x-cdlink": { + source: "apache", + extensions: ["vcd"] + }, + "application/x-cfs-compressed": { + source: "apache", + extensions: ["cfs"] + }, + "application/x-chat": { + source: "apache", + extensions: ["chat"] + }, + "application/x-chess-pgn": { + source: "apache", + extensions: ["pgn"] + }, + "application/x-chrome-extension": { + extensions: ["crx"] + }, + "application/x-cocoa": { + source: "nginx", + extensions: ["cco"] + }, + "application/x-compress": { + source: "apache" + }, + "application/x-conference": { + source: "apache", + extensions: ["nsc"] + }, + "application/x-cpio": { + source: "apache", + extensions: ["cpio"] + }, + "application/x-csh": { + source: "apache", + extensions: ["csh"] + }, + "application/x-deb": { + compressible: false + }, + "application/x-debian-package": { + source: "apache", + extensions: ["deb", "udeb"] + }, + "application/x-dgc-compressed": { + source: "apache", + extensions: ["dgc"] + }, + "application/x-director": { + source: "apache", + extensions: ["dir", "dcr", "dxr", "cst", "cct", "cxt", "w3d", "fgd", "swa"] + }, + "application/x-doom": { + source: "apache", + extensions: ["wad"] + }, + "application/x-dtbncx+xml": { + source: "apache", + compressible: true, + extensions: ["ncx"] + }, + "application/x-dtbook+xml": { + source: "apache", + compressible: true, + extensions: ["dtb"] + }, + "application/x-dtbresource+xml": { + source: "apache", + compressible: true, + extensions: ["res"] + }, + "application/x-dvi": { + source: "apache", + compressible: false, + extensions: ["dvi"] + }, + "application/x-envoy": { + source: "apache", + extensions: ["evy"] + }, + "application/x-eva": { + source: "apache", + extensions: ["eva"] + }, + "application/x-font-bdf": { + source: "apache", + extensions: ["bdf"] + }, + "application/x-font-dos": { + source: "apache" + }, + "application/x-font-framemaker": { + source: "apache" + }, + "application/x-font-ghostscript": { + source: "apache", + extensions: ["gsf"] + }, + "application/x-font-libgrx": { + source: "apache" + }, + "application/x-font-linux-psf": { + source: "apache", + extensions: ["psf"] + }, + "application/x-font-pcf": { + source: "apache", + extensions: ["pcf"] + }, + "application/x-font-snf": { + source: "apache", + extensions: ["snf"] + }, + "application/x-font-speedo": { + source: "apache" + }, + "application/x-font-sunos-news": { + source: "apache" + }, + "application/x-font-type1": { + source: "apache", + extensions: ["pfa", "pfb", "pfm", "afm"] + }, + "application/x-font-vfont": { + source: "apache" + }, + "application/x-freearc": { + source: "apache", + extensions: ["arc"] + }, + "application/x-futuresplash": { + source: "apache", + extensions: ["spl"] + }, + "application/x-gca-compressed": { + source: "apache", + extensions: ["gca"] + }, + "application/x-glulx": { + source: "apache", + extensions: ["ulx"] + }, + "application/x-gnumeric": { + source: "apache", + extensions: ["gnumeric"] + }, + "application/x-gramps-xml": { + source: "apache", + extensions: ["gramps"] + }, + "application/x-gtar": { + source: "apache", + extensions: ["gtar"] + }, + "application/x-gzip": { + source: "apache" + }, + "application/x-hdf": { + source: "apache", + extensions: ["hdf"] + }, + "application/x-httpd-php": { + compressible: true, + extensions: ["php"] + }, + "application/x-install-instructions": { + source: "apache", + extensions: ["install"] + }, + "application/x-iso9660-image": { + source: "apache", + extensions: ["iso"] + }, + "application/x-iwork-keynote-sffkey": { + extensions: ["key"] + }, + "application/x-iwork-numbers-sffnumbers": { + extensions: ["numbers"] + }, + "application/x-iwork-pages-sffpages": { + extensions: ["pages"] + }, + "application/x-java-archive-diff": { + source: "nginx", + extensions: ["jardiff"] + }, + "application/x-java-jnlp-file": { + source: "apache", + compressible: false, + extensions: ["jnlp"] + }, + "application/x-javascript": { + compressible: true + }, + "application/x-keepass2": { + extensions: ["kdbx"] + }, + "application/x-latex": { + source: "apache", + compressible: false, + extensions: ["latex"] + }, + "application/x-lua-bytecode": { + extensions: ["luac"] + }, + "application/x-lzh-compressed": { + source: "apache", + extensions: ["lzh", "lha"] + }, + "application/x-makeself": { + source: "nginx", + extensions: ["run"] + }, + "application/x-mie": { + source: "apache", + extensions: ["mie"] + }, + "application/x-mobipocket-ebook": { + source: "apache", + extensions: ["prc", "mobi"] + }, + "application/x-mpegurl": { + compressible: false + }, + "application/x-ms-application": { + source: "apache", + extensions: ["application"] + }, + "application/x-ms-shortcut": { + source: "apache", + extensions: ["lnk"] + }, + "application/x-ms-wmd": { + source: "apache", + extensions: ["wmd"] + }, + "application/x-ms-wmz": { + source: "apache", + extensions: ["wmz"] + }, + "application/x-ms-xbap": { + source: "apache", + extensions: ["xbap"] + }, + "application/x-msaccess": { + source: "apache", + extensions: ["mdb"] + }, + "application/x-msbinder": { + source: "apache", + extensions: ["obd"] + }, + "application/x-mscardfile": { + source: "apache", + extensions: ["crd"] + }, + "application/x-msclip": { + source: "apache", + extensions: ["clp"] + }, + "application/x-msdos-program": { + extensions: ["exe"] + }, + "application/x-msdownload": { + source: "apache", + extensions: ["exe", "dll", "com", "bat", "msi"] + }, + "application/x-msmediaview": { + source: "apache", + extensions: ["mvb", "m13", "m14"] + }, + "application/x-msmetafile": { + source: "apache", + extensions: ["wmf", "wmz", "emf", "emz"] + }, + "application/x-msmoney": { + source: "apache", + extensions: ["mny"] + }, + "application/x-mspublisher": { + source: "apache", + extensions: ["pub"] + }, + "application/x-msschedule": { + source: "apache", + extensions: ["scd"] + }, + "application/x-msterminal": { + source: "apache", + extensions: ["trm"] + }, + "application/x-mswrite": { + source: "apache", + extensions: ["wri"] + }, + "application/x-netcdf": { + source: "apache", + extensions: ["nc", "cdf"] + }, + "application/x-ns-proxy-autoconfig": { + compressible: true, + extensions: ["pac"] + }, + "application/x-nzb": { + source: "apache", + extensions: ["nzb"] + }, + "application/x-perl": { + source: "nginx", + extensions: ["pl", "pm"] + }, + "application/x-pilot": { + source: "nginx", + extensions: ["prc", "pdb"] + }, + "application/x-pkcs12": { + source: "apache", + compressible: false, + extensions: ["p12", "pfx"] + }, + "application/x-pkcs7-certificates": { + source: "apache", + extensions: ["p7b", "spc"] + }, + "application/x-pkcs7-certreqresp": { + source: "apache", + extensions: ["p7r"] + }, + "application/x-pki-message": { + source: "iana" + }, + "application/x-rar-compressed": { + source: "apache", + compressible: false, + extensions: ["rar"] + }, + "application/x-redhat-package-manager": { + source: "nginx", + extensions: ["rpm"] + }, + "application/x-research-info-systems": { + source: "apache", + extensions: ["ris"] + }, + "application/x-sea": { + source: "nginx", + extensions: ["sea"] + }, + "application/x-sh": { + source: "apache", + compressible: true, + extensions: ["sh"] + }, + "application/x-shar": { + source: "apache", + extensions: ["shar"] + }, + "application/x-shockwave-flash": { + source: "apache", + compressible: false, + extensions: ["swf"] + }, + "application/x-silverlight-app": { + source: "apache", + extensions: ["xap"] + }, + "application/x-sql": { + source: "apache", + extensions: ["sql"] + }, + "application/x-stuffit": { + source: "apache", + compressible: false, + extensions: ["sit"] + }, + "application/x-stuffitx": { + source: "apache", + extensions: ["sitx"] + }, + "application/x-subrip": { + source: "apache", + extensions: ["srt"] + }, + "application/x-sv4cpio": { + source: "apache", + extensions: ["sv4cpio"] + }, + "application/x-sv4crc": { + source: "apache", + extensions: ["sv4crc"] + }, + "application/x-t3vm-image": { + source: "apache", + extensions: ["t3"] + }, + "application/x-tads": { + source: "apache", + extensions: ["gam"] + }, + "application/x-tar": { + source: "apache", + compressible: true, + extensions: ["tar"] + }, + "application/x-tcl": { + source: "apache", + extensions: ["tcl", "tk"] + }, + "application/x-tex": { + source: "apache", + extensions: ["tex"] + }, + "application/x-tex-tfm": { + source: "apache", + extensions: ["tfm"] + }, + "application/x-texinfo": { + source: "apache", + extensions: ["texinfo", "texi"] + }, + "application/x-tgif": { + source: "apache", + extensions: ["obj"] + }, + "application/x-ustar": { + source: "apache", + extensions: ["ustar"] + }, + "application/x-virtualbox-hdd": { + compressible: true, + extensions: ["hdd"] + }, + "application/x-virtualbox-ova": { + compressible: true, + extensions: ["ova"] + }, + "application/x-virtualbox-ovf": { + compressible: true, + extensions: ["ovf"] + }, + "application/x-virtualbox-vbox": { + compressible: true, + extensions: ["vbox"] + }, + "application/x-virtualbox-vbox-extpack": { + compressible: false, + extensions: ["vbox-extpack"] + }, + "application/x-virtualbox-vdi": { + compressible: true, + extensions: ["vdi"] + }, + "application/x-virtualbox-vhd": { + compressible: true, + extensions: ["vhd"] + }, + "application/x-virtualbox-vmdk": { + compressible: true, + extensions: ["vmdk"] + }, + "application/x-wais-source": { + source: "apache", + extensions: ["src"] + }, + "application/x-web-app-manifest+json": { + compressible: true, + extensions: ["webapp"] + }, + "application/x-www-form-urlencoded": { + source: "iana", + compressible: true + }, + "application/x-x509-ca-cert": { + source: "iana", + extensions: ["der", "crt", "pem"] + }, + "application/x-x509-ca-ra-cert": { + source: "iana" + }, + "application/x-x509-next-ca-cert": { + source: "iana" + }, + "application/x-xfig": { + source: "apache", + extensions: ["fig"] + }, + "application/x-xliff+xml": { + source: "apache", + compressible: true, + extensions: ["xlf"] + }, + "application/x-xpinstall": { + source: "apache", + compressible: false, + extensions: ["xpi"] + }, + "application/x-xz": { + source: "apache", + extensions: ["xz"] + }, + "application/x-zmachine": { + source: "apache", + extensions: ["z1", "z2", "z3", "z4", "z5", "z6", "z7", "z8"] + }, + "application/x400-bp": { + source: "iana" + }, + "application/xacml+xml": { + source: "iana", + compressible: true + }, + "application/xaml+xml": { + source: "apache", + compressible: true, + extensions: ["xaml"] + }, + "application/xcap-att+xml": { + source: "iana", + compressible: true, + extensions: ["xav"] + }, + "application/xcap-caps+xml": { + source: "iana", + compressible: true, + extensions: ["xca"] + }, + "application/xcap-diff+xml": { + source: "iana", + compressible: true, + extensions: ["xdf"] + }, + "application/xcap-el+xml": { + source: "iana", + compressible: true, + extensions: ["xel"] + }, + "application/xcap-error+xml": { + source: "iana", + compressible: true + }, + "application/xcap-ns+xml": { + source: "iana", + compressible: true, + extensions: ["xns"] + }, + "application/xcon-conference-info+xml": { + source: "iana", + compressible: true + }, + "application/xcon-conference-info-diff+xml": { + source: "iana", + compressible: true + }, + "application/xenc+xml": { + source: "iana", + compressible: true, + extensions: ["xenc"] + }, + "application/xhtml+xml": { + source: "iana", + compressible: true, + extensions: ["xhtml", "xht"] + }, + "application/xhtml-voice+xml": { + source: "apache", + compressible: true + }, + "application/xliff+xml": { + source: "iana", + compressible: true, + extensions: ["xlf"] + }, + "application/xml": { + source: "iana", + compressible: true, + extensions: ["xml", "xsl", "xsd", "rng"] + }, + "application/xml-dtd": { + source: "iana", + compressible: true, + extensions: ["dtd"] + }, + "application/xml-external-parsed-entity": { + source: "iana" + }, + "application/xml-patch+xml": { + source: "iana", + compressible: true + }, + "application/xmpp+xml": { + source: "iana", + compressible: true + }, + "application/xop+xml": { + source: "iana", + compressible: true, + extensions: ["xop"] + }, + "application/xproc+xml": { + source: "apache", + compressible: true, + extensions: ["xpl"] + }, + "application/xslt+xml": { + source: "iana", + compressible: true, + extensions: ["xsl", "xslt"] + }, + "application/xspf+xml": { + source: "apache", + compressible: true, + extensions: ["xspf"] + }, + "application/xv+xml": { + source: "iana", + compressible: true, + extensions: ["mxml", "xhvml", "xvml", "xvm"] + }, + "application/yang": { + source: "iana", + extensions: ["yang"] + }, + "application/yang-data+json": { + source: "iana", + compressible: true + }, + "application/yang-data+xml": { + source: "iana", + compressible: true + }, + "application/yang-patch+json": { + source: "iana", + compressible: true + }, + "application/yang-patch+xml": { + source: "iana", + compressible: true + }, + "application/yin+xml": { + source: "iana", + compressible: true, + extensions: ["yin"] + }, + "application/zip": { + source: "iana", + compressible: false, + extensions: ["zip"] + }, + "application/zlib": { + source: "iana" + }, + "application/zstd": { + source: "iana" + }, + "audio/1d-interleaved-parityfec": { + source: "iana" + }, + "audio/32kadpcm": { + source: "iana" + }, + "audio/3gpp": { + source: "iana", + compressible: false, + extensions: ["3gpp"] + }, + "audio/3gpp2": { + source: "iana" + }, + "audio/aac": { + source: "iana" + }, + "audio/ac3": { + source: "iana" + }, + "audio/adpcm": { + source: "apache", + extensions: ["adp"] + }, + "audio/amr": { + source: "iana", + extensions: ["amr"] + }, + "audio/amr-wb": { + source: "iana" + }, + "audio/amr-wb+": { + source: "iana" + }, + "audio/aptx": { + source: "iana" + }, + "audio/asc": { + source: "iana" + }, + "audio/atrac-advanced-lossless": { + source: "iana" + }, + "audio/atrac-x": { + source: "iana" + }, + "audio/atrac3": { + source: "iana" + }, + "audio/basic": { + source: "iana", + compressible: false, + extensions: ["au", "snd"] + }, + "audio/bv16": { + source: "iana" + }, + "audio/bv32": { + source: "iana" + }, + "audio/clearmode": { + source: "iana" + }, + "audio/cn": { + source: "iana" + }, + "audio/dat12": { + source: "iana" + }, + "audio/dls": { + source: "iana" + }, + "audio/dsr-es201108": { + source: "iana" + }, + "audio/dsr-es202050": { + source: "iana" + }, + "audio/dsr-es202211": { + source: "iana" + }, + "audio/dsr-es202212": { + source: "iana" + }, + "audio/dv": { + source: "iana" + }, + "audio/dvi4": { + source: "iana" + }, + "audio/eac3": { + source: "iana" + }, + "audio/encaprtp": { + source: "iana" + }, + "audio/evrc": { + source: "iana" + }, + "audio/evrc-qcp": { + source: "iana" + }, + "audio/evrc0": { + source: "iana" + }, + "audio/evrc1": { + source: "iana" + }, + "audio/evrcb": { + source: "iana" + }, + "audio/evrcb0": { + source: "iana" + }, + "audio/evrcb1": { + source: "iana" + }, + "audio/evrcnw": { + source: "iana" + }, + "audio/evrcnw0": { + source: "iana" + }, + "audio/evrcnw1": { + source: "iana" + }, + "audio/evrcwb": { + source: "iana" + }, + "audio/evrcwb0": { + source: "iana" + }, + "audio/evrcwb1": { + source: "iana" + }, + "audio/evs": { + source: "iana" + }, + "audio/flexfec": { + source: "iana" + }, + "audio/fwdred": { + source: "iana" + }, + "audio/g711-0": { + source: "iana" + }, + "audio/g719": { + source: "iana" + }, + "audio/g722": { + source: "iana" + }, + "audio/g7221": { + source: "iana" + }, + "audio/g723": { + source: "iana" + }, + "audio/g726-16": { + source: "iana" + }, + "audio/g726-24": { + source: "iana" + }, + "audio/g726-32": { + source: "iana" + }, + "audio/g726-40": { + source: "iana" + }, + "audio/g728": { + source: "iana" + }, + "audio/g729": { + source: "iana" + }, + "audio/g7291": { + source: "iana" + }, + "audio/g729d": { + source: "iana" + }, + "audio/g729e": { + source: "iana" + }, + "audio/gsm": { + source: "iana" + }, + "audio/gsm-efr": { + source: "iana" + }, + "audio/gsm-hr-08": { + source: "iana" + }, + "audio/ilbc": { + source: "iana" + }, + "audio/ip-mr_v2.5": { + source: "iana" + }, + "audio/isac": { + source: "apache" + }, + "audio/l16": { + source: "iana" + }, + "audio/l20": { + source: "iana" + }, + "audio/l24": { + source: "iana", + compressible: false + }, + "audio/l8": { + source: "iana" + }, + "audio/lpc": { + source: "iana" + }, + "audio/melp": { + source: "iana" + }, + "audio/melp1200": { + source: "iana" + }, + "audio/melp2400": { + source: "iana" + }, + "audio/melp600": { + source: "iana" + }, + "audio/mhas": { + source: "iana" + }, + "audio/midi": { + source: "apache", + extensions: ["mid", "midi", "kar", "rmi"] + }, + "audio/mobile-xmf": { + source: "iana", + extensions: ["mxmf"] + }, + "audio/mp3": { + compressible: false, + extensions: ["mp3"] + }, + "audio/mp4": { + source: "iana", + compressible: false, + extensions: ["m4a", "mp4a"] + }, + "audio/mp4a-latm": { + source: "iana" + }, + "audio/mpa": { + source: "iana" + }, + "audio/mpa-robust": { + source: "iana" + }, + "audio/mpeg": { + source: "iana", + compressible: false, + extensions: ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"] + }, + "audio/mpeg4-generic": { + source: "iana" + }, + "audio/musepack": { + source: "apache" + }, + "audio/ogg": { + source: "iana", + compressible: false, + extensions: ["oga", "ogg", "spx", "opus"] + }, + "audio/opus": { + source: "iana" + }, + "audio/parityfec": { + source: "iana" + }, + "audio/pcma": { + source: "iana" + }, + "audio/pcma-wb": { + source: "iana" + }, + "audio/pcmu": { + source: "iana" + }, + "audio/pcmu-wb": { + source: "iana" + }, + "audio/prs.sid": { + source: "iana" + }, + "audio/qcelp": { + source: "iana" + }, + "audio/raptorfec": { + source: "iana" + }, + "audio/red": { + source: "iana" + }, + "audio/rtp-enc-aescm128": { + source: "iana" + }, + "audio/rtp-midi": { + source: "iana" + }, + "audio/rtploopback": { + source: "iana" + }, + "audio/rtx": { + source: "iana" + }, + "audio/s3m": { + source: "apache", + extensions: ["s3m"] + }, + "audio/scip": { + source: "iana" + }, + "audio/silk": { + source: "apache", + extensions: ["sil"] + }, + "audio/smv": { + source: "iana" + }, + "audio/smv-qcp": { + source: "iana" + }, + "audio/smv0": { + source: "iana" + }, + "audio/sofa": { + source: "iana" + }, + "audio/sp-midi": { + source: "iana" + }, + "audio/speex": { + source: "iana" + }, + "audio/t140c": { + source: "iana" + }, + "audio/t38": { + source: "iana" + }, + "audio/telephone-event": { + source: "iana" + }, + "audio/tetra_acelp": { + source: "iana" + }, + "audio/tetra_acelp_bb": { + source: "iana" + }, + "audio/tone": { + source: "iana" + }, + "audio/tsvcis": { + source: "iana" + }, + "audio/uemclip": { + source: "iana" + }, + "audio/ulpfec": { + source: "iana" + }, + "audio/usac": { + source: "iana" + }, + "audio/vdvi": { + source: "iana" + }, + "audio/vmr-wb": { + source: "iana" + }, + "audio/vnd.3gpp.iufp": { + source: "iana" + }, + "audio/vnd.4sb": { + source: "iana" + }, + "audio/vnd.audiokoz": { + source: "iana" + }, + "audio/vnd.celp": { + source: "iana" + }, + "audio/vnd.cisco.nse": { + source: "iana" + }, + "audio/vnd.cmles.radio-events": { + source: "iana" + }, + "audio/vnd.cns.anp1": { + source: "iana" + }, + "audio/vnd.cns.inf1": { + source: "iana" + }, + "audio/vnd.dece.audio": { + source: "iana", + extensions: ["uva", "uvva"] + }, + "audio/vnd.digital-winds": { + source: "iana", + extensions: ["eol"] + }, + "audio/vnd.dlna.adts": { + source: "iana" + }, + "audio/vnd.dolby.heaac.1": { + source: "iana" + }, + "audio/vnd.dolby.heaac.2": { + source: "iana" + }, + "audio/vnd.dolby.mlp": { + source: "iana" + }, + "audio/vnd.dolby.mps": { + source: "iana" + }, + "audio/vnd.dolby.pl2": { + source: "iana" + }, + "audio/vnd.dolby.pl2x": { + source: "iana" + }, + "audio/vnd.dolby.pl2z": { + source: "iana" + }, + "audio/vnd.dolby.pulse.1": { + source: "iana" + }, + "audio/vnd.dra": { + source: "iana", + extensions: ["dra"] + }, + "audio/vnd.dts": { + source: "iana", + extensions: ["dts"] + }, + "audio/vnd.dts.hd": { + source: "iana", + extensions: ["dtshd"] + }, + "audio/vnd.dts.uhd": { + source: "iana" + }, + "audio/vnd.dvb.file": { + source: "iana" + }, + "audio/vnd.everad.plj": { + source: "iana" + }, + "audio/vnd.hns.audio": { + source: "iana" + }, + "audio/vnd.lucent.voice": { + source: "iana", + extensions: ["lvp"] + }, + "audio/vnd.ms-playready.media.pya": { + source: "iana", + extensions: ["pya"] + }, + "audio/vnd.nokia.mobile-xmf": { + source: "iana" + }, + "audio/vnd.nortel.vbk": { + source: "iana" + }, + "audio/vnd.nuera.ecelp4800": { + source: "iana", + extensions: ["ecelp4800"] + }, + "audio/vnd.nuera.ecelp7470": { + source: "iana", + extensions: ["ecelp7470"] + }, + "audio/vnd.nuera.ecelp9600": { + source: "iana", + extensions: ["ecelp9600"] + }, + "audio/vnd.octel.sbc": { + source: "iana" + }, + "audio/vnd.presonus.multitrack": { + source: "iana" + }, + "audio/vnd.qcelp": { + source: "iana" + }, + "audio/vnd.rhetorex.32kadpcm": { + source: "iana" + }, + "audio/vnd.rip": { + source: "iana", + extensions: ["rip"] + }, + "audio/vnd.rn-realaudio": { + compressible: false + }, + "audio/vnd.sealedmedia.softseal.mpeg": { + source: "iana" + }, + "audio/vnd.vmx.cvsd": { + source: "iana" + }, + "audio/vnd.wave": { + compressible: false + }, + "audio/vorbis": { + source: "iana", + compressible: false + }, + "audio/vorbis-config": { + source: "iana" + }, + "audio/wav": { + compressible: false, + extensions: ["wav"] + }, + "audio/wave": { + compressible: false, + extensions: ["wav"] + }, + "audio/webm": { + source: "apache", + compressible: false, + extensions: ["weba"] + }, + "audio/x-aac": { + source: "apache", + compressible: false, + extensions: ["aac"] + }, + "audio/x-aiff": { + source: "apache", + extensions: ["aif", "aiff", "aifc"] + }, + "audio/x-caf": { + source: "apache", + compressible: false, + extensions: ["caf"] + }, + "audio/x-flac": { + source: "apache", + extensions: ["flac"] + }, + "audio/x-m4a": { + source: "nginx", + extensions: ["m4a"] + }, + "audio/x-matroska": { + source: "apache", + extensions: ["mka"] + }, + "audio/x-mpegurl": { + source: "apache", + extensions: ["m3u"] + }, + "audio/x-ms-wax": { + source: "apache", + extensions: ["wax"] + }, + "audio/x-ms-wma": { + source: "apache", + extensions: ["wma"] + }, + "audio/x-pn-realaudio": { + source: "apache", + extensions: ["ram", "ra"] + }, + "audio/x-pn-realaudio-plugin": { + source: "apache", + extensions: ["rmp"] + }, + "audio/x-realaudio": { + source: "nginx", + extensions: ["ra"] + }, + "audio/x-tta": { + source: "apache" + }, + "audio/x-wav": { + source: "apache", + extensions: ["wav"] + }, + "audio/xm": { + source: "apache", + extensions: ["xm"] + }, + "chemical/x-cdx": { + source: "apache", + extensions: ["cdx"] + }, + "chemical/x-cif": { + source: "apache", + extensions: ["cif"] + }, + "chemical/x-cmdf": { + source: "apache", + extensions: ["cmdf"] + }, + "chemical/x-cml": { + source: "apache", + extensions: ["cml"] + }, + "chemical/x-csml": { + source: "apache", + extensions: ["csml"] + }, + "chemical/x-pdb": { + source: "apache" + }, + "chemical/x-xyz": { + source: "apache", + extensions: ["xyz"] + }, + "font/collection": { + source: "iana", + extensions: ["ttc"] + }, + "font/otf": { + source: "iana", + compressible: true, + extensions: ["otf"] + }, + "font/sfnt": { + source: "iana" + }, + "font/ttf": { + source: "iana", + compressible: true, + extensions: ["ttf"] + }, + "font/woff": { + source: "iana", + extensions: ["woff"] + }, + "font/woff2": { + source: "iana", + extensions: ["woff2"] + }, + "image/aces": { + source: "iana", + extensions: ["exr"] + }, + "image/apng": { + compressible: false, + extensions: ["apng"] + }, + "image/avci": { + source: "iana", + extensions: ["avci"] + }, + "image/avcs": { + source: "iana", + extensions: ["avcs"] + }, + "image/avif": { + source: "iana", + compressible: false, + extensions: ["avif"] + }, + "image/bmp": { + source: "iana", + compressible: true, + extensions: ["bmp"] + }, + "image/cgm": { + source: "iana", + extensions: ["cgm"] + }, + "image/dicom-rle": { + source: "iana", + extensions: ["drle"] + }, + "image/emf": { + source: "iana", + extensions: ["emf"] + }, + "image/fits": { + source: "iana", + extensions: ["fits"] + }, + "image/g3fax": { + source: "iana", + extensions: ["g3"] + }, + "image/gif": { + source: "iana", + compressible: false, + extensions: ["gif"] + }, + "image/heic": { + source: "iana", + extensions: ["heic"] + }, + "image/heic-sequence": { + source: "iana", + extensions: ["heics"] + }, + "image/heif": { + source: "iana", + extensions: ["heif"] + }, + "image/heif-sequence": { + source: "iana", + extensions: ["heifs"] + }, + "image/hej2k": { + source: "iana", + extensions: ["hej2"] + }, + "image/hsj2": { + source: "iana", + extensions: ["hsj2"] + }, + "image/ief": { + source: "iana", + extensions: ["ief"] + }, + "image/jls": { + source: "iana", + extensions: ["jls"] + }, + "image/jp2": { + source: "iana", + compressible: false, + extensions: ["jp2", "jpg2"] + }, + "image/jpeg": { + source: "iana", + compressible: false, + extensions: ["jpeg", "jpg", "jpe"] + }, + "image/jph": { + source: "iana", + extensions: ["jph"] + }, + "image/jphc": { + source: "iana", + extensions: ["jhc"] + }, + "image/jpm": { + source: "iana", + compressible: false, + extensions: ["jpm"] + }, + "image/jpx": { + source: "iana", + compressible: false, + extensions: ["jpx", "jpf"] + }, + "image/jxr": { + source: "iana", + extensions: ["jxr"] + }, + "image/jxra": { + source: "iana", + extensions: ["jxra"] + }, + "image/jxrs": { + source: "iana", + extensions: ["jxrs"] + }, + "image/jxs": { + source: "iana", + extensions: ["jxs"] + }, + "image/jxsc": { + source: "iana", + extensions: ["jxsc"] + }, + "image/jxsi": { + source: "iana", + extensions: ["jxsi"] + }, + "image/jxss": { + source: "iana", + extensions: ["jxss"] + }, + "image/ktx": { + source: "iana", + extensions: ["ktx"] + }, + "image/ktx2": { + source: "iana", + extensions: ["ktx2"] + }, + "image/naplps": { + source: "iana" + }, + "image/pjpeg": { + compressible: false + }, + "image/png": { + source: "iana", + compressible: false, + extensions: ["png"] + }, + "image/prs.btif": { + source: "iana", + extensions: ["btif"] + }, + "image/prs.pti": { + source: "iana", + extensions: ["pti"] + }, + "image/pwg-raster": { + source: "iana" + }, + "image/sgi": { + source: "apache", + extensions: ["sgi"] + }, + "image/svg+xml": { + source: "iana", + compressible: true, + extensions: ["svg", "svgz"] + }, + "image/t38": { + source: "iana", + extensions: ["t38"] + }, + "image/tiff": { + source: "iana", + compressible: false, + extensions: ["tif", "tiff"] + }, + "image/tiff-fx": { + source: "iana", + extensions: ["tfx"] + }, + "image/vnd.adobe.photoshop": { + source: "iana", + compressible: true, + extensions: ["psd"] + }, + "image/vnd.airzip.accelerator.azv": { + source: "iana", + extensions: ["azv"] + }, + "image/vnd.cns.inf2": { + source: "iana" + }, + "image/vnd.dece.graphic": { + source: "iana", + extensions: ["uvi", "uvvi", "uvg", "uvvg"] + }, + "image/vnd.djvu": { + source: "iana", + extensions: ["djvu", "djv"] + }, + "image/vnd.dvb.subtitle": { + source: "iana", + extensions: ["sub"] + }, + "image/vnd.dwg": { + source: "iana", + extensions: ["dwg"] + }, + "image/vnd.dxf": { + source: "iana", + extensions: ["dxf"] + }, + "image/vnd.fastbidsheet": { + source: "iana", + extensions: ["fbs"] + }, + "image/vnd.fpx": { + source: "iana", + extensions: ["fpx"] + }, + "image/vnd.fst": { + source: "iana", + extensions: ["fst"] + }, + "image/vnd.fujixerox.edmics-mmr": { + source: "iana", + extensions: ["mmr"] + }, + "image/vnd.fujixerox.edmics-rlc": { + source: "iana", + extensions: ["rlc"] + }, + "image/vnd.globalgraphics.pgb": { + source: "iana" + }, + "image/vnd.microsoft.icon": { + source: "iana", + compressible: true, + extensions: ["ico"] + }, + "image/vnd.mix": { + source: "iana" + }, + "image/vnd.mozilla.apng": { + source: "iana" + }, + "image/vnd.ms-dds": { + compressible: true, + extensions: ["dds"] + }, + "image/vnd.ms-modi": { + source: "iana", + extensions: ["mdi"] + }, + "image/vnd.ms-photo": { + source: "apache", + extensions: ["wdp"] + }, + "image/vnd.net-fpx": { + source: "iana", + extensions: ["npx"] + }, + "image/vnd.pco.b16": { + source: "iana", + extensions: ["b16"] + }, + "image/vnd.radiance": { + source: "iana" + }, + "image/vnd.sealed.png": { + source: "iana" + }, + "image/vnd.sealedmedia.softseal.gif": { + source: "iana" + }, + "image/vnd.sealedmedia.softseal.jpg": { + source: "iana" + }, + "image/vnd.svf": { + source: "iana" + }, + "image/vnd.tencent.tap": { + source: "iana", + extensions: ["tap"] + }, + "image/vnd.valve.source.texture": { + source: "iana", + extensions: ["vtf"] + }, + "image/vnd.wap.wbmp": { + source: "iana", + extensions: ["wbmp"] + }, + "image/vnd.xiff": { + source: "iana", + extensions: ["xif"] + }, + "image/vnd.zbrush.pcx": { + source: "iana", + extensions: ["pcx"] + }, + "image/webp": { + source: "apache", + extensions: ["webp"] + }, + "image/wmf": { + source: "iana", + extensions: ["wmf"] + }, + "image/x-3ds": { + source: "apache", + extensions: ["3ds"] + }, + "image/x-cmu-raster": { + source: "apache", + extensions: ["ras"] + }, + "image/x-cmx": { + source: "apache", + extensions: ["cmx"] + }, + "image/x-freehand": { + source: "apache", + extensions: ["fh", "fhc", "fh4", "fh5", "fh7"] + }, + "image/x-icon": { + source: "apache", + compressible: true, + extensions: ["ico"] + }, + "image/x-jng": { + source: "nginx", + extensions: ["jng"] + }, + "image/x-mrsid-image": { + source: "apache", + extensions: ["sid"] + }, + "image/x-ms-bmp": { + source: "nginx", + compressible: true, + extensions: ["bmp"] + }, + "image/x-pcx": { + source: "apache", + extensions: ["pcx"] + }, + "image/x-pict": { + source: "apache", + extensions: ["pic", "pct"] + }, + "image/x-portable-anymap": { + source: "apache", + extensions: ["pnm"] + }, + "image/x-portable-bitmap": { + source: "apache", + extensions: ["pbm"] + }, + "image/x-portable-graymap": { + source: "apache", + extensions: ["pgm"] + }, + "image/x-portable-pixmap": { + source: "apache", + extensions: ["ppm"] + }, + "image/x-rgb": { + source: "apache", + extensions: ["rgb"] + }, + "image/x-tga": { + source: "apache", + extensions: ["tga"] + }, + "image/x-xbitmap": { + source: "apache", + extensions: ["xbm"] + }, + "image/x-xcf": { + compressible: false + }, + "image/x-xpixmap": { + source: "apache", + extensions: ["xpm"] + }, + "image/x-xwindowdump": { + source: "apache", + extensions: ["xwd"] + }, + "message/cpim": { + source: "iana" + }, + "message/delivery-status": { + source: "iana" + }, + "message/disposition-notification": { + source: "iana", + extensions: [ + "disposition-notification" + ] + }, + "message/external-body": { + source: "iana" + }, + "message/feedback-report": { + source: "iana" + }, + "message/global": { + source: "iana", + extensions: ["u8msg"] + }, + "message/global-delivery-status": { + source: "iana", + extensions: ["u8dsn"] + }, + "message/global-disposition-notification": { + source: "iana", + extensions: ["u8mdn"] + }, + "message/global-headers": { + source: "iana", + extensions: ["u8hdr"] + }, + "message/http": { + source: "iana", + compressible: false + }, + "message/imdn+xml": { + source: "iana", + compressible: true + }, + "message/news": { + source: "iana" + }, + "message/partial": { + source: "iana", + compressible: false + }, + "message/rfc822": { + source: "iana", + compressible: true, + extensions: ["eml", "mime"] + }, + "message/s-http": { + source: "iana" + }, + "message/sip": { + source: "iana" + }, + "message/sipfrag": { + source: "iana" + }, + "message/tracking-status": { + source: "iana" + }, + "message/vnd.si.simp": { + source: "iana" + }, + "message/vnd.wfa.wsc": { + source: "iana", + extensions: ["wsc"] + }, + "model/3mf": { + source: "iana", + extensions: ["3mf"] + }, + "model/e57": { + source: "iana" + }, + "model/gltf+json": { + source: "iana", + compressible: true, + extensions: ["gltf"] + }, + "model/gltf-binary": { + source: "iana", + compressible: true, + extensions: ["glb"] + }, + "model/iges": { + source: "iana", + compressible: false, + extensions: ["igs", "iges"] + }, + "model/mesh": { + source: "iana", + compressible: false, + extensions: ["msh", "mesh", "silo"] + }, + "model/mtl": { + source: "iana", + extensions: ["mtl"] + }, + "model/obj": { + source: "iana", + extensions: ["obj"] + }, + "model/step": { + source: "iana" + }, + "model/step+xml": { + source: "iana", + compressible: true, + extensions: ["stpx"] + }, + "model/step+zip": { + source: "iana", + compressible: false, + extensions: ["stpz"] + }, + "model/step-xml+zip": { + source: "iana", + compressible: false, + extensions: ["stpxz"] + }, + "model/stl": { + source: "iana", + extensions: ["stl"] + }, + "model/vnd.collada+xml": { + source: "iana", + compressible: true, + extensions: ["dae"] + }, + "model/vnd.dwf": { + source: "iana", + extensions: ["dwf"] + }, + "model/vnd.flatland.3dml": { + source: "iana" + }, + "model/vnd.gdl": { + source: "iana", + extensions: ["gdl"] + }, + "model/vnd.gs-gdl": { + source: "apache" + }, + "model/vnd.gs.gdl": { + source: "iana" + }, + "model/vnd.gtw": { + source: "iana", + extensions: ["gtw"] + }, + "model/vnd.moml+xml": { + source: "iana", + compressible: true + }, + "model/vnd.mts": { + source: "iana", + extensions: ["mts"] + }, + "model/vnd.opengex": { + source: "iana", + extensions: ["ogex"] + }, + "model/vnd.parasolid.transmit.binary": { + source: "iana", + extensions: ["x_b"] + }, + "model/vnd.parasolid.transmit.text": { + source: "iana", + extensions: ["x_t"] + }, + "model/vnd.pytha.pyox": { + source: "iana" + }, + "model/vnd.rosette.annotated-data-model": { + source: "iana" + }, + "model/vnd.sap.vds": { + source: "iana", + extensions: ["vds"] + }, + "model/vnd.usdz+zip": { + source: "iana", + compressible: false, + extensions: ["usdz"] + }, + "model/vnd.valve.source.compiled-map": { + source: "iana", + extensions: ["bsp"] + }, + "model/vnd.vtu": { + source: "iana", + extensions: ["vtu"] + }, + "model/vrml": { + source: "iana", + compressible: false, + extensions: ["wrl", "vrml"] + }, + "model/x3d+binary": { + source: "apache", + compressible: false, + extensions: ["x3db", "x3dbz"] + }, + "model/x3d+fastinfoset": { + source: "iana", + extensions: ["x3db"] + }, + "model/x3d+vrml": { + source: "apache", + compressible: false, + extensions: ["x3dv", "x3dvz"] + }, + "model/x3d+xml": { + source: "iana", + compressible: true, + extensions: ["x3d", "x3dz"] + }, + "model/x3d-vrml": { + source: "iana", + extensions: ["x3dv"] + }, + "multipart/alternative": { + source: "iana", + compressible: false + }, + "multipart/appledouble": { + source: "iana" + }, + "multipart/byteranges": { + source: "iana" + }, + "multipart/digest": { + source: "iana" + }, + "multipart/encrypted": { + source: "iana", + compressible: false + }, + "multipart/form-data": { + source: "iana", + compressible: false + }, + "multipart/header-set": { + source: "iana" + }, + "multipart/mixed": { + source: "iana" + }, + "multipart/multilingual": { + source: "iana" + }, + "multipart/parallel": { + source: "iana" + }, + "multipart/related": { + source: "iana", + compressible: false + }, + "multipart/report": { + source: "iana" + }, + "multipart/signed": { + source: "iana", + compressible: false + }, + "multipart/vnd.bint.med-plus": { + source: "iana" + }, + "multipart/voice-message": { + source: "iana" + }, + "multipart/x-mixed-replace": { + source: "iana" + }, + "text/1d-interleaved-parityfec": { + source: "iana" + }, + "text/cache-manifest": { + source: "iana", + compressible: true, + extensions: ["appcache", "manifest"] + }, + "text/calendar": { + source: "iana", + extensions: ["ics", "ifb"] + }, + "text/calender": { + compressible: true + }, + "text/cmd": { + compressible: true + }, + "text/coffeescript": { + extensions: ["coffee", "litcoffee"] + }, + "text/cql": { + source: "iana" + }, + "text/cql-expression": { + source: "iana" + }, + "text/cql-identifier": { + source: "iana" + }, + "text/css": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["css"] + }, + "text/csv": { + source: "iana", + compressible: true, + extensions: ["csv"] + }, + "text/csv-schema": { + source: "iana" + }, + "text/directory": { + source: "iana" + }, + "text/dns": { + source: "iana" + }, + "text/ecmascript": { + source: "iana" + }, + "text/encaprtp": { + source: "iana" + }, + "text/enriched": { + source: "iana" + }, + "text/fhirpath": { + source: "iana" + }, + "text/flexfec": { + source: "iana" + }, + "text/fwdred": { + source: "iana" + }, + "text/gff3": { + source: "iana" + }, + "text/grammar-ref-list": { + source: "iana" + }, + "text/html": { + source: "iana", + compressible: true, + extensions: ["html", "htm", "shtml"] + }, + "text/jade": { + extensions: ["jade"] + }, + "text/javascript": { + source: "iana", + compressible: true + }, + "text/jcr-cnd": { + source: "iana" + }, + "text/jsx": { + compressible: true, + extensions: ["jsx"] + }, + "text/less": { + compressible: true, + extensions: ["less"] + }, + "text/markdown": { + source: "iana", + compressible: true, + extensions: ["markdown", "md"] + }, + "text/mathml": { + source: "nginx", + extensions: ["mml"] + }, + "text/mdx": { + compressible: true, + extensions: ["mdx"] + }, + "text/mizar": { + source: "iana" + }, + "text/n3": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["n3"] + }, + "text/parameters": { + source: "iana", + charset: "UTF-8" + }, + "text/parityfec": { + source: "iana" + }, + "text/plain": { + source: "iana", + compressible: true, + extensions: ["txt", "text", "conf", "def", "list", "log", "in", "ini"] + }, + "text/provenance-notation": { + source: "iana", + charset: "UTF-8" + }, + "text/prs.fallenstein.rst": { + source: "iana" + }, + "text/prs.lines.tag": { + source: "iana", + extensions: ["dsc"] + }, + "text/prs.prop.logic": { + source: "iana" + }, + "text/raptorfec": { + source: "iana" + }, + "text/red": { + source: "iana" + }, + "text/rfc822-headers": { + source: "iana" + }, + "text/richtext": { + source: "iana", + compressible: true, + extensions: ["rtx"] + }, + "text/rtf": { + source: "iana", + compressible: true, + extensions: ["rtf"] + }, + "text/rtp-enc-aescm128": { + source: "iana" + }, + "text/rtploopback": { + source: "iana" + }, + "text/rtx": { + source: "iana" + }, + "text/sgml": { + source: "iana", + extensions: ["sgml", "sgm"] + }, + "text/shaclc": { + source: "iana" + }, + "text/shex": { + source: "iana", + extensions: ["shex"] + }, + "text/slim": { + extensions: ["slim", "slm"] + }, + "text/spdx": { + source: "iana", + extensions: ["spdx"] + }, + "text/strings": { + source: "iana" + }, + "text/stylus": { + extensions: ["stylus", "styl"] + }, + "text/t140": { + source: "iana" + }, + "text/tab-separated-values": { + source: "iana", + compressible: true, + extensions: ["tsv"] + }, + "text/troff": { + source: "iana", + extensions: ["t", "tr", "roff", "man", "me", "ms"] + }, + "text/turtle": { + source: "iana", + charset: "UTF-8", + extensions: ["ttl"] + }, + "text/ulpfec": { + source: "iana" + }, + "text/uri-list": { + source: "iana", + compressible: true, + extensions: ["uri", "uris", "urls"] + }, + "text/vcard": { + source: "iana", + compressible: true, + extensions: ["vcard"] + }, + "text/vnd.a": { + source: "iana" + }, + "text/vnd.abc": { + source: "iana" + }, + "text/vnd.ascii-art": { + source: "iana" + }, + "text/vnd.curl": { + source: "iana", + extensions: ["curl"] + }, + "text/vnd.curl.dcurl": { + source: "apache", + extensions: ["dcurl"] + }, + "text/vnd.curl.mcurl": { + source: "apache", + extensions: ["mcurl"] + }, + "text/vnd.curl.scurl": { + source: "apache", + extensions: ["scurl"] + }, + "text/vnd.debian.copyright": { + source: "iana", + charset: "UTF-8" + }, + "text/vnd.dmclientscript": { + source: "iana" + }, + "text/vnd.dvb.subtitle": { + source: "iana", + extensions: ["sub"] + }, + "text/vnd.esmertec.theme-descriptor": { + source: "iana", + charset: "UTF-8" + }, + "text/vnd.familysearch.gedcom": { + source: "iana", + extensions: ["ged"] + }, + "text/vnd.ficlab.flt": { + source: "iana" + }, + "text/vnd.fly": { + source: "iana", + extensions: ["fly"] + }, + "text/vnd.fmi.flexstor": { + source: "iana", + extensions: ["flx"] + }, + "text/vnd.gml": { + source: "iana" + }, + "text/vnd.graphviz": { + source: "iana", + extensions: ["gv"] + }, + "text/vnd.hans": { + source: "iana" + }, + "text/vnd.hgl": { + source: "iana" + }, + "text/vnd.in3d.3dml": { + source: "iana", + extensions: ["3dml"] + }, + "text/vnd.in3d.spot": { + source: "iana", + extensions: ["spot"] + }, + "text/vnd.iptc.newsml": { + source: "iana" + }, + "text/vnd.iptc.nitf": { + source: "iana" + }, + "text/vnd.latex-z": { + source: "iana" + }, + "text/vnd.motorola.reflex": { + source: "iana" + }, + "text/vnd.ms-mediapackage": { + source: "iana" + }, + "text/vnd.net2phone.commcenter.command": { + source: "iana" + }, + "text/vnd.radisys.msml-basic-layout": { + source: "iana" + }, + "text/vnd.senx.warpscript": { + source: "iana" + }, + "text/vnd.si.uricatalogue": { + source: "iana" + }, + "text/vnd.sosi": { + source: "iana" + }, + "text/vnd.sun.j2me.app-descriptor": { + source: "iana", + charset: "UTF-8", + extensions: ["jad"] + }, + "text/vnd.trolltech.linguist": { + source: "iana", + charset: "UTF-8" + }, + "text/vnd.wap.si": { + source: "iana" + }, + "text/vnd.wap.sl": { + source: "iana" + }, + "text/vnd.wap.wml": { + source: "iana", + extensions: ["wml"] + }, + "text/vnd.wap.wmlscript": { + source: "iana", + extensions: ["wmls"] + }, + "text/vtt": { + source: "iana", + charset: "UTF-8", + compressible: true, + extensions: ["vtt"] + }, + "text/x-asm": { + source: "apache", + extensions: ["s", "asm"] + }, + "text/x-c": { + source: "apache", + extensions: ["c", "cc", "cxx", "cpp", "h", "hh", "dic"] + }, + "text/x-component": { + source: "nginx", + extensions: ["htc"] + }, + "text/x-fortran": { + source: "apache", + extensions: ["f", "for", "f77", "f90"] + }, + "text/x-gwt-rpc": { + compressible: true + }, + "text/x-handlebars-template": { + extensions: ["hbs"] + }, + "text/x-java-source": { + source: "apache", + extensions: ["java"] + }, + "text/x-jquery-tmpl": { + compressible: true + }, + "text/x-lua": { + extensions: ["lua"] + }, + "text/x-markdown": { + compressible: true, + extensions: ["mkd"] + }, + "text/x-nfo": { + source: "apache", + extensions: ["nfo"] + }, + "text/x-opml": { + source: "apache", + extensions: ["opml"] + }, + "text/x-org": { + compressible: true, + extensions: ["org"] + }, + "text/x-pascal": { + source: "apache", + extensions: ["p", "pas"] + }, + "text/x-processing": { + compressible: true, + extensions: ["pde"] + }, + "text/x-sass": { + extensions: ["sass"] + }, + "text/x-scss": { + extensions: ["scss"] + }, + "text/x-setext": { + source: "apache", + extensions: ["etx"] + }, + "text/x-sfv": { + source: "apache", + extensions: ["sfv"] + }, + "text/x-suse-ymp": { + compressible: true, + extensions: ["ymp"] + }, + "text/x-uuencode": { + source: "apache", + extensions: ["uu"] + }, + "text/x-vcalendar": { + source: "apache", + extensions: ["vcs"] + }, + "text/x-vcard": { + source: "apache", + extensions: ["vcf"] + }, + "text/xml": { + source: "iana", + compressible: true, + extensions: ["xml"] + }, + "text/xml-external-parsed-entity": { + source: "iana" + }, + "text/yaml": { + compressible: true, + extensions: ["yaml", "yml"] + }, + "video/1d-interleaved-parityfec": { + source: "iana" + }, + "video/3gpp": { + source: "iana", + extensions: ["3gp", "3gpp"] + }, + "video/3gpp-tt": { + source: "iana" + }, + "video/3gpp2": { + source: "iana", + extensions: ["3g2"] + }, + "video/av1": { + source: "iana" + }, + "video/bmpeg": { + source: "iana" + }, + "video/bt656": { + source: "iana" + }, + "video/celb": { + source: "iana" + }, + "video/dv": { + source: "iana" + }, + "video/encaprtp": { + source: "iana" + }, + "video/ffv1": { + source: "iana" + }, + "video/flexfec": { + source: "iana" + }, + "video/h261": { + source: "iana", + extensions: ["h261"] + }, + "video/h263": { + source: "iana", + extensions: ["h263"] + }, + "video/h263-1998": { + source: "iana" + }, + "video/h263-2000": { + source: "iana" + }, + "video/h264": { + source: "iana", + extensions: ["h264"] + }, + "video/h264-rcdo": { + source: "iana" + }, + "video/h264-svc": { + source: "iana" + }, + "video/h265": { + source: "iana" + }, + "video/iso.segment": { + source: "iana", + extensions: ["m4s"] + }, + "video/jpeg": { + source: "iana", + extensions: ["jpgv"] + }, + "video/jpeg2000": { + source: "iana" + }, + "video/jpm": { + source: "apache", + extensions: ["jpm", "jpgm"] + }, + "video/jxsv": { + source: "iana" + }, + "video/mj2": { + source: "iana", + extensions: ["mj2", "mjp2"] + }, + "video/mp1s": { + source: "iana" + }, + "video/mp2p": { + source: "iana" + }, + "video/mp2t": { + source: "iana", + extensions: ["ts"] + }, + "video/mp4": { + source: "iana", + compressible: false, + extensions: ["mp4", "mp4v", "mpg4"] + }, + "video/mp4v-es": { + source: "iana" + }, + "video/mpeg": { + source: "iana", + compressible: false, + extensions: ["mpeg", "mpg", "mpe", "m1v", "m2v"] + }, + "video/mpeg4-generic": { + source: "iana" + }, + "video/mpv": { + source: "iana" + }, + "video/nv": { + source: "iana" + }, + "video/ogg": { + source: "iana", + compressible: false, + extensions: ["ogv"] + }, + "video/parityfec": { + source: "iana" + }, + "video/pointer": { + source: "iana" + }, + "video/quicktime": { + source: "iana", + compressible: false, + extensions: ["qt", "mov"] + }, + "video/raptorfec": { + source: "iana" + }, + "video/raw": { + source: "iana" + }, + "video/rtp-enc-aescm128": { + source: "iana" + }, + "video/rtploopback": { + source: "iana" + }, + "video/rtx": { + source: "iana" + }, + "video/scip": { + source: "iana" + }, + "video/smpte291": { + source: "iana" + }, + "video/smpte292m": { + source: "iana" + }, + "video/ulpfec": { + source: "iana" + }, + "video/vc1": { + source: "iana" + }, + "video/vc2": { + source: "iana" + }, + "video/vnd.cctv": { + source: "iana" + }, + "video/vnd.dece.hd": { + source: "iana", + extensions: ["uvh", "uvvh"] + }, + "video/vnd.dece.mobile": { + source: "iana", + extensions: ["uvm", "uvvm"] + }, + "video/vnd.dece.mp4": { + source: "iana" + }, + "video/vnd.dece.pd": { + source: "iana", + extensions: ["uvp", "uvvp"] + }, + "video/vnd.dece.sd": { + source: "iana", + extensions: ["uvs", "uvvs"] + }, + "video/vnd.dece.video": { + source: "iana", + extensions: ["uvv", "uvvv"] + }, + "video/vnd.directv.mpeg": { + source: "iana" + }, + "video/vnd.directv.mpeg-tts": { + source: "iana" + }, + "video/vnd.dlna.mpeg-tts": { + source: "iana" + }, + "video/vnd.dvb.file": { + source: "iana", + extensions: ["dvb"] + }, + "video/vnd.fvt": { + source: "iana", + extensions: ["fvt"] + }, + "video/vnd.hns.video": { + source: "iana" + }, + "video/vnd.iptvforum.1dparityfec-1010": { + source: "iana" + }, + "video/vnd.iptvforum.1dparityfec-2005": { + source: "iana" + }, + "video/vnd.iptvforum.2dparityfec-1010": { + source: "iana" + }, + "video/vnd.iptvforum.2dparityfec-2005": { + source: "iana" + }, + "video/vnd.iptvforum.ttsavc": { + source: "iana" + }, + "video/vnd.iptvforum.ttsmpeg2": { + source: "iana" + }, + "video/vnd.motorola.video": { + source: "iana" + }, + "video/vnd.motorola.videop": { + source: "iana" + }, + "video/vnd.mpegurl": { + source: "iana", + extensions: ["mxu", "m4u"] + }, + "video/vnd.ms-playready.media.pyv": { + source: "iana", + extensions: ["pyv"] + }, + "video/vnd.nokia.interleaved-multimedia": { + source: "iana" + }, + "video/vnd.nokia.mp4vr": { + source: "iana" + }, + "video/vnd.nokia.videovoip": { + source: "iana" + }, + "video/vnd.objectvideo": { + source: "iana" + }, + "video/vnd.radgamettools.bink": { + source: "iana" + }, + "video/vnd.radgamettools.smacker": { + source: "iana" + }, + "video/vnd.sealed.mpeg1": { + source: "iana" + }, + "video/vnd.sealed.mpeg4": { + source: "iana" + }, + "video/vnd.sealed.swf": { + source: "iana" + }, + "video/vnd.sealedmedia.softseal.mov": { + source: "iana" + }, + "video/vnd.uvvu.mp4": { + source: "iana", + extensions: ["uvu", "uvvu"] + }, + "video/vnd.vivo": { + source: "iana", + extensions: ["viv"] + }, + "video/vnd.youtube.yt": { + source: "iana" + }, + "video/vp8": { + source: "iana" + }, + "video/vp9": { + source: "iana" + }, + "video/webm": { + source: "apache", + compressible: false, + extensions: ["webm"] + }, + "video/x-f4v": { + source: "apache", + extensions: ["f4v"] + }, + "video/x-fli": { + source: "apache", + extensions: ["fli"] + }, + "video/x-flv": { + source: "apache", + compressible: false, + extensions: ["flv"] + }, + "video/x-m4v": { + source: "apache", + extensions: ["m4v"] + }, + "video/x-matroska": { + source: "apache", + compressible: false, + extensions: ["mkv", "mk3d", "mks"] + }, + "video/x-mng": { + source: "apache", + extensions: ["mng"] + }, + "video/x-ms-asf": { + source: "apache", + extensions: ["asf", "asx"] + }, + "video/x-ms-vob": { + source: "apache", + extensions: ["vob"] + }, + "video/x-ms-wm": { + source: "apache", + extensions: ["wm"] + }, + "video/x-ms-wmv": { + source: "apache", + compressible: false, + extensions: ["wmv"] + }, + "video/x-ms-wmx": { + source: "apache", + extensions: ["wmx"] + }, + "video/x-ms-wvx": { + source: "apache", + extensions: ["wvx"] + }, + "video/x-msvideo": { + source: "apache", + extensions: ["avi"] + }, + "video/x-sgi-movie": { + source: "apache", + extensions: ["movie"] + }, + "video/x-smv": { + source: "apache", + extensions: ["smv"] + }, + "x-conference/x-cooltalk": { + source: "apache", + extensions: ["ice"] + }, + "x-shader/x-fragment": { + compressible: true + }, + "x-shader/x-vertex": { + compressible: true + } + }; + } + }); + + // node_modules/mime-db/index.js + var require_mime_db = __commonJS({ + "node_modules/mime-db/index.js"(exports, module) { + module.exports = require_db(); + } + }); + + // src/rewrite/html.js + var import_events = __toESM(require_events(), 1); + + // node_modules/parse5/dist/common/unicode.js + var UNDEFINED_CODE_POINTS = /* @__PURE__ */ new Set([ + 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 REPLACEMENT_CHARACTER = "\uFFFD"; + var CODE_POINTS; + (function(CODE_POINTS2) { + CODE_POINTS2[CODE_POINTS2["EOF"] = -1] = "EOF"; + CODE_POINTS2[CODE_POINTS2["NULL"] = 0] = "NULL"; + CODE_POINTS2[CODE_POINTS2["TABULATION"] = 9] = "TABULATION"; + CODE_POINTS2[CODE_POINTS2["CARRIAGE_RETURN"] = 13] = "CARRIAGE_RETURN"; + CODE_POINTS2[CODE_POINTS2["LINE_FEED"] = 10] = "LINE_FEED"; + CODE_POINTS2[CODE_POINTS2["FORM_FEED"] = 12] = "FORM_FEED"; + CODE_POINTS2[CODE_POINTS2["SPACE"] = 32] = "SPACE"; + CODE_POINTS2[CODE_POINTS2["EXCLAMATION_MARK"] = 33] = "EXCLAMATION_MARK"; + CODE_POINTS2[CODE_POINTS2["QUOTATION_MARK"] = 34] = "QUOTATION_MARK"; + CODE_POINTS2[CODE_POINTS2["NUMBER_SIGN"] = 35] = "NUMBER_SIGN"; + CODE_POINTS2[CODE_POINTS2["AMPERSAND"] = 38] = "AMPERSAND"; + CODE_POINTS2[CODE_POINTS2["APOSTROPHE"] = 39] = "APOSTROPHE"; + CODE_POINTS2[CODE_POINTS2["HYPHEN_MINUS"] = 45] = "HYPHEN_MINUS"; + CODE_POINTS2[CODE_POINTS2["SOLIDUS"] = 47] = "SOLIDUS"; + CODE_POINTS2[CODE_POINTS2["DIGIT_0"] = 48] = "DIGIT_0"; + CODE_POINTS2[CODE_POINTS2["DIGIT_9"] = 57] = "DIGIT_9"; + CODE_POINTS2[CODE_POINTS2["SEMICOLON"] = 59] = "SEMICOLON"; + CODE_POINTS2[CODE_POINTS2["LESS_THAN_SIGN"] = 60] = "LESS_THAN_SIGN"; + CODE_POINTS2[CODE_POINTS2["EQUALS_SIGN"] = 61] = "EQUALS_SIGN"; + CODE_POINTS2[CODE_POINTS2["GREATER_THAN_SIGN"] = 62] = "GREATER_THAN_SIGN"; + CODE_POINTS2[CODE_POINTS2["QUESTION_MARK"] = 63] = "QUESTION_MARK"; + CODE_POINTS2[CODE_POINTS2["LATIN_CAPITAL_A"] = 65] = "LATIN_CAPITAL_A"; + CODE_POINTS2[CODE_POINTS2["LATIN_CAPITAL_F"] = 70] = "LATIN_CAPITAL_F"; + CODE_POINTS2[CODE_POINTS2["LATIN_CAPITAL_X"] = 88] = "LATIN_CAPITAL_X"; + CODE_POINTS2[CODE_POINTS2["LATIN_CAPITAL_Z"] = 90] = "LATIN_CAPITAL_Z"; + CODE_POINTS2[CODE_POINTS2["RIGHT_SQUARE_BRACKET"] = 93] = "RIGHT_SQUARE_BRACKET"; + CODE_POINTS2[CODE_POINTS2["GRAVE_ACCENT"] = 96] = "GRAVE_ACCENT"; + CODE_POINTS2[CODE_POINTS2["LATIN_SMALL_A"] = 97] = "LATIN_SMALL_A"; + CODE_POINTS2[CODE_POINTS2["LATIN_SMALL_F"] = 102] = "LATIN_SMALL_F"; + CODE_POINTS2[CODE_POINTS2["LATIN_SMALL_X"] = 120] = "LATIN_SMALL_X"; + CODE_POINTS2[CODE_POINTS2["LATIN_SMALL_Z"] = 122] = "LATIN_SMALL_Z"; + CODE_POINTS2[CODE_POINTS2["REPLACEMENT_CHARACTER"] = 65533] = "REPLACEMENT_CHARACTER"; + })(CODE_POINTS = CODE_POINTS || (CODE_POINTS = {})); + var SEQUENCES = { + DASH_DASH: "--", + CDATA_START: "[CDATA[", + DOCTYPE: "doctype", + SCRIPT: "script", + PUBLIC: "public", + SYSTEM: "system" + }; + function isSurrogate(cp) { + return cp >= 55296 && cp <= 57343; + } + function isSurrogatePair(cp) { + return cp >= 56320 && cp <= 57343; + } + function getSurrogatePairCodePoint(cp1, cp2) { + return (cp1 - 55296) * 1024 + 9216 + cp2; + } + function isControlCodePoint(cp) { + return cp !== 32 && cp !== 10 && cp !== 13 && cp !== 9 && cp !== 12 && cp >= 1 && cp <= 31 || cp >= 127 && cp <= 159; + } + function isUndefinedCodePoint(cp) { + return cp >= 64976 && cp <= 65007 || UNDEFINED_CODE_POINTS.has(cp); + } + + // node_modules/parse5/dist/common/error-codes.js + var ERR; + (function(ERR2) { + ERR2["controlCharacterInInputStream"] = "control-character-in-input-stream"; + ERR2["noncharacterInInputStream"] = "noncharacter-in-input-stream"; + ERR2["surrogateInInputStream"] = "surrogate-in-input-stream"; + ERR2["nonVoidHtmlElementStartTagWithTrailingSolidus"] = "non-void-html-element-start-tag-with-trailing-solidus"; + ERR2["endTagWithAttributes"] = "end-tag-with-attributes"; + ERR2["endTagWithTrailingSolidus"] = "end-tag-with-trailing-solidus"; + ERR2["unexpectedSolidusInTag"] = "unexpected-solidus-in-tag"; + ERR2["unexpectedNullCharacter"] = "unexpected-null-character"; + ERR2["unexpectedQuestionMarkInsteadOfTagName"] = "unexpected-question-mark-instead-of-tag-name"; + ERR2["invalidFirstCharacterOfTagName"] = "invalid-first-character-of-tag-name"; + ERR2["unexpectedEqualsSignBeforeAttributeName"] = "unexpected-equals-sign-before-attribute-name"; + ERR2["missingEndTagName"] = "missing-end-tag-name"; + ERR2["unexpectedCharacterInAttributeName"] = "unexpected-character-in-attribute-name"; + ERR2["unknownNamedCharacterReference"] = "unknown-named-character-reference"; + ERR2["missingSemicolonAfterCharacterReference"] = "missing-semicolon-after-character-reference"; + ERR2["unexpectedCharacterAfterDoctypeSystemIdentifier"] = "unexpected-character-after-doctype-system-identifier"; + ERR2["unexpectedCharacterInUnquotedAttributeValue"] = "unexpected-character-in-unquoted-attribute-value"; + ERR2["eofBeforeTagName"] = "eof-before-tag-name"; + ERR2["eofInTag"] = "eof-in-tag"; + ERR2["missingAttributeValue"] = "missing-attribute-value"; + ERR2["missingWhitespaceBetweenAttributes"] = "missing-whitespace-between-attributes"; + ERR2["missingWhitespaceAfterDoctypePublicKeyword"] = "missing-whitespace-after-doctype-public-keyword"; + ERR2["missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers"] = "missing-whitespace-between-doctype-public-and-system-identifiers"; + ERR2["missingWhitespaceAfterDoctypeSystemKeyword"] = "missing-whitespace-after-doctype-system-keyword"; + ERR2["missingQuoteBeforeDoctypePublicIdentifier"] = "missing-quote-before-doctype-public-identifier"; + ERR2["missingQuoteBeforeDoctypeSystemIdentifier"] = "missing-quote-before-doctype-system-identifier"; + ERR2["missingDoctypePublicIdentifier"] = "missing-doctype-public-identifier"; + ERR2["missingDoctypeSystemIdentifier"] = "missing-doctype-system-identifier"; + ERR2["abruptDoctypePublicIdentifier"] = "abrupt-doctype-public-identifier"; + ERR2["abruptDoctypeSystemIdentifier"] = "abrupt-doctype-system-identifier"; + ERR2["cdataInHtmlContent"] = "cdata-in-html-content"; + ERR2["incorrectlyOpenedComment"] = "incorrectly-opened-comment"; + ERR2["eofInScriptHtmlCommentLikeText"] = "eof-in-script-html-comment-like-text"; + ERR2["eofInDoctype"] = "eof-in-doctype"; + ERR2["nestedComment"] = "nested-comment"; + ERR2["abruptClosingOfEmptyComment"] = "abrupt-closing-of-empty-comment"; + ERR2["eofInComment"] = "eof-in-comment"; + ERR2["incorrectlyClosedComment"] = "incorrectly-closed-comment"; + ERR2["eofInCdata"] = "eof-in-cdata"; + ERR2["absenceOfDigitsInNumericCharacterReference"] = "absence-of-digits-in-numeric-character-reference"; + ERR2["nullCharacterReference"] = "null-character-reference"; + ERR2["surrogateCharacterReference"] = "surrogate-character-reference"; + ERR2["characterReferenceOutsideUnicodeRange"] = "character-reference-outside-unicode-range"; + ERR2["controlCharacterReference"] = "control-character-reference"; + ERR2["noncharacterCharacterReference"] = "noncharacter-character-reference"; + ERR2["missingWhitespaceBeforeDoctypeName"] = "missing-whitespace-before-doctype-name"; + ERR2["missingDoctypeName"] = "missing-doctype-name"; + ERR2["invalidCharacterSequenceAfterDoctypeName"] = "invalid-character-sequence-after-doctype-name"; + ERR2["duplicateAttribute"] = "duplicate-attribute"; + ERR2["nonConformingDoctype"] = "non-conforming-doctype"; + ERR2["missingDoctype"] = "missing-doctype"; + ERR2["misplacedDoctype"] = "misplaced-doctype"; + ERR2["endTagWithoutMatchingOpenElement"] = "end-tag-without-matching-open-element"; + ERR2["closingOfElementWithOpenChildElements"] = "closing-of-element-with-open-child-elements"; + ERR2["disallowedContentInNoscriptInHead"] = "disallowed-content-in-noscript-in-head"; + ERR2["openElementsLeftAfterEof"] = "open-elements-left-after-eof"; + ERR2["abandonedHeadElementChild"] = "abandoned-head-element-child"; + ERR2["misplacedStartTagForHeadElement"] = "misplaced-start-tag-for-head-element"; + ERR2["nestedNoscriptInHead"] = "nested-noscript-in-head"; + ERR2["eofInElementThatCanContainOnlyText"] = "eof-in-element-that-can-contain-only-text"; + })(ERR = ERR || (ERR = {})); + + // node_modules/parse5/dist/tokenizer/preprocessor.js + var DEFAULT_BUFFER_WATERLINE = 1 << 16; + var Preprocessor = class { + constructor(handler) { + this.handler = handler; + this.html = ""; + this.pos = -1; + this.lastGapPos = -2; + this.gapStack = []; + this.skipNextNewLine = false; + this.lastChunkWritten = false; + this.endOfChunkHit = false; + this.bufferWaterline = DEFAULT_BUFFER_WATERLINE; + this.isEol = false; + this.lineStartPos = 0; + this.droppedBufferSize = 0; + this.line = 1; + this.lastErrOffset = -1; + } + /** The column on the current line. If we just saw a gap (eg. a surrogate pair), return the index before. */ + get col() { + return this.pos - this.lineStartPos + Number(this.lastGapPos !== this.pos); + } + get offset() { + return this.droppedBufferSize + this.pos; + } + getError(code2) { + const { line, col, offset } = this; + return { + code: code2, + startLine: line, + endLine: line, + startCol: col, + endCol: col, + startOffset: offset, + endOffset: offset + }; + } + _err(code2) { + if (this.handler.onParseError && this.lastErrOffset !== this.offset) { + this.lastErrOffset = this.offset; + this.handler.onParseError(this.getError(code2)); + } + } + _addGap() { + this.gapStack.push(this.lastGapPos); + this.lastGapPos = this.pos; + } + _processSurrogate(cp) { + if (this.pos !== this.html.length - 1) { + const nextCp = this.html.charCodeAt(this.pos + 1); + if (isSurrogatePair(nextCp)) { + this.pos++; + this._addGap(); + return getSurrogatePairCodePoint(cp, nextCp); + } + } else if (!this.lastChunkWritten) { + this.endOfChunkHit = true; + return CODE_POINTS.EOF; + } + this._err(ERR.surrogateInInputStream); + return cp; + } + willDropParsedChunk() { + return this.pos > this.bufferWaterline; + } + dropParsedChunk() { + if (this.willDropParsedChunk()) { + this.html = this.html.substring(this.pos); + this.lineStartPos -= this.pos; + this.droppedBufferSize += this.pos; + this.pos = 0; + this.lastGapPos = -2; + this.gapStack.length = 0; + } + } + write(chunk, isLastChunk) { + if (this.html.length > 0) { + this.html += chunk; + } else { + this.html = chunk; + } + 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.endOfChunkHit = false; + } + startsWith(pattern, caseSensitive) { + if (this.pos + pattern.length > this.html.length) { + this.endOfChunkHit = !this.lastChunkWritten; + return false; + } + if (caseSensitive) { + return this.html.startsWith(pattern, this.pos); + } + for (let i = 0; i < pattern.length; i++) { + const cp = this.html.charCodeAt(this.pos + i) | 32; + if (cp !== pattern.charCodeAt(i)) { + return false; + } + } + return true; + } + peek(offset) { + const pos = this.pos + offset; + if (pos >= this.html.length) { + this.endOfChunkHit = !this.lastChunkWritten; + return CODE_POINTS.EOF; + } + const code2 = this.html.charCodeAt(pos); + return code2 === CODE_POINTS.CARRIAGE_RETURN ? CODE_POINTS.LINE_FEED : code2; + } + advance() { + this.pos++; + if (this.isEol) { + this.isEol = false; + this.line++; + this.lineStartPos = this.pos; + } + if (this.pos >= this.html.length) { + this.endOfChunkHit = !this.lastChunkWritten; + return CODE_POINTS.EOF; + } + let cp = this.html.charCodeAt(this.pos); + if (cp === CODE_POINTS.CARRIAGE_RETURN) { + this.isEol = true; + this.skipNextNewLine = true; + return CODE_POINTS.LINE_FEED; + } + if (cp === CODE_POINTS.LINE_FEED) { + this.isEol = true; + if (this.skipNextNewLine) { + this.line--; + this.skipNextNewLine = false; + this._addGap(); + return this.advance(); + } + } + this.skipNextNewLine = false; + if (isSurrogate(cp)) { + cp = this._processSurrogate(cp); + } + const isCommonValidRange = this.handler.onParseError === null || cp > 31 && cp < 127 || cp === CODE_POINTS.LINE_FEED || cp === CODE_POINTS.CARRIAGE_RETURN || cp > 159 && cp < 64976; + if (!isCommonValidRange) { + this._checkForProblematicCharacters(cp); + } + return cp; + } + _checkForProblematicCharacters(cp) { + if (isControlCodePoint(cp)) { + this._err(ERR.controlCharacterInInputStream); + } else if (isUndefinedCodePoint(cp)) { + this._err(ERR.noncharacterInInputStream); + } + } + retreat(count) { + this.pos -= count; + while (this.pos < this.lastGapPos) { + this.lastGapPos = this.gapStack.pop(); + this.pos--; + } + this.isEol = false; + } + }; + + // node_modules/parse5/dist/common/token.js + var TokenType; + (function(TokenType2) { + TokenType2[TokenType2["CHARACTER"] = 0] = "CHARACTER"; + TokenType2[TokenType2["NULL_CHARACTER"] = 1] = "NULL_CHARACTER"; + TokenType2[TokenType2["WHITESPACE_CHARACTER"] = 2] = "WHITESPACE_CHARACTER"; + TokenType2[TokenType2["START_TAG"] = 3] = "START_TAG"; + TokenType2[TokenType2["END_TAG"] = 4] = "END_TAG"; + TokenType2[TokenType2["COMMENT"] = 5] = "COMMENT"; + TokenType2[TokenType2["DOCTYPE"] = 6] = "DOCTYPE"; + TokenType2[TokenType2["EOF"] = 7] = "EOF"; + TokenType2[TokenType2["HIBERNATION"] = 8] = "HIBERNATION"; + })(TokenType = TokenType || (TokenType = {})); + function getTokenAttr(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; + } + + // node_modules/entities/lib/esm/generated/decode-data-html.js + var decode_data_html_default = new Uint16Array( + // prettier-ignore + '\u1D41<\xD5\u0131\u028A\u049D\u057B\u05D0\u0675\u06DE\u07A2\u07D6\u080F\u0A4A\u0A91\u0DA1\u0E6D\u0F09\u0F26\u10CA\u1228\u12E1\u1415\u149D\u14C3\u14DF\u1525\0\0\0\0\0\0\u156B\u16CD\u198D\u1C12\u1DDD\u1F7E\u2060\u21B0\u228D\u23C0\u23FB\u2442\u2824\u2912\u2D08\u2E48\u2FCE\u3016\u32BA\u3639\u37AC\u38FE\u3A28\u3A71\u3AE0\u3B2E\u0800EMabcfglmnoprstu\\bfms\x7F\x84\x8B\x90\x95\x98\xA6\xB3\xB9\xC8\xCFlig\u803B\xC6\u40C6P\u803B&\u4026cute\u803B\xC1\u40C1reve;\u4102\u0100iyx}rc\u803B\xC2\u40C2;\u4410r;\uC000\u{1D504}rave\u803B\xC0\u40C0pha;\u4391acr;\u4100d;\u6A53\u0100gp\x9D\xA1on;\u4104f;\uC000\u{1D538}plyFunction;\u6061ing\u803B\xC5\u40C5\u0100cs\xBE\xC3r;\uC000\u{1D49C}ign;\u6254ilde\u803B\xC3\u40C3ml\u803B\xC4\u40C4\u0400aceforsu\xE5\xFB\xFE\u0117\u011C\u0122\u0127\u012A\u0100cr\xEA\xF2kslash;\u6216\u0176\xF6\xF8;\u6AE7ed;\u6306y;\u4411\u0180crt\u0105\u010B\u0114ause;\u6235noullis;\u612Ca;\u4392r;\uC000\u{1D505}pf;\uC000\u{1D539}eve;\u42D8c\xF2\u0113mpeq;\u624E\u0700HOacdefhilorsu\u014D\u0151\u0156\u0180\u019E\u01A2\u01B5\u01B7\u01BA\u01DC\u0215\u0273\u0278\u027Ecy;\u4427PY\u803B\xA9\u40A9\u0180cpy\u015D\u0162\u017Aute;\u4106\u0100;i\u0167\u0168\u62D2talDifferentialD;\u6145leys;\u612D\u0200aeio\u0189\u018E\u0194\u0198ron;\u410Cdil\u803B\xC7\u40C7rc;\u4108nint;\u6230ot;\u410A\u0100dn\u01A7\u01ADilla;\u40B8terDot;\u40B7\xF2\u017Fi;\u43A7rcle\u0200DMPT\u01C7\u01CB\u01D1\u01D6ot;\u6299inus;\u6296lus;\u6295imes;\u6297o\u0100cs\u01E2\u01F8kwiseContourIntegral;\u6232eCurly\u0100DQ\u0203\u020FoubleQuote;\u601Duote;\u6019\u0200lnpu\u021E\u0228\u0247\u0255on\u0100;e\u0225\u0226\u6237;\u6A74\u0180git\u022F\u0236\u023Aruent;\u6261nt;\u622FourIntegral;\u622E\u0100fr\u024C\u024E;\u6102oduct;\u6210nterClockwiseContourIntegral;\u6233oss;\u6A2Fcr;\uC000\u{1D49E}p\u0100;C\u0284\u0285\u62D3ap;\u624D\u0580DJSZacefios\u02A0\u02AC\u02B0\u02B4\u02B8\u02CB\u02D7\u02E1\u02E6\u0333\u048D\u0100;o\u0179\u02A5trahd;\u6911cy;\u4402cy;\u4405cy;\u440F\u0180grs\u02BF\u02C4\u02C7ger;\u6021r;\u61A1hv;\u6AE4\u0100ay\u02D0\u02D5ron;\u410E;\u4414l\u0100;t\u02DD\u02DE\u6207a;\u4394r;\uC000\u{1D507}\u0100af\u02EB\u0327\u0100cm\u02F0\u0322ritical\u0200ADGT\u0300\u0306\u0316\u031Ccute;\u40B4o\u0174\u030B\u030D;\u42D9bleAcute;\u42DDrave;\u4060ilde;\u42DCond;\u62C4ferentialD;\u6146\u0470\u033D\0\0\0\u0342\u0354\0\u0405f;\uC000\u{1D53B}\u0180;DE\u0348\u0349\u034D\u40A8ot;\u60DCqual;\u6250ble\u0300CDLRUV\u0363\u0372\u0382\u03CF\u03E2\u03F8ontourIntegra\xEC\u0239o\u0274\u0379\0\0\u037B\xBB\u0349nArrow;\u61D3\u0100eo\u0387\u03A4ft\u0180ART\u0390\u0396\u03A1rrow;\u61D0ightArrow;\u61D4e\xE5\u02CAng\u0100LR\u03AB\u03C4eft\u0100AR\u03B3\u03B9rrow;\u67F8ightArrow;\u67FAightArrow;\u67F9ight\u0100AT\u03D8\u03DErrow;\u61D2ee;\u62A8p\u0241\u03E9\0\0\u03EFrrow;\u61D1ownArrow;\u61D5erticalBar;\u6225n\u0300ABLRTa\u0412\u042A\u0430\u045E\u047F\u037Crrow\u0180;BU\u041D\u041E\u0422\u6193ar;\u6913pArrow;\u61F5reve;\u4311eft\u02D2\u043A\0\u0446\0\u0450ightVector;\u6950eeVector;\u695Eector\u0100;B\u0459\u045A\u61BDar;\u6956ight\u01D4\u0467\0\u0471eeVector;\u695Fector\u0100;B\u047A\u047B\u61C1ar;\u6957ee\u0100;A\u0486\u0487\u62A4rrow;\u61A7\u0100ct\u0492\u0497r;\uC000\u{1D49F}rok;\u4110\u0800NTacdfglmopqstux\u04BD\u04C0\u04C4\u04CB\u04DE\u04E2\u04E7\u04EE\u04F5\u0521\u052F\u0536\u0552\u055D\u0560\u0565G;\u414AH\u803B\xD0\u40D0cute\u803B\xC9\u40C9\u0180aiy\u04D2\u04D7\u04DCron;\u411Arc\u803B\xCA\u40CA;\u442Dot;\u4116r;\uC000\u{1D508}rave\u803B\xC8\u40C8ement;\u6208\u0100ap\u04FA\u04FEcr;\u4112ty\u0253\u0506\0\0\u0512mallSquare;\u65FBerySmallSquare;\u65AB\u0100gp\u0526\u052Aon;\u4118f;\uC000\u{1D53C}silon;\u4395u\u0100ai\u053C\u0549l\u0100;T\u0542\u0543\u6A75ilde;\u6242librium;\u61CC\u0100ci\u0557\u055Ar;\u6130m;\u6A73a;\u4397ml\u803B\xCB\u40CB\u0100ip\u056A\u056Fsts;\u6203onentialE;\u6147\u0280cfios\u0585\u0588\u058D\u05B2\u05CCy;\u4424r;\uC000\u{1D509}lled\u0253\u0597\0\0\u05A3mallSquare;\u65FCerySmallSquare;\u65AA\u0370\u05BA\0\u05BF\0\0\u05C4f;\uC000\u{1D53D}All;\u6200riertrf;\u6131c\xF2\u05CB\u0600JTabcdfgorst\u05E8\u05EC\u05EF\u05FA\u0600\u0612\u0616\u061B\u061D\u0623\u066C\u0672cy;\u4403\u803B>\u403Emma\u0100;d\u05F7\u05F8\u4393;\u43DCreve;\u411E\u0180eiy\u0607\u060C\u0610dil;\u4122rc;\u411C;\u4413ot;\u4120r;\uC000\u{1D50A};\u62D9pf;\uC000\u{1D53E}eater\u0300EFGLST\u0635\u0644\u064E\u0656\u065B\u0666qual\u0100;L\u063E\u063F\u6265ess;\u62DBullEqual;\u6267reater;\u6AA2ess;\u6277lantEqual;\u6A7Eilde;\u6273cr;\uC000\u{1D4A2};\u626B\u0400Aacfiosu\u0685\u068B\u0696\u069B\u069E\u06AA\u06BE\u06CARDcy;\u442A\u0100ct\u0690\u0694ek;\u42C7;\u405Eirc;\u4124r;\u610ClbertSpace;\u610B\u01F0\u06AF\0\u06B2f;\u610DizontalLine;\u6500\u0100ct\u06C3\u06C5\xF2\u06A9rok;\u4126mp\u0144\u06D0\u06D8ownHum\xF0\u012Fqual;\u624F\u0700EJOacdfgmnostu\u06FA\u06FE\u0703\u0707\u070E\u071A\u071E\u0721\u0728\u0744\u0778\u078B\u078F\u0795cy;\u4415lig;\u4132cy;\u4401cute\u803B\xCD\u40CD\u0100iy\u0713\u0718rc\u803B\xCE\u40CE;\u4418ot;\u4130r;\u6111rave\u803B\xCC\u40CC\u0180;ap\u0720\u072F\u073F\u0100cg\u0734\u0737r;\u412AinaryI;\u6148lie\xF3\u03DD\u01F4\u0749\0\u0762\u0100;e\u074D\u074E\u622C\u0100gr\u0753\u0758ral;\u622Bsection;\u62C2isible\u0100CT\u076C\u0772omma;\u6063imes;\u6062\u0180gpt\u077F\u0783\u0788on;\u412Ef;\uC000\u{1D540}a;\u4399cr;\u6110ilde;\u4128\u01EB\u079A\0\u079Ecy;\u4406l\u803B\xCF\u40CF\u0280cfosu\u07AC\u07B7\u07BC\u07C2\u07D0\u0100iy\u07B1\u07B5rc;\u4134;\u4419r;\uC000\u{1D50D}pf;\uC000\u{1D541}\u01E3\u07C7\0\u07CCr;\uC000\u{1D4A5}rcy;\u4408kcy;\u4404\u0380HJacfos\u07E4\u07E8\u07EC\u07F1\u07FD\u0802\u0808cy;\u4425cy;\u440Cppa;\u439A\u0100ey\u07F6\u07FBdil;\u4136;\u441Ar;\uC000\u{1D50E}pf;\uC000\u{1D542}cr;\uC000\u{1D4A6}\u0580JTaceflmost\u0825\u0829\u082C\u0850\u0863\u09B3\u09B8\u09C7\u09CD\u0A37\u0A47cy;\u4409\u803B<\u403C\u0280cmnpr\u0837\u083C\u0841\u0844\u084Dute;\u4139bda;\u439Bg;\u67EAlacetrf;\u6112r;\u619E\u0180aey\u0857\u085C\u0861ron;\u413Ddil;\u413B;\u441B\u0100fs\u0868\u0970t\u0500ACDFRTUVar\u087E\u08A9\u08B1\u08E0\u08E6\u08FC\u092F\u095B\u0390\u096A\u0100nr\u0883\u088FgleBracket;\u67E8row\u0180;BR\u0899\u089A\u089E\u6190ar;\u61E4ightArrow;\u61C6eiling;\u6308o\u01F5\u08B7\0\u08C3bleBracket;\u67E6n\u01D4\u08C8\0\u08D2eeVector;\u6961ector\u0100;B\u08DB\u08DC\u61C3ar;\u6959loor;\u630Aight\u0100AV\u08EF\u08F5rrow;\u6194ector;\u694E\u0100er\u0901\u0917e\u0180;AV\u0909\u090A\u0910\u62A3rrow;\u61A4ector;\u695Aiangle\u0180;BE\u0924\u0925\u0929\u62B2ar;\u69CFqual;\u62B4p\u0180DTV\u0937\u0942\u094CownVector;\u6951eeVector;\u6960ector\u0100;B\u0956\u0957\u61BFar;\u6958ector\u0100;B\u0965\u0966\u61BCar;\u6952ight\xE1\u039Cs\u0300EFGLST\u097E\u098B\u0995\u099D\u09A2\u09ADqualGreater;\u62DAullEqual;\u6266reater;\u6276ess;\u6AA1lantEqual;\u6A7Dilde;\u6272r;\uC000\u{1D50F}\u0100;e\u09BD\u09BE\u62D8ftarrow;\u61DAidot;\u413F\u0180npw\u09D4\u0A16\u0A1Bg\u0200LRlr\u09DE\u09F7\u0A02\u0A10eft\u0100AR\u09E6\u09ECrrow;\u67F5ightArrow;\u67F7ightArrow;\u67F6eft\u0100ar\u03B3\u0A0Aight\xE1\u03BFight\xE1\u03CAf;\uC000\u{1D543}er\u0100LR\u0A22\u0A2CeftArrow;\u6199ightArrow;\u6198\u0180cht\u0A3E\u0A40\u0A42\xF2\u084C;\u61B0rok;\u4141;\u626A\u0400acefiosu\u0A5A\u0A5D\u0A60\u0A77\u0A7C\u0A85\u0A8B\u0A8Ep;\u6905y;\u441C\u0100dl\u0A65\u0A6FiumSpace;\u605Flintrf;\u6133r;\uC000\u{1D510}nusPlus;\u6213pf;\uC000\u{1D544}c\xF2\u0A76;\u439C\u0480Jacefostu\u0AA3\u0AA7\u0AAD\u0AC0\u0B14\u0B19\u0D91\u0D97\u0D9Ecy;\u440Acute;\u4143\u0180aey\u0AB4\u0AB9\u0ABEron;\u4147dil;\u4145;\u441D\u0180gsw\u0AC7\u0AF0\u0B0Eative\u0180MTV\u0AD3\u0ADF\u0AE8ediumSpace;\u600Bhi\u0100cn\u0AE6\u0AD8\xEB\u0AD9eryThi\xEE\u0AD9ted\u0100GL\u0AF8\u0B06reaterGreate\xF2\u0673essLes\xF3\u0A48Line;\u400Ar;\uC000\u{1D511}\u0200Bnpt\u0B22\u0B28\u0B37\u0B3Areak;\u6060BreakingSpace;\u40A0f;\u6115\u0680;CDEGHLNPRSTV\u0B55\u0B56\u0B6A\u0B7C\u0BA1\u0BEB\u0C04\u0C5E\u0C84\u0CA6\u0CD8\u0D61\u0D85\u6AEC\u0100ou\u0B5B\u0B64ngruent;\u6262pCap;\u626DoubleVerticalBar;\u6226\u0180lqx\u0B83\u0B8A\u0B9Bement;\u6209ual\u0100;T\u0B92\u0B93\u6260ilde;\uC000\u2242\u0338ists;\u6204reater\u0380;EFGLST\u0BB6\u0BB7\u0BBD\u0BC9\u0BD3\u0BD8\u0BE5\u626Fqual;\u6271ullEqual;\uC000\u2267\u0338reater;\uC000\u226B\u0338ess;\u6279lantEqual;\uC000\u2A7E\u0338ilde;\u6275ump\u0144\u0BF2\u0BFDownHump;\uC000\u224E\u0338qual;\uC000\u224F\u0338e\u0100fs\u0C0A\u0C27tTriangle\u0180;BE\u0C1A\u0C1B\u0C21\u62EAar;\uC000\u29CF\u0338qual;\u62ECs\u0300;EGLST\u0C35\u0C36\u0C3C\u0C44\u0C4B\u0C58\u626Equal;\u6270reater;\u6278ess;\uC000\u226A\u0338lantEqual;\uC000\u2A7D\u0338ilde;\u6274ested\u0100GL\u0C68\u0C79reaterGreater;\uC000\u2AA2\u0338essLess;\uC000\u2AA1\u0338recedes\u0180;ES\u0C92\u0C93\u0C9B\u6280qual;\uC000\u2AAF\u0338lantEqual;\u62E0\u0100ei\u0CAB\u0CB9verseElement;\u620CghtTriangle\u0180;BE\u0CCB\u0CCC\u0CD2\u62EBar;\uC000\u29D0\u0338qual;\u62ED\u0100qu\u0CDD\u0D0CuareSu\u0100bp\u0CE8\u0CF9set\u0100;E\u0CF0\u0CF3\uC000\u228F\u0338qual;\u62E2erset\u0100;E\u0D03\u0D06\uC000\u2290\u0338qual;\u62E3\u0180bcp\u0D13\u0D24\u0D4Eset\u0100;E\u0D1B\u0D1E\uC000\u2282\u20D2qual;\u6288ceeds\u0200;EST\u0D32\u0D33\u0D3B\u0D46\u6281qual;\uC000\u2AB0\u0338lantEqual;\u62E1ilde;\uC000\u227F\u0338erset\u0100;E\u0D58\u0D5B\uC000\u2283\u20D2qual;\u6289ilde\u0200;EFT\u0D6E\u0D6F\u0D75\u0D7F\u6241qual;\u6244ullEqual;\u6247ilde;\u6249erticalBar;\u6224cr;\uC000\u{1D4A9}ilde\u803B\xD1\u40D1;\u439D\u0700Eacdfgmoprstuv\u0DBD\u0DC2\u0DC9\u0DD5\u0DDB\u0DE0\u0DE7\u0DFC\u0E02\u0E20\u0E22\u0E32\u0E3F\u0E44lig;\u4152cute\u803B\xD3\u40D3\u0100iy\u0DCE\u0DD3rc\u803B\xD4\u40D4;\u441Eblac;\u4150r;\uC000\u{1D512}rave\u803B\xD2\u40D2\u0180aei\u0DEE\u0DF2\u0DF6cr;\u414Cga;\u43A9cron;\u439Fpf;\uC000\u{1D546}enCurly\u0100DQ\u0E0E\u0E1AoubleQuote;\u601Cuote;\u6018;\u6A54\u0100cl\u0E27\u0E2Cr;\uC000\u{1D4AA}ash\u803B\xD8\u40D8i\u016C\u0E37\u0E3Cde\u803B\xD5\u40D5es;\u6A37ml\u803B\xD6\u40D6er\u0100BP\u0E4B\u0E60\u0100ar\u0E50\u0E53r;\u603Eac\u0100ek\u0E5A\u0E5C;\u63DEet;\u63B4arenthesis;\u63DC\u0480acfhilors\u0E7F\u0E87\u0E8A\u0E8F\u0E92\u0E94\u0E9D\u0EB0\u0EFCrtialD;\u6202y;\u441Fr;\uC000\u{1D513}i;\u43A6;\u43A0usMinus;\u40B1\u0100ip\u0EA2\u0EADncareplan\xE5\u069Df;\u6119\u0200;eio\u0EB9\u0EBA\u0EE0\u0EE4\u6ABBcedes\u0200;EST\u0EC8\u0EC9\u0ECF\u0EDA\u627Aqual;\u6AAFlantEqual;\u627Cilde;\u627Eme;\u6033\u0100dp\u0EE9\u0EEEuct;\u620Fortion\u0100;a\u0225\u0EF9l;\u621D\u0100ci\u0F01\u0F06r;\uC000\u{1D4AB};\u43A8\u0200Ufos\u0F11\u0F16\u0F1B\u0F1FOT\u803B"\u4022r;\uC000\u{1D514}pf;\u611Acr;\uC000\u{1D4AC}\u0600BEacefhiorsu\u0F3E\u0F43\u0F47\u0F60\u0F73\u0FA7\u0FAA\u0FAD\u1096\u10A9\u10B4\u10BEarr;\u6910G\u803B\xAE\u40AE\u0180cnr\u0F4E\u0F53\u0F56ute;\u4154g;\u67EBr\u0100;t\u0F5C\u0F5D\u61A0l;\u6916\u0180aey\u0F67\u0F6C\u0F71ron;\u4158dil;\u4156;\u4420\u0100;v\u0F78\u0F79\u611Cerse\u0100EU\u0F82\u0F99\u0100lq\u0F87\u0F8Eement;\u620Builibrium;\u61CBpEquilibrium;\u696Fr\xBB\u0F79o;\u43A1ght\u0400ACDFTUVa\u0FC1\u0FEB\u0FF3\u1022\u1028\u105B\u1087\u03D8\u0100nr\u0FC6\u0FD2gleBracket;\u67E9row\u0180;BL\u0FDC\u0FDD\u0FE1\u6192ar;\u61E5eftArrow;\u61C4eiling;\u6309o\u01F5\u0FF9\0\u1005bleBracket;\u67E7n\u01D4\u100A\0\u1014eeVector;\u695Dector\u0100;B\u101D\u101E\u61C2ar;\u6955loor;\u630B\u0100er\u102D\u1043e\u0180;AV\u1035\u1036\u103C\u62A2rrow;\u61A6ector;\u695Biangle\u0180;BE\u1050\u1051\u1055\u62B3ar;\u69D0qual;\u62B5p\u0180DTV\u1063\u106E\u1078ownVector;\u694FeeVector;\u695Cector\u0100;B\u1082\u1083\u61BEar;\u6954ector\u0100;B\u1091\u1092\u61C0ar;\u6953\u0100pu\u109B\u109Ef;\u611DndImplies;\u6970ightarrow;\u61DB\u0100ch\u10B9\u10BCr;\u611B;\u61B1leDelayed;\u69F4\u0680HOacfhimoqstu\u10E4\u10F1\u10F7\u10FD\u1119\u111E\u1151\u1156\u1161\u1167\u11B5\u11BB\u11BF\u0100Cc\u10E9\u10EEHcy;\u4429y;\u4428FTcy;\u442Ccute;\u415A\u0280;aeiy\u1108\u1109\u110E\u1113\u1117\u6ABCron;\u4160dil;\u415Erc;\u415C;\u4421r;\uC000\u{1D516}ort\u0200DLRU\u112A\u1134\u113E\u1149ownArrow\xBB\u041EeftArrow\xBB\u089AightArrow\xBB\u0FDDpArrow;\u6191gma;\u43A3allCircle;\u6218pf;\uC000\u{1D54A}\u0272\u116D\0\0\u1170t;\u621Aare\u0200;ISU\u117B\u117C\u1189\u11AF\u65A1ntersection;\u6293u\u0100bp\u118F\u119Eset\u0100;E\u1197\u1198\u628Fqual;\u6291erset\u0100;E\u11A8\u11A9\u6290qual;\u6292nion;\u6294cr;\uC000\u{1D4AE}ar;\u62C6\u0200bcmp\u11C8\u11DB\u1209\u120B\u0100;s\u11CD\u11CE\u62D0et\u0100;E\u11CD\u11D5qual;\u6286\u0100ch\u11E0\u1205eeds\u0200;EST\u11ED\u11EE\u11F4\u11FF\u627Bqual;\u6AB0lantEqual;\u627Dilde;\u627FTh\xE1\u0F8C;\u6211\u0180;es\u1212\u1213\u1223\u62D1rset\u0100;E\u121C\u121D\u6283qual;\u6287et\xBB\u1213\u0580HRSacfhiors\u123E\u1244\u1249\u1255\u125E\u1271\u1276\u129F\u12C2\u12C8\u12D1ORN\u803B\xDE\u40DEADE;\u6122\u0100Hc\u124E\u1252cy;\u440By;\u4426\u0100bu\u125A\u125C;\u4009;\u43A4\u0180aey\u1265\u126A\u126Fron;\u4164dil;\u4162;\u4422r;\uC000\u{1D517}\u0100ei\u127B\u1289\u01F2\u1280\0\u1287efore;\u6234a;\u4398\u0100cn\u128E\u1298kSpace;\uC000\u205F\u200ASpace;\u6009lde\u0200;EFT\u12AB\u12AC\u12B2\u12BC\u623Cqual;\u6243ullEqual;\u6245ilde;\u6248pf;\uC000\u{1D54B}ipleDot;\u60DB\u0100ct\u12D6\u12DBr;\uC000\u{1D4AF}rok;\u4166\u0AE1\u12F7\u130E\u131A\u1326\0\u132C\u1331\0\0\0\0\0\u1338\u133D\u1377\u1385\0\u13FF\u1404\u140A\u1410\u0100cr\u12FB\u1301ute\u803B\xDA\u40DAr\u0100;o\u1307\u1308\u619Fcir;\u6949r\u01E3\u1313\0\u1316y;\u440Eve;\u416C\u0100iy\u131E\u1323rc\u803B\xDB\u40DB;\u4423blac;\u4170r;\uC000\u{1D518}rave\u803B\xD9\u40D9acr;\u416A\u0100di\u1341\u1369er\u0100BP\u1348\u135D\u0100ar\u134D\u1350r;\u405Fac\u0100ek\u1357\u1359;\u63DFet;\u63B5arenthesis;\u63DDon\u0100;P\u1370\u1371\u62C3lus;\u628E\u0100gp\u137B\u137Fon;\u4172f;\uC000\u{1D54C}\u0400ADETadps\u1395\u13AE\u13B8\u13C4\u03E8\u13D2\u13D7\u13F3rrow\u0180;BD\u1150\u13A0\u13A4ar;\u6912ownArrow;\u61C5ownArrow;\u6195quilibrium;\u696Eee\u0100;A\u13CB\u13CC\u62A5rrow;\u61A5own\xE1\u03F3er\u0100LR\u13DE\u13E8eftArrow;\u6196ightArrow;\u6197i\u0100;l\u13F9\u13FA\u43D2on;\u43A5ing;\u416Ecr;\uC000\u{1D4B0}ilde;\u4168ml\u803B\xDC\u40DC\u0480Dbcdefosv\u1427\u142C\u1430\u1433\u143E\u1485\u148A\u1490\u1496ash;\u62ABar;\u6AEBy;\u4412ash\u0100;l\u143B\u143C\u62A9;\u6AE6\u0100er\u1443\u1445;\u62C1\u0180bty\u144C\u1450\u147Aar;\u6016\u0100;i\u144F\u1455cal\u0200BLST\u1461\u1465\u146A\u1474ar;\u6223ine;\u407Ceparator;\u6758ilde;\u6240ThinSpace;\u600Ar;\uC000\u{1D519}pf;\uC000\u{1D54D}cr;\uC000\u{1D4B1}dash;\u62AA\u0280cefos\u14A7\u14AC\u14B1\u14B6\u14BCirc;\u4174dge;\u62C0r;\uC000\u{1D51A}pf;\uC000\u{1D54E}cr;\uC000\u{1D4B2}\u0200fios\u14CB\u14D0\u14D2\u14D8r;\uC000\u{1D51B};\u439Epf;\uC000\u{1D54F}cr;\uC000\u{1D4B3}\u0480AIUacfosu\u14F1\u14F5\u14F9\u14FD\u1504\u150F\u1514\u151A\u1520cy;\u442Fcy;\u4407cy;\u442Ecute\u803B\xDD\u40DD\u0100iy\u1509\u150Drc;\u4176;\u442Br;\uC000\u{1D51C}pf;\uC000\u{1D550}cr;\uC000\u{1D4B4}ml;\u4178\u0400Hacdefos\u1535\u1539\u153F\u154B\u154F\u155D\u1560\u1564cy;\u4416cute;\u4179\u0100ay\u1544\u1549ron;\u417D;\u4417ot;\u417B\u01F2\u1554\0\u155BoWidt\xE8\u0AD9a;\u4396r;\u6128pf;\u6124cr;\uC000\u{1D4B5}\u0BE1\u1583\u158A\u1590\0\u15B0\u15B6\u15BF\0\0\0\0\u15C6\u15DB\u15EB\u165F\u166D\0\u1695\u169B\u16B2\u16B9\0\u16BEcute\u803B\xE1\u40E1reve;\u4103\u0300;Ediuy\u159C\u159D\u15A1\u15A3\u15A8\u15AD\u623E;\uC000\u223E\u0333;\u623Frc\u803B\xE2\u40E2te\u80BB\xB4\u0306;\u4430lig\u803B\xE6\u40E6\u0100;r\xB2\u15BA;\uC000\u{1D51E}rave\u803B\xE0\u40E0\u0100ep\u15CA\u15D6\u0100fp\u15CF\u15D4sym;\u6135\xE8\u15D3ha;\u43B1\u0100ap\u15DFc\u0100cl\u15E4\u15E7r;\u4101g;\u6A3F\u0264\u15F0\0\0\u160A\u0280;adsv\u15FA\u15FB\u15FF\u1601\u1607\u6227nd;\u6A55;\u6A5Clope;\u6A58;\u6A5A\u0380;elmrsz\u1618\u1619\u161B\u161E\u163F\u164F\u1659\u6220;\u69A4e\xBB\u1619sd\u0100;a\u1625\u1626\u6221\u0461\u1630\u1632\u1634\u1636\u1638\u163A\u163C\u163E;\u69A8;\u69A9;\u69AA;\u69AB;\u69AC;\u69AD;\u69AE;\u69AFt\u0100;v\u1645\u1646\u621Fb\u0100;d\u164C\u164D\u62BE;\u699D\u0100pt\u1654\u1657h;\u6222\xBB\xB9arr;\u637C\u0100gp\u1663\u1667on;\u4105f;\uC000\u{1D552}\u0380;Eaeiop\u12C1\u167B\u167D\u1682\u1684\u1687\u168A;\u6A70cir;\u6A6F;\u624Ad;\u624Bs;\u4027rox\u0100;e\u12C1\u1692\xF1\u1683ing\u803B\xE5\u40E5\u0180cty\u16A1\u16A6\u16A8r;\uC000\u{1D4B6};\u402Amp\u0100;e\u12C1\u16AF\xF1\u0288ilde\u803B\xE3\u40E3ml\u803B\xE4\u40E4\u0100ci\u16C2\u16C8onin\xF4\u0272nt;\u6A11\u0800Nabcdefiklnoprsu\u16ED\u16F1\u1730\u173C\u1743\u1748\u1778\u177D\u17E0\u17E6\u1839\u1850\u170D\u193D\u1948\u1970ot;\u6AED\u0100cr\u16F6\u171Ek\u0200ceps\u1700\u1705\u170D\u1713ong;\u624Cpsilon;\u43F6rime;\u6035im\u0100;e\u171A\u171B\u623Dq;\u62CD\u0176\u1722\u1726ee;\u62BDed\u0100;g\u172C\u172D\u6305e\xBB\u172Drk\u0100;t\u135C\u1737brk;\u63B6\u0100oy\u1701\u1741;\u4431quo;\u601E\u0280cmprt\u1753\u175B\u1761\u1764\u1768aus\u0100;e\u010A\u0109ptyv;\u69B0s\xE9\u170Cno\xF5\u0113\u0180ahw\u176F\u1771\u1773;\u43B2;\u6136een;\u626Cr;\uC000\u{1D51F}g\u0380costuvw\u178D\u179D\u17B3\u17C1\u17D5\u17DB\u17DE\u0180aiu\u1794\u1796\u179A\xF0\u0760rc;\u65EFp\xBB\u1371\u0180dpt\u17A4\u17A8\u17ADot;\u6A00lus;\u6A01imes;\u6A02\u0271\u17B9\0\0\u17BEcup;\u6A06ar;\u6605riangle\u0100du\u17CD\u17D2own;\u65BDp;\u65B3plus;\u6A04e\xE5\u1444\xE5\u14ADarow;\u690D\u0180ako\u17ED\u1826\u1835\u0100cn\u17F2\u1823k\u0180lst\u17FA\u05AB\u1802ozenge;\u69EBriangle\u0200;dlr\u1812\u1813\u1818\u181D\u65B4own;\u65BEeft;\u65C2ight;\u65B8k;\u6423\u01B1\u182B\0\u1833\u01B2\u182F\0\u1831;\u6592;\u65914;\u6593ck;\u6588\u0100eo\u183E\u184D\u0100;q\u1843\u1846\uC000=\u20E5uiv;\uC000\u2261\u20E5t;\u6310\u0200ptwx\u1859\u185E\u1867\u186Cf;\uC000\u{1D553}\u0100;t\u13CB\u1863om\xBB\u13CCtie;\u62C8\u0600DHUVbdhmptuv\u1885\u1896\u18AA\u18BB\u18D7\u18DB\u18EC\u18FF\u1905\u190A\u1910\u1921\u0200LRlr\u188E\u1890\u1892\u1894;\u6557;\u6554;\u6556;\u6553\u0280;DUdu\u18A1\u18A2\u18A4\u18A6\u18A8\u6550;\u6566;\u6569;\u6564;\u6567\u0200LRlr\u18B3\u18B5\u18B7\u18B9;\u655D;\u655A;\u655C;\u6559\u0380;HLRhlr\u18CA\u18CB\u18CD\u18CF\u18D1\u18D3\u18D5\u6551;\u656C;\u6563;\u6560;\u656B;\u6562;\u655Fox;\u69C9\u0200LRlr\u18E4\u18E6\u18E8\u18EA;\u6555;\u6552;\u6510;\u650C\u0280;DUdu\u06BD\u18F7\u18F9\u18FB\u18FD;\u6565;\u6568;\u652C;\u6534inus;\u629Flus;\u629Eimes;\u62A0\u0200LRlr\u1919\u191B\u191D\u191F;\u655B;\u6558;\u6518;\u6514\u0380;HLRhlr\u1930\u1931\u1933\u1935\u1937\u1939\u193B\u6502;\u656A;\u6561;\u655E;\u653C;\u6524;\u651C\u0100ev\u0123\u1942bar\u803B\xA6\u40A6\u0200ceio\u1951\u1956\u195A\u1960r;\uC000\u{1D4B7}mi;\u604Fm\u0100;e\u171A\u171Cl\u0180;bh\u1968\u1969\u196B\u405C;\u69C5sub;\u67C8\u016C\u1974\u197El\u0100;e\u1979\u197A\u6022t\xBB\u197Ap\u0180;Ee\u012F\u1985\u1987;\u6AAE\u0100;q\u06DC\u06DB\u0CE1\u19A7\0\u19E8\u1A11\u1A15\u1A32\0\u1A37\u1A50\0\0\u1AB4\0\0\u1AC1\0\0\u1B21\u1B2E\u1B4D\u1B52\0\u1BFD\0\u1C0C\u0180cpr\u19AD\u19B2\u19DDute;\u4107\u0300;abcds\u19BF\u19C0\u19C4\u19CA\u19D5\u19D9\u6229nd;\u6A44rcup;\u6A49\u0100au\u19CF\u19D2p;\u6A4Bp;\u6A47ot;\u6A40;\uC000\u2229\uFE00\u0100eo\u19E2\u19E5t;\u6041\xEE\u0693\u0200aeiu\u19F0\u19FB\u1A01\u1A05\u01F0\u19F5\0\u19F8s;\u6A4Don;\u410Ddil\u803B\xE7\u40E7rc;\u4109ps\u0100;s\u1A0C\u1A0D\u6A4Cm;\u6A50ot;\u410B\u0180dmn\u1A1B\u1A20\u1A26il\u80BB\xB8\u01ADptyv;\u69B2t\u8100\xA2;e\u1A2D\u1A2E\u40A2r\xE4\u01B2r;\uC000\u{1D520}\u0180cei\u1A3D\u1A40\u1A4Dy;\u4447ck\u0100;m\u1A47\u1A48\u6713ark\xBB\u1A48;\u43C7r\u0380;Ecefms\u1A5F\u1A60\u1A62\u1A6B\u1AA4\u1AAA\u1AAE\u65CB;\u69C3\u0180;el\u1A69\u1A6A\u1A6D\u42C6q;\u6257e\u0261\u1A74\0\0\u1A88rrow\u0100lr\u1A7C\u1A81eft;\u61BAight;\u61BB\u0280RSacd\u1A92\u1A94\u1A96\u1A9A\u1A9F\xBB\u0F47;\u64C8st;\u629Birc;\u629Aash;\u629Dnint;\u6A10id;\u6AEFcir;\u69C2ubs\u0100;u\u1ABB\u1ABC\u6663it\xBB\u1ABC\u02EC\u1AC7\u1AD4\u1AFA\0\u1B0Aon\u0100;e\u1ACD\u1ACE\u403A\u0100;q\xC7\xC6\u026D\u1AD9\0\0\u1AE2a\u0100;t\u1ADE\u1ADF\u402C;\u4040\u0180;fl\u1AE8\u1AE9\u1AEB\u6201\xEE\u1160e\u0100mx\u1AF1\u1AF6ent\xBB\u1AE9e\xF3\u024D\u01E7\u1AFE\0\u1B07\u0100;d\u12BB\u1B02ot;\u6A6Dn\xF4\u0246\u0180fry\u1B10\u1B14\u1B17;\uC000\u{1D554}o\xE4\u0254\u8100\xA9;s\u0155\u1B1Dr;\u6117\u0100ao\u1B25\u1B29rr;\u61B5ss;\u6717\u0100cu\u1B32\u1B37r;\uC000\u{1D4B8}\u0100bp\u1B3C\u1B44\u0100;e\u1B41\u1B42\u6ACF;\u6AD1\u0100;e\u1B49\u1B4A\u6AD0;\u6AD2dot;\u62EF\u0380delprvw\u1B60\u1B6C\u1B77\u1B82\u1BAC\u1BD4\u1BF9arr\u0100lr\u1B68\u1B6A;\u6938;\u6935\u0270\u1B72\0\0\u1B75r;\u62DEc;\u62DFarr\u0100;p\u1B7F\u1B80\u61B6;\u693D\u0300;bcdos\u1B8F\u1B90\u1B96\u1BA1\u1BA5\u1BA8\u622Arcap;\u6A48\u0100au\u1B9B\u1B9Ep;\u6A46p;\u6A4Aot;\u628Dr;\u6A45;\uC000\u222A\uFE00\u0200alrv\u1BB5\u1BBF\u1BDE\u1BE3rr\u0100;m\u1BBC\u1BBD\u61B7;\u693Cy\u0180evw\u1BC7\u1BD4\u1BD8q\u0270\u1BCE\0\0\u1BD2re\xE3\u1B73u\xE3\u1B75ee;\u62CEedge;\u62CFen\u803B\xA4\u40A4earrow\u0100lr\u1BEE\u1BF3eft\xBB\u1B80ight\xBB\u1BBDe\xE4\u1BDD\u0100ci\u1C01\u1C07onin\xF4\u01F7nt;\u6231lcty;\u632D\u0980AHabcdefhijlorstuwz\u1C38\u1C3B\u1C3F\u1C5D\u1C69\u1C75\u1C8A\u1C9E\u1CAC\u1CB7\u1CFB\u1CFF\u1D0D\u1D7B\u1D91\u1DAB\u1DBB\u1DC6\u1DCDr\xF2\u0381ar;\u6965\u0200glrs\u1C48\u1C4D\u1C52\u1C54ger;\u6020eth;\u6138\xF2\u1133h\u0100;v\u1C5A\u1C5B\u6010\xBB\u090A\u016B\u1C61\u1C67arow;\u690Fa\xE3\u0315\u0100ay\u1C6E\u1C73ron;\u410F;\u4434\u0180;ao\u0332\u1C7C\u1C84\u0100gr\u02BF\u1C81r;\u61CAtseq;\u6A77\u0180glm\u1C91\u1C94\u1C98\u803B\xB0\u40B0ta;\u43B4ptyv;\u69B1\u0100ir\u1CA3\u1CA8sht;\u697F;\uC000\u{1D521}ar\u0100lr\u1CB3\u1CB5\xBB\u08DC\xBB\u101E\u0280aegsv\u1CC2\u0378\u1CD6\u1CDC\u1CE0m\u0180;os\u0326\u1CCA\u1CD4nd\u0100;s\u0326\u1CD1uit;\u6666amma;\u43DDin;\u62F2\u0180;io\u1CE7\u1CE8\u1CF8\u40F7de\u8100\xF7;o\u1CE7\u1CF0ntimes;\u62C7n\xF8\u1CF7cy;\u4452c\u026F\u1D06\0\0\u1D0Arn;\u631Eop;\u630D\u0280lptuw\u1D18\u1D1D\u1D22\u1D49\u1D55lar;\u4024f;\uC000\u{1D555}\u0280;emps\u030B\u1D2D\u1D37\u1D3D\u1D42q\u0100;d\u0352\u1D33ot;\u6251inus;\u6238lus;\u6214quare;\u62A1blebarwedg\xE5\xFAn\u0180adh\u112E\u1D5D\u1D67ownarrow\xF3\u1C83arpoon\u0100lr\u1D72\u1D76ef\xF4\u1CB4igh\xF4\u1CB6\u0162\u1D7F\u1D85karo\xF7\u0F42\u026F\u1D8A\0\0\u1D8Ern;\u631Fop;\u630C\u0180cot\u1D98\u1DA3\u1DA6\u0100ry\u1D9D\u1DA1;\uC000\u{1D4B9};\u4455l;\u69F6rok;\u4111\u0100dr\u1DB0\u1DB4ot;\u62F1i\u0100;f\u1DBA\u1816\u65BF\u0100ah\u1DC0\u1DC3r\xF2\u0429a\xF2\u0FA6angle;\u69A6\u0100ci\u1DD2\u1DD5y;\u445Fgrarr;\u67FF\u0900Dacdefglmnopqrstux\u1E01\u1E09\u1E19\u1E38\u0578\u1E3C\u1E49\u1E61\u1E7E\u1EA5\u1EAF\u1EBD\u1EE1\u1F2A\u1F37\u1F44\u1F4E\u1F5A\u0100Do\u1E06\u1D34o\xF4\u1C89\u0100cs\u1E0E\u1E14ute\u803B\xE9\u40E9ter;\u6A6E\u0200aioy\u1E22\u1E27\u1E31\u1E36ron;\u411Br\u0100;c\u1E2D\u1E2E\u6256\u803B\xEA\u40EAlon;\u6255;\u444Dot;\u4117\u0100Dr\u1E41\u1E45ot;\u6252;\uC000\u{1D522}\u0180;rs\u1E50\u1E51\u1E57\u6A9Aave\u803B\xE8\u40E8\u0100;d\u1E5C\u1E5D\u6A96ot;\u6A98\u0200;ils\u1E6A\u1E6B\u1E72\u1E74\u6A99nters;\u63E7;\u6113\u0100;d\u1E79\u1E7A\u6A95ot;\u6A97\u0180aps\u1E85\u1E89\u1E97cr;\u4113ty\u0180;sv\u1E92\u1E93\u1E95\u6205et\xBB\u1E93p\u01001;\u1E9D\u1EA4\u0133\u1EA1\u1EA3;\u6004;\u6005\u6003\u0100gs\u1EAA\u1EAC;\u414Bp;\u6002\u0100gp\u1EB4\u1EB8on;\u4119f;\uC000\u{1D556}\u0180als\u1EC4\u1ECE\u1ED2r\u0100;s\u1ECA\u1ECB\u62D5l;\u69E3us;\u6A71i\u0180;lv\u1EDA\u1EDB\u1EDF\u43B5on\xBB\u1EDB;\u43F5\u0200csuv\u1EEA\u1EF3\u1F0B\u1F23\u0100io\u1EEF\u1E31rc\xBB\u1E2E\u0269\u1EF9\0\0\u1EFB\xED\u0548ant\u0100gl\u1F02\u1F06tr\xBB\u1E5Dess\xBB\u1E7A\u0180aei\u1F12\u1F16\u1F1Als;\u403Dst;\u625Fv\u0100;D\u0235\u1F20D;\u6A78parsl;\u69E5\u0100Da\u1F2F\u1F33ot;\u6253rr;\u6971\u0180cdi\u1F3E\u1F41\u1EF8r;\u612Fo\xF4\u0352\u0100ah\u1F49\u1F4B;\u43B7\u803B\xF0\u40F0\u0100mr\u1F53\u1F57l\u803B\xEB\u40EBo;\u60AC\u0180cip\u1F61\u1F64\u1F67l;\u4021s\xF4\u056E\u0100eo\u1F6C\u1F74ctatio\xEE\u0559nential\xE5\u0579\u09E1\u1F92\0\u1F9E\0\u1FA1\u1FA7\0\0\u1FC6\u1FCC\0\u1FD3\0\u1FE6\u1FEA\u2000\0\u2008\u205Allingdotse\xF1\u1E44y;\u4444male;\u6640\u0180ilr\u1FAD\u1FB3\u1FC1lig;\u8000\uFB03\u0269\u1FB9\0\0\u1FBDg;\u8000\uFB00ig;\u8000\uFB04;\uC000\u{1D523}lig;\u8000\uFB01lig;\uC000fj\u0180alt\u1FD9\u1FDC\u1FE1t;\u666Dig;\u8000\uFB02ns;\u65B1of;\u4192\u01F0\u1FEE\0\u1FF3f;\uC000\u{1D557}\u0100ak\u05BF\u1FF7\u0100;v\u1FFC\u1FFD\u62D4;\u6AD9artint;\u6A0D\u0100ao\u200C\u2055\u0100cs\u2011\u2052\u03B1\u201A\u2030\u2038\u2045\u2048\0\u2050\u03B2\u2022\u2025\u2027\u202A\u202C\0\u202E\u803B\xBD\u40BD;\u6153\u803B\xBC\u40BC;\u6155;\u6159;\u615B\u01B3\u2034\0\u2036;\u6154;\u6156\u02B4\u203E\u2041\0\0\u2043\u803B\xBE\u40BE;\u6157;\u615C5;\u6158\u01B6\u204C\0\u204E;\u615A;\u615D8;\u615El;\u6044wn;\u6322cr;\uC000\u{1D4BB}\u0880Eabcdefgijlnorstv\u2082\u2089\u209F\u20A5\u20B0\u20B4\u20F0\u20F5\u20FA\u20FF\u2103\u2112\u2138\u0317\u213E\u2152\u219E\u0100;l\u064D\u2087;\u6A8C\u0180cmp\u2090\u2095\u209Dute;\u41F5ma\u0100;d\u209C\u1CDA\u43B3;\u6A86reve;\u411F\u0100iy\u20AA\u20AErc;\u411D;\u4433ot;\u4121\u0200;lqs\u063E\u0642\u20BD\u20C9\u0180;qs\u063E\u064C\u20C4lan\xF4\u0665\u0200;cdl\u0665\u20D2\u20D5\u20E5c;\u6AA9ot\u0100;o\u20DC\u20DD\u6A80\u0100;l\u20E2\u20E3\u6A82;\u6A84\u0100;e\u20EA\u20ED\uC000\u22DB\uFE00s;\u6A94r;\uC000\u{1D524}\u0100;g\u0673\u061Bmel;\u6137cy;\u4453\u0200;Eaj\u065A\u210C\u210E\u2110;\u6A92;\u6AA5;\u6AA4\u0200Eaes\u211B\u211D\u2129\u2134;\u6269p\u0100;p\u2123\u2124\u6A8Arox\xBB\u2124\u0100;q\u212E\u212F\u6A88\u0100;q\u212E\u211Bim;\u62E7pf;\uC000\u{1D558}\u0100ci\u2143\u2146r;\u610Am\u0180;el\u066B\u214E\u2150;\u6A8E;\u6A90\u8300>;cdlqr\u05EE\u2160\u216A\u216E\u2173\u2179\u0100ci\u2165\u2167;\u6AA7r;\u6A7Aot;\u62D7Par;\u6995uest;\u6A7C\u0280adels\u2184\u216A\u2190\u0656\u219B\u01F0\u2189\0\u218Epro\xF8\u209Er;\u6978q\u0100lq\u063F\u2196les\xF3\u2088i\xED\u066B\u0100en\u21A3\u21ADrtneqq;\uC000\u2269\uFE00\xC5\u21AA\u0500Aabcefkosy\u21C4\u21C7\u21F1\u21F5\u21FA\u2218\u221D\u222F\u2268\u227Dr\xF2\u03A0\u0200ilmr\u21D0\u21D4\u21D7\u21DBrs\xF0\u1484f\xBB\u2024il\xF4\u06A9\u0100dr\u21E0\u21E4cy;\u444A\u0180;cw\u08F4\u21EB\u21EFir;\u6948;\u61ADar;\u610Firc;\u4125\u0180alr\u2201\u220E\u2213rts\u0100;u\u2209\u220A\u6665it\xBB\u220Alip;\u6026con;\u62B9r;\uC000\u{1D525}s\u0100ew\u2223\u2229arow;\u6925arow;\u6926\u0280amopr\u223A\u223E\u2243\u225E\u2263rr;\u61FFtht;\u623Bk\u0100lr\u2249\u2253eftarrow;\u61A9ightarrow;\u61AAf;\uC000\u{1D559}bar;\u6015\u0180clt\u226F\u2274\u2278r;\uC000\u{1D4BD}as\xE8\u21F4rok;\u4127\u0100bp\u2282\u2287ull;\u6043hen\xBB\u1C5B\u0AE1\u22A3\0\u22AA\0\u22B8\u22C5\u22CE\0\u22D5\u22F3\0\0\u22F8\u2322\u2367\u2362\u237F\0\u2386\u23AA\u23B4cute\u803B\xED\u40ED\u0180;iy\u0771\u22B0\u22B5rc\u803B\xEE\u40EE;\u4438\u0100cx\u22BC\u22BFy;\u4435cl\u803B\xA1\u40A1\u0100fr\u039F\u22C9;\uC000\u{1D526}rave\u803B\xEC\u40EC\u0200;ino\u073E\u22DD\u22E9\u22EE\u0100in\u22E2\u22E6nt;\u6A0Ct;\u622Dfin;\u69DCta;\u6129lig;\u4133\u0180aop\u22FE\u231A\u231D\u0180cgt\u2305\u2308\u2317r;\u412B\u0180elp\u071F\u230F\u2313in\xE5\u078Ear\xF4\u0720h;\u4131f;\u62B7ed;\u41B5\u0280;cfot\u04F4\u232C\u2331\u233D\u2341are;\u6105in\u0100;t\u2338\u2339\u621Eie;\u69DDdo\xF4\u2319\u0280;celp\u0757\u234C\u2350\u235B\u2361al;\u62BA\u0100gr\u2355\u2359er\xF3\u1563\xE3\u234Darhk;\u6A17rod;\u6A3C\u0200cgpt\u236F\u2372\u2376\u237By;\u4451on;\u412Ff;\uC000\u{1D55A}a;\u43B9uest\u803B\xBF\u40BF\u0100ci\u238A\u238Fr;\uC000\u{1D4BE}n\u0280;Edsv\u04F4\u239B\u239D\u23A1\u04F3;\u62F9ot;\u62F5\u0100;v\u23A6\u23A7\u62F4;\u62F3\u0100;i\u0777\u23AElde;\u4129\u01EB\u23B8\0\u23BCcy;\u4456l\u803B\xEF\u40EF\u0300cfmosu\u23CC\u23D7\u23DC\u23E1\u23E7\u23F5\u0100iy\u23D1\u23D5rc;\u4135;\u4439r;\uC000\u{1D527}ath;\u4237pf;\uC000\u{1D55B}\u01E3\u23EC\0\u23F1r;\uC000\u{1D4BF}rcy;\u4458kcy;\u4454\u0400acfghjos\u240B\u2416\u2422\u2427\u242D\u2431\u2435\u243Bppa\u0100;v\u2413\u2414\u43BA;\u43F0\u0100ey\u241B\u2420dil;\u4137;\u443Ar;\uC000\u{1D528}reen;\u4138cy;\u4445cy;\u445Cpf;\uC000\u{1D55C}cr;\uC000\u{1D4C0}\u0B80ABEHabcdefghjlmnoprstuv\u2470\u2481\u2486\u248D\u2491\u250E\u253D\u255A\u2580\u264E\u265E\u2665\u2679\u267D\u269A\u26B2\u26D8\u275D\u2768\u278B\u27C0\u2801\u2812\u0180art\u2477\u247A\u247Cr\xF2\u09C6\xF2\u0395ail;\u691Barr;\u690E\u0100;g\u0994\u248B;\u6A8Bar;\u6962\u0963\u24A5\0\u24AA\0\u24B1\0\0\0\0\0\u24B5\u24BA\0\u24C6\u24C8\u24CD\0\u24F9ute;\u413Amptyv;\u69B4ra\xEE\u084Cbda;\u43BBg\u0180;dl\u088E\u24C1\u24C3;\u6991\xE5\u088E;\u6A85uo\u803B\xAB\u40ABr\u0400;bfhlpst\u0899\u24DE\u24E6\u24E9\u24EB\u24EE\u24F1\u24F5\u0100;f\u089D\u24E3s;\u691Fs;\u691D\xEB\u2252p;\u61ABl;\u6939im;\u6973l;\u61A2\u0180;ae\u24FF\u2500\u2504\u6AABil;\u6919\u0100;s\u2509\u250A\u6AAD;\uC000\u2AAD\uFE00\u0180abr\u2515\u2519\u251Drr;\u690Crk;\u6772\u0100ak\u2522\u252Cc\u0100ek\u2528\u252A;\u407B;\u405B\u0100es\u2531\u2533;\u698Bl\u0100du\u2539\u253B;\u698F;\u698D\u0200aeuy\u2546\u254B\u2556\u2558ron;\u413E\u0100di\u2550\u2554il;\u413C\xEC\u08B0\xE2\u2529;\u443B\u0200cqrs\u2563\u2566\u256D\u257Da;\u6936uo\u0100;r\u0E19\u1746\u0100du\u2572\u2577har;\u6967shar;\u694Bh;\u61B2\u0280;fgqs\u258B\u258C\u0989\u25F3\u25FF\u6264t\u0280ahlrt\u2598\u25A4\u25B7\u25C2\u25E8rrow\u0100;t\u0899\u25A1a\xE9\u24F6arpoon\u0100du\u25AF\u25B4own\xBB\u045Ap\xBB\u0966eftarrows;\u61C7ight\u0180ahs\u25CD\u25D6\u25DErrow\u0100;s\u08F4\u08A7arpoon\xF3\u0F98quigarro\xF7\u21F0hreetimes;\u62CB\u0180;qs\u258B\u0993\u25FAlan\xF4\u09AC\u0280;cdgs\u09AC\u260A\u260D\u261D\u2628c;\u6AA8ot\u0100;o\u2614\u2615\u6A7F\u0100;r\u261A\u261B\u6A81;\u6A83\u0100;e\u2622\u2625\uC000\u22DA\uFE00s;\u6A93\u0280adegs\u2633\u2639\u263D\u2649\u264Bppro\xF8\u24C6ot;\u62D6q\u0100gq\u2643\u2645\xF4\u0989gt\xF2\u248C\xF4\u099Bi\xED\u09B2\u0180ilr\u2655\u08E1\u265Asht;\u697C;\uC000\u{1D529}\u0100;E\u099C\u2663;\u6A91\u0161\u2669\u2676r\u0100du\u25B2\u266E\u0100;l\u0965\u2673;\u696Alk;\u6584cy;\u4459\u0280;acht\u0A48\u2688\u268B\u2691\u2696r\xF2\u25C1orne\xF2\u1D08ard;\u696Bri;\u65FA\u0100io\u269F\u26A4dot;\u4140ust\u0100;a\u26AC\u26AD\u63B0che\xBB\u26AD\u0200Eaes\u26BB\u26BD\u26C9\u26D4;\u6268p\u0100;p\u26C3\u26C4\u6A89rox\xBB\u26C4\u0100;q\u26CE\u26CF\u6A87\u0100;q\u26CE\u26BBim;\u62E6\u0400abnoptwz\u26E9\u26F4\u26F7\u271A\u272F\u2741\u2747\u2750\u0100nr\u26EE\u26F1g;\u67ECr;\u61FDr\xEB\u08C1g\u0180lmr\u26FF\u270D\u2714eft\u0100ar\u09E6\u2707ight\xE1\u09F2apsto;\u67FCight\xE1\u09FDparrow\u0100lr\u2725\u2729ef\xF4\u24EDight;\u61AC\u0180afl\u2736\u2739\u273Dr;\u6985;\uC000\u{1D55D}us;\u6A2Dimes;\u6A34\u0161\u274B\u274Fst;\u6217\xE1\u134E\u0180;ef\u2757\u2758\u1800\u65CAnge\xBB\u2758ar\u0100;l\u2764\u2765\u4028t;\u6993\u0280achmt\u2773\u2776\u277C\u2785\u2787r\xF2\u08A8orne\xF2\u1D8Car\u0100;d\u0F98\u2783;\u696D;\u600Eri;\u62BF\u0300achiqt\u2798\u279D\u0A40\u27A2\u27AE\u27BBquo;\u6039r;\uC000\u{1D4C1}m\u0180;eg\u09B2\u27AA\u27AC;\u6A8D;\u6A8F\u0100bu\u252A\u27B3o\u0100;r\u0E1F\u27B9;\u601Arok;\u4142\u8400<;cdhilqr\u082B\u27D2\u2639\u27DC\u27E0\u27E5\u27EA\u27F0\u0100ci\u27D7\u27D9;\u6AA6r;\u6A79re\xE5\u25F2mes;\u62C9arr;\u6976uest;\u6A7B\u0100Pi\u27F5\u27F9ar;\u6996\u0180;ef\u2800\u092D\u181B\u65C3r\u0100du\u2807\u280Dshar;\u694Ahar;\u6966\u0100en\u2817\u2821rtneqq;\uC000\u2268\uFE00\xC5\u281E\u0700Dacdefhilnopsu\u2840\u2845\u2882\u288E\u2893\u28A0\u28A5\u28A8\u28DA\u28E2\u28E4\u0A83\u28F3\u2902Dot;\u623A\u0200clpr\u284E\u2852\u2863\u287Dr\u803B\xAF\u40AF\u0100et\u2857\u2859;\u6642\u0100;e\u285E\u285F\u6720se\xBB\u285F\u0100;s\u103B\u2868to\u0200;dlu\u103B\u2873\u2877\u287Bow\xEE\u048Cef\xF4\u090F\xF0\u13D1ker;\u65AE\u0100oy\u2887\u288Cmma;\u6A29;\u443Cash;\u6014asuredangle\xBB\u1626r;\uC000\u{1D52A}o;\u6127\u0180cdn\u28AF\u28B4\u28C9ro\u803B\xB5\u40B5\u0200;acd\u1464\u28BD\u28C0\u28C4s\xF4\u16A7ir;\u6AF0ot\u80BB\xB7\u01B5us\u0180;bd\u28D2\u1903\u28D3\u6212\u0100;u\u1D3C\u28D8;\u6A2A\u0163\u28DE\u28E1p;\u6ADB\xF2\u2212\xF0\u0A81\u0100dp\u28E9\u28EEels;\u62A7f;\uC000\u{1D55E}\u0100ct\u28F8\u28FDr;\uC000\u{1D4C2}pos\xBB\u159D\u0180;lm\u2909\u290A\u290D\u43BCtimap;\u62B8\u0C00GLRVabcdefghijlmoprstuvw\u2942\u2953\u297E\u2989\u2998\u29DA\u29E9\u2A15\u2A1A\u2A58\u2A5D\u2A83\u2A95\u2AA4\u2AA8\u2B04\u2B07\u2B44\u2B7F\u2BAE\u2C34\u2C67\u2C7C\u2CE9\u0100gt\u2947\u294B;\uC000\u22D9\u0338\u0100;v\u2950\u0BCF\uC000\u226B\u20D2\u0180elt\u295A\u2972\u2976ft\u0100ar\u2961\u2967rrow;\u61CDightarrow;\u61CE;\uC000\u22D8\u0338\u0100;v\u297B\u0C47\uC000\u226A\u20D2ightarrow;\u61CF\u0100Dd\u298E\u2993ash;\u62AFash;\u62AE\u0280bcnpt\u29A3\u29A7\u29AC\u29B1\u29CCla\xBB\u02DEute;\u4144g;\uC000\u2220\u20D2\u0280;Eiop\u0D84\u29BC\u29C0\u29C5\u29C8;\uC000\u2A70\u0338d;\uC000\u224B\u0338s;\u4149ro\xF8\u0D84ur\u0100;a\u29D3\u29D4\u666El\u0100;s\u29D3\u0B38\u01F3\u29DF\0\u29E3p\u80BB\xA0\u0B37mp\u0100;e\u0BF9\u0C00\u0280aeouy\u29F4\u29FE\u2A03\u2A10\u2A13\u01F0\u29F9\0\u29FB;\u6A43on;\u4148dil;\u4146ng\u0100;d\u0D7E\u2A0Aot;\uC000\u2A6D\u0338p;\u6A42;\u443Dash;\u6013\u0380;Aadqsx\u0B92\u2A29\u2A2D\u2A3B\u2A41\u2A45\u2A50rr;\u61D7r\u0100hr\u2A33\u2A36k;\u6924\u0100;o\u13F2\u13F0ot;\uC000\u2250\u0338ui\xF6\u0B63\u0100ei\u2A4A\u2A4Ear;\u6928\xED\u0B98ist\u0100;s\u0BA0\u0B9Fr;\uC000\u{1D52B}\u0200Eest\u0BC5\u2A66\u2A79\u2A7C\u0180;qs\u0BBC\u2A6D\u0BE1\u0180;qs\u0BBC\u0BC5\u2A74lan\xF4\u0BE2i\xED\u0BEA\u0100;r\u0BB6\u2A81\xBB\u0BB7\u0180Aap\u2A8A\u2A8D\u2A91r\xF2\u2971rr;\u61AEar;\u6AF2\u0180;sv\u0F8D\u2A9C\u0F8C\u0100;d\u2AA1\u2AA2\u62FC;\u62FAcy;\u445A\u0380AEadest\u2AB7\u2ABA\u2ABE\u2AC2\u2AC5\u2AF6\u2AF9r\xF2\u2966;\uC000\u2266\u0338rr;\u619Ar;\u6025\u0200;fqs\u0C3B\u2ACE\u2AE3\u2AEFt\u0100ar\u2AD4\u2AD9rro\xF7\u2AC1ightarro\xF7\u2A90\u0180;qs\u0C3B\u2ABA\u2AEAlan\xF4\u0C55\u0100;s\u0C55\u2AF4\xBB\u0C36i\xED\u0C5D\u0100;r\u0C35\u2AFEi\u0100;e\u0C1A\u0C25i\xE4\u0D90\u0100pt\u2B0C\u2B11f;\uC000\u{1D55F}\u8180\xAC;in\u2B19\u2B1A\u2B36\u40ACn\u0200;Edv\u0B89\u2B24\u2B28\u2B2E;\uC000\u22F9\u0338ot;\uC000\u22F5\u0338\u01E1\u0B89\u2B33\u2B35;\u62F7;\u62F6i\u0100;v\u0CB8\u2B3C\u01E1\u0CB8\u2B41\u2B43;\u62FE;\u62FD\u0180aor\u2B4B\u2B63\u2B69r\u0200;ast\u0B7B\u2B55\u2B5A\u2B5Flle\xEC\u0B7Bl;\uC000\u2AFD\u20E5;\uC000\u2202\u0338lint;\u6A14\u0180;ce\u0C92\u2B70\u2B73u\xE5\u0CA5\u0100;c\u0C98\u2B78\u0100;e\u0C92\u2B7D\xF1\u0C98\u0200Aait\u2B88\u2B8B\u2B9D\u2BA7r\xF2\u2988rr\u0180;cw\u2B94\u2B95\u2B99\u619B;\uC000\u2933\u0338;\uC000\u219D\u0338ghtarrow\xBB\u2B95ri\u0100;e\u0CCB\u0CD6\u0380chimpqu\u2BBD\u2BCD\u2BD9\u2B04\u0B78\u2BE4\u2BEF\u0200;cer\u0D32\u2BC6\u0D37\u2BC9u\xE5\u0D45;\uC000\u{1D4C3}ort\u026D\u2B05\0\0\u2BD6ar\xE1\u2B56m\u0100;e\u0D6E\u2BDF\u0100;q\u0D74\u0D73su\u0100bp\u2BEB\u2BED\xE5\u0CF8\xE5\u0D0B\u0180bcp\u2BF6\u2C11\u2C19\u0200;Ees\u2BFF\u2C00\u0D22\u2C04\u6284;\uC000\u2AC5\u0338et\u0100;e\u0D1B\u2C0Bq\u0100;q\u0D23\u2C00c\u0100;e\u0D32\u2C17\xF1\u0D38\u0200;Ees\u2C22\u2C23\u0D5F\u2C27\u6285;\uC000\u2AC6\u0338et\u0100;e\u0D58\u2C2Eq\u0100;q\u0D60\u2C23\u0200gilr\u2C3D\u2C3F\u2C45\u2C47\xEC\u0BD7lde\u803B\xF1\u40F1\xE7\u0C43iangle\u0100lr\u2C52\u2C5Ceft\u0100;e\u0C1A\u2C5A\xF1\u0C26ight\u0100;e\u0CCB\u2C65\xF1\u0CD7\u0100;m\u2C6C\u2C6D\u43BD\u0180;es\u2C74\u2C75\u2C79\u4023ro;\u6116p;\u6007\u0480DHadgilrs\u2C8F\u2C94\u2C99\u2C9E\u2CA3\u2CB0\u2CB6\u2CD3\u2CE3ash;\u62ADarr;\u6904p;\uC000\u224D\u20D2ash;\u62AC\u0100et\u2CA8\u2CAC;\uC000\u2265\u20D2;\uC000>\u20D2nfin;\u69DE\u0180Aet\u2CBD\u2CC1\u2CC5rr;\u6902;\uC000\u2264\u20D2\u0100;r\u2CCA\u2CCD\uC000<\u20D2ie;\uC000\u22B4\u20D2\u0100At\u2CD8\u2CDCrr;\u6903rie;\uC000\u22B5\u20D2im;\uC000\u223C\u20D2\u0180Aan\u2CF0\u2CF4\u2D02rr;\u61D6r\u0100hr\u2CFA\u2CFDk;\u6923\u0100;o\u13E7\u13E5ear;\u6927\u1253\u1A95\0\0\0\0\0\0\0\0\0\0\0\0\0\u2D2D\0\u2D38\u2D48\u2D60\u2D65\u2D72\u2D84\u1B07\0\0\u2D8D\u2DAB\0\u2DC8\u2DCE\0\u2DDC\u2E19\u2E2B\u2E3E\u2E43\u0100cs\u2D31\u1A97ute\u803B\xF3\u40F3\u0100iy\u2D3C\u2D45r\u0100;c\u1A9E\u2D42\u803B\xF4\u40F4;\u443E\u0280abios\u1AA0\u2D52\u2D57\u01C8\u2D5Alac;\u4151v;\u6A38old;\u69BClig;\u4153\u0100cr\u2D69\u2D6Dir;\u69BF;\uC000\u{1D52C}\u036F\u2D79\0\0\u2D7C\0\u2D82n;\u42DBave\u803B\xF2\u40F2;\u69C1\u0100bm\u2D88\u0DF4ar;\u69B5\u0200acit\u2D95\u2D98\u2DA5\u2DA8r\xF2\u1A80\u0100ir\u2D9D\u2DA0r;\u69BEoss;\u69BBn\xE5\u0E52;\u69C0\u0180aei\u2DB1\u2DB5\u2DB9cr;\u414Dga;\u43C9\u0180cdn\u2DC0\u2DC5\u01CDron;\u43BF;\u69B6pf;\uC000\u{1D560}\u0180ael\u2DD4\u2DD7\u01D2r;\u69B7rp;\u69B9\u0380;adiosv\u2DEA\u2DEB\u2DEE\u2E08\u2E0D\u2E10\u2E16\u6228r\xF2\u1A86\u0200;efm\u2DF7\u2DF8\u2E02\u2E05\u6A5Dr\u0100;o\u2DFE\u2DFF\u6134f\xBB\u2DFF\u803B\xAA\u40AA\u803B\xBA\u40BAgof;\u62B6r;\u6A56lope;\u6A57;\u6A5B\u0180clo\u2E1F\u2E21\u2E27\xF2\u2E01ash\u803B\xF8\u40F8l;\u6298i\u016C\u2E2F\u2E34de\u803B\xF5\u40F5es\u0100;a\u01DB\u2E3As;\u6A36ml\u803B\xF6\u40F6bar;\u633D\u0AE1\u2E5E\0\u2E7D\0\u2E80\u2E9D\0\u2EA2\u2EB9\0\0\u2ECB\u0E9C\0\u2F13\0\0\u2F2B\u2FBC\0\u2FC8r\u0200;ast\u0403\u2E67\u2E72\u0E85\u8100\xB6;l\u2E6D\u2E6E\u40B6le\xEC\u0403\u0269\u2E78\0\0\u2E7Bm;\u6AF3;\u6AFDy;\u443Fr\u0280cimpt\u2E8B\u2E8F\u2E93\u1865\u2E97nt;\u4025od;\u402Eil;\u6030enk;\u6031r;\uC000\u{1D52D}\u0180imo\u2EA8\u2EB0\u2EB4\u0100;v\u2EAD\u2EAE\u43C6;\u43D5ma\xF4\u0A76ne;\u660E\u0180;tv\u2EBF\u2EC0\u2EC8\u43C0chfork\xBB\u1FFD;\u43D6\u0100au\u2ECF\u2EDFn\u0100ck\u2ED5\u2EDDk\u0100;h\u21F4\u2EDB;\u610E\xF6\u21F4s\u0480;abcdemst\u2EF3\u2EF4\u1908\u2EF9\u2EFD\u2F04\u2F06\u2F0A\u2F0E\u402Bcir;\u6A23ir;\u6A22\u0100ou\u1D40\u2F02;\u6A25;\u6A72n\u80BB\xB1\u0E9Dim;\u6A26wo;\u6A27\u0180ipu\u2F19\u2F20\u2F25ntint;\u6A15f;\uC000\u{1D561}nd\u803B\xA3\u40A3\u0500;Eaceinosu\u0EC8\u2F3F\u2F41\u2F44\u2F47\u2F81\u2F89\u2F92\u2F7E\u2FB6;\u6AB3p;\u6AB7u\xE5\u0ED9\u0100;c\u0ECE\u2F4C\u0300;acens\u0EC8\u2F59\u2F5F\u2F66\u2F68\u2F7Eppro\xF8\u2F43urlye\xF1\u0ED9\xF1\u0ECE\u0180aes\u2F6F\u2F76\u2F7Approx;\u6AB9qq;\u6AB5im;\u62E8i\xED\u0EDFme\u0100;s\u2F88\u0EAE\u6032\u0180Eas\u2F78\u2F90\u2F7A\xF0\u2F75\u0180dfp\u0EEC\u2F99\u2FAF\u0180als\u2FA0\u2FA5\u2FAAlar;\u632Eine;\u6312urf;\u6313\u0100;t\u0EFB\u2FB4\xEF\u0EFBrel;\u62B0\u0100ci\u2FC0\u2FC5r;\uC000\u{1D4C5};\u43C8ncsp;\u6008\u0300fiopsu\u2FDA\u22E2\u2FDF\u2FE5\u2FEB\u2FF1r;\uC000\u{1D52E}pf;\uC000\u{1D562}rime;\u6057cr;\uC000\u{1D4C6}\u0180aeo\u2FF8\u3009\u3013t\u0100ei\u2FFE\u3005rnion\xF3\u06B0nt;\u6A16st\u0100;e\u3010\u3011\u403F\xF1\u1F19\xF4\u0F14\u0A80ABHabcdefhilmnoprstux\u3040\u3051\u3055\u3059\u30E0\u310E\u312B\u3147\u3162\u3172\u318E\u3206\u3215\u3224\u3229\u3258\u326E\u3272\u3290\u32B0\u32B7\u0180art\u3047\u304A\u304Cr\xF2\u10B3\xF2\u03DDail;\u691Car\xF2\u1C65ar;\u6964\u0380cdenqrt\u3068\u3075\u3078\u307F\u308F\u3094\u30CC\u0100eu\u306D\u3071;\uC000\u223D\u0331te;\u4155i\xE3\u116Emptyv;\u69B3g\u0200;del\u0FD1\u3089\u308B\u308D;\u6992;\u69A5\xE5\u0FD1uo\u803B\xBB\u40BBr\u0580;abcfhlpstw\u0FDC\u30AC\u30AF\u30B7\u30B9\u30BC\u30BE\u30C0\u30C3\u30C7\u30CAp;\u6975\u0100;f\u0FE0\u30B4s;\u6920;\u6933s;\u691E\xEB\u225D\xF0\u272El;\u6945im;\u6974l;\u61A3;\u619D\u0100ai\u30D1\u30D5il;\u691Ao\u0100;n\u30DB\u30DC\u6236al\xF3\u0F1E\u0180abr\u30E7\u30EA\u30EEr\xF2\u17E5rk;\u6773\u0100ak\u30F3\u30FDc\u0100ek\u30F9\u30FB;\u407D;\u405D\u0100es\u3102\u3104;\u698Cl\u0100du\u310A\u310C;\u698E;\u6990\u0200aeuy\u3117\u311C\u3127\u3129ron;\u4159\u0100di\u3121\u3125il;\u4157\xEC\u0FF2\xE2\u30FA;\u4440\u0200clqs\u3134\u3137\u313D\u3144a;\u6937dhar;\u6969uo\u0100;r\u020E\u020Dh;\u61B3\u0180acg\u314E\u315F\u0F44l\u0200;ips\u0F78\u3158\u315B\u109Cn\xE5\u10BBar\xF4\u0FA9t;\u65AD\u0180ilr\u3169\u1023\u316Esht;\u697D;\uC000\u{1D52F}\u0100ao\u3177\u3186r\u0100du\u317D\u317F\xBB\u047B\u0100;l\u1091\u3184;\u696C\u0100;v\u318B\u318C\u43C1;\u43F1\u0180gns\u3195\u31F9\u31FCht\u0300ahlrst\u31A4\u31B0\u31C2\u31D8\u31E4\u31EErrow\u0100;t\u0FDC\u31ADa\xE9\u30C8arpoon\u0100du\u31BB\u31BFow\xEE\u317Ep\xBB\u1092eft\u0100ah\u31CA\u31D0rrow\xF3\u0FEAarpoon\xF3\u0551ightarrows;\u61C9quigarro\xF7\u30CBhreetimes;\u62CCg;\u42DAingdotse\xF1\u1F32\u0180ahm\u320D\u3210\u3213r\xF2\u0FEAa\xF2\u0551;\u600Foust\u0100;a\u321E\u321F\u63B1che\xBB\u321Fmid;\u6AEE\u0200abpt\u3232\u323D\u3240\u3252\u0100nr\u3237\u323Ag;\u67EDr;\u61FEr\xEB\u1003\u0180afl\u3247\u324A\u324Er;\u6986;\uC000\u{1D563}us;\u6A2Eimes;\u6A35\u0100ap\u325D\u3267r\u0100;g\u3263\u3264\u4029t;\u6994olint;\u6A12ar\xF2\u31E3\u0200achq\u327B\u3280\u10BC\u3285quo;\u603Ar;\uC000\u{1D4C7}\u0100bu\u30FB\u328Ao\u0100;r\u0214\u0213\u0180hir\u3297\u329B\u32A0re\xE5\u31F8mes;\u62CAi\u0200;efl\u32AA\u1059\u1821\u32AB\u65B9tri;\u69CEluhar;\u6968;\u611E\u0D61\u32D5\u32DB\u32DF\u332C\u3338\u3371\0\u337A\u33A4\0\0\u33EC\u33F0\0\u3428\u3448\u345A\u34AD\u34B1\u34CA\u34F1\0\u3616\0\0\u3633cute;\u415Bqu\xEF\u27BA\u0500;Eaceinpsy\u11ED\u32F3\u32F5\u32FF\u3302\u330B\u330F\u331F\u3326\u3329;\u6AB4\u01F0\u32FA\0\u32FC;\u6AB8on;\u4161u\xE5\u11FE\u0100;d\u11F3\u3307il;\u415Frc;\u415D\u0180Eas\u3316\u3318\u331B;\u6AB6p;\u6ABAim;\u62E9olint;\u6A13i\xED\u1204;\u4441ot\u0180;be\u3334\u1D47\u3335\u62C5;\u6A66\u0380Aacmstx\u3346\u334A\u3357\u335B\u335E\u3363\u336Drr;\u61D8r\u0100hr\u3350\u3352\xEB\u2228\u0100;o\u0A36\u0A34t\u803B\xA7\u40A7i;\u403Bwar;\u6929m\u0100in\u3369\xF0nu\xF3\xF1t;\u6736r\u0100;o\u3376\u2055\uC000\u{1D530}\u0200acoy\u3382\u3386\u3391\u33A0rp;\u666F\u0100hy\u338B\u338Fcy;\u4449;\u4448rt\u026D\u3399\0\0\u339Ci\xE4\u1464ara\xEC\u2E6F\u803B\xAD\u40AD\u0100gm\u33A8\u33B4ma\u0180;fv\u33B1\u33B2\u33B2\u43C3;\u43C2\u0400;deglnpr\u12AB\u33C5\u33C9\u33CE\u33D6\u33DE\u33E1\u33E6ot;\u6A6A\u0100;q\u12B1\u12B0\u0100;E\u33D3\u33D4\u6A9E;\u6AA0\u0100;E\u33DB\u33DC\u6A9D;\u6A9Fe;\u6246lus;\u6A24arr;\u6972ar\xF2\u113D\u0200aeit\u33F8\u3408\u340F\u3417\u0100ls\u33FD\u3404lsetm\xE9\u336Ahp;\u6A33parsl;\u69E4\u0100dl\u1463\u3414e;\u6323\u0100;e\u341C\u341D\u6AAA\u0100;s\u3422\u3423\u6AAC;\uC000\u2AAC\uFE00\u0180flp\u342E\u3433\u3442tcy;\u444C\u0100;b\u3438\u3439\u402F\u0100;a\u343E\u343F\u69C4r;\u633Ff;\uC000\u{1D564}a\u0100dr\u344D\u0402es\u0100;u\u3454\u3455\u6660it\xBB\u3455\u0180csu\u3460\u3479\u349F\u0100au\u3465\u346Fp\u0100;s\u1188\u346B;\uC000\u2293\uFE00p\u0100;s\u11B4\u3475;\uC000\u2294\uFE00u\u0100bp\u347F\u348F\u0180;es\u1197\u119C\u3486et\u0100;e\u1197\u348D\xF1\u119D\u0180;es\u11A8\u11AD\u3496et\u0100;e\u11A8\u349D\xF1\u11AE\u0180;af\u117B\u34A6\u05B0r\u0165\u34AB\u05B1\xBB\u117Car\xF2\u1148\u0200cemt\u34B9\u34BE\u34C2\u34C5r;\uC000\u{1D4C8}tm\xEE\xF1i\xEC\u3415ar\xE6\u11BE\u0100ar\u34CE\u34D5r\u0100;f\u34D4\u17BF\u6606\u0100an\u34DA\u34EDight\u0100ep\u34E3\u34EApsilo\xEE\u1EE0h\xE9\u2EAFs\xBB\u2852\u0280bcmnp\u34FB\u355E\u1209\u358B\u358E\u0480;Edemnprs\u350E\u350F\u3511\u3515\u351E\u3523\u352C\u3531\u3536\u6282;\u6AC5ot;\u6ABD\u0100;d\u11DA\u351Aot;\u6AC3ult;\u6AC1\u0100Ee\u3528\u352A;\u6ACB;\u628Alus;\u6ABFarr;\u6979\u0180eiu\u353D\u3552\u3555t\u0180;en\u350E\u3545\u354Bq\u0100;q\u11DA\u350Feq\u0100;q\u352B\u3528m;\u6AC7\u0100bp\u355A\u355C;\u6AD5;\u6AD3c\u0300;acens\u11ED\u356C\u3572\u3579\u357B\u3326ppro\xF8\u32FAurlye\xF1\u11FE\xF1\u11F3\u0180aes\u3582\u3588\u331Bppro\xF8\u331Aq\xF1\u3317g;\u666A\u0680123;Edehlmnps\u35A9\u35AC\u35AF\u121C\u35B2\u35B4\u35C0\u35C9\u35D5\u35DA\u35DF\u35E8\u35ED\u803B\xB9\u40B9\u803B\xB2\u40B2\u803B\xB3\u40B3;\u6AC6\u0100os\u35B9\u35BCt;\u6ABEub;\u6AD8\u0100;d\u1222\u35C5ot;\u6AC4s\u0100ou\u35CF\u35D2l;\u67C9b;\u6AD7arr;\u697Bult;\u6AC2\u0100Ee\u35E4\u35E6;\u6ACC;\u628Blus;\u6AC0\u0180eiu\u35F4\u3609\u360Ct\u0180;en\u121C\u35FC\u3602q\u0100;q\u1222\u35B2eq\u0100;q\u35E7\u35E4m;\u6AC8\u0100bp\u3611\u3613;\u6AD4;\u6AD6\u0180Aan\u361C\u3620\u362Drr;\u61D9r\u0100hr\u3626\u3628\xEB\u222E\u0100;o\u0A2B\u0A29war;\u692Alig\u803B\xDF\u40DF\u0BE1\u3651\u365D\u3660\u12CE\u3673\u3679\0\u367E\u36C2\0\0\0\0\0\u36DB\u3703\0\u3709\u376C\0\0\0\u3787\u0272\u3656\0\0\u365Bget;\u6316;\u43C4r\xEB\u0E5F\u0180aey\u3666\u366B\u3670ron;\u4165dil;\u4163;\u4442lrec;\u6315r;\uC000\u{1D531}\u0200eiko\u3686\u369D\u36B5\u36BC\u01F2\u368B\0\u3691e\u01004f\u1284\u1281a\u0180;sv\u3698\u3699\u369B\u43B8ym;\u43D1\u0100cn\u36A2\u36B2k\u0100as\u36A8\u36AEppro\xF8\u12C1im\xBB\u12ACs\xF0\u129E\u0100as\u36BA\u36AE\xF0\u12C1rn\u803B\xFE\u40FE\u01EC\u031F\u36C6\u22E7es\u8180\xD7;bd\u36CF\u36D0\u36D8\u40D7\u0100;a\u190F\u36D5r;\u6A31;\u6A30\u0180eps\u36E1\u36E3\u3700\xE1\u2A4D\u0200;bcf\u0486\u36EC\u36F0\u36F4ot;\u6336ir;\u6AF1\u0100;o\u36F9\u36FC\uC000\u{1D565}rk;\u6ADA\xE1\u3362rime;\u6034\u0180aip\u370F\u3712\u3764d\xE5\u1248\u0380adempst\u3721\u374D\u3740\u3751\u3757\u375C\u375Fngle\u0280;dlqr\u3730\u3731\u3736\u3740\u3742\u65B5own\xBB\u1DBBeft\u0100;e\u2800\u373E\xF1\u092E;\u625Cight\u0100;e\u32AA\u374B\xF1\u105Aot;\u65ECinus;\u6A3Alus;\u6A39b;\u69CDime;\u6A3Bezium;\u63E2\u0180cht\u3772\u377D\u3781\u0100ry\u3777\u377B;\uC000\u{1D4C9};\u4446cy;\u445Brok;\u4167\u0100io\u378B\u378Ex\xF4\u1777head\u0100lr\u3797\u37A0eftarro\xF7\u084Fightarrow\xBB\u0F5D\u0900AHabcdfghlmoprstuw\u37D0\u37D3\u37D7\u37E4\u37F0\u37FC\u380E\u381C\u3823\u3834\u3851\u385D\u386B\u38A9\u38CC\u38D2\u38EA\u38F6r\xF2\u03EDar;\u6963\u0100cr\u37DC\u37E2ute\u803B\xFA\u40FA\xF2\u1150r\u01E3\u37EA\0\u37EDy;\u445Eve;\u416D\u0100iy\u37F5\u37FArc\u803B\xFB\u40FB;\u4443\u0180abh\u3803\u3806\u380Br\xF2\u13ADlac;\u4171a\xF2\u13C3\u0100ir\u3813\u3818sht;\u697E;\uC000\u{1D532}rave\u803B\xF9\u40F9\u0161\u3827\u3831r\u0100lr\u382C\u382E\xBB\u0957\xBB\u1083lk;\u6580\u0100ct\u3839\u384D\u026F\u383F\0\0\u384Arn\u0100;e\u3845\u3846\u631Cr\xBB\u3846op;\u630Fri;\u65F8\u0100al\u3856\u385Acr;\u416B\u80BB\xA8\u0349\u0100gp\u3862\u3866on;\u4173f;\uC000\u{1D566}\u0300adhlsu\u114B\u3878\u387D\u1372\u3891\u38A0own\xE1\u13B3arpoon\u0100lr\u3888\u388Cef\xF4\u382Digh\xF4\u382Fi\u0180;hl\u3899\u389A\u389C\u43C5\xBB\u13FAon\xBB\u389Aparrows;\u61C8\u0180cit\u38B0\u38C4\u38C8\u026F\u38B6\0\0\u38C1rn\u0100;e\u38BC\u38BD\u631Dr\xBB\u38BDop;\u630Eng;\u416Fri;\u65F9cr;\uC000\u{1D4CA}\u0180dir\u38D9\u38DD\u38E2ot;\u62F0lde;\u4169i\u0100;f\u3730\u38E8\xBB\u1813\u0100am\u38EF\u38F2r\xF2\u38A8l\u803B\xFC\u40FCangle;\u69A7\u0780ABDacdeflnoprsz\u391C\u391F\u3929\u392D\u39B5\u39B8\u39BD\u39DF\u39E4\u39E8\u39F3\u39F9\u39FD\u3A01\u3A20r\xF2\u03F7ar\u0100;v\u3926\u3927\u6AE8;\u6AE9as\xE8\u03E1\u0100nr\u3932\u3937grt;\u699C\u0380eknprst\u34E3\u3946\u394B\u3952\u395D\u3964\u3996app\xE1\u2415othin\xE7\u1E96\u0180hir\u34EB\u2EC8\u3959op\xF4\u2FB5\u0100;h\u13B7\u3962\xEF\u318D\u0100iu\u3969\u396Dgm\xE1\u33B3\u0100bp\u3972\u3984setneq\u0100;q\u397D\u3980\uC000\u228A\uFE00;\uC000\u2ACB\uFE00setneq\u0100;q\u398F\u3992\uC000\u228B\uFE00;\uC000\u2ACC\uFE00\u0100hr\u399B\u399Fet\xE1\u369Ciangle\u0100lr\u39AA\u39AFeft\xBB\u0925ight\xBB\u1051y;\u4432ash\xBB\u1036\u0180elr\u39C4\u39D2\u39D7\u0180;be\u2DEA\u39CB\u39CFar;\u62BBq;\u625Alip;\u62EE\u0100bt\u39DC\u1468a\xF2\u1469r;\uC000\u{1D533}tr\xE9\u39AEsu\u0100bp\u39EF\u39F1\xBB\u0D1C\xBB\u0D59pf;\uC000\u{1D567}ro\xF0\u0EFBtr\xE9\u39B4\u0100cu\u3A06\u3A0Br;\uC000\u{1D4CB}\u0100bp\u3A10\u3A18n\u0100Ee\u3980\u3A16\xBB\u397En\u0100Ee\u3992\u3A1E\xBB\u3990igzag;\u699A\u0380cefoprs\u3A36\u3A3B\u3A56\u3A5B\u3A54\u3A61\u3A6Airc;\u4175\u0100di\u3A40\u3A51\u0100bg\u3A45\u3A49ar;\u6A5Fe\u0100;q\u15FA\u3A4F;\u6259erp;\u6118r;\uC000\u{1D534}pf;\uC000\u{1D568}\u0100;e\u1479\u3A66at\xE8\u1479cr;\uC000\u{1D4CC}\u0AE3\u178E\u3A87\0\u3A8B\0\u3A90\u3A9B\0\0\u3A9D\u3AA8\u3AAB\u3AAF\0\0\u3AC3\u3ACE\0\u3AD8\u17DC\u17DFtr\xE9\u17D1r;\uC000\u{1D535}\u0100Aa\u3A94\u3A97r\xF2\u03C3r\xF2\u09F6;\u43BE\u0100Aa\u3AA1\u3AA4r\xF2\u03B8r\xF2\u09EBa\xF0\u2713is;\u62FB\u0180dpt\u17A4\u3AB5\u3ABE\u0100fl\u3ABA\u17A9;\uC000\u{1D569}im\xE5\u17B2\u0100Aa\u3AC7\u3ACAr\xF2\u03CEr\xF2\u0A01\u0100cq\u3AD2\u17B8r;\uC000\u{1D4CD}\u0100pt\u17D6\u3ADCr\xE9\u17D4\u0400acefiosu\u3AF0\u3AFD\u3B08\u3B0C\u3B11\u3B15\u3B1B\u3B21c\u0100uy\u3AF6\u3AFBte\u803B\xFD\u40FD;\u444F\u0100iy\u3B02\u3B06rc;\u4177;\u444Bn\u803B\xA5\u40A5r;\uC000\u{1D536}cy;\u4457pf;\uC000\u{1D56A}cr;\uC000\u{1D4CE}\u0100cm\u3B26\u3B29y;\u444El\u803B\xFF\u40FF\u0500acdefhiosw\u3B42\u3B48\u3B54\u3B58\u3B64\u3B69\u3B6D\u3B74\u3B7A\u3B80cute;\u417A\u0100ay\u3B4D\u3B52ron;\u417E;\u4437ot;\u417C\u0100et\u3B5D\u3B61tr\xE6\u155Fa;\u43B6r;\uC000\u{1D537}cy;\u4436grarr;\u61DDpf;\uC000\u{1D56B}cr;\uC000\u{1D4CF}\u0100jn\u3B85\u3B87;\u600Dj;\u600C'.split("").map((c) => c.charCodeAt(0)) + ); + + // node_modules/entities/lib/esm/generated/decode-data-xml.js + var decode_data_xml_default = new Uint16Array( + // prettier-ignore + "\u0200aglq \x1B\u026D\0\0p;\u4026os;\u4027t;\u403Et;\u403Cuot;\u4022".split("").map((c) => c.charCodeAt(0)) + ); + + // node_modules/entities/lib/esm/decode_codepoint.js + var _a; + var decodeMap = /* @__PURE__ */ new Map([ + [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 fromCodePoint = ( + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, node/no-unsupported-features/es-builtins + (_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : function(codePoint) { + let output = ""; + if (codePoint > 65535) { + codePoint -= 65536; + output += String.fromCharCode(codePoint >>> 10 & 1023 | 55296); + codePoint = 56320 | codePoint & 1023; + } + output += String.fromCharCode(codePoint); + return output; + } + ); + function replaceCodePoint(codePoint) { + var _a2; + if (codePoint >= 55296 && codePoint <= 57343 || codePoint > 1114111) { + return 65533; + } + return (_a2 = decodeMap.get(codePoint)) !== null && _a2 !== void 0 ? _a2 : codePoint; + } + function decodeCodePoint(codePoint) { + return fromCodePoint(replaceCodePoint(codePoint)); + } + + // node_modules/entities/lib/esm/decode.js + var CharCodes; + (function(CharCodes2) { + CharCodes2[CharCodes2["NUM"] = 35] = "NUM"; + CharCodes2[CharCodes2["SEMI"] = 59] = "SEMI"; + CharCodes2[CharCodes2["ZERO"] = 48] = "ZERO"; + CharCodes2[CharCodes2["NINE"] = 57] = "NINE"; + CharCodes2[CharCodes2["LOWER_A"] = 97] = "LOWER_A"; + CharCodes2[CharCodes2["LOWER_F"] = 102] = "LOWER_F"; + CharCodes2[CharCodes2["LOWER_X"] = 120] = "LOWER_X"; + CharCodes2[CharCodes2["To_LOWER_BIT"] = 32] = "To_LOWER_BIT"; + })(CharCodes || (CharCodes = {})); + var BinTrieFlags; + (function(BinTrieFlags2) { + BinTrieFlags2[BinTrieFlags2["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH"; + BinTrieFlags2[BinTrieFlags2["BRANCH_LENGTH"] = 16256] = "BRANCH_LENGTH"; + BinTrieFlags2[BinTrieFlags2["JUMP_TABLE"] = 127] = "JUMP_TABLE"; + })(BinTrieFlags || (BinTrieFlags = {})); + function getDecoder(decodeTree) { + return function decodeHTMLBinary(str, strict) { + let ret = ""; + let lastIdx = 0; + let strIdx = 0; + while ((strIdx = str.indexOf("&", strIdx)) >= 0) { + ret += str.slice(lastIdx, strIdx); + lastIdx = strIdx; + strIdx += 1; + if (str.charCodeAt(strIdx) === CharCodes.NUM) { + let start = strIdx + 1; + let base = 10; + let cp = str.charCodeAt(start); + if ((cp | CharCodes.To_LOWER_BIT) === CharCodes.LOWER_X) { + base = 16; + strIdx += 1; + start += 1; + } + do + cp = str.charCodeAt(++strIdx); + while (cp >= CharCodes.ZERO && cp <= CharCodes.NINE || base === 16 && (cp | CharCodes.To_LOWER_BIT) >= CharCodes.LOWER_A && (cp | CharCodes.To_LOWER_BIT) <= CharCodes.LOWER_F); + if (start !== strIdx) { + const entity = str.substring(start, strIdx); + const parsed = parseInt(entity, base); + if (str.charCodeAt(strIdx) === CharCodes.SEMI) { + strIdx += 1; + } else if (strict) { + continue; + } + ret += decodeCodePoint(parsed); + lastIdx = strIdx; + } + continue; + } + let resultIdx = 0; + let excess = 1; + let treeIdx = 0; + let current = decodeTree[treeIdx]; + for (; strIdx < str.length; strIdx++, excess++) { + treeIdx = determineBranch(decodeTree, current, treeIdx + 1, str.charCodeAt(strIdx)); + if (treeIdx < 0) + break; + current = decodeTree[treeIdx]; + const masked = current & BinTrieFlags.VALUE_LENGTH; + if (masked) { + if (!strict || str.charCodeAt(strIdx) === CharCodes.SEMI) { + resultIdx = treeIdx; + excess = 0; + } + const valueLength = (masked >> 14) - 1; + if (valueLength === 0) + break; + treeIdx += valueLength; + } + } + if (resultIdx !== 0) { + const valueLength = (decodeTree[resultIdx] & BinTrieFlags.VALUE_LENGTH) >> 14; + ret += valueLength === 1 ? String.fromCharCode(decodeTree[resultIdx] & ~BinTrieFlags.VALUE_LENGTH) : valueLength === 2 ? String.fromCharCode(decodeTree[resultIdx + 1]) : String.fromCharCode(decodeTree[resultIdx + 1], decodeTree[resultIdx + 2]); + lastIdx = strIdx - excess + 1; + } + } + return ret + str.slice(lastIdx); + }; + } + function determineBranch(decodeTree, current, nodeIdx, char) { + const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7; + const jumpOffset = current & BinTrieFlags.JUMP_TABLE; + if (branchCount === 0) { + return jumpOffset !== 0 && char === jumpOffset ? nodeIdx : -1; + } + if (jumpOffset) { + const value = char - jumpOffset; + return value < 0 || value >= branchCount ? -1 : decodeTree[nodeIdx + value] - 1; + } + let lo = nodeIdx; + let hi = lo + branchCount - 1; + while (lo <= hi) { + const mid = lo + hi >>> 1; + const midVal = decodeTree[mid]; + if (midVal < char) { + lo = mid + 1; + } else if (midVal > char) { + hi = mid - 1; + } else { + return decodeTree[mid + branchCount]; + } + } + return -1; + } + var htmlDecoder = getDecoder(decode_data_html_default); + var xmlDecoder = getDecoder(decode_data_xml_default); + + // node_modules/parse5/dist/common/html.js + var NS; + (function(NS2) { + NS2["HTML"] = "http://www.w3.org/1999/xhtml"; + NS2["MATHML"] = "http://www.w3.org/1998/Math/MathML"; + NS2["SVG"] = "http://www.w3.org/2000/svg"; + NS2["XLINK"] = "http://www.w3.org/1999/xlink"; + NS2["XML"] = "http://www.w3.org/XML/1998/namespace"; + NS2["XMLNS"] = "http://www.w3.org/2000/xmlns/"; + })(NS = NS || (NS = {})); + var ATTRS; + (function(ATTRS2) { + ATTRS2["TYPE"] = "type"; + ATTRS2["ACTION"] = "action"; + ATTRS2["ENCODING"] = "encoding"; + ATTRS2["PROMPT"] = "prompt"; + ATTRS2["NAME"] = "name"; + ATTRS2["COLOR"] = "color"; + ATTRS2["FACE"] = "face"; + ATTRS2["SIZE"] = "size"; + })(ATTRS = ATTRS || (ATTRS = {})); + var DOCUMENT_MODE; + (function(DOCUMENT_MODE2) { + DOCUMENT_MODE2["NO_QUIRKS"] = "no-quirks"; + DOCUMENT_MODE2["QUIRKS"] = "quirks"; + DOCUMENT_MODE2["LIMITED_QUIRKS"] = "limited-quirks"; + })(DOCUMENT_MODE = DOCUMENT_MODE || (DOCUMENT_MODE = {})); + var TAG_NAMES; + (function(TAG_NAMES2) { + TAG_NAMES2["A"] = "a"; + TAG_NAMES2["ADDRESS"] = "address"; + TAG_NAMES2["ANNOTATION_XML"] = "annotation-xml"; + TAG_NAMES2["APPLET"] = "applet"; + TAG_NAMES2["AREA"] = "area"; + TAG_NAMES2["ARTICLE"] = "article"; + TAG_NAMES2["ASIDE"] = "aside"; + TAG_NAMES2["B"] = "b"; + TAG_NAMES2["BASE"] = "base"; + TAG_NAMES2["BASEFONT"] = "basefont"; + TAG_NAMES2["BGSOUND"] = "bgsound"; + TAG_NAMES2["BIG"] = "big"; + TAG_NAMES2["BLOCKQUOTE"] = "blockquote"; + TAG_NAMES2["BODY"] = "body"; + TAG_NAMES2["BR"] = "br"; + TAG_NAMES2["BUTTON"] = "button"; + TAG_NAMES2["CAPTION"] = "caption"; + TAG_NAMES2["CENTER"] = "center"; + TAG_NAMES2["CODE"] = "code"; + TAG_NAMES2["COL"] = "col"; + TAG_NAMES2["COLGROUP"] = "colgroup"; + TAG_NAMES2["DD"] = "dd"; + TAG_NAMES2["DESC"] = "desc"; + TAG_NAMES2["DETAILS"] = "details"; + TAG_NAMES2["DIALOG"] = "dialog"; + TAG_NAMES2["DIR"] = "dir"; + TAG_NAMES2["DIV"] = "div"; + TAG_NAMES2["DL"] = "dl"; + TAG_NAMES2["DT"] = "dt"; + TAG_NAMES2["EM"] = "em"; + TAG_NAMES2["EMBED"] = "embed"; + TAG_NAMES2["FIELDSET"] = "fieldset"; + TAG_NAMES2["FIGCAPTION"] = "figcaption"; + TAG_NAMES2["FIGURE"] = "figure"; + TAG_NAMES2["FONT"] = "font"; + TAG_NAMES2["FOOTER"] = "footer"; + TAG_NAMES2["FOREIGN_OBJECT"] = "foreignObject"; + TAG_NAMES2["FORM"] = "form"; + TAG_NAMES2["FRAME"] = "frame"; + TAG_NAMES2["FRAMESET"] = "frameset"; + TAG_NAMES2["H1"] = "h1"; + TAG_NAMES2["H2"] = "h2"; + TAG_NAMES2["H3"] = "h3"; + TAG_NAMES2["H4"] = "h4"; + TAG_NAMES2["H5"] = "h5"; + TAG_NAMES2["H6"] = "h6"; + TAG_NAMES2["HEAD"] = "head"; + TAG_NAMES2["HEADER"] = "header"; + TAG_NAMES2["HGROUP"] = "hgroup"; + TAG_NAMES2["HR"] = "hr"; + TAG_NAMES2["HTML"] = "html"; + TAG_NAMES2["I"] = "i"; + TAG_NAMES2["IMG"] = "img"; + TAG_NAMES2["IMAGE"] = "image"; + TAG_NAMES2["INPUT"] = "input"; + TAG_NAMES2["IFRAME"] = "iframe"; + TAG_NAMES2["KEYGEN"] = "keygen"; + TAG_NAMES2["LABEL"] = "label"; + TAG_NAMES2["LI"] = "li"; + TAG_NAMES2["LINK"] = "link"; + TAG_NAMES2["LISTING"] = "listing"; + TAG_NAMES2["MAIN"] = "main"; + TAG_NAMES2["MALIGNMARK"] = "malignmark"; + TAG_NAMES2["MARQUEE"] = "marquee"; + TAG_NAMES2["MATH"] = "math"; + TAG_NAMES2["MENU"] = "menu"; + TAG_NAMES2["META"] = "meta"; + TAG_NAMES2["MGLYPH"] = "mglyph"; + TAG_NAMES2["MI"] = "mi"; + TAG_NAMES2["MO"] = "mo"; + TAG_NAMES2["MN"] = "mn"; + TAG_NAMES2["MS"] = "ms"; + TAG_NAMES2["MTEXT"] = "mtext"; + TAG_NAMES2["NAV"] = "nav"; + TAG_NAMES2["NOBR"] = "nobr"; + TAG_NAMES2["NOFRAMES"] = "noframes"; + TAG_NAMES2["NOEMBED"] = "noembed"; + TAG_NAMES2["NOSCRIPT"] = "noscript"; + TAG_NAMES2["OBJECT"] = "object"; + TAG_NAMES2["OL"] = "ol"; + TAG_NAMES2["OPTGROUP"] = "optgroup"; + TAG_NAMES2["OPTION"] = "option"; + TAG_NAMES2["P"] = "p"; + TAG_NAMES2["PARAM"] = "param"; + TAG_NAMES2["PLAINTEXT"] = "plaintext"; + TAG_NAMES2["PRE"] = "pre"; + TAG_NAMES2["RB"] = "rb"; + TAG_NAMES2["RP"] = "rp"; + TAG_NAMES2["RT"] = "rt"; + TAG_NAMES2["RTC"] = "rtc"; + TAG_NAMES2["RUBY"] = "ruby"; + TAG_NAMES2["S"] = "s"; + TAG_NAMES2["SCRIPT"] = "script"; + TAG_NAMES2["SECTION"] = "section"; + TAG_NAMES2["SELECT"] = "select"; + TAG_NAMES2["SOURCE"] = "source"; + TAG_NAMES2["SMALL"] = "small"; + TAG_NAMES2["SPAN"] = "span"; + TAG_NAMES2["STRIKE"] = "strike"; + TAG_NAMES2["STRONG"] = "strong"; + TAG_NAMES2["STYLE"] = "style"; + TAG_NAMES2["SUB"] = "sub"; + TAG_NAMES2["SUMMARY"] = "summary"; + TAG_NAMES2["SUP"] = "sup"; + TAG_NAMES2["TABLE"] = "table"; + TAG_NAMES2["TBODY"] = "tbody"; + TAG_NAMES2["TEMPLATE"] = "template"; + TAG_NAMES2["TEXTAREA"] = "textarea"; + TAG_NAMES2["TFOOT"] = "tfoot"; + TAG_NAMES2["TD"] = "td"; + TAG_NAMES2["TH"] = "th"; + TAG_NAMES2["THEAD"] = "thead"; + TAG_NAMES2["TITLE"] = "title"; + TAG_NAMES2["TR"] = "tr"; + TAG_NAMES2["TRACK"] = "track"; + TAG_NAMES2["TT"] = "tt"; + TAG_NAMES2["U"] = "u"; + TAG_NAMES2["UL"] = "ul"; + TAG_NAMES2["SVG"] = "svg"; + TAG_NAMES2["VAR"] = "var"; + TAG_NAMES2["WBR"] = "wbr"; + TAG_NAMES2["XMP"] = "xmp"; + })(TAG_NAMES = TAG_NAMES || (TAG_NAMES = {})); + var TAG_ID; + (function(TAG_ID2) { + TAG_ID2[TAG_ID2["UNKNOWN"] = 0] = "UNKNOWN"; + TAG_ID2[TAG_ID2["A"] = 1] = "A"; + TAG_ID2[TAG_ID2["ADDRESS"] = 2] = "ADDRESS"; + TAG_ID2[TAG_ID2["ANNOTATION_XML"] = 3] = "ANNOTATION_XML"; + TAG_ID2[TAG_ID2["APPLET"] = 4] = "APPLET"; + TAG_ID2[TAG_ID2["AREA"] = 5] = "AREA"; + TAG_ID2[TAG_ID2["ARTICLE"] = 6] = "ARTICLE"; + TAG_ID2[TAG_ID2["ASIDE"] = 7] = "ASIDE"; + TAG_ID2[TAG_ID2["B"] = 8] = "B"; + TAG_ID2[TAG_ID2["BASE"] = 9] = "BASE"; + TAG_ID2[TAG_ID2["BASEFONT"] = 10] = "BASEFONT"; + TAG_ID2[TAG_ID2["BGSOUND"] = 11] = "BGSOUND"; + TAG_ID2[TAG_ID2["BIG"] = 12] = "BIG"; + TAG_ID2[TAG_ID2["BLOCKQUOTE"] = 13] = "BLOCKQUOTE"; + TAG_ID2[TAG_ID2["BODY"] = 14] = "BODY"; + TAG_ID2[TAG_ID2["BR"] = 15] = "BR"; + TAG_ID2[TAG_ID2["BUTTON"] = 16] = "BUTTON"; + TAG_ID2[TAG_ID2["CAPTION"] = 17] = "CAPTION"; + TAG_ID2[TAG_ID2["CENTER"] = 18] = "CENTER"; + TAG_ID2[TAG_ID2["CODE"] = 19] = "CODE"; + TAG_ID2[TAG_ID2["COL"] = 20] = "COL"; + TAG_ID2[TAG_ID2["COLGROUP"] = 21] = "COLGROUP"; + TAG_ID2[TAG_ID2["DD"] = 22] = "DD"; + TAG_ID2[TAG_ID2["DESC"] = 23] = "DESC"; + TAG_ID2[TAG_ID2["DETAILS"] = 24] = "DETAILS"; + TAG_ID2[TAG_ID2["DIALOG"] = 25] = "DIALOG"; + TAG_ID2[TAG_ID2["DIR"] = 26] = "DIR"; + TAG_ID2[TAG_ID2["DIV"] = 27] = "DIV"; + TAG_ID2[TAG_ID2["DL"] = 28] = "DL"; + TAG_ID2[TAG_ID2["DT"] = 29] = "DT"; + TAG_ID2[TAG_ID2["EM"] = 30] = "EM"; + TAG_ID2[TAG_ID2["EMBED"] = 31] = "EMBED"; + TAG_ID2[TAG_ID2["FIELDSET"] = 32] = "FIELDSET"; + TAG_ID2[TAG_ID2["FIGCAPTION"] = 33] = "FIGCAPTION"; + TAG_ID2[TAG_ID2["FIGURE"] = 34] = "FIGURE"; + TAG_ID2[TAG_ID2["FONT"] = 35] = "FONT"; + TAG_ID2[TAG_ID2["FOOTER"] = 36] = "FOOTER"; + TAG_ID2[TAG_ID2["FOREIGN_OBJECT"] = 37] = "FOREIGN_OBJECT"; + TAG_ID2[TAG_ID2["FORM"] = 38] = "FORM"; + TAG_ID2[TAG_ID2["FRAME"] = 39] = "FRAME"; + TAG_ID2[TAG_ID2["FRAMESET"] = 40] = "FRAMESET"; + TAG_ID2[TAG_ID2["H1"] = 41] = "H1"; + TAG_ID2[TAG_ID2["H2"] = 42] = "H2"; + TAG_ID2[TAG_ID2["H3"] = 43] = "H3"; + TAG_ID2[TAG_ID2["H4"] = 44] = "H4"; + TAG_ID2[TAG_ID2["H5"] = 45] = "H5"; + TAG_ID2[TAG_ID2["H6"] = 46] = "H6"; + TAG_ID2[TAG_ID2["HEAD"] = 47] = "HEAD"; + TAG_ID2[TAG_ID2["HEADER"] = 48] = "HEADER"; + TAG_ID2[TAG_ID2["HGROUP"] = 49] = "HGROUP"; + TAG_ID2[TAG_ID2["HR"] = 50] = "HR"; + TAG_ID2[TAG_ID2["HTML"] = 51] = "HTML"; + TAG_ID2[TAG_ID2["I"] = 52] = "I"; + TAG_ID2[TAG_ID2["IMG"] = 53] = "IMG"; + TAG_ID2[TAG_ID2["IMAGE"] = 54] = "IMAGE"; + TAG_ID2[TAG_ID2["INPUT"] = 55] = "INPUT"; + TAG_ID2[TAG_ID2["IFRAME"] = 56] = "IFRAME"; + TAG_ID2[TAG_ID2["KEYGEN"] = 57] = "KEYGEN"; + TAG_ID2[TAG_ID2["LABEL"] = 58] = "LABEL"; + TAG_ID2[TAG_ID2["LI"] = 59] = "LI"; + TAG_ID2[TAG_ID2["LINK"] = 60] = "LINK"; + TAG_ID2[TAG_ID2["LISTING"] = 61] = "LISTING"; + TAG_ID2[TAG_ID2["MAIN"] = 62] = "MAIN"; + TAG_ID2[TAG_ID2["MALIGNMARK"] = 63] = "MALIGNMARK"; + TAG_ID2[TAG_ID2["MARQUEE"] = 64] = "MARQUEE"; + TAG_ID2[TAG_ID2["MATH"] = 65] = "MATH"; + TAG_ID2[TAG_ID2["MENU"] = 66] = "MENU"; + TAG_ID2[TAG_ID2["META"] = 67] = "META"; + TAG_ID2[TAG_ID2["MGLYPH"] = 68] = "MGLYPH"; + TAG_ID2[TAG_ID2["MI"] = 69] = "MI"; + TAG_ID2[TAG_ID2["MO"] = 70] = "MO"; + TAG_ID2[TAG_ID2["MN"] = 71] = "MN"; + TAG_ID2[TAG_ID2["MS"] = 72] = "MS"; + TAG_ID2[TAG_ID2["MTEXT"] = 73] = "MTEXT"; + TAG_ID2[TAG_ID2["NAV"] = 74] = "NAV"; + TAG_ID2[TAG_ID2["NOBR"] = 75] = "NOBR"; + TAG_ID2[TAG_ID2["NOFRAMES"] = 76] = "NOFRAMES"; + TAG_ID2[TAG_ID2["NOEMBED"] = 77] = "NOEMBED"; + TAG_ID2[TAG_ID2["NOSCRIPT"] = 78] = "NOSCRIPT"; + TAG_ID2[TAG_ID2["OBJECT"] = 79] = "OBJECT"; + TAG_ID2[TAG_ID2["OL"] = 80] = "OL"; + TAG_ID2[TAG_ID2["OPTGROUP"] = 81] = "OPTGROUP"; + TAG_ID2[TAG_ID2["OPTION"] = 82] = "OPTION"; + TAG_ID2[TAG_ID2["P"] = 83] = "P"; + TAG_ID2[TAG_ID2["PARAM"] = 84] = "PARAM"; + TAG_ID2[TAG_ID2["PLAINTEXT"] = 85] = "PLAINTEXT"; + TAG_ID2[TAG_ID2["PRE"] = 86] = "PRE"; + TAG_ID2[TAG_ID2["RB"] = 87] = "RB"; + TAG_ID2[TAG_ID2["RP"] = 88] = "RP"; + TAG_ID2[TAG_ID2["RT"] = 89] = "RT"; + TAG_ID2[TAG_ID2["RTC"] = 90] = "RTC"; + TAG_ID2[TAG_ID2["RUBY"] = 91] = "RUBY"; + TAG_ID2[TAG_ID2["S"] = 92] = "S"; + TAG_ID2[TAG_ID2["SCRIPT"] = 93] = "SCRIPT"; + TAG_ID2[TAG_ID2["SECTION"] = 94] = "SECTION"; + TAG_ID2[TAG_ID2["SELECT"] = 95] = "SELECT"; + TAG_ID2[TAG_ID2["SOURCE"] = 96] = "SOURCE"; + TAG_ID2[TAG_ID2["SMALL"] = 97] = "SMALL"; + TAG_ID2[TAG_ID2["SPAN"] = 98] = "SPAN"; + TAG_ID2[TAG_ID2["STRIKE"] = 99] = "STRIKE"; + TAG_ID2[TAG_ID2["STRONG"] = 100] = "STRONG"; + TAG_ID2[TAG_ID2["STYLE"] = 101] = "STYLE"; + TAG_ID2[TAG_ID2["SUB"] = 102] = "SUB"; + TAG_ID2[TAG_ID2["SUMMARY"] = 103] = "SUMMARY"; + TAG_ID2[TAG_ID2["SUP"] = 104] = "SUP"; + TAG_ID2[TAG_ID2["TABLE"] = 105] = "TABLE"; + TAG_ID2[TAG_ID2["TBODY"] = 106] = "TBODY"; + TAG_ID2[TAG_ID2["TEMPLATE"] = 107] = "TEMPLATE"; + TAG_ID2[TAG_ID2["TEXTAREA"] = 108] = "TEXTAREA"; + TAG_ID2[TAG_ID2["TFOOT"] = 109] = "TFOOT"; + TAG_ID2[TAG_ID2["TD"] = 110] = "TD"; + TAG_ID2[TAG_ID2["TH"] = 111] = "TH"; + TAG_ID2[TAG_ID2["THEAD"] = 112] = "THEAD"; + TAG_ID2[TAG_ID2["TITLE"] = 113] = "TITLE"; + TAG_ID2[TAG_ID2["TR"] = 114] = "TR"; + TAG_ID2[TAG_ID2["TRACK"] = 115] = "TRACK"; + TAG_ID2[TAG_ID2["TT"] = 116] = "TT"; + TAG_ID2[TAG_ID2["U"] = 117] = "U"; + TAG_ID2[TAG_ID2["UL"] = 118] = "UL"; + TAG_ID2[TAG_ID2["SVG"] = 119] = "SVG"; + TAG_ID2[TAG_ID2["VAR"] = 120] = "VAR"; + TAG_ID2[TAG_ID2["WBR"] = 121] = "WBR"; + TAG_ID2[TAG_ID2["XMP"] = 122] = "XMP"; + })(TAG_ID = TAG_ID || (TAG_ID = {})); + var TAG_NAME_TO_ID = /* @__PURE__ */ new Map([ + [TAG_NAMES.A, TAG_ID.A], + [TAG_NAMES.ADDRESS, TAG_ID.ADDRESS], + [TAG_NAMES.ANNOTATION_XML, TAG_ID.ANNOTATION_XML], + [TAG_NAMES.APPLET, TAG_ID.APPLET], + [TAG_NAMES.AREA, TAG_ID.AREA], + [TAG_NAMES.ARTICLE, TAG_ID.ARTICLE], + [TAG_NAMES.ASIDE, TAG_ID.ASIDE], + [TAG_NAMES.B, TAG_ID.B], + [TAG_NAMES.BASE, TAG_ID.BASE], + [TAG_NAMES.BASEFONT, TAG_ID.BASEFONT], + [TAG_NAMES.BGSOUND, TAG_ID.BGSOUND], + [TAG_NAMES.BIG, TAG_ID.BIG], + [TAG_NAMES.BLOCKQUOTE, TAG_ID.BLOCKQUOTE], + [TAG_NAMES.BODY, TAG_ID.BODY], + [TAG_NAMES.BR, TAG_ID.BR], + [TAG_NAMES.BUTTON, TAG_ID.BUTTON], + [TAG_NAMES.CAPTION, TAG_ID.CAPTION], + [TAG_NAMES.CENTER, TAG_ID.CENTER], + [TAG_NAMES.CODE, TAG_ID.CODE], + [TAG_NAMES.COL, TAG_ID.COL], + [TAG_NAMES.COLGROUP, TAG_ID.COLGROUP], + [TAG_NAMES.DD, TAG_ID.DD], + [TAG_NAMES.DESC, TAG_ID.DESC], + [TAG_NAMES.DETAILS, TAG_ID.DETAILS], + [TAG_NAMES.DIALOG, TAG_ID.DIALOG], + [TAG_NAMES.DIR, TAG_ID.DIR], + [TAG_NAMES.DIV, TAG_ID.DIV], + [TAG_NAMES.DL, TAG_ID.DL], + [TAG_NAMES.DT, TAG_ID.DT], + [TAG_NAMES.EM, TAG_ID.EM], + [TAG_NAMES.EMBED, TAG_ID.EMBED], + [TAG_NAMES.FIELDSET, TAG_ID.FIELDSET], + [TAG_NAMES.FIGCAPTION, TAG_ID.FIGCAPTION], + [TAG_NAMES.FIGURE, TAG_ID.FIGURE], + [TAG_NAMES.FONT, TAG_ID.FONT], + [TAG_NAMES.FOOTER, TAG_ID.FOOTER], + [TAG_NAMES.FOREIGN_OBJECT, TAG_ID.FOREIGN_OBJECT], + [TAG_NAMES.FORM, TAG_ID.FORM], + [TAG_NAMES.FRAME, TAG_ID.FRAME], + [TAG_NAMES.FRAMESET, TAG_ID.FRAMESET], + [TAG_NAMES.H1, TAG_ID.H1], + [TAG_NAMES.H2, TAG_ID.H2], + [TAG_NAMES.H3, TAG_ID.H3], + [TAG_NAMES.H4, TAG_ID.H4], + [TAG_NAMES.H5, TAG_ID.H5], + [TAG_NAMES.H6, TAG_ID.H6], + [TAG_NAMES.HEAD, TAG_ID.HEAD], + [TAG_NAMES.HEADER, TAG_ID.HEADER], + [TAG_NAMES.HGROUP, TAG_ID.HGROUP], + [TAG_NAMES.HR, TAG_ID.HR], + [TAG_NAMES.HTML, TAG_ID.HTML], + [TAG_NAMES.I, TAG_ID.I], + [TAG_NAMES.IMG, TAG_ID.IMG], + [TAG_NAMES.IMAGE, TAG_ID.IMAGE], + [TAG_NAMES.INPUT, TAG_ID.INPUT], + [TAG_NAMES.IFRAME, TAG_ID.IFRAME], + [TAG_NAMES.KEYGEN, TAG_ID.KEYGEN], + [TAG_NAMES.LABEL, TAG_ID.LABEL], + [TAG_NAMES.LI, TAG_ID.LI], + [TAG_NAMES.LINK, TAG_ID.LINK], + [TAG_NAMES.LISTING, TAG_ID.LISTING], + [TAG_NAMES.MAIN, TAG_ID.MAIN], + [TAG_NAMES.MALIGNMARK, TAG_ID.MALIGNMARK], + [TAG_NAMES.MARQUEE, TAG_ID.MARQUEE], + [TAG_NAMES.MATH, TAG_ID.MATH], + [TAG_NAMES.MENU, TAG_ID.MENU], + [TAG_NAMES.META, TAG_ID.META], + [TAG_NAMES.MGLYPH, TAG_ID.MGLYPH], + [TAG_NAMES.MI, TAG_ID.MI], + [TAG_NAMES.MO, TAG_ID.MO], + [TAG_NAMES.MN, TAG_ID.MN], + [TAG_NAMES.MS, TAG_ID.MS], + [TAG_NAMES.MTEXT, TAG_ID.MTEXT], + [TAG_NAMES.NAV, TAG_ID.NAV], + [TAG_NAMES.NOBR, TAG_ID.NOBR], + [TAG_NAMES.NOFRAMES, TAG_ID.NOFRAMES], + [TAG_NAMES.NOEMBED, TAG_ID.NOEMBED], + [TAG_NAMES.NOSCRIPT, TAG_ID.NOSCRIPT], + [TAG_NAMES.OBJECT, TAG_ID.OBJECT], + [TAG_NAMES.OL, TAG_ID.OL], + [TAG_NAMES.OPTGROUP, TAG_ID.OPTGROUP], + [TAG_NAMES.OPTION, TAG_ID.OPTION], + [TAG_NAMES.P, TAG_ID.P], + [TAG_NAMES.PARAM, TAG_ID.PARAM], + [TAG_NAMES.PLAINTEXT, TAG_ID.PLAINTEXT], + [TAG_NAMES.PRE, TAG_ID.PRE], + [TAG_NAMES.RB, TAG_ID.RB], + [TAG_NAMES.RP, TAG_ID.RP], + [TAG_NAMES.RT, TAG_ID.RT], + [TAG_NAMES.RTC, TAG_ID.RTC], + [TAG_NAMES.RUBY, TAG_ID.RUBY], + [TAG_NAMES.S, TAG_ID.S], + [TAG_NAMES.SCRIPT, TAG_ID.SCRIPT], + [TAG_NAMES.SECTION, TAG_ID.SECTION], + [TAG_NAMES.SELECT, TAG_ID.SELECT], + [TAG_NAMES.SOURCE, TAG_ID.SOURCE], + [TAG_NAMES.SMALL, TAG_ID.SMALL], + [TAG_NAMES.SPAN, TAG_ID.SPAN], + [TAG_NAMES.STRIKE, TAG_ID.STRIKE], + [TAG_NAMES.STRONG, TAG_ID.STRONG], + [TAG_NAMES.STYLE, TAG_ID.STYLE], + [TAG_NAMES.SUB, TAG_ID.SUB], + [TAG_NAMES.SUMMARY, TAG_ID.SUMMARY], + [TAG_NAMES.SUP, TAG_ID.SUP], + [TAG_NAMES.TABLE, TAG_ID.TABLE], + [TAG_NAMES.TBODY, TAG_ID.TBODY], + [TAG_NAMES.TEMPLATE, TAG_ID.TEMPLATE], + [TAG_NAMES.TEXTAREA, TAG_ID.TEXTAREA], + [TAG_NAMES.TFOOT, TAG_ID.TFOOT], + [TAG_NAMES.TD, TAG_ID.TD], + [TAG_NAMES.TH, TAG_ID.TH], + [TAG_NAMES.THEAD, TAG_ID.THEAD], + [TAG_NAMES.TITLE, TAG_ID.TITLE], + [TAG_NAMES.TR, TAG_ID.TR], + [TAG_NAMES.TRACK, TAG_ID.TRACK], + [TAG_NAMES.TT, TAG_ID.TT], + [TAG_NAMES.U, TAG_ID.U], + [TAG_NAMES.UL, TAG_ID.UL], + [TAG_NAMES.SVG, TAG_ID.SVG], + [TAG_NAMES.VAR, TAG_ID.VAR], + [TAG_NAMES.WBR, TAG_ID.WBR], + [TAG_NAMES.XMP, TAG_ID.XMP] + ]); + function getTagID(tagName) { + var _a2; + return (_a2 = TAG_NAME_TO_ID.get(tagName)) !== null && _a2 !== void 0 ? _a2 : TAG_ID.UNKNOWN; + } + var $ = TAG_ID; + var SPECIAL_ELEMENTS = { + [NS.HTML]: /* @__PURE__ */ new Set([ + $.ADDRESS, + $.APPLET, + $.AREA, + $.ARTICLE, + $.ASIDE, + $.BASE, + $.BASEFONT, + $.BGSOUND, + $.BLOCKQUOTE, + $.BODY, + $.BR, + $.BUTTON, + $.CAPTION, + $.CENTER, + $.COL, + $.COLGROUP, + $.DD, + $.DETAILS, + $.DIR, + $.DIV, + $.DL, + $.DT, + $.EMBED, + $.FIELDSET, + $.FIGCAPTION, + $.FIGURE, + $.FOOTER, + $.FORM, + $.FRAME, + $.FRAMESET, + $.H1, + $.H2, + $.H3, + $.H4, + $.H5, + $.H6, + $.HEAD, + $.HEADER, + $.HGROUP, + $.HR, + $.HTML, + $.IFRAME, + $.IMG, + $.INPUT, + $.LI, + $.LINK, + $.LISTING, + $.MAIN, + $.MARQUEE, + $.MENU, + $.META, + $.NAV, + $.NOEMBED, + $.NOFRAMES, + $.NOSCRIPT, + $.OBJECT, + $.OL, + $.P, + $.PARAM, + $.PLAINTEXT, + $.PRE, + $.SCRIPT, + $.SECTION, + $.SELECT, + $.SOURCE, + $.STYLE, + $.SUMMARY, + $.TABLE, + $.TBODY, + $.TD, + $.TEMPLATE, + $.TEXTAREA, + $.TFOOT, + $.TH, + $.THEAD, + $.TITLE, + $.TR, + $.TRACK, + $.UL, + $.WBR, + $.XMP + ]), + [NS.MATHML]: /* @__PURE__ */ new Set([$.MI, $.MO, $.MN, $.MS, $.MTEXT, $.ANNOTATION_XML]), + [NS.SVG]: /* @__PURE__ */ new Set([$.TITLE, $.FOREIGN_OBJECT, $.DESC]), + [NS.XLINK]: /* @__PURE__ */ new Set(), + [NS.XML]: /* @__PURE__ */ new Set(), + [NS.XMLNS]: /* @__PURE__ */ new Set() + }; + function isNumberedHeader(tn) { + return tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6; + } + var UNESCAPED_TEXT = /* @__PURE__ */ new Set([ + TAG_NAMES.STYLE, + TAG_NAMES.SCRIPT, + TAG_NAMES.XMP, + TAG_NAMES.IFRAME, + TAG_NAMES.NOEMBED, + TAG_NAMES.NOFRAMES, + TAG_NAMES.PLAINTEXT + ]); + function hasUnescapedText(tn, scriptingEnabled) { + return UNESCAPED_TEXT.has(tn) || scriptingEnabled && tn === TAG_NAMES.NOSCRIPT; + } + + // node_modules/parse5/dist/tokenizer/index.js + var C1_CONTROLS_REFERENCE_REPLACEMENTS = /* @__PURE__ */ new Map([ + [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 State; + (function(State2) { + State2[State2["DATA"] = 0] = "DATA"; + State2[State2["RCDATA"] = 1] = "RCDATA"; + State2[State2["RAWTEXT"] = 2] = "RAWTEXT"; + State2[State2["SCRIPT_DATA"] = 3] = "SCRIPT_DATA"; + State2[State2["PLAINTEXT"] = 4] = "PLAINTEXT"; + State2[State2["TAG_OPEN"] = 5] = "TAG_OPEN"; + State2[State2["END_TAG_OPEN"] = 6] = "END_TAG_OPEN"; + State2[State2["TAG_NAME"] = 7] = "TAG_NAME"; + State2[State2["RCDATA_LESS_THAN_SIGN"] = 8] = "RCDATA_LESS_THAN_SIGN"; + State2[State2["RCDATA_END_TAG_OPEN"] = 9] = "RCDATA_END_TAG_OPEN"; + State2[State2["RCDATA_END_TAG_NAME"] = 10] = "RCDATA_END_TAG_NAME"; + State2[State2["RAWTEXT_LESS_THAN_SIGN"] = 11] = "RAWTEXT_LESS_THAN_SIGN"; + State2[State2["RAWTEXT_END_TAG_OPEN"] = 12] = "RAWTEXT_END_TAG_OPEN"; + State2[State2["RAWTEXT_END_TAG_NAME"] = 13] = "RAWTEXT_END_TAG_NAME"; + State2[State2["SCRIPT_DATA_LESS_THAN_SIGN"] = 14] = "SCRIPT_DATA_LESS_THAN_SIGN"; + State2[State2["SCRIPT_DATA_END_TAG_OPEN"] = 15] = "SCRIPT_DATA_END_TAG_OPEN"; + State2[State2["SCRIPT_DATA_END_TAG_NAME"] = 16] = "SCRIPT_DATA_END_TAG_NAME"; + State2[State2["SCRIPT_DATA_ESCAPE_START"] = 17] = "SCRIPT_DATA_ESCAPE_START"; + State2[State2["SCRIPT_DATA_ESCAPE_START_DASH"] = 18] = "SCRIPT_DATA_ESCAPE_START_DASH"; + State2[State2["SCRIPT_DATA_ESCAPED"] = 19] = "SCRIPT_DATA_ESCAPED"; + State2[State2["SCRIPT_DATA_ESCAPED_DASH"] = 20] = "SCRIPT_DATA_ESCAPED_DASH"; + State2[State2["SCRIPT_DATA_ESCAPED_DASH_DASH"] = 21] = "SCRIPT_DATA_ESCAPED_DASH_DASH"; + State2[State2["SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN"] = 22] = "SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN"; + State2[State2["SCRIPT_DATA_ESCAPED_END_TAG_OPEN"] = 23] = "SCRIPT_DATA_ESCAPED_END_TAG_OPEN"; + State2[State2["SCRIPT_DATA_ESCAPED_END_TAG_NAME"] = 24] = "SCRIPT_DATA_ESCAPED_END_TAG_NAME"; + State2[State2["SCRIPT_DATA_DOUBLE_ESCAPE_START"] = 25] = "SCRIPT_DATA_DOUBLE_ESCAPE_START"; + State2[State2["SCRIPT_DATA_DOUBLE_ESCAPED"] = 26] = "SCRIPT_DATA_DOUBLE_ESCAPED"; + State2[State2["SCRIPT_DATA_DOUBLE_ESCAPED_DASH"] = 27] = "SCRIPT_DATA_DOUBLE_ESCAPED_DASH"; + State2[State2["SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH"] = 28] = "SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH"; + State2[State2["SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN"] = 29] = "SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN"; + State2[State2["SCRIPT_DATA_DOUBLE_ESCAPE_END"] = 30] = "SCRIPT_DATA_DOUBLE_ESCAPE_END"; + State2[State2["BEFORE_ATTRIBUTE_NAME"] = 31] = "BEFORE_ATTRIBUTE_NAME"; + State2[State2["ATTRIBUTE_NAME"] = 32] = "ATTRIBUTE_NAME"; + State2[State2["AFTER_ATTRIBUTE_NAME"] = 33] = "AFTER_ATTRIBUTE_NAME"; + State2[State2["BEFORE_ATTRIBUTE_VALUE"] = 34] = "BEFORE_ATTRIBUTE_VALUE"; + State2[State2["ATTRIBUTE_VALUE_DOUBLE_QUOTED"] = 35] = "ATTRIBUTE_VALUE_DOUBLE_QUOTED"; + State2[State2["ATTRIBUTE_VALUE_SINGLE_QUOTED"] = 36] = "ATTRIBUTE_VALUE_SINGLE_QUOTED"; + State2[State2["ATTRIBUTE_VALUE_UNQUOTED"] = 37] = "ATTRIBUTE_VALUE_UNQUOTED"; + State2[State2["AFTER_ATTRIBUTE_VALUE_QUOTED"] = 38] = "AFTER_ATTRIBUTE_VALUE_QUOTED"; + State2[State2["SELF_CLOSING_START_TAG"] = 39] = "SELF_CLOSING_START_TAG"; + State2[State2["BOGUS_COMMENT"] = 40] = "BOGUS_COMMENT"; + State2[State2["MARKUP_DECLARATION_OPEN"] = 41] = "MARKUP_DECLARATION_OPEN"; + State2[State2["COMMENT_START"] = 42] = "COMMENT_START"; + State2[State2["COMMENT_START_DASH"] = 43] = "COMMENT_START_DASH"; + State2[State2["COMMENT"] = 44] = "COMMENT"; + State2[State2["COMMENT_LESS_THAN_SIGN"] = 45] = "COMMENT_LESS_THAN_SIGN"; + State2[State2["COMMENT_LESS_THAN_SIGN_BANG"] = 46] = "COMMENT_LESS_THAN_SIGN_BANG"; + State2[State2["COMMENT_LESS_THAN_SIGN_BANG_DASH"] = 47] = "COMMENT_LESS_THAN_SIGN_BANG_DASH"; + State2[State2["COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH"] = 48] = "COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH"; + State2[State2["COMMENT_END_DASH"] = 49] = "COMMENT_END_DASH"; + State2[State2["COMMENT_END"] = 50] = "COMMENT_END"; + State2[State2["COMMENT_END_BANG"] = 51] = "COMMENT_END_BANG"; + State2[State2["DOCTYPE"] = 52] = "DOCTYPE"; + State2[State2["BEFORE_DOCTYPE_NAME"] = 53] = "BEFORE_DOCTYPE_NAME"; + State2[State2["DOCTYPE_NAME"] = 54] = "DOCTYPE_NAME"; + State2[State2["AFTER_DOCTYPE_NAME"] = 55] = "AFTER_DOCTYPE_NAME"; + State2[State2["AFTER_DOCTYPE_PUBLIC_KEYWORD"] = 56] = "AFTER_DOCTYPE_PUBLIC_KEYWORD"; + State2[State2["BEFORE_DOCTYPE_PUBLIC_IDENTIFIER"] = 57] = "BEFORE_DOCTYPE_PUBLIC_IDENTIFIER"; + State2[State2["DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED"] = 58] = "DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED"; + State2[State2["DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED"] = 59] = "DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED"; + State2[State2["AFTER_DOCTYPE_PUBLIC_IDENTIFIER"] = 60] = "AFTER_DOCTYPE_PUBLIC_IDENTIFIER"; + State2[State2["BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS"] = 61] = "BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS"; + State2[State2["AFTER_DOCTYPE_SYSTEM_KEYWORD"] = 62] = "AFTER_DOCTYPE_SYSTEM_KEYWORD"; + State2[State2["BEFORE_DOCTYPE_SYSTEM_IDENTIFIER"] = 63] = "BEFORE_DOCTYPE_SYSTEM_IDENTIFIER"; + State2[State2["DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED"] = 64] = "DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED"; + State2[State2["DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED"] = 65] = "DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED"; + State2[State2["AFTER_DOCTYPE_SYSTEM_IDENTIFIER"] = 66] = "AFTER_DOCTYPE_SYSTEM_IDENTIFIER"; + State2[State2["BOGUS_DOCTYPE"] = 67] = "BOGUS_DOCTYPE"; + State2[State2["CDATA_SECTION"] = 68] = "CDATA_SECTION"; + State2[State2["CDATA_SECTION_BRACKET"] = 69] = "CDATA_SECTION_BRACKET"; + State2[State2["CDATA_SECTION_END"] = 70] = "CDATA_SECTION_END"; + State2[State2["CHARACTER_REFERENCE"] = 71] = "CHARACTER_REFERENCE"; + State2[State2["NAMED_CHARACTER_REFERENCE"] = 72] = "NAMED_CHARACTER_REFERENCE"; + State2[State2["AMBIGUOUS_AMPERSAND"] = 73] = "AMBIGUOUS_AMPERSAND"; + State2[State2["NUMERIC_CHARACTER_REFERENCE"] = 74] = "NUMERIC_CHARACTER_REFERENCE"; + State2[State2["HEXADEMICAL_CHARACTER_REFERENCE_START"] = 75] = "HEXADEMICAL_CHARACTER_REFERENCE_START"; + State2[State2["HEXADEMICAL_CHARACTER_REFERENCE"] = 76] = "HEXADEMICAL_CHARACTER_REFERENCE"; + State2[State2["DECIMAL_CHARACTER_REFERENCE"] = 77] = "DECIMAL_CHARACTER_REFERENCE"; + State2[State2["NUMERIC_CHARACTER_REFERENCE_END"] = 78] = "NUMERIC_CHARACTER_REFERENCE_END"; + })(State || (State = {})); + var TokenizerMode = { + DATA: State.DATA, + RCDATA: State.RCDATA, + RAWTEXT: State.RAWTEXT, + SCRIPT_DATA: State.SCRIPT_DATA, + PLAINTEXT: State.PLAINTEXT, + CDATA_SECTION: State.CDATA_SECTION + }; + function isAsciiDigit(cp) { + return cp >= CODE_POINTS.DIGIT_0 && cp <= CODE_POINTS.DIGIT_9; + } + function isAsciiUpper(cp) { + return cp >= CODE_POINTS.LATIN_CAPITAL_A && cp <= CODE_POINTS.LATIN_CAPITAL_Z; + } + function isAsciiLower(cp) { + return cp >= CODE_POINTS.LATIN_SMALL_A && cp <= CODE_POINTS.LATIN_SMALL_Z; + } + function isAsciiLetter(cp) { + return isAsciiLower(cp) || isAsciiUpper(cp); + } + function isAsciiAlphaNumeric(cp) { + return isAsciiLetter(cp) || isAsciiDigit(cp); + } + function isAsciiUpperHexDigit(cp) { + return cp >= CODE_POINTS.LATIN_CAPITAL_A && cp <= CODE_POINTS.LATIN_CAPITAL_F; + } + function isAsciiLowerHexDigit(cp) { + return cp >= CODE_POINTS.LATIN_SMALL_A && cp <= CODE_POINTS.LATIN_SMALL_F; + } + function isAsciiHexDigit(cp) { + return isAsciiDigit(cp) || isAsciiUpperHexDigit(cp) || isAsciiLowerHexDigit(cp); + } + function toAsciiLower(cp) { + return cp + 32; + } + function isWhitespace(cp) { + return cp === CODE_POINTS.SPACE || cp === CODE_POINTS.LINE_FEED || cp === CODE_POINTS.TABULATION || cp === CODE_POINTS.FORM_FEED; + } + function isEntityInAttributeInvalidEnd(nextCp) { + return nextCp === CODE_POINTS.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp); + } + function isScriptDataDoubleEscapeSequenceEnd(cp) { + return isWhitespace(cp) || cp === CODE_POINTS.SOLIDUS || cp === CODE_POINTS.GREATER_THAN_SIGN; + } + var Tokenizer = class { + constructor(options, handler) { + this.options = options; + this.handler = handler; + this.paused = false; + this.inLoop = false; + this.inForeignNode = false; + this.lastStartTagName = ""; + this.active = false; + this.state = State.DATA; + this.returnState = State.DATA; + this.charRefCode = -1; + this.consumedAfterSnapshot = -1; + this.currentCharacterToken = null; + this.currentToken = null; + this.currentAttr = { name: "", value: "" }; + this.preprocessor = new Preprocessor(handler); + this.currentLocation = this.getCurrentLocation(-1); + } + //Errors + _err(code2) { + var _a2, _b; + (_b = (_a2 = this.handler).onParseError) === null || _b === void 0 ? void 0 : _b.call(_a2, this.preprocessor.getError(code2)); + } + // NOTE: `offset` may never run across line boundaries. + getCurrentLocation(offset) { + if (!this.options.sourceCodeLocationInfo) { + return null; + } + return { + startLine: this.preprocessor.line, + startCol: this.preprocessor.col - offset, + startOffset: this.preprocessor.offset - offset, + endLine: -1, + endCol: -1, + endOffset: -1 + }; + } + _runParsingLoop() { + if (this.inLoop) + return; + this.inLoop = true; + while (this.active && !this.paused) { + this.consumedAfterSnapshot = 0; + const cp = this._consume(); + if (!this._ensureHibernation()) { + this._callState(cp); + } + } + this.inLoop = false; + } + //API + pause() { + this.paused = true; + } + resume(writeCallback) { + if (!this.paused) { + throw new Error("Parser was already resumed"); + } + this.paused = false; + if (this.inLoop) + return; + this._runParsingLoop(); + if (!this.paused) { + writeCallback === null || writeCallback === void 0 ? void 0 : writeCallback(); + } + } + write(chunk, isLastChunk, writeCallback) { + this.active = true; + this.preprocessor.write(chunk, isLastChunk); + this._runParsingLoop(); + if (!this.paused) { + writeCallback === null || writeCallback === void 0 ? void 0 : writeCallback(); + } + } + insertHtmlAtCurrentPos(chunk) { + this.active = true; + this.preprocessor.insertHtmlAtCurrentPos(chunk); + this._runParsingLoop(); + } + //Hibernation + _ensureHibernation() { + if (this.preprocessor.endOfChunkHit) { + this._unconsume(this.consumedAfterSnapshot); + this.active = false; + return true; + } + return false; + } + //Consumption + _consume() { + this.consumedAfterSnapshot++; + return this.preprocessor.advance(); + } + _unconsume(count) { + this.consumedAfterSnapshot -= count; + this.preprocessor.retreat(count); + } + _reconsumeInState(state, cp) { + this.state = state; + this._callState(cp); + } + _advanceBy(count) { + this.consumedAfterSnapshot += count; + for (let i = 0; i < count; i++) { + this.preprocessor.advance(); + } + } + _consumeSequenceIfMatch(pattern, caseSensitive) { + if (this.preprocessor.startsWith(pattern, caseSensitive)) { + this._advanceBy(pattern.length - 1); + return true; + } + return false; + } + //Token creation + _createStartTagToken() { + this.currentToken = { + type: TokenType.START_TAG, + tagName: "", + tagID: TAG_ID.UNKNOWN, + selfClosing: false, + ackSelfClosing: false, + attrs: [], + location: this.getCurrentLocation(1) + }; + } + _createEndTagToken() { + this.currentToken = { + type: TokenType.END_TAG, + tagName: "", + tagID: TAG_ID.UNKNOWN, + selfClosing: false, + ackSelfClosing: false, + attrs: [], + location: this.getCurrentLocation(2) + }; + } + _createCommentToken(offset) { + this.currentToken = { + type: TokenType.COMMENT, + data: "", + location: this.getCurrentLocation(offset) + }; + } + _createDoctypeToken(initialName) { + this.currentToken = { + type: TokenType.DOCTYPE, + name: initialName, + forceQuirks: false, + publicId: null, + systemId: null, + location: this.currentLocation + }; + } + _createCharacterToken(type, chars) { + this.currentCharacterToken = { + type, + chars, + location: this.currentLocation + }; + } + //Tag attributes + _createAttr(attrNameFirstCh) { + this.currentAttr = { + name: attrNameFirstCh, + value: "" + }; + this.currentLocation = this.getCurrentLocation(0); + } + _leaveAttrName() { + var _a2; + var _b; + const token = this.currentToken; + if (getTokenAttr(token, this.currentAttr.name) === null) { + token.attrs.push(this.currentAttr); + if (token.location && this.currentLocation) { + const attrLocations = (_a2 = (_b = token.location).attrs) !== null && _a2 !== void 0 ? _a2 : _b.attrs = /* @__PURE__ */ Object.create(null); + attrLocations[this.currentAttr.name] = this.currentLocation; + this._leaveAttrValue(); + } + } else { + this._err(ERR.duplicateAttribute); + } + } + _leaveAttrValue() { + if (this.currentLocation) { + this.currentLocation.endLine = this.preprocessor.line; + this.currentLocation.endCol = this.preprocessor.col; + this.currentLocation.endOffset = this.preprocessor.offset; + } + } + //Token emission + prepareToken(ct) { + this._emitCurrentCharacterToken(ct.location); + this.currentToken = null; + if (ct.location) { + ct.location.endLine = this.preprocessor.line; + ct.location.endCol = this.preprocessor.col + 1; + ct.location.endOffset = this.preprocessor.offset + 1; + } + this.currentLocation = this.getCurrentLocation(-1); + } + emitCurrentTagToken() { + const ct = this.currentToken; + this.prepareToken(ct); + ct.tagID = getTagID(ct.tagName); + if (ct.type === TokenType.START_TAG) { + this.lastStartTagName = ct.tagName; + this.handler.onStartTag(ct); + } else { + if (ct.attrs.length > 0) { + this._err(ERR.endTagWithAttributes); + } + if (ct.selfClosing) { + this._err(ERR.endTagWithTrailingSolidus); + } + this.handler.onEndTag(ct); + } + this.preprocessor.dropParsedChunk(); + } + emitCurrentComment(ct) { + this.prepareToken(ct); + this.handler.onComment(ct); + this.preprocessor.dropParsedChunk(); + } + emitCurrentDoctype(ct) { + this.prepareToken(ct); + this.handler.onDoctype(ct); + this.preprocessor.dropParsedChunk(); + } + _emitCurrentCharacterToken(nextLocation) { + if (this.currentCharacterToken) { + if (nextLocation && this.currentCharacterToken.location) { + this.currentCharacterToken.location.endLine = nextLocation.startLine; + this.currentCharacterToken.location.endCol = nextLocation.startCol; + this.currentCharacterToken.location.endOffset = nextLocation.startOffset; + } + switch (this.currentCharacterToken.type) { + case TokenType.CHARACTER: { + this.handler.onCharacter(this.currentCharacterToken); + break; + } + case TokenType.NULL_CHARACTER: { + this.handler.onNullCharacter(this.currentCharacterToken); + break; + } + case TokenType.WHITESPACE_CHARACTER: { + this.handler.onWhitespaceCharacter(this.currentCharacterToken); + break; + } + } + this.currentCharacterToken = null; + } + } + _emitEOFToken() { + const location = this.getCurrentLocation(0); + if (location) { + location.endLine = location.startLine; + location.endCol = location.startCol; + location.endOffset = location.startOffset; + } + this._emitCurrentCharacterToken(location); + this.handler.onEof({ type: TokenType.EOF, location }); + this.active = false; + } + //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, the parser can process it + //as a single solid character token. + //So, there are 3 types of character tokens in parse5: + //1)TokenType.NULL_CHARACTER - \u0000-character sequences (e.g. '\u0000\u0000\u0000') + //2)TokenType.WHITESPACE_CHARACTER - any whitespace/new-line character sequences (e.g. '\n \r\t \f') + //3)TokenType.CHARACTER - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^') + _appendCharToCurrentCharacterToken(type, ch) { + if (this.currentCharacterToken) { + if (this.currentCharacterToken.type !== type) { + this.currentLocation = this.getCurrentLocation(0); + this._emitCurrentCharacterToken(this.currentLocation); + this.preprocessor.dropParsedChunk(); + } else { + this.currentCharacterToken.chars += ch; + return; + } + } + this._createCharacterToken(type, ch); + } + _emitCodePoint(cp) { + const type = isWhitespace(cp) ? TokenType.WHITESPACE_CHARACTER : cp === CODE_POINTS.NULL ? TokenType.NULL_CHARACTER : TokenType.CHARACTER; + this._appendCharToCurrentCharacterToken(type, String.fromCodePoint(cp)); + } + //NOTE: used when we emit characters explicitly. + //This is always for non-whitespace and non-null characters, which allows us to avoid additional checks. + _emitChars(ch) { + this._appendCharToCurrentCharacterToken(TokenType.CHARACTER, ch); + } + // Character reference helpers + _matchNamedCharacterReference(cp) { + let result = null; + let excess = 0; + let withoutSemicolon = false; + for (let i = 0, current = decode_data_html_default[0]; i >= 0; cp = this._consume()) { + i = determineBranch(decode_data_html_default, current, i + 1, cp); + if (i < 0) + break; + excess += 1; + current = decode_data_html_default[i]; + const masked = current & BinTrieFlags.VALUE_LENGTH; + if (masked) { + const valueLength = (masked >> 14) - 1; + if (cp !== CODE_POINTS.SEMICOLON && this._isCharacterReferenceInAttribute() && isEntityInAttributeInvalidEnd(this.preprocessor.peek(1))) { + result = [CODE_POINTS.AMPERSAND]; + i += valueLength; + } else { + result = valueLength === 0 ? [decode_data_html_default[i] & ~BinTrieFlags.VALUE_LENGTH] : valueLength === 1 ? [decode_data_html_default[++i]] : [decode_data_html_default[++i], decode_data_html_default[++i]]; + excess = 0; + withoutSemicolon = cp !== CODE_POINTS.SEMICOLON; + } + if (valueLength === 0) { + this._consume(); + break; + } + } + } + this._unconsume(excess); + if (withoutSemicolon && !this.preprocessor.endOfChunkHit) { + this._err(ERR.missingSemicolonAfterCharacterReference); + } + this._unconsume(1); + return result; + } + _isCharacterReferenceInAttribute() { + return this.returnState === State.ATTRIBUTE_VALUE_DOUBLE_QUOTED || this.returnState === State.ATTRIBUTE_VALUE_SINGLE_QUOTED || this.returnState === State.ATTRIBUTE_VALUE_UNQUOTED; + } + _flushCodePointConsumedAsCharacterReference(cp) { + if (this._isCharacterReferenceInAttribute()) { + this.currentAttr.value += String.fromCodePoint(cp); + } else { + this._emitCodePoint(cp); + } + } + // Calling states this way turns out to be much faster than any other approach. + _callState(cp) { + switch (this.state) { + case State.DATA: { + this._stateData(cp); + break; + } + case State.RCDATA: { + this._stateRcdata(cp); + break; + } + case State.RAWTEXT: { + this._stateRawtext(cp); + break; + } + case State.SCRIPT_DATA: { + this._stateScriptData(cp); + break; + } + case State.PLAINTEXT: { + this._statePlaintext(cp); + break; + } + case State.TAG_OPEN: { + this._stateTagOpen(cp); + break; + } + case State.END_TAG_OPEN: { + this._stateEndTagOpen(cp); + break; + } + case State.TAG_NAME: { + this._stateTagName(cp); + break; + } + case State.RCDATA_LESS_THAN_SIGN: { + this._stateRcdataLessThanSign(cp); + break; + } + case State.RCDATA_END_TAG_OPEN: { + this._stateRcdataEndTagOpen(cp); + break; + } + case State.RCDATA_END_TAG_NAME: { + this._stateRcdataEndTagName(cp); + break; + } + case State.RAWTEXT_LESS_THAN_SIGN: { + this._stateRawtextLessThanSign(cp); + break; + } + case State.RAWTEXT_END_TAG_OPEN: { + this._stateRawtextEndTagOpen(cp); + break; + } + case State.RAWTEXT_END_TAG_NAME: { + this._stateRawtextEndTagName(cp); + break; + } + case State.SCRIPT_DATA_LESS_THAN_SIGN: { + this._stateScriptDataLessThanSign(cp); + break; + } + case State.SCRIPT_DATA_END_TAG_OPEN: { + this._stateScriptDataEndTagOpen(cp); + break; + } + case State.SCRIPT_DATA_END_TAG_NAME: { + this._stateScriptDataEndTagName(cp); + break; + } + case State.SCRIPT_DATA_ESCAPE_START: { + this._stateScriptDataEscapeStart(cp); + break; + } + case State.SCRIPT_DATA_ESCAPE_START_DASH: { + this._stateScriptDataEscapeStartDash(cp); + break; + } + case State.SCRIPT_DATA_ESCAPED: { + this._stateScriptDataEscaped(cp); + break; + } + case State.SCRIPT_DATA_ESCAPED_DASH: { + this._stateScriptDataEscapedDash(cp); + break; + } + case State.SCRIPT_DATA_ESCAPED_DASH_DASH: { + this._stateScriptDataEscapedDashDash(cp); + break; + } + case State.SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN: { + this._stateScriptDataEscapedLessThanSign(cp); + break; + } + case State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN: { + this._stateScriptDataEscapedEndTagOpen(cp); + break; + } + case State.SCRIPT_DATA_ESCAPED_END_TAG_NAME: { + this._stateScriptDataEscapedEndTagName(cp); + break; + } + case State.SCRIPT_DATA_DOUBLE_ESCAPE_START: { + this._stateScriptDataDoubleEscapeStart(cp); + break; + } + case State.SCRIPT_DATA_DOUBLE_ESCAPED: { + this._stateScriptDataDoubleEscaped(cp); + break; + } + case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH: { + this._stateScriptDataDoubleEscapedDash(cp); + break; + } + case State.SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH: { + this._stateScriptDataDoubleEscapedDashDash(cp); + break; + } + case State.SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN: { + this._stateScriptDataDoubleEscapedLessThanSign(cp); + break; + } + case State.SCRIPT_DATA_DOUBLE_ESCAPE_END: { + this._stateScriptDataDoubleEscapeEnd(cp); + break; + } + case State.BEFORE_ATTRIBUTE_NAME: { + this._stateBeforeAttributeName(cp); + break; + } + case State.ATTRIBUTE_NAME: { + this._stateAttributeName(cp); + break; + } + case State.AFTER_ATTRIBUTE_NAME: { + this._stateAfterAttributeName(cp); + break; + } + case State.BEFORE_ATTRIBUTE_VALUE: { + this._stateBeforeAttributeValue(cp); + break; + } + case State.ATTRIBUTE_VALUE_DOUBLE_QUOTED: { + this._stateAttributeValueDoubleQuoted(cp); + break; + } + case State.ATTRIBUTE_VALUE_SINGLE_QUOTED: { + this._stateAttributeValueSingleQuoted(cp); + break; + } + case State.ATTRIBUTE_VALUE_UNQUOTED: { + this._stateAttributeValueUnquoted(cp); + break; + } + case State.AFTER_ATTRIBUTE_VALUE_QUOTED: { + this._stateAfterAttributeValueQuoted(cp); + break; + } + case State.SELF_CLOSING_START_TAG: { + this._stateSelfClosingStartTag(cp); + break; + } + case State.BOGUS_COMMENT: { + this._stateBogusComment(cp); + break; + } + case State.MARKUP_DECLARATION_OPEN: { + this._stateMarkupDeclarationOpen(cp); + break; + } + case State.COMMENT_START: { + this._stateCommentStart(cp); + break; + } + case State.COMMENT_START_DASH: { + this._stateCommentStartDash(cp); + break; + } + case State.COMMENT: { + this._stateComment(cp); + break; + } + case State.COMMENT_LESS_THAN_SIGN: { + this._stateCommentLessThanSign(cp); + break; + } + case State.COMMENT_LESS_THAN_SIGN_BANG: { + this._stateCommentLessThanSignBang(cp); + break; + } + case State.COMMENT_LESS_THAN_SIGN_BANG_DASH: { + this._stateCommentLessThanSignBangDash(cp); + break; + } + case State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH: { + this._stateCommentLessThanSignBangDashDash(cp); + break; + } + case State.COMMENT_END_DASH: { + this._stateCommentEndDash(cp); + break; + } + case State.COMMENT_END: { + this._stateCommentEnd(cp); + break; + } + case State.COMMENT_END_BANG: { + this._stateCommentEndBang(cp); + break; + } + case State.DOCTYPE: { + this._stateDoctype(cp); + break; + } + case State.BEFORE_DOCTYPE_NAME: { + this._stateBeforeDoctypeName(cp); + break; + } + case State.DOCTYPE_NAME: { + this._stateDoctypeName(cp); + break; + } + case State.AFTER_DOCTYPE_NAME: { + this._stateAfterDoctypeName(cp); + break; + } + case State.AFTER_DOCTYPE_PUBLIC_KEYWORD: { + this._stateAfterDoctypePublicKeyword(cp); + break; + } + case State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER: { + this._stateBeforeDoctypePublicIdentifier(cp); + break; + } + case State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED: { + this._stateDoctypePublicIdentifierDoubleQuoted(cp); + break; + } + case State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED: { + this._stateDoctypePublicIdentifierSingleQuoted(cp); + break; + } + case State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER: { + this._stateAfterDoctypePublicIdentifier(cp); + break; + } + case State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS: { + this._stateBetweenDoctypePublicAndSystemIdentifiers(cp); + break; + } + case State.AFTER_DOCTYPE_SYSTEM_KEYWORD: { + this._stateAfterDoctypeSystemKeyword(cp); + break; + } + case State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER: { + this._stateBeforeDoctypeSystemIdentifier(cp); + break; + } + case State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED: { + this._stateDoctypeSystemIdentifierDoubleQuoted(cp); + break; + } + case State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED: { + this._stateDoctypeSystemIdentifierSingleQuoted(cp); + break; + } + case State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER: { + this._stateAfterDoctypeSystemIdentifier(cp); + break; + } + case State.BOGUS_DOCTYPE: { + this._stateBogusDoctype(cp); + break; + } + case State.CDATA_SECTION: { + this._stateCdataSection(cp); + break; + } + case State.CDATA_SECTION_BRACKET: { + this._stateCdataSectionBracket(cp); + break; + } + case State.CDATA_SECTION_END: { + this._stateCdataSectionEnd(cp); + break; + } + case State.CHARACTER_REFERENCE: { + this._stateCharacterReference(cp); + break; + } + case State.NAMED_CHARACTER_REFERENCE: { + this._stateNamedCharacterReference(cp); + break; + } + case State.AMBIGUOUS_AMPERSAND: { + this._stateAmbiguousAmpersand(cp); + break; + } + case State.NUMERIC_CHARACTER_REFERENCE: { + this._stateNumericCharacterReference(cp); + break; + } + case State.HEXADEMICAL_CHARACTER_REFERENCE_START: { + this._stateHexademicalCharacterReferenceStart(cp); + break; + } + case State.HEXADEMICAL_CHARACTER_REFERENCE: { + this._stateHexademicalCharacterReference(cp); + break; + } + case State.DECIMAL_CHARACTER_REFERENCE: { + this._stateDecimalCharacterReference(cp); + break; + } + case State.NUMERIC_CHARACTER_REFERENCE_END: { + this._stateNumericCharacterReferenceEnd(cp); + break; + } + default: { + throw new Error("Unknown state"); + } + } + } + // State machine + // Data state + //------------------------------------------------------------------ + _stateData(cp) { + switch (cp) { + case CODE_POINTS.LESS_THAN_SIGN: { + this.state = State.TAG_OPEN; + break; + } + case CODE_POINTS.AMPERSAND: { + this.returnState = State.DATA; + this.state = State.CHARACTER_REFERENCE; + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + this._emitCodePoint(cp); + break; + } + case CODE_POINTS.EOF: { + this._emitEOFToken(); + break; + } + default: { + this._emitCodePoint(cp); + } + } + } + // RCDATA state + //------------------------------------------------------------------ + _stateRcdata(cp) { + switch (cp) { + case CODE_POINTS.AMPERSAND: { + this.returnState = State.RCDATA; + this.state = State.CHARACTER_REFERENCE; + break; + } + case CODE_POINTS.LESS_THAN_SIGN: { + this.state = State.RCDATA_LESS_THAN_SIGN; + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + this._emitChars(REPLACEMENT_CHARACTER); + break; + } + case CODE_POINTS.EOF: { + this._emitEOFToken(); + break; + } + default: { + this._emitCodePoint(cp); + } + } + } + // RAWTEXT state + //------------------------------------------------------------------ + _stateRawtext(cp) { + switch (cp) { + case CODE_POINTS.LESS_THAN_SIGN: { + this.state = State.RAWTEXT_LESS_THAN_SIGN; + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + this._emitChars(REPLACEMENT_CHARACTER); + break; + } + case CODE_POINTS.EOF: { + this._emitEOFToken(); + break; + } + default: { + this._emitCodePoint(cp); + } + } + } + // Script data state + //------------------------------------------------------------------ + _stateScriptData(cp) { + switch (cp) { + case CODE_POINTS.LESS_THAN_SIGN: { + this.state = State.SCRIPT_DATA_LESS_THAN_SIGN; + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + this._emitChars(REPLACEMENT_CHARACTER); + break; + } + case CODE_POINTS.EOF: { + this._emitEOFToken(); + break; + } + default: { + this._emitCodePoint(cp); + } + } + } + // PLAINTEXT state + //------------------------------------------------------------------ + _statePlaintext(cp) { + switch (cp) { + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + this._emitChars(REPLACEMENT_CHARACTER); + break; + } + case CODE_POINTS.EOF: { + this._emitEOFToken(); + break; + } + default: { + this._emitCodePoint(cp); + } + } + } + // Tag open state + //------------------------------------------------------------------ + _stateTagOpen(cp) { + if (isAsciiLetter(cp)) { + this._createStartTagToken(); + this.state = State.TAG_NAME; + this._stateTagName(cp); + } else + switch (cp) { + case CODE_POINTS.EXCLAMATION_MARK: { + this.state = State.MARKUP_DECLARATION_OPEN; + break; + } + case CODE_POINTS.SOLIDUS: { + this.state = State.END_TAG_OPEN; + break; + } + case CODE_POINTS.QUESTION_MARK: { + this._err(ERR.unexpectedQuestionMarkInsteadOfTagName); + this._createCommentToken(1); + this.state = State.BOGUS_COMMENT; + this._stateBogusComment(cp); + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofBeforeTagName); + this._emitChars("<"); + this._emitEOFToken(); + break; + } + default: { + this._err(ERR.invalidFirstCharacterOfTagName); + this._emitChars("<"); + this.state = State.DATA; + this._stateData(cp); + } + } + } + // End tag open state + //------------------------------------------------------------------ + _stateEndTagOpen(cp) { + if (isAsciiLetter(cp)) { + this._createEndTagToken(); + this.state = State.TAG_NAME; + this._stateTagName(cp); + } else + switch (cp) { + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(ERR.missingEndTagName); + this.state = State.DATA; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofBeforeTagName); + this._emitChars(""); + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + this.state = State.SCRIPT_DATA_ESCAPED; + this._emitChars(REPLACEMENT_CHARACTER); + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInScriptHtmlCommentLikeText); + this._emitEOFToken(); + break; + } + default: { + this.state = State.SCRIPT_DATA_ESCAPED; + this._emitCodePoint(cp); + } + } + } + // Script data escaped less-than sign state + //------------------------------------------------------------------ + _stateScriptDataEscapedLessThanSign(cp) { + if (cp === CODE_POINTS.SOLIDUS) { + this.state = State.SCRIPT_DATA_ESCAPED_END_TAG_OPEN; + } else if (isAsciiLetter(cp)) { + this._emitChars("<"); + this.state = State.SCRIPT_DATA_DOUBLE_ESCAPE_START; + this._stateScriptDataDoubleEscapeStart(cp); + } else { + this._emitChars("<"); + this.state = State.SCRIPT_DATA_ESCAPED; + this._stateScriptDataEscaped(cp); + } + } + // Script data escaped end tag open state + //------------------------------------------------------------------ + _stateScriptDataEscapedEndTagOpen(cp) { + if (isAsciiLetter(cp)) { + this.state = State.SCRIPT_DATA_ESCAPED_END_TAG_NAME; + this._stateScriptDataEscapedEndTagName(cp); + } else { + this._emitChars(""); + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED; + this._emitChars(REPLACEMENT_CHARACTER); + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInScriptHtmlCommentLikeText); + this._emitEOFToken(); + break; + } + default: { + this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED; + this._emitCodePoint(cp); + } + } + } + // Script data double escaped less-than sign state + //------------------------------------------------------------------ + _stateScriptDataDoubleEscapedLessThanSign(cp) { + if (cp === CODE_POINTS.SOLIDUS) { + this.state = State.SCRIPT_DATA_DOUBLE_ESCAPE_END; + this._emitChars("/"); + } else { + this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED; + this._stateScriptDataDoubleEscaped(cp); + } + } + // Script data double escape end state + //------------------------------------------------------------------ + _stateScriptDataDoubleEscapeEnd(cp) { + if (this.preprocessor.startsWith(SEQUENCES.SCRIPT, false) && isScriptDataDoubleEscapeSequenceEnd(this.preprocessor.peek(SEQUENCES.SCRIPT.length))) { + this._emitCodePoint(cp); + for (let i = 0; i < SEQUENCES.SCRIPT.length; i++) { + this._emitCodePoint(this._consume()); + } + this.state = State.SCRIPT_DATA_ESCAPED; + } else if (!this._ensureHibernation()) { + this.state = State.SCRIPT_DATA_DOUBLE_ESCAPED; + this._stateScriptDataDoubleEscaped(cp); + } + } + // Before attribute name state + //------------------------------------------------------------------ + _stateBeforeAttributeName(cp) { + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + break; + } + case CODE_POINTS.SOLIDUS: + case CODE_POINTS.GREATER_THAN_SIGN: + case CODE_POINTS.EOF: { + this.state = State.AFTER_ATTRIBUTE_NAME; + this._stateAfterAttributeName(cp); + break; + } + case CODE_POINTS.EQUALS_SIGN: { + this._err(ERR.unexpectedEqualsSignBeforeAttributeName); + this._createAttr("="); + this.state = State.ATTRIBUTE_NAME; + break; + } + default: { + this._createAttr(""); + this.state = State.ATTRIBUTE_NAME; + this._stateAttributeName(cp); + } + } + } + // Attribute name state + //------------------------------------------------------------------ + _stateAttributeName(cp) { + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: + case CODE_POINTS.SOLIDUS: + case CODE_POINTS.GREATER_THAN_SIGN: + case CODE_POINTS.EOF: { + this._leaveAttrName(); + this.state = State.AFTER_ATTRIBUTE_NAME; + this._stateAfterAttributeName(cp); + break; + } + case CODE_POINTS.EQUALS_SIGN: { + this._leaveAttrName(); + this.state = State.BEFORE_ATTRIBUTE_VALUE; + break; + } + case CODE_POINTS.QUOTATION_MARK: + case CODE_POINTS.APOSTROPHE: + case CODE_POINTS.LESS_THAN_SIGN: { + this._err(ERR.unexpectedCharacterInAttributeName); + this.currentAttr.name += String.fromCodePoint(cp); + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + this.currentAttr.name += REPLACEMENT_CHARACTER; + break; + } + default: { + this.currentAttr.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp); + } + } + } + // After attribute name state + //------------------------------------------------------------------ + _stateAfterAttributeName(cp) { + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + break; + } + case CODE_POINTS.SOLIDUS: { + this.state = State.SELF_CLOSING_START_TAG; + break; + } + case CODE_POINTS.EQUALS_SIGN: { + this.state = State.BEFORE_ATTRIBUTE_VALUE; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.DATA; + this.emitCurrentTagToken(); + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInTag); + this._emitEOFToken(); + break; + } + default: { + this._createAttr(""); + this.state = State.ATTRIBUTE_NAME; + this._stateAttributeName(cp); + } + } + } + // Before attribute value state + //------------------------------------------------------------------ + _stateBeforeAttributeValue(cp) { + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + break; + } + case CODE_POINTS.QUOTATION_MARK: { + this.state = State.ATTRIBUTE_VALUE_DOUBLE_QUOTED; + break; + } + case CODE_POINTS.APOSTROPHE: { + this.state = State.ATTRIBUTE_VALUE_SINGLE_QUOTED; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(ERR.missingAttributeValue); + this.state = State.DATA; + this.emitCurrentTagToken(); + break; + } + default: { + this.state = State.ATTRIBUTE_VALUE_UNQUOTED; + this._stateAttributeValueUnquoted(cp); + } + } + } + // Attribute value (double-quoted) state + //------------------------------------------------------------------ + _stateAttributeValueDoubleQuoted(cp) { + switch (cp) { + case CODE_POINTS.QUOTATION_MARK: { + this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED; + break; + } + case CODE_POINTS.AMPERSAND: { + this.returnState = State.ATTRIBUTE_VALUE_DOUBLE_QUOTED; + this.state = State.CHARACTER_REFERENCE; + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + this.currentAttr.value += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInTag); + this._emitEOFToken(); + break; + } + default: { + this.currentAttr.value += String.fromCodePoint(cp); + } + } + } + // Attribute value (single-quoted) state + //------------------------------------------------------------------ + _stateAttributeValueSingleQuoted(cp) { + switch (cp) { + case CODE_POINTS.APOSTROPHE: { + this.state = State.AFTER_ATTRIBUTE_VALUE_QUOTED; + break; + } + case CODE_POINTS.AMPERSAND: { + this.returnState = State.ATTRIBUTE_VALUE_SINGLE_QUOTED; + this.state = State.CHARACTER_REFERENCE; + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + this.currentAttr.value += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInTag); + this._emitEOFToken(); + break; + } + default: { + this.currentAttr.value += String.fromCodePoint(cp); + } + } + } + // Attribute value (unquoted) state + //------------------------------------------------------------------ + _stateAttributeValueUnquoted(cp) { + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + this._leaveAttrValue(); + this.state = State.BEFORE_ATTRIBUTE_NAME; + break; + } + case CODE_POINTS.AMPERSAND: { + this.returnState = State.ATTRIBUTE_VALUE_UNQUOTED; + this.state = State.CHARACTER_REFERENCE; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._leaveAttrValue(); + this.state = State.DATA; + this.emitCurrentTagToken(); + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + this.currentAttr.value += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.QUOTATION_MARK: + case CODE_POINTS.APOSTROPHE: + case CODE_POINTS.LESS_THAN_SIGN: + case CODE_POINTS.EQUALS_SIGN: + case CODE_POINTS.GRAVE_ACCENT: { + this._err(ERR.unexpectedCharacterInUnquotedAttributeValue); + this.currentAttr.value += String.fromCodePoint(cp); + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInTag); + this._emitEOFToken(); + break; + } + default: { + this.currentAttr.value += String.fromCodePoint(cp); + } + } + } + // After attribute value (quoted) state + //------------------------------------------------------------------ + _stateAfterAttributeValueQuoted(cp) { + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + this._leaveAttrValue(); + this.state = State.BEFORE_ATTRIBUTE_NAME; + break; + } + case CODE_POINTS.SOLIDUS: { + this._leaveAttrValue(); + this.state = State.SELF_CLOSING_START_TAG; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._leaveAttrValue(); + this.state = State.DATA; + this.emitCurrentTagToken(); + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInTag); + this._emitEOFToken(); + break; + } + default: { + this._err(ERR.missingWhitespaceBetweenAttributes); + this.state = State.BEFORE_ATTRIBUTE_NAME; + this._stateBeforeAttributeName(cp); + } + } + } + // Self-closing start tag state + //------------------------------------------------------------------ + _stateSelfClosingStartTag(cp) { + switch (cp) { + case CODE_POINTS.GREATER_THAN_SIGN: { + const token = this.currentToken; + token.selfClosing = true; + this.state = State.DATA; + this.emitCurrentTagToken(); + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInTag); + this._emitEOFToken(); + break; + } + default: { + this._err(ERR.unexpectedSolidusInTag); + this.state = State.BEFORE_ATTRIBUTE_NAME; + this._stateBeforeAttributeName(cp); + } + } + } + // Bogus comment state + //------------------------------------------------------------------ + _stateBogusComment(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.DATA; + this.emitCurrentComment(token); + break; + } + case CODE_POINTS.EOF: { + this.emitCurrentComment(token); + this._emitEOFToken(); + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + token.data += REPLACEMENT_CHARACTER; + break; + } + default: { + token.data += String.fromCodePoint(cp); + } + } + } + // Markup declaration open state + //------------------------------------------------------------------ + _stateMarkupDeclarationOpen(cp) { + if (this._consumeSequenceIfMatch(SEQUENCES.DASH_DASH, true)) { + this._createCommentToken(SEQUENCES.DASH_DASH.length + 1); + this.state = State.COMMENT_START; + } else if (this._consumeSequenceIfMatch(SEQUENCES.DOCTYPE, false)) { + this.currentLocation = this.getCurrentLocation(SEQUENCES.DOCTYPE.length + 1); + this.state = State.DOCTYPE; + } else if (this._consumeSequenceIfMatch(SEQUENCES.CDATA_START, true)) { + if (this.inForeignNode) { + this.state = State.CDATA_SECTION; + } else { + this._err(ERR.cdataInHtmlContent); + this._createCommentToken(SEQUENCES.CDATA_START.length + 1); + this.currentToken.data = "[CDATA["; + this.state = State.BOGUS_COMMENT; + } + } else if (!this._ensureHibernation()) { + this._err(ERR.incorrectlyOpenedComment); + this._createCommentToken(2); + this.state = State.BOGUS_COMMENT; + this._stateBogusComment(cp); + } + } + // Comment start state + //------------------------------------------------------------------ + _stateCommentStart(cp) { + switch (cp) { + case CODE_POINTS.HYPHEN_MINUS: { + this.state = State.COMMENT_START_DASH; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(ERR.abruptClosingOfEmptyComment); + this.state = State.DATA; + const token = this.currentToken; + this.emitCurrentComment(token); + break; + } + default: { + this.state = State.COMMENT; + this._stateComment(cp); + } + } + } + // Comment start dash state + //------------------------------------------------------------------ + _stateCommentStartDash(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.HYPHEN_MINUS: { + this.state = State.COMMENT_END; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(ERR.abruptClosingOfEmptyComment); + this.state = State.DATA; + this.emitCurrentComment(token); + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInComment); + this.emitCurrentComment(token); + this._emitEOFToken(); + break; + } + default: { + token.data += "-"; + this.state = State.COMMENT; + this._stateComment(cp); + } + } + } + // Comment state + //------------------------------------------------------------------ + _stateComment(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.HYPHEN_MINUS: { + this.state = State.COMMENT_END_DASH; + break; + } + case CODE_POINTS.LESS_THAN_SIGN: { + token.data += "<"; + this.state = State.COMMENT_LESS_THAN_SIGN; + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + token.data += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInComment); + this.emitCurrentComment(token); + this._emitEOFToken(); + break; + } + default: { + token.data += String.fromCodePoint(cp); + } + } + } + // Comment less-than sign state + //------------------------------------------------------------------ + _stateCommentLessThanSign(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.EXCLAMATION_MARK: { + token.data += "!"; + this.state = State.COMMENT_LESS_THAN_SIGN_BANG; + break; + } + case CODE_POINTS.LESS_THAN_SIGN: { + token.data += "<"; + break; + } + default: { + this.state = State.COMMENT; + this._stateComment(cp); + } + } + } + // Comment less-than sign bang state + //------------------------------------------------------------------ + _stateCommentLessThanSignBang(cp) { + if (cp === CODE_POINTS.HYPHEN_MINUS) { + this.state = State.COMMENT_LESS_THAN_SIGN_BANG_DASH; + } else { + this.state = State.COMMENT; + this._stateComment(cp); + } + } + // Comment less-than sign bang dash state + //------------------------------------------------------------------ + _stateCommentLessThanSignBangDash(cp) { + if (cp === CODE_POINTS.HYPHEN_MINUS) { + this.state = State.COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH; + } else { + this.state = State.COMMENT_END_DASH; + this._stateCommentEndDash(cp); + } + } + // Comment less-than sign bang dash dash state + //------------------------------------------------------------------ + _stateCommentLessThanSignBangDashDash(cp) { + if (cp !== CODE_POINTS.GREATER_THAN_SIGN && cp !== CODE_POINTS.EOF) { + this._err(ERR.nestedComment); + } + this.state = State.COMMENT_END; + this._stateCommentEnd(cp); + } + // Comment end dash state + //------------------------------------------------------------------ + _stateCommentEndDash(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.HYPHEN_MINUS: { + this.state = State.COMMENT_END; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInComment); + this.emitCurrentComment(token); + this._emitEOFToken(); + break; + } + default: { + token.data += "-"; + this.state = State.COMMENT; + this._stateComment(cp); + } + } + } + // Comment end state + //------------------------------------------------------------------ + _stateCommentEnd(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.DATA; + this.emitCurrentComment(token); + break; + } + case CODE_POINTS.EXCLAMATION_MARK: { + this.state = State.COMMENT_END_BANG; + break; + } + case CODE_POINTS.HYPHEN_MINUS: { + token.data += "-"; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInComment); + this.emitCurrentComment(token); + this._emitEOFToken(); + break; + } + default: { + token.data += "--"; + this.state = State.COMMENT; + this._stateComment(cp); + } + } + } + // Comment end bang state + //------------------------------------------------------------------ + _stateCommentEndBang(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.HYPHEN_MINUS: { + token.data += "--!"; + this.state = State.COMMENT_END_DASH; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(ERR.incorrectlyClosedComment); + this.state = State.DATA; + this.emitCurrentComment(token); + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInComment); + this.emitCurrentComment(token); + this._emitEOFToken(); + break; + } + default: { + token.data += "--!"; + this.state = State.COMMENT; + this._stateComment(cp); + } + } + } + // DOCTYPE state + //------------------------------------------------------------------ + _stateDoctype(cp) { + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + this.state = State.BEFORE_DOCTYPE_NAME; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.BEFORE_DOCTYPE_NAME; + this._stateBeforeDoctypeName(cp); + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInDoctype); + this._createDoctypeToken(null); + const token = this.currentToken; + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(ERR.missingWhitespaceBeforeDoctypeName); + this.state = State.BEFORE_DOCTYPE_NAME; + this._stateBeforeDoctypeName(cp); + } + } + } + // Before DOCTYPE name state + //------------------------------------------------------------------ + _stateBeforeDoctypeName(cp) { + if (isAsciiUpper(cp)) { + this._createDoctypeToken(String.fromCharCode(toAsciiLower(cp))); + this.state = State.DOCTYPE_NAME; + } else + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + this._createDoctypeToken(REPLACEMENT_CHARACTER); + this.state = State.DOCTYPE_NAME; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(ERR.missingDoctypeName); + this._createDoctypeToken(null); + const token = this.currentToken; + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInDoctype); + this._createDoctypeToken(null); + const token = this.currentToken; + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._createDoctypeToken(String.fromCodePoint(cp)); + this.state = State.DOCTYPE_NAME; + } + } + } + // DOCTYPE name state + //------------------------------------------------------------------ + _stateDoctypeName(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + this.state = State.AFTER_DOCTYPE_NAME; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.DATA; + this.emitCurrentDoctype(token); + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + token.name += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + token.name += String.fromCodePoint(isAsciiUpper(cp) ? toAsciiLower(cp) : cp); + } + } + } + // After DOCTYPE name state + //------------------------------------------------------------------ + _stateAfterDoctypeName(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.DATA; + this.emitCurrentDoctype(token); + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + if (this._consumeSequenceIfMatch(SEQUENCES.PUBLIC, false)) { + this.state = State.AFTER_DOCTYPE_PUBLIC_KEYWORD; + } else if (this._consumeSequenceIfMatch(SEQUENCES.SYSTEM, false)) { + this.state = State.AFTER_DOCTYPE_SYSTEM_KEYWORD; + } else if (!this._ensureHibernation()) { + this._err(ERR.invalidCharacterSequenceAfterDoctypeName); + token.forceQuirks = true; + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + } + // After DOCTYPE public keyword state + //------------------------------------------------------------------ + _stateAfterDoctypePublicKeyword(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + this.state = State.BEFORE_DOCTYPE_PUBLIC_IDENTIFIER; + break; + } + case CODE_POINTS.QUOTATION_MARK: { + this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword); + token.publicId = ""; + this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED; + break; + } + case CODE_POINTS.APOSTROPHE: { + this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword); + token.publicId = ""; + this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(ERR.missingDoctypePublicIdentifier); + token.forceQuirks = true; + this.state = State.DATA; + this.emitCurrentDoctype(token); + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier); + token.forceQuirks = true; + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + // Before DOCTYPE public identifier state + //------------------------------------------------------------------ + _stateBeforeDoctypePublicIdentifier(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + break; + } + case CODE_POINTS.QUOTATION_MARK: { + token.publicId = ""; + this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED; + break; + } + case CODE_POINTS.APOSTROPHE: { + token.publicId = ""; + this.state = State.DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(ERR.missingDoctypePublicIdentifier); + token.forceQuirks = true; + this.state = State.DATA; + this.emitCurrentDoctype(token); + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier); + token.forceQuirks = true; + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + // DOCTYPE public identifier (double-quoted) state + //------------------------------------------------------------------ + _stateDoctypePublicIdentifierDoubleQuoted(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.QUOTATION_MARK: { + this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER; + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + token.publicId += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(ERR.abruptDoctypePublicIdentifier); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + token.publicId += String.fromCodePoint(cp); + } + } + } + // DOCTYPE public identifier (single-quoted) state + //------------------------------------------------------------------ + _stateDoctypePublicIdentifierSingleQuoted(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.APOSTROPHE: { + this.state = State.AFTER_DOCTYPE_PUBLIC_IDENTIFIER; + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + token.publicId += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(ERR.abruptDoctypePublicIdentifier); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + token.publicId += String.fromCodePoint(cp); + } + } + } + // After DOCTYPE public identifier state + //------------------------------------------------------------------ + _stateAfterDoctypePublicIdentifier(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + this.state = State.BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.DATA; + this.emitCurrentDoctype(token); + break; + } + case CODE_POINTS.QUOTATION_MARK: { + this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers); + token.systemId = ""; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED; + break; + } + case CODE_POINTS.APOSTROPHE: { + this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers); + token.systemId = ""; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier); + token.forceQuirks = true; + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + // Between DOCTYPE public and system identifiers state + //------------------------------------------------------------------ + _stateBetweenDoctypePublicAndSystemIdentifiers(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.QUOTATION_MARK: { + token.systemId = ""; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED; + break; + } + case CODE_POINTS.APOSTROPHE: { + token.systemId = ""; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier); + token.forceQuirks = true; + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + // After DOCTYPE system keyword state + //------------------------------------------------------------------ + _stateAfterDoctypeSystemKeyword(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + this.state = State.BEFORE_DOCTYPE_SYSTEM_IDENTIFIER; + break; + } + case CODE_POINTS.QUOTATION_MARK: { + this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword); + token.systemId = ""; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED; + break; + } + case CODE_POINTS.APOSTROPHE: { + this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword); + token.systemId = ""; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(ERR.missingDoctypeSystemIdentifier); + token.forceQuirks = true; + this.state = State.DATA; + this.emitCurrentDoctype(token); + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier); + token.forceQuirks = true; + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + // Before DOCTYPE system identifier state + //------------------------------------------------------------------ + _stateBeforeDoctypeSystemIdentifier(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + break; + } + case CODE_POINTS.QUOTATION_MARK: { + token.systemId = ""; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED; + break; + } + case CODE_POINTS.APOSTROPHE: { + token.systemId = ""; + this.state = State.DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(ERR.missingDoctypeSystemIdentifier); + token.forceQuirks = true; + this.state = State.DATA; + this.emitCurrentDoctype(token); + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier); + token.forceQuirks = true; + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + // DOCTYPE system identifier (double-quoted) state + //------------------------------------------------------------------ + _stateDoctypeSystemIdentifierDoubleQuoted(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.QUOTATION_MARK: { + this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER; + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + token.systemId += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(ERR.abruptDoctypeSystemIdentifier); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + token.systemId += String.fromCodePoint(cp); + } + } + } + // DOCTYPE system identifier (single-quoted) state + //------------------------------------------------------------------ + _stateDoctypeSystemIdentifierSingleQuoted(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.APOSTROPHE: { + this.state = State.AFTER_DOCTYPE_SYSTEM_IDENTIFIER; + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + token.systemId += REPLACEMENT_CHARACTER; + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this._err(ERR.abruptDoctypeSystemIdentifier); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + token.systemId += String.fromCodePoint(cp); + } + } + } + // After DOCTYPE system identifier state + //------------------------------------------------------------------ + _stateAfterDoctypeSystemIdentifier(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.SPACE: + case CODE_POINTS.LINE_FEED: + case CODE_POINTS.TABULATION: + case CODE_POINTS.FORM_FEED: { + break; + } + case CODE_POINTS.GREATER_THAN_SIGN: { + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInDoctype); + token.forceQuirks = true; + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: { + this._err(ERR.unexpectedCharacterAfterDoctypeSystemIdentifier); + this.state = State.BOGUS_DOCTYPE; + this._stateBogusDoctype(cp); + } + } + } + // Bogus DOCTYPE state + //------------------------------------------------------------------ + _stateBogusDoctype(cp) { + const token = this.currentToken; + switch (cp) { + case CODE_POINTS.GREATER_THAN_SIGN: { + this.emitCurrentDoctype(token); + this.state = State.DATA; + break; + } + case CODE_POINTS.NULL: { + this._err(ERR.unexpectedNullCharacter); + break; + } + case CODE_POINTS.EOF: { + this.emitCurrentDoctype(token); + this._emitEOFToken(); + break; + } + default: + } + } + // CDATA section state + //------------------------------------------------------------------ + _stateCdataSection(cp) { + switch (cp) { + case CODE_POINTS.RIGHT_SQUARE_BRACKET: { + this.state = State.CDATA_SECTION_BRACKET; + break; + } + case CODE_POINTS.EOF: { + this._err(ERR.eofInCdata); + this._emitEOFToken(); + break; + } + default: { + this._emitCodePoint(cp); + } + } + } + // CDATA section bracket state + //------------------------------------------------------------------ + _stateCdataSectionBracket(cp) { + if (cp === CODE_POINTS.RIGHT_SQUARE_BRACKET) { + this.state = State.CDATA_SECTION_END; + } else { + this._emitChars("]"); + this.state = State.CDATA_SECTION; + this._stateCdataSection(cp); + } + } + // CDATA section end state + //------------------------------------------------------------------ + _stateCdataSectionEnd(cp) { + switch (cp) { + case CODE_POINTS.GREATER_THAN_SIGN: { + this.state = State.DATA; + break; + } + case CODE_POINTS.RIGHT_SQUARE_BRACKET: { + this._emitChars("]"); + break; + } + default: { + this._emitChars("]]"); + this.state = State.CDATA_SECTION; + this._stateCdataSection(cp); + } + } + } + // Character reference state + //------------------------------------------------------------------ + _stateCharacterReference(cp) { + if (cp === CODE_POINTS.NUMBER_SIGN) { + this.state = State.NUMERIC_CHARACTER_REFERENCE; + } else if (isAsciiAlphaNumeric(cp)) { + this.state = State.NAMED_CHARACTER_REFERENCE; + this._stateNamedCharacterReference(cp); + } else { + this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND); + this._reconsumeInState(this.returnState, cp); + } + } + // Named character reference state + //------------------------------------------------------------------ + _stateNamedCharacterReference(cp) { + const matchResult = this._matchNamedCharacterReference(cp); + if (this._ensureHibernation()) { + } else if (matchResult) { + for (let i = 0; i < matchResult.length; i++) { + this._flushCodePointConsumedAsCharacterReference(matchResult[i]); + } + this.state = this.returnState; + } else { + this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND); + this.state = State.AMBIGUOUS_AMPERSAND; + } + } + // Ambiguos ampersand state + //------------------------------------------------------------------ + _stateAmbiguousAmpersand(cp) { + if (isAsciiAlphaNumeric(cp)) { + this._flushCodePointConsumedAsCharacterReference(cp); + } else { + if (cp === CODE_POINTS.SEMICOLON) { + this._err(ERR.unknownNamedCharacterReference); + } + this._reconsumeInState(this.returnState, cp); + } + } + // Numeric character reference state + //------------------------------------------------------------------ + _stateNumericCharacterReference(cp) { + this.charRefCode = 0; + if (cp === CODE_POINTS.LATIN_SMALL_X || cp === CODE_POINTS.LATIN_CAPITAL_X) { + this.state = State.HEXADEMICAL_CHARACTER_REFERENCE_START; + } else if (isAsciiDigit(cp)) { + this.state = State.DECIMAL_CHARACTER_REFERENCE; + this._stateDecimalCharacterReference(cp); + } else { + this._err(ERR.absenceOfDigitsInNumericCharacterReference); + this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND); + this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.NUMBER_SIGN); + this._reconsumeInState(this.returnState, cp); + } + } + // Hexademical character reference start state + //------------------------------------------------------------------ + _stateHexademicalCharacterReferenceStart(cp) { + if (isAsciiHexDigit(cp)) { + this.state = State.HEXADEMICAL_CHARACTER_REFERENCE; + this._stateHexademicalCharacterReference(cp); + } else { + this._err(ERR.absenceOfDigitsInNumericCharacterReference); + this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.AMPERSAND); + this._flushCodePointConsumedAsCharacterReference(CODE_POINTS.NUMBER_SIGN); + this._unconsume(2); + this.state = this.returnState; + } + } + // Hexademical character reference state + //------------------------------------------------------------------ + _stateHexademicalCharacterReference(cp) { + if (isAsciiUpperHexDigit(cp)) { + this.charRefCode = this.charRefCode * 16 + cp - 55; + } else if (isAsciiLowerHexDigit(cp)) { + this.charRefCode = this.charRefCode * 16 + cp - 87; + } else if (isAsciiDigit(cp)) { + this.charRefCode = this.charRefCode * 16 + cp - 48; + } else if (cp === CODE_POINTS.SEMICOLON) { + this.state = State.NUMERIC_CHARACTER_REFERENCE_END; + } else { + this._err(ERR.missingSemicolonAfterCharacterReference); + this.state = State.NUMERIC_CHARACTER_REFERENCE_END; + this._stateNumericCharacterReferenceEnd(cp); + } + } + // Decimal character reference state + //------------------------------------------------------------------ + _stateDecimalCharacterReference(cp) { + if (isAsciiDigit(cp)) { + this.charRefCode = this.charRefCode * 10 + cp - 48; + } else if (cp === CODE_POINTS.SEMICOLON) { + this.state = State.NUMERIC_CHARACTER_REFERENCE_END; + } else { + this._err(ERR.missingSemicolonAfterCharacterReference); + this.state = State.NUMERIC_CHARACTER_REFERENCE_END; + this._stateNumericCharacterReferenceEnd(cp); + } + } + // Numeric character reference end state + //------------------------------------------------------------------ + _stateNumericCharacterReferenceEnd(cp) { + if (this.charRefCode === CODE_POINTS.NULL) { + this._err(ERR.nullCharacterReference); + this.charRefCode = CODE_POINTS.REPLACEMENT_CHARACTER; + } else if (this.charRefCode > 1114111) { + this._err(ERR.characterReferenceOutsideUnicodeRange); + this.charRefCode = CODE_POINTS.REPLACEMENT_CHARACTER; + } else if (isSurrogate(this.charRefCode)) { + this._err(ERR.surrogateCharacterReference); + this.charRefCode = CODE_POINTS.REPLACEMENT_CHARACTER; + } else if (isUndefinedCodePoint(this.charRefCode)) { + this._err(ERR.noncharacterCharacterReference); + } else if (isControlCodePoint(this.charRefCode) || this.charRefCode === CODE_POINTS.CARRIAGE_RETURN) { + this._err(ERR.controlCharacterReference); + const replacement = C1_CONTROLS_REFERENCE_REPLACEMENTS.get(this.charRefCode); + if (replacement !== void 0) { + this.charRefCode = replacement; + } + } + this._flushCodePointConsumedAsCharacterReference(this.charRefCode); + this._reconsumeInState(this.returnState, cp); + } + }; + + // node_modules/parse5/dist/parser/open-element-stack.js + var IMPLICIT_END_TAG_REQUIRED = /* @__PURE__ */ new Set([TAG_ID.DD, TAG_ID.DT, TAG_ID.LI, TAG_ID.OPTGROUP, TAG_ID.OPTION, TAG_ID.P, TAG_ID.RB, TAG_ID.RP, TAG_ID.RT, TAG_ID.RTC]); + var IMPLICIT_END_TAG_REQUIRED_THOROUGHLY = /* @__PURE__ */ new Set([ + ...IMPLICIT_END_TAG_REQUIRED, + TAG_ID.CAPTION, + TAG_ID.COLGROUP, + TAG_ID.TBODY, + TAG_ID.TD, + TAG_ID.TFOOT, + TAG_ID.TH, + TAG_ID.THEAD, + TAG_ID.TR + ]); + var SCOPING_ELEMENT_NS = /* @__PURE__ */ new Map([ + [TAG_ID.APPLET, NS.HTML], + [TAG_ID.CAPTION, NS.HTML], + [TAG_ID.HTML, NS.HTML], + [TAG_ID.MARQUEE, NS.HTML], + [TAG_ID.OBJECT, NS.HTML], + [TAG_ID.TABLE, NS.HTML], + [TAG_ID.TD, NS.HTML], + [TAG_ID.TEMPLATE, NS.HTML], + [TAG_ID.TH, NS.HTML], + [TAG_ID.ANNOTATION_XML, NS.MATHML], + [TAG_ID.MI, NS.MATHML], + [TAG_ID.MN, NS.MATHML], + [TAG_ID.MO, NS.MATHML], + [TAG_ID.MS, NS.MATHML], + [TAG_ID.MTEXT, NS.MATHML], + [TAG_ID.DESC, NS.SVG], + [TAG_ID.FOREIGN_OBJECT, NS.SVG], + [TAG_ID.TITLE, NS.SVG] + ]); + var NAMED_HEADERS = [TAG_ID.H1, TAG_ID.H2, TAG_ID.H3, TAG_ID.H4, TAG_ID.H5, TAG_ID.H6]; + var TABLE_ROW_CONTEXT = [TAG_ID.TR, TAG_ID.TEMPLATE, TAG_ID.HTML]; + var TABLE_BODY_CONTEXT = [TAG_ID.TBODY, TAG_ID.TFOOT, TAG_ID.THEAD, TAG_ID.TEMPLATE, TAG_ID.HTML]; + var TABLE_CONTEXT = [TAG_ID.TABLE, TAG_ID.TEMPLATE, TAG_ID.HTML]; + var TABLE_CELLS = [TAG_ID.TD, TAG_ID.TH]; + var OpenElementStack = class { + get currentTmplContentOrNode() { + return this._isInTemplate() ? this.treeAdapter.getTemplateContent(this.current) : this.current; + } + constructor(document, treeAdapter, handler) { + this.treeAdapter = treeAdapter; + this.handler = handler; + this.items = []; + this.tagIDs = []; + this.stackTop = -1; + this.tmplCount = 0; + this.currentTagId = TAG_ID.UNKNOWN; + this.current = document; + } + //Index of element + _indexOf(element) { + return this.items.lastIndexOf(element, this.stackTop); + } + //Update current element + _isInTemplate() { + return this.currentTagId === TAG_ID.TEMPLATE && this.treeAdapter.getNamespaceURI(this.current) === NS.HTML; + } + _updateCurrentElement() { + this.current = this.items[this.stackTop]; + this.currentTagId = this.tagIDs[this.stackTop]; + } + //Mutations + push(element, tagID) { + this.stackTop++; + this.items[this.stackTop] = element; + this.current = element; + this.tagIDs[this.stackTop] = tagID; + this.currentTagId = tagID; + if (this._isInTemplate()) { + this.tmplCount++; + } + this.handler.onItemPush(element, tagID, true); + } + pop() { + const popped = this.current; + if (this.tmplCount > 0 && this._isInTemplate()) { + this.tmplCount--; + } + this.stackTop--; + this._updateCurrentElement(); + this.handler.onItemPop(popped, true); + } + replace(oldElement, newElement) { + const idx = this._indexOf(oldElement); + this.items[idx] = newElement; + if (idx === this.stackTop) { + this.current = newElement; + } + } + insertAfter(referenceElement, newElement, newElementID) { + const insertionIdx = this._indexOf(referenceElement) + 1; + this.items.splice(insertionIdx, 0, newElement); + this.tagIDs.splice(insertionIdx, 0, newElementID); + this.stackTop++; + if (insertionIdx === this.stackTop) { + this._updateCurrentElement(); + } + this.handler.onItemPush(this.current, this.currentTagId, insertionIdx === this.stackTop); + } + popUntilTagNamePopped(tagName) { + let targetIdx = this.stackTop + 1; + do { + targetIdx = this.tagIDs.lastIndexOf(tagName, targetIdx - 1); + } while (targetIdx > 0 && this.treeAdapter.getNamespaceURI(this.items[targetIdx]) !== NS.HTML); + this.shortenToLength(targetIdx < 0 ? 0 : targetIdx); + } + shortenToLength(idx) { + while (this.stackTop >= idx) { + const popped = this.current; + if (this.tmplCount > 0 && this._isInTemplate()) { + this.tmplCount -= 1; + } + this.stackTop--; + this._updateCurrentElement(); + this.handler.onItemPop(popped, this.stackTop < idx); + } + } + popUntilElementPopped(element) { + const idx = this._indexOf(element); + this.shortenToLength(idx < 0 ? 0 : idx); + } + popUntilPopped(tagNames, targetNS) { + const idx = this._indexOfTagNames(tagNames, targetNS); + this.shortenToLength(idx < 0 ? 0 : idx); + } + popUntilNumberedHeaderPopped() { + this.popUntilPopped(NAMED_HEADERS, NS.HTML); + } + popUntilTableCellPopped() { + this.popUntilPopped(TABLE_CELLS, NS.HTML); + } + popAllUpToHtmlElement() { + this.tmplCount = 0; + this.shortenToLength(1); + } + _indexOfTagNames(tagNames, namespace) { + for (let i = this.stackTop; i >= 0; i--) { + if (tagNames.includes(this.tagIDs[i]) && this.treeAdapter.getNamespaceURI(this.items[i]) === namespace) { + return i; + } + } + return -1; + } + clearBackTo(tagNames, targetNS) { + const idx = this._indexOfTagNames(tagNames, targetNS); + this.shortenToLength(idx + 1); + } + clearBackToTableContext() { + this.clearBackTo(TABLE_CONTEXT, NS.HTML); + } + clearBackToTableBodyContext() { + this.clearBackTo(TABLE_BODY_CONTEXT, NS.HTML); + } + clearBackToTableRowContext() { + this.clearBackTo(TABLE_ROW_CONTEXT, NS.HTML); + } + remove(element) { + const idx = this._indexOf(element); + if (idx >= 0) { + if (idx === this.stackTop) { + this.pop(); + } else { + this.items.splice(idx, 1); + this.tagIDs.splice(idx, 1); + this.stackTop--; + this._updateCurrentElement(); + this.handler.onItemPop(element, false); + } + } + } + //Search + tryPeekProperlyNestedBodyElement() { + return this.stackTop >= 1 && this.tagIDs[1] === TAG_ID.BODY ? this.items[1] : null; + } + contains(element) { + return this._indexOf(element) > -1; + } + getCommonAncestor(element) { + const elementIdx = this._indexOf(element) - 1; + return elementIdx >= 0 ? this.items[elementIdx] : null; + } + isRootHtmlElementCurrent() { + return this.stackTop === 0 && this.tagIDs[0] === TAG_ID.HTML; + } + //Element in scope + hasInScope(tagName) { + for (let i = this.stackTop; i >= 0; i--) { + const tn = this.tagIDs[i]; + const ns = this.treeAdapter.getNamespaceURI(this.items[i]); + if (tn === tagName && ns === NS.HTML) { + return true; + } + if (SCOPING_ELEMENT_NS.get(tn) === ns) { + return false; + } + } + return true; + } + hasNumberedHeaderInScope() { + for (let i = this.stackTop; i >= 0; i--) { + const tn = this.tagIDs[i]; + const ns = this.treeAdapter.getNamespaceURI(this.items[i]); + if (isNumberedHeader(tn) && ns === NS.HTML) { + return true; + } + if (SCOPING_ELEMENT_NS.get(tn) === ns) { + return false; + } + } + return true; + } + hasInListItemScope(tagName) { + for (let i = this.stackTop; i >= 0; i--) { + const tn = this.tagIDs[i]; + const ns = this.treeAdapter.getNamespaceURI(this.items[i]); + if (tn === tagName && ns === NS.HTML) { + return true; + } + if ((tn === TAG_ID.UL || tn === TAG_ID.OL) && ns === NS.HTML || SCOPING_ELEMENT_NS.get(tn) === ns) { + return false; + } + } + return true; + } + hasInButtonScope(tagName) { + for (let i = this.stackTop; i >= 0; i--) { + const tn = this.tagIDs[i]; + const ns = this.treeAdapter.getNamespaceURI(this.items[i]); + if (tn === tagName && ns === NS.HTML) { + return true; + } + if (tn === TAG_ID.BUTTON && ns === NS.HTML || SCOPING_ELEMENT_NS.get(tn) === ns) { + return false; + } + } + return true; + } + hasInTableScope(tagName) { + for (let i = this.stackTop; i >= 0; i--) { + const tn = this.tagIDs[i]; + const ns = this.treeAdapter.getNamespaceURI(this.items[i]); + if (ns !== NS.HTML) { + continue; + } + if (tn === tagName) { + return true; + } + if (tn === TAG_ID.TABLE || tn === TAG_ID.TEMPLATE || tn === TAG_ID.HTML) { + return false; + } + } + return true; + } + hasTableBodyContextInTableScope() { + for (let i = this.stackTop; i >= 0; i--) { + const tn = this.tagIDs[i]; + const ns = this.treeAdapter.getNamespaceURI(this.items[i]); + if (ns !== NS.HTML) { + continue; + } + if (tn === TAG_ID.TBODY || tn === TAG_ID.THEAD || tn === TAG_ID.TFOOT) { + return true; + } + if (tn === TAG_ID.TABLE || tn === TAG_ID.HTML) { + return false; + } + } + return true; + } + hasInSelectScope(tagName) { + for (let i = this.stackTop; i >= 0; i--) { + const tn = this.tagIDs[i]; + const ns = this.treeAdapter.getNamespaceURI(this.items[i]); + if (ns !== NS.HTML) { + continue; + } + if (tn === tagName) { + return true; + } + if (tn !== TAG_ID.OPTION && tn !== TAG_ID.OPTGROUP) { + return false; + } + } + return true; + } + //Implied end tags + generateImpliedEndTags() { + while (IMPLICIT_END_TAG_REQUIRED.has(this.currentTagId)) { + this.pop(); + } + } + generateImpliedEndTagsThoroughly() { + while (IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) { + this.pop(); + } + } + generateImpliedEndTagsWithExclusion(exclusionId) { + while (this.currentTagId !== exclusionId && IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) { + this.pop(); + } + } + }; + + // node_modules/parse5/dist/parser/formatting-element-list.js + var NOAH_ARK_CAPACITY = 3; + var EntryType; + (function(EntryType2) { + EntryType2[EntryType2["Marker"] = 0] = "Marker"; + EntryType2[EntryType2["Element"] = 1] = "Element"; + })(EntryType = EntryType || (EntryType = {})); + var MARKER = { type: EntryType.Marker }; + var FormattingElementList = class { + constructor(treeAdapter) { + this.treeAdapter = treeAdapter; + this.entries = []; + 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, neAttrs) { + const candidates = []; + const neAttrsLength = neAttrs.length; + const neTagName = this.treeAdapter.getTagName(newElement); + const neNamespaceURI = this.treeAdapter.getNamespaceURI(newElement); + for (let i = 0; i < this.entries.length; i++) { + const entry = this.entries[i]; + if (entry.type === EntryType.Marker) { + break; + } + const { element } = entry; + if (this.treeAdapter.getTagName(element) === neTagName && this.treeAdapter.getNamespaceURI(element) === neNamespaceURI) { + const elementAttrs = this.treeAdapter.getAttrList(element); + if (elementAttrs.length === neAttrsLength) { + candidates.push({ idx: i, attrs: elementAttrs }); + } + } + } + return candidates; + } + _ensureNoahArkCondition(newElement) { + if (this.entries.length < NOAH_ARK_CAPACITY) + return; + const neAttrs = this.treeAdapter.getAttrList(newElement); + const candidates = this._getNoahArkConditionCandidates(newElement, neAttrs); + if (candidates.length < NOAH_ARK_CAPACITY) + return; + const neAttrsMap = new Map(neAttrs.map((neAttr) => [neAttr.name, neAttr.value])); + let validCandidates = 0; + for (let i = 0; i < candidates.length; i++) { + const candidate = candidates[i]; + if (candidate.attrs.every((cAttr) => neAttrsMap.get(cAttr.name) === cAttr.value)) { + validCandidates += 1; + if (validCandidates >= NOAH_ARK_CAPACITY) { + this.entries.splice(candidate.idx, 1); + } + } + } + } + //Mutations + insertMarker() { + this.entries.unshift(MARKER); + } + pushElement(element, token) { + this._ensureNoahArkCondition(element); + this.entries.unshift({ + type: EntryType.Element, + element, + token + }); + } + insertElementAfterBookmark(element, token) { + const bookmarkIdx = this.entries.indexOf(this.bookmark); + this.entries.splice(bookmarkIdx, 0, { + type: EntryType.Element, + element, + token + }); + } + removeEntry(entry) { + const entryIndex = this.entries.indexOf(entry); + if (entryIndex >= 0) { + this.entries.splice(entryIndex, 1); + } + } + /** + * Clears the list of formatting elements up to the last marker. + * + * @see https://html.spec.whatwg.org/multipage/parsing.html#clear-the-list-of-active-formatting-elements-up-to-the-last-marker + */ + clearToLastMarker() { + const markerIdx = this.entries.indexOf(MARKER); + if (markerIdx >= 0) { + this.entries.splice(0, markerIdx + 1); + } else { + this.entries.length = 0; + } + } + //Search + getElementEntryInScopeWithTagName(tagName) { + const entry = this.entries.find((entry2) => entry2.type === EntryType.Marker || this.treeAdapter.getTagName(entry2.element) === tagName); + return entry && entry.type === EntryType.Element ? entry : null; + } + getElementEntry(element) { + return this.entries.find((entry) => entry.type === EntryType.Element && entry.element === element); + } + }; + + // node_modules/parse5/dist/tree-adapters/default.js + function createTextNode(value) { + return { + nodeName: "#text", + value, + parentNode: null + }; + } + var defaultTreeAdapter = { + //Node construction + createDocument() { + return { + nodeName: "#document", + mode: DOCUMENT_MODE.NO_QUIRKS, + childNodes: [] + }; + }, + createDocumentFragment() { + return { + nodeName: "#document-fragment", + childNodes: [] + }; + }, + createElement(tagName, namespaceURI, attrs) { + return { + nodeName: tagName, + tagName, + attrs, + namespaceURI, + childNodes: [], + parentNode: null + }; + }, + createCommentNode(data) { + return { + nodeName: "#comment", + data, + parentNode: null + }; + }, + //Tree mutation + appendChild(parentNode, newNode) { + parentNode.childNodes.push(newNode); + newNode.parentNode = parentNode; + }, + insertBefore(parentNode, newNode, referenceNode) { + const insertionIdx = parentNode.childNodes.indexOf(referenceNode); + parentNode.childNodes.splice(insertionIdx, 0, newNode); + newNode.parentNode = parentNode; + }, + setTemplateContent(templateElement, contentElement) { + templateElement.content = contentElement; + }, + getTemplateContent(templateElement) { + return templateElement.content; + }, + setDocumentType(document, name42, publicId, systemId) { + const doctypeNode = document.childNodes.find((node) => node.nodeName === "#documentType"); + if (doctypeNode) { + doctypeNode.name = name42; + doctypeNode.publicId = publicId; + doctypeNode.systemId = systemId; + } else { + const node = { + nodeName: "#documentType", + name: name42, + publicId, + systemId, + parentNode: null + }; + defaultTreeAdapter.appendChild(document, node); + } + }, + setDocumentMode(document, mode) { + document.mode = mode; + }, + getDocumentMode(document) { + return document.mode; + }, + detachNode(node) { + if (node.parentNode) { + const idx = node.parentNode.childNodes.indexOf(node); + node.parentNode.childNodes.splice(idx, 1); + node.parentNode = null; + } + }, + insertText(parentNode, text2) { + if (parentNode.childNodes.length > 0) { + const prevNode = parentNode.childNodes[parentNode.childNodes.length - 1]; + if (defaultTreeAdapter.isTextNode(prevNode)) { + prevNode.value += text2; + return; + } + } + defaultTreeAdapter.appendChild(parentNode, createTextNode(text2)); + }, + insertTextBefore(parentNode, text2, referenceNode) { + const prevNode = parentNode.childNodes[parentNode.childNodes.indexOf(referenceNode) - 1]; + if (prevNode && defaultTreeAdapter.isTextNode(prevNode)) { + prevNode.value += text2; + } else { + defaultTreeAdapter.insertBefore(parentNode, createTextNode(text2), referenceNode); + } + }, + adoptAttributes(recipient, attrs) { + const recipientAttrsMap = new Set(recipient.attrs.map((attr) => attr.name)); + for (let j = 0; j < attrs.length; j++) { + if (!recipientAttrsMap.has(attrs[j].name)) { + recipient.attrs.push(attrs[j]); + } + } + }, + //Tree traversing + getFirstChild(node) { + return node.childNodes[0]; + }, + getChildNodes(node) { + return node.childNodes; + }, + getParentNode(node) { + return node.parentNode; + }, + getAttrList(element) { + return element.attrs; + }, + //Node data + getTagName(element) { + return element.tagName; + }, + getNamespaceURI(element) { + return element.namespaceURI; + }, + getTextNodeContent(textNode) { + return textNode.value; + }, + getCommentNodeContent(commentNode) { + return commentNode.data; + }, + getDocumentTypeNodeName(doctypeNode) { + return doctypeNode.name; + }, + getDocumentTypeNodePublicId(doctypeNode) { + return doctypeNode.publicId; + }, + getDocumentTypeNodeSystemId(doctypeNode) { + return doctypeNode.systemId; + }, + //Node types + isTextNode(node) { + return node.nodeName === "#text"; + }, + isCommentNode(node) { + return node.nodeName === "#comment"; + }, + isDocumentTypeNode(node) { + return node.nodeName === "#documentType"; + }, + isElementNode(node) { + return Object.prototype.hasOwnProperty.call(node, "tagName"); + }, + // Source code location + setNodeSourceCodeLocation(node, location) { + node.sourceCodeLocation = location; + }, + getNodeSourceCodeLocation(node) { + return node.sourceCodeLocation; + }, + updateNodeSourceCodeLocation(node, endLocation) { + node.sourceCodeLocation = { ...node.sourceCodeLocation, ...endLocation }; + } + }; + + // node_modules/parse5/dist/common/doctype.js + var VALID_DOCTYPE_NAME = "html"; + var VALID_SYSTEM_ID = "about:legacy-compat"; + var QUIRKS_MODE_SYSTEM_ID = "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd"; + var 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//" + ]; + var QUIRKS_MODE_NO_SYSTEM_ID_PUBLIC_ID_PREFIXES = [ + ...QUIRKS_MODE_PUBLIC_ID_PREFIXES, + "-//w3c//dtd html 4.01 frameset//", + "-//w3c//dtd html 4.01 transitional//" + ]; + var QUIRKS_MODE_PUBLIC_IDS = /* @__PURE__ */ new Set([ + "-//w3o//dtd w3 html strict 3.0//en//", + "-/w3c/dtd html 4.0 transitional/en", + "html" + ]); + var LIMITED_QUIRKS_PUBLIC_ID_PREFIXES = ["-//w3c//dtd xhtml 1.0 frameset//", "-//w3c//dtd xhtml 1.0 transitional//"]; + var LIMITED_QUIRKS_WITH_SYSTEM_ID_PUBLIC_ID_PREFIXES = [ + ...LIMITED_QUIRKS_PUBLIC_ID_PREFIXES, + "-//w3c//dtd html 4.01 frameset//", + "-//w3c//dtd html 4.01 transitional//" + ]; + function hasPrefix(publicId, prefixes) { + return prefixes.some((prefix) => publicId.startsWith(prefix)); + } + function isConforming(token) { + return token.name === VALID_DOCTYPE_NAME && token.publicId === null && (token.systemId === null || token.systemId === VALID_SYSTEM_ID); + } + function getDocumentMode(token) { + if (token.name !== VALID_DOCTYPE_NAME) { + return DOCUMENT_MODE.QUIRKS; + } + const { systemId } = token; + if (systemId && systemId.toLowerCase() === QUIRKS_MODE_SYSTEM_ID) { + return DOCUMENT_MODE.QUIRKS; + } + let { publicId } = token; + if (publicId !== null) { + publicId = publicId.toLowerCase(); + if (QUIRKS_MODE_PUBLIC_IDS.has(publicId)) { + 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; + } + + // node_modules/parse5/dist/common/foreign-content.js + var MIME_TYPES = { + TEXT_HTML: "text/html", + APPLICATION_XML: "application/xhtml+xml" + }; + var DEFINITION_URL_ATTR = "definitionurl"; + var ADJUSTED_DEFINITION_URL_ATTR = "definitionURL"; + var SVG_ATTRS_ADJUSTMENT_MAP = new Map([ + "attributeName", + "attributeType", + "baseFrequency", + "baseProfile", + "calcMode", + "clipPathUnits", + "diffuseConstant", + "edgeMode", + "filterUnits", + "glyphRef", + "gradientTransform", + "gradientUnits", + "kernelMatrix", + "kernelUnitLength", + "keyPoints", + "keySplines", + "keyTimes", + "lengthAdjust", + "limitingConeAngle", + "markerHeight", + "markerUnits", + "markerWidth", + "maskContentUnits", + "maskUnits", + "numOctaves", + "pathLength", + "patternContentUnits", + "patternTransform", + "patternUnits", + "pointsAtX", + "pointsAtY", + "pointsAtZ", + "preserveAlpha", + "preserveAspectRatio", + "primitiveUnits", + "refX", + "refY", + "repeatCount", + "repeatDur", + "requiredExtensions", + "requiredFeatures", + "specularConstant", + "specularExponent", + "spreadMethod", + "startOffset", + "stdDeviation", + "stitchTiles", + "surfaceScale", + "systemLanguage", + "tableValues", + "targetX", + "targetY", + "textLength", + "viewBox", + "viewTarget", + "xChannelSelector", + "yChannelSelector", + "zoomAndPan" + ].map((attr) => [attr.toLowerCase(), attr])); + var XML_ATTRS_ADJUSTMENT_MAP = /* @__PURE__ */ new Map([ + ["xlink:actuate", { prefix: "xlink", name: "actuate", namespace: NS.XLINK }], + ["xlink:arcrole", { prefix: "xlink", name: "arcrole", namespace: NS.XLINK }], + ["xlink:href", { prefix: "xlink", name: "href", namespace: NS.XLINK }], + ["xlink:role", { prefix: "xlink", name: "role", namespace: NS.XLINK }], + ["xlink:show", { prefix: "xlink", name: "show", namespace: NS.XLINK }], + ["xlink:title", { prefix: "xlink", name: "title", namespace: NS.XLINK }], + ["xlink:type", { prefix: "xlink", name: "type", namespace: NS.XLINK }], + ["xml:base", { prefix: "xml", name: "base", namespace: NS.XML }], + ["xml:lang", { prefix: "xml", name: "lang", namespace: NS.XML }], + ["xml:space", { prefix: "xml", name: "space", namespace: NS.XML }], + ["xmlns", { prefix: "", name: "xmlns", namespace: NS.XMLNS }], + ["xmlns:xlink", { prefix: "xmlns", name: "xlink", namespace: NS.XMLNS }] + ]); + var SVG_TAG_NAMES_ADJUSTMENT_MAP = new Map([ + "altGlyph", + "altGlyphDef", + "altGlyphItem", + "animateColor", + "animateMotion", + "animateTransform", + "clipPath", + "feBlend", + "feColorMatrix", + "feComponentTransfer", + "feComposite", + "feConvolveMatrix", + "feDiffuseLighting", + "feDisplacementMap", + "feDistantLight", + "feFlood", + "feFuncA", + "feFuncB", + "feFuncG", + "feFuncR", + "feGaussianBlur", + "feImage", + "feMerge", + "feMergeNode", + "feMorphology", + "feOffset", + "fePointLight", + "feSpecularLighting", + "feSpotLight", + "feTile", + "feTurbulence", + "foreignObject", + "glyphRef", + "linearGradient", + "radialGradient", + "textPath" + ].map((tn) => [tn.toLowerCase(), tn])); + var EXITS_FOREIGN_CONTENT = /* @__PURE__ */ new Set([ + TAG_ID.B, + TAG_ID.BIG, + TAG_ID.BLOCKQUOTE, + TAG_ID.BODY, + TAG_ID.BR, + TAG_ID.CENTER, + TAG_ID.CODE, + TAG_ID.DD, + TAG_ID.DIV, + TAG_ID.DL, + TAG_ID.DT, + TAG_ID.EM, + TAG_ID.EMBED, + TAG_ID.H1, + TAG_ID.H2, + TAG_ID.H3, + TAG_ID.H4, + TAG_ID.H5, + TAG_ID.H6, + TAG_ID.HEAD, + TAG_ID.HR, + TAG_ID.I, + TAG_ID.IMG, + TAG_ID.LI, + TAG_ID.LISTING, + TAG_ID.MENU, + TAG_ID.META, + TAG_ID.NOBR, + TAG_ID.OL, + TAG_ID.P, + TAG_ID.PRE, + TAG_ID.RUBY, + TAG_ID.S, + TAG_ID.SMALL, + TAG_ID.SPAN, + TAG_ID.STRONG, + TAG_ID.STRIKE, + TAG_ID.SUB, + TAG_ID.SUP, + TAG_ID.TABLE, + TAG_ID.TT, + TAG_ID.U, + TAG_ID.UL, + TAG_ID.VAR + ]); + function causesExit(startTagToken) { + const tn = startTagToken.tagID; + const isFontWithAttrs = tn === TAG_ID.FONT && startTagToken.attrs.some(({ name: name42 }) => name42 === ATTRS.COLOR || name42 === ATTRS.SIZE || name42 === ATTRS.FACE); + return isFontWithAttrs || EXITS_FOREIGN_CONTENT.has(tn); + } + function adjustTokenMathMLAttrs(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; + } + } + } + function adjustTokenSVGAttrs(token) { + for (let i = 0; i < token.attrs.length; i++) { + const adjustedAttrName = SVG_ATTRS_ADJUSTMENT_MAP.get(token.attrs[i].name); + if (adjustedAttrName != null) { + token.attrs[i].name = adjustedAttrName; + } + } + } + function adjustTokenXMLAttrs(token) { + for (let i = 0; i < token.attrs.length; i++) { + const adjustedAttrEntry = XML_ATTRS_ADJUSTMENT_MAP.get(token.attrs[i].name); + if (adjustedAttrEntry) { + token.attrs[i].prefix = adjustedAttrEntry.prefix; + token.attrs[i].name = adjustedAttrEntry.name; + token.attrs[i].namespace = adjustedAttrEntry.namespace; + } + } + } + function adjustTokenSVGTagName(token) { + const adjustedTagName = SVG_TAG_NAMES_ADJUSTMENT_MAP.get(token.tagName); + if (adjustedTagName != null) { + token.tagName = adjustedTagName; + token.tagID = getTagID(token.tagName); + } + } + function isMathMLTextIntegrationPoint(tn, ns) { + return ns === NS.MATHML && (tn === TAG_ID.MI || tn === TAG_ID.MO || tn === TAG_ID.MN || tn === TAG_ID.MS || tn === TAG_ID.MTEXT); + } + function isHtmlIntegrationPoint(tn, ns, attrs) { + if (ns === NS.MATHML && tn === TAG_ID.ANNOTATION_XML) { + for (let i = 0; i < attrs.length; i++) { + if (attrs[i].name === ATTRS.ENCODING) { + const value = attrs[i].value.toLowerCase(); + return value === MIME_TYPES.TEXT_HTML || value === MIME_TYPES.APPLICATION_XML; + } + } + } + return ns === NS.SVG && (tn === TAG_ID.FOREIGN_OBJECT || tn === TAG_ID.DESC || tn === TAG_ID.TITLE); + } + function isIntegrationPoint(tn, ns, attrs, foreignNS) { + return (!foreignNS || foreignNS === NS.HTML) && isHtmlIntegrationPoint(tn, ns, attrs) || (!foreignNS || foreignNS === NS.MATHML) && isMathMLTextIntegrationPoint(tn, ns); + } + + // node_modules/parse5/dist/parser/index.js + var HIDDEN_INPUT_TYPE = "hidden"; + var AA_OUTER_LOOP_ITER = 8; + var AA_INNER_LOOP_ITER = 3; + var InsertionMode; + (function(InsertionMode2) { + InsertionMode2[InsertionMode2["INITIAL"] = 0] = "INITIAL"; + InsertionMode2[InsertionMode2["BEFORE_HTML"] = 1] = "BEFORE_HTML"; + InsertionMode2[InsertionMode2["BEFORE_HEAD"] = 2] = "BEFORE_HEAD"; + InsertionMode2[InsertionMode2["IN_HEAD"] = 3] = "IN_HEAD"; + InsertionMode2[InsertionMode2["IN_HEAD_NO_SCRIPT"] = 4] = "IN_HEAD_NO_SCRIPT"; + InsertionMode2[InsertionMode2["AFTER_HEAD"] = 5] = "AFTER_HEAD"; + InsertionMode2[InsertionMode2["IN_BODY"] = 6] = "IN_BODY"; + InsertionMode2[InsertionMode2["TEXT"] = 7] = "TEXT"; + InsertionMode2[InsertionMode2["IN_TABLE"] = 8] = "IN_TABLE"; + InsertionMode2[InsertionMode2["IN_TABLE_TEXT"] = 9] = "IN_TABLE_TEXT"; + InsertionMode2[InsertionMode2["IN_CAPTION"] = 10] = "IN_CAPTION"; + InsertionMode2[InsertionMode2["IN_COLUMN_GROUP"] = 11] = "IN_COLUMN_GROUP"; + InsertionMode2[InsertionMode2["IN_TABLE_BODY"] = 12] = "IN_TABLE_BODY"; + InsertionMode2[InsertionMode2["IN_ROW"] = 13] = "IN_ROW"; + InsertionMode2[InsertionMode2["IN_CELL"] = 14] = "IN_CELL"; + InsertionMode2[InsertionMode2["IN_SELECT"] = 15] = "IN_SELECT"; + InsertionMode2[InsertionMode2["IN_SELECT_IN_TABLE"] = 16] = "IN_SELECT_IN_TABLE"; + InsertionMode2[InsertionMode2["IN_TEMPLATE"] = 17] = "IN_TEMPLATE"; + InsertionMode2[InsertionMode2["AFTER_BODY"] = 18] = "AFTER_BODY"; + InsertionMode2[InsertionMode2["IN_FRAMESET"] = 19] = "IN_FRAMESET"; + InsertionMode2[InsertionMode2["AFTER_FRAMESET"] = 20] = "AFTER_FRAMESET"; + InsertionMode2[InsertionMode2["AFTER_AFTER_BODY"] = 21] = "AFTER_AFTER_BODY"; + InsertionMode2[InsertionMode2["AFTER_AFTER_FRAMESET"] = 22] = "AFTER_AFTER_FRAMESET"; + })(InsertionMode || (InsertionMode = {})); + var BASE_LOC = { + startLine: -1, + startCol: -1, + startOffset: -1, + endLine: -1, + endCol: -1, + endOffset: -1 + }; + var TABLE_STRUCTURE_TAGS = /* @__PURE__ */ new Set([TAG_ID.TABLE, TAG_ID.TBODY, TAG_ID.TFOOT, TAG_ID.THEAD, TAG_ID.TR]); + var defaultParserOptions = { + scriptingEnabled: true, + sourceCodeLocationInfo: false, + treeAdapter: defaultTreeAdapter, + onParseError: null + }; + var Parser = class { + constructor(options, document, fragmentContext = null, scriptHandler = null) { + this.fragmentContext = fragmentContext; + this.scriptHandler = scriptHandler; + this.currentToken = null; + this.stopped = false; + this.insertionMode = InsertionMode.INITIAL; + this.originalInsertionMode = InsertionMode.INITIAL; + this.headElement = null; + this.formElement = null; + this.currentNotInHTML = false; + this.tmplInsertionModeStack = []; + this.pendingCharacterTokens = []; + this.hasNonWhitespacePendingCharacterToken = false; + this.framesetOk = true; + this.skipNextNewLine = false; + this.fosterParentingEnabled = false; + this.options = { + ...defaultParserOptions, + ...options + }; + this.treeAdapter = this.options.treeAdapter; + this.onParseError = this.options.onParseError; + if (this.onParseError) { + this.options.sourceCodeLocationInfo = true; + } + this.document = document !== null && document !== void 0 ? document : this.treeAdapter.createDocument(); + this.tokenizer = new Tokenizer(this.options, this); + this.activeFormattingElements = new FormattingElementList(this.treeAdapter); + this.fragmentContextID = fragmentContext ? getTagID(this.treeAdapter.getTagName(fragmentContext)) : TAG_ID.UNKNOWN; + this._setContextModes(fragmentContext !== null && fragmentContext !== void 0 ? fragmentContext : this.document, this.fragmentContextID); + this.openElements = new OpenElementStack(this.document, this.treeAdapter, this); + } + // API + static parse(html, options) { + const parser = new this(options); + parser.tokenizer.write(html, true); + return parser.document; + } + static getFragmentParser(fragmentContext, options) { + const opts = { + ...defaultParserOptions, + ...options + }; + fragmentContext !== null && fragmentContext !== void 0 ? fragmentContext : fragmentContext = opts.treeAdapter.createElement(TAG_NAMES.TEMPLATE, NS.HTML, []); + const documentMock = opts.treeAdapter.createElement("documentmock", NS.HTML, []); + const parser = new this(opts, documentMock, fragmentContext); + if (parser.fragmentContextID === TAG_ID.TEMPLATE) { + parser.tmplInsertionModeStack.unshift(InsertionMode.IN_TEMPLATE); + } + parser._initTokenizerForFragmentParsing(); + parser._insertFakeRootElement(); + parser._resetInsertionMode(); + parser._findFormInFragmentContext(); + return parser; + } + getFragment() { + const rootElement = this.treeAdapter.getFirstChild(this.document); + const fragment = this.treeAdapter.createDocumentFragment(); + this._adoptNodes(rootElement, fragment); + return fragment; + } + //Errors + _err(token, code2, beforeToken) { + var _a2; + if (!this.onParseError) + return; + const loc = (_a2 = token.location) !== null && _a2 !== void 0 ? _a2 : BASE_LOC; + const err = { + code: code2, + startLine: loc.startLine, + startCol: loc.startCol, + startOffset: loc.startOffset, + endLine: beforeToken ? loc.startLine : loc.endLine, + endCol: beforeToken ? loc.startCol : loc.endCol, + endOffset: beforeToken ? loc.startOffset : loc.endOffset + }; + this.onParseError(err); + } + //Stack events + onItemPush(node, tid, isTop) { + var _a2, _b; + (_b = (_a2 = this.treeAdapter).onItemPush) === null || _b === void 0 ? void 0 : _b.call(_a2, node); + if (isTop && this.openElements.stackTop > 0) + this._setContextModes(node, tid); + } + onItemPop(node, isTop) { + var _a2, _b; + if (this.options.sourceCodeLocationInfo) { + this._setEndLocation(node, this.currentToken); + } + (_b = (_a2 = this.treeAdapter).onItemPop) === null || _b === void 0 ? void 0 : _b.call(_a2, node, this.openElements.current); + if (isTop) { + let current; + let currentTagId; + if (this.openElements.stackTop === 0 && this.fragmentContext) { + current = this.fragmentContext; + currentTagId = this.fragmentContextID; + } else { + ({ current, currentTagId } = this.openElements); + } + this._setContextModes(current, currentTagId); + } + } + _setContextModes(current, tid) { + const isHTML = current === this.document || this.treeAdapter.getNamespaceURI(current) === NS.HTML; + this.currentNotInHTML = !isHTML; + this.tokenizer.inForeignNode = !isHTML && !this._isIntegrationPoint(tid, current); + } + _switchToTextParsing(currentToken, nextTokenizerState) { + this._insertElement(currentToken, NS.HTML); + this.tokenizer.state = nextTokenizerState; + this.originalInsertionMode = this.insertionMode; + this.insertionMode = InsertionMode.TEXT; + } + switchToPlaintextParsing() { + this.insertionMode = InsertionMode.TEXT; + this.originalInsertionMode = InsertionMode.IN_BODY; + this.tokenizer.state = TokenizerMode.PLAINTEXT; + } + //Fragment parsing + _getAdjustedCurrentElement() { + return this.openElements.stackTop === 0 && this.fragmentContext ? this.fragmentContext : this.openElements.current; + } + _findFormInFragmentContext() { + let node = this.fragmentContext; + while (node) { + if (this.treeAdapter.getTagName(node) === TAG_NAMES.FORM) { + this.formElement = node; + break; + } + node = this.treeAdapter.getParentNode(node); + } + } + _initTokenizerForFragmentParsing() { + if (!this.fragmentContext || this.treeAdapter.getNamespaceURI(this.fragmentContext) !== NS.HTML) { + return; + } + switch (this.fragmentContextID) { + case TAG_ID.TITLE: + case TAG_ID.TEXTAREA: { + this.tokenizer.state = TokenizerMode.RCDATA; + break; + } + case TAG_ID.STYLE: + case TAG_ID.XMP: + case TAG_ID.IFRAME: + case TAG_ID.NOEMBED: + case TAG_ID.NOFRAMES: + case TAG_ID.NOSCRIPT: { + this.tokenizer.state = TokenizerMode.RAWTEXT; + break; + } + case TAG_ID.SCRIPT: { + this.tokenizer.state = TokenizerMode.SCRIPT_DATA; + break; + } + case TAG_ID.PLAINTEXT: { + this.tokenizer.state = TokenizerMode.PLAINTEXT; + break; + } + default: + } + } + //Tree mutation + _setDocumentType(token) { + const name42 = token.name || ""; + const publicId = token.publicId || ""; + const systemId = token.systemId || ""; + this.treeAdapter.setDocumentType(this.document, name42, publicId, systemId); + if (token.location) { + const documentChildren = this.treeAdapter.getChildNodes(this.document); + const docTypeNode = documentChildren.find((node) => this.treeAdapter.isDocumentTypeNode(node)); + if (docTypeNode) { + this.treeAdapter.setNodeSourceCodeLocation(docTypeNode, token.location); + } + } + } + _attachElementToTree(element, location) { + if (this.options.sourceCodeLocationInfo) { + const loc = location && { + ...location, + startTag: location + }; + this.treeAdapter.setNodeSourceCodeLocation(element, loc); + } + if (this._shouldFosterParentOnInsertion()) { + this._fosterParentElement(element); + } else { + const parent = this.openElements.currentTmplContentOrNode; + this.treeAdapter.appendChild(parent, element); + } + } + _appendElement(token, namespaceURI) { + const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs); + this._attachElementToTree(element, token.location); + } + _insertElement(token, namespaceURI) { + const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs); + this._attachElementToTree(element, token.location); + this.openElements.push(element, token.tagID); + } + _insertFakeElement(tagName, tagID) { + const element = this.treeAdapter.createElement(tagName, NS.HTML, []); + this._attachElementToTree(element, null); + this.openElements.push(element, tagID); + } + _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, token.location); + this.openElements.push(tmpl, token.tagID); + if (this.options.sourceCodeLocationInfo) + this.treeAdapter.setNodeSourceCodeLocation(content, null); + } + _insertFakeRootElement() { + const element = this.treeAdapter.createElement(TAG_NAMES.HTML, NS.HTML, []); + if (this.options.sourceCodeLocationInfo) + this.treeAdapter.setNodeSourceCodeLocation(element, null); + this.treeAdapter.appendChild(this.openElements.current, element); + this.openElements.push(element, TAG_ID.HTML); + } + _appendCommentNode(token, parent) { + const commentNode = this.treeAdapter.createCommentNode(token.data); + this.treeAdapter.appendChild(parent, commentNode); + if (this.options.sourceCodeLocationInfo) { + this.treeAdapter.setNodeSourceCodeLocation(commentNode, token.location); + } + } + _insertCharacters(token) { + let parent; + let beforeElement; + if (this._shouldFosterParentOnInsertion()) { + ({ parent, beforeElement } = this._findFosterParentingLocation()); + if (beforeElement) { + this.treeAdapter.insertTextBefore(parent, token.chars, beforeElement); + } else { + this.treeAdapter.insertText(parent, token.chars); + } + } else { + parent = this.openElements.currentTmplContentOrNode; + this.treeAdapter.insertText(parent, token.chars); + } + if (!token.location) + return; + const siblings = this.treeAdapter.getChildNodes(parent); + const textNodeIdx = beforeElement ? siblings.lastIndexOf(beforeElement) : siblings.length; + const textNode = siblings[textNodeIdx - 1]; + const tnLoc = this.treeAdapter.getNodeSourceCodeLocation(textNode); + if (tnLoc) { + const { endLine, endCol, endOffset } = token.location; + this.treeAdapter.updateNodeSourceCodeLocation(textNode, { endLine, endCol, endOffset }); + } else if (this.options.sourceCodeLocationInfo) { + this.treeAdapter.setNodeSourceCodeLocation(textNode, token.location); + } + } + _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); + } + } + _setEndLocation(element, closingToken) { + if (this.treeAdapter.getNodeSourceCodeLocation(element) && closingToken.location) { + const ctLoc = closingToken.location; + const tn = this.treeAdapter.getTagName(element); + const endLoc = ( + // NOTE: For cases like

- First 'p' closes without a closing + // tag and for cases like

- 'p' closes without a closing tag. + closingToken.type === TokenType.END_TAG && tn === closingToken.tagName ? { + endTag: { ...ctLoc }, + endLine: ctLoc.endLine, + endCol: ctLoc.endCol, + endOffset: ctLoc.endOffset + } : { + endLine: ctLoc.startLine, + endCol: ctLoc.startCol, + endOffset: ctLoc.startOffset + } + ); + this.treeAdapter.updateNodeSourceCodeLocation(element, endLoc); + } + } + //Token processing + shouldProcessStartTagTokenInForeignContent(token) { + if (!this.currentNotInHTML) + return false; + let current; + let currentTagId; + if (this.openElements.stackTop === 0 && this.fragmentContext) { + current = this.fragmentContext; + currentTagId = this.fragmentContextID; + } else { + ({ current, currentTagId } = this.openElements); + } + if (token.tagID === TAG_ID.SVG && this.treeAdapter.getTagName(current) === TAG_NAMES.ANNOTATION_XML && this.treeAdapter.getNamespaceURI(current) === NS.MATHML) { + return false; + } + return ( + // Check that `current` is not an integration point for HTML or MathML elements. + this.tokenizer.inForeignNode || // If it _is_ an integration point, then we might have to check that it is not an HTML + // integration point. + (token.tagID === TAG_ID.MGLYPH || token.tagID === TAG_ID.MALIGNMARK) && !this._isIntegrationPoint(currentTagId, current, NS.HTML) + ); + } + _processToken(token) { + switch (token.type) { + case TokenType.CHARACTER: { + this.onCharacter(token); + break; + } + case TokenType.NULL_CHARACTER: { + this.onNullCharacter(token); + break; + } + case TokenType.COMMENT: { + this.onComment(token); + break; + } + case TokenType.DOCTYPE: { + this.onDoctype(token); + break; + } + case TokenType.START_TAG: { + this._processStartTag(token); + break; + } + case TokenType.END_TAG: { + this.onEndTag(token); + break; + } + case TokenType.EOF: { + this.onEof(token); + break; + } + case TokenType.WHITESPACE_CHARACTER: { + this.onWhitespaceCharacter(token); + break; + } + } + } + //Integration points + _isIntegrationPoint(tid, element, foreignNS) { + const ns = this.treeAdapter.getNamespaceURI(element); + const attrs = this.treeAdapter.getAttrList(element); + return isIntegrationPoint(tid, ns, attrs, foreignNS); + } + //Active formatting elements reconstruction + _reconstructActiveFormattingElements() { + const listLength = this.activeFormattingElements.entries.length; + if (listLength) { + const endIndex = this.activeFormattingElements.entries.findIndex((entry) => entry.type === EntryType.Marker || this.openElements.contains(entry.element)); + const unopenIdx = endIndex < 0 ? listLength - 1 : endIndex - 1; + for (let i = unopenIdx; i >= 0; i--) { + const 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 = InsertionMode.IN_ROW; + } + _closePElement() { + this.openElements.generateImpliedEndTagsWithExclusion(TAG_ID.P); + this.openElements.popUntilTagNamePopped(TAG_ID.P); + } + //Insertion modes + _resetInsertionMode() { + for (let i = this.openElements.stackTop; i >= 0; i--) { + switch (i === 0 && this.fragmentContext ? this.fragmentContextID : this.openElements.tagIDs[i]) { + case TAG_ID.TR: { + this.insertionMode = InsertionMode.IN_ROW; + return; + } + case TAG_ID.TBODY: + case TAG_ID.THEAD: + case TAG_ID.TFOOT: { + this.insertionMode = InsertionMode.IN_TABLE_BODY; + return; + } + case TAG_ID.CAPTION: { + this.insertionMode = InsertionMode.IN_CAPTION; + return; + } + case TAG_ID.COLGROUP: { + this.insertionMode = InsertionMode.IN_COLUMN_GROUP; + return; + } + case TAG_ID.TABLE: { + this.insertionMode = InsertionMode.IN_TABLE; + return; + } + case TAG_ID.BODY: { + this.insertionMode = InsertionMode.IN_BODY; + return; + } + case TAG_ID.FRAMESET: { + this.insertionMode = InsertionMode.IN_FRAMESET; + return; + } + case TAG_ID.SELECT: { + this._resetInsertionModeForSelect(i); + return; + } + case TAG_ID.TEMPLATE: { + this.insertionMode = this.tmplInsertionModeStack[0]; + return; + } + case TAG_ID.HTML: { + this.insertionMode = this.headElement ? InsertionMode.AFTER_HEAD : InsertionMode.BEFORE_HEAD; + return; + } + case TAG_ID.TD: + case TAG_ID.TH: { + if (i > 0) { + this.insertionMode = InsertionMode.IN_CELL; + return; + } + break; + } + case TAG_ID.HEAD: { + if (i > 0) { + this.insertionMode = InsertionMode.IN_HEAD; + return; + } + break; + } + } + } + this.insertionMode = InsertionMode.IN_BODY; + } + _resetInsertionModeForSelect(selectIdx) { + if (selectIdx > 0) { + for (let i = selectIdx - 1; i > 0; i--) { + const tn = this.openElements.tagIDs[i]; + if (tn === TAG_ID.TEMPLATE) { + break; + } else if (tn === TAG_ID.TABLE) { + this.insertionMode = InsertionMode.IN_SELECT_IN_TABLE; + return; + } + } + } + this.insertionMode = InsertionMode.IN_SELECT; + } + //Foster parenting + _isElementCausesFosterParenting(tn) { + return TABLE_STRUCTURE_TAGS.has(tn); + } + _shouldFosterParentOnInsertion() { + return this.fosterParentingEnabled && this._isElementCausesFosterParenting(this.openElements.currentTagId); + } + _findFosterParentingLocation() { + for (let i = this.openElements.stackTop; i >= 0; i--) { + const openElement = this.openElements.items[i]; + switch (this.openElements.tagIDs[i]) { + case TAG_ID.TEMPLATE: { + if (this.treeAdapter.getNamespaceURI(openElement) === NS.HTML) { + return { parent: this.treeAdapter.getTemplateContent(openElement), beforeElement: null }; + } + break; + } + case TAG_ID.TABLE: { + const parent = this.treeAdapter.getParentNode(openElement); + if (parent) { + return { parent, beforeElement: openElement }; + } + return { parent: this.openElements.items[i - 1], beforeElement: null }; + } + default: + } + } + return { parent: this.openElements.items[0], beforeElement: null }; + } + _fosterParentElement(element) { + const location = this._findFosterParentingLocation(); + if (location.beforeElement) { + this.treeAdapter.insertBefore(location.parent, element, location.beforeElement); + } else { + this.treeAdapter.appendChild(location.parent, element); + } + } + //Special elements + _isSpecialElement(element, id) { + const ns = this.treeAdapter.getNamespaceURI(element); + return SPECIAL_ELEMENTS[ns].has(id); + } + onCharacter(token) { + this.skipNextNewLine = false; + if (this.tokenizer.inForeignNode) { + characterInForeignContent(this, token); + return; + } + switch (this.insertionMode) { + case InsertionMode.INITIAL: { + tokenInInitialMode(this, token); + break; + } + case InsertionMode.BEFORE_HTML: { + tokenBeforeHtml(this, token); + break; + } + case InsertionMode.BEFORE_HEAD: { + tokenBeforeHead(this, token); + break; + } + case InsertionMode.IN_HEAD: { + tokenInHead(this, token); + break; + } + case InsertionMode.IN_HEAD_NO_SCRIPT: { + tokenInHeadNoScript(this, token); + break; + } + case InsertionMode.AFTER_HEAD: { + tokenAfterHead(this, token); + break; + } + case InsertionMode.IN_BODY: + case InsertionMode.IN_CAPTION: + case InsertionMode.IN_CELL: + case InsertionMode.IN_TEMPLATE: { + characterInBody(this, token); + break; + } + case InsertionMode.TEXT: + case InsertionMode.IN_SELECT: + case InsertionMode.IN_SELECT_IN_TABLE: { + this._insertCharacters(token); + break; + } + case InsertionMode.IN_TABLE: + case InsertionMode.IN_TABLE_BODY: + case InsertionMode.IN_ROW: { + characterInTable(this, token); + break; + } + case InsertionMode.IN_TABLE_TEXT: { + characterInTableText(this, token); + break; + } + case InsertionMode.IN_COLUMN_GROUP: { + tokenInColumnGroup(this, token); + break; + } + case InsertionMode.AFTER_BODY: { + tokenAfterBody(this, token); + break; + } + case InsertionMode.AFTER_AFTER_BODY: { + tokenAfterAfterBody(this, token); + break; + } + default: + } + } + onNullCharacter(token) { + this.skipNextNewLine = false; + if (this.tokenizer.inForeignNode) { + nullCharacterInForeignContent(this, token); + return; + } + switch (this.insertionMode) { + case InsertionMode.INITIAL: { + tokenInInitialMode(this, token); + break; + } + case InsertionMode.BEFORE_HTML: { + tokenBeforeHtml(this, token); + break; + } + case InsertionMode.BEFORE_HEAD: { + tokenBeforeHead(this, token); + break; + } + case InsertionMode.IN_HEAD: { + tokenInHead(this, token); + break; + } + case InsertionMode.IN_HEAD_NO_SCRIPT: { + tokenInHeadNoScript(this, token); + break; + } + case InsertionMode.AFTER_HEAD: { + tokenAfterHead(this, token); + break; + } + case InsertionMode.TEXT: { + this._insertCharacters(token); + break; + } + case InsertionMode.IN_TABLE: + case InsertionMode.IN_TABLE_BODY: + case InsertionMode.IN_ROW: { + characterInTable(this, token); + break; + } + case InsertionMode.IN_COLUMN_GROUP: { + tokenInColumnGroup(this, token); + break; + } + case InsertionMode.AFTER_BODY: { + tokenAfterBody(this, token); + break; + } + case InsertionMode.AFTER_AFTER_BODY: { + tokenAfterAfterBody(this, token); + break; + } + default: + } + } + onComment(token) { + this.skipNextNewLine = false; + if (this.currentNotInHTML) { + appendComment(this, token); + return; + } + switch (this.insertionMode) { + case InsertionMode.INITIAL: + case InsertionMode.BEFORE_HTML: + case InsertionMode.BEFORE_HEAD: + case InsertionMode.IN_HEAD: + case InsertionMode.IN_HEAD_NO_SCRIPT: + case InsertionMode.AFTER_HEAD: + case InsertionMode.IN_BODY: + case InsertionMode.IN_TABLE: + case InsertionMode.IN_CAPTION: + case InsertionMode.IN_COLUMN_GROUP: + case InsertionMode.IN_TABLE_BODY: + case InsertionMode.IN_ROW: + case InsertionMode.IN_CELL: + case InsertionMode.IN_SELECT: + case InsertionMode.IN_SELECT_IN_TABLE: + case InsertionMode.IN_TEMPLATE: + case InsertionMode.IN_FRAMESET: + case InsertionMode.AFTER_FRAMESET: { + appendComment(this, token); + break; + } + case InsertionMode.IN_TABLE_TEXT: { + tokenInTableText(this, token); + break; + } + case InsertionMode.AFTER_BODY: { + appendCommentToRootHtmlElement(this, token); + break; + } + case InsertionMode.AFTER_AFTER_BODY: + case InsertionMode.AFTER_AFTER_FRAMESET: { + appendCommentToDocument(this, token); + break; + } + default: + } + } + onDoctype(token) { + this.skipNextNewLine = false; + switch (this.insertionMode) { + case InsertionMode.INITIAL: { + doctypeInInitialMode(this, token); + break; + } + case InsertionMode.BEFORE_HEAD: + case InsertionMode.IN_HEAD: + case InsertionMode.IN_HEAD_NO_SCRIPT: + case InsertionMode.AFTER_HEAD: { + this._err(token, ERR.misplacedDoctype); + break; + } + case InsertionMode.IN_TABLE_TEXT: { + tokenInTableText(this, token); + break; + } + default: + } + } + onStartTag(token) { + this.skipNextNewLine = false; + this.currentToken = token; + this._processStartTag(token); + if (token.selfClosing && !token.ackSelfClosing) { + this._err(token, ERR.nonVoidHtmlElementStartTagWithTrailingSolidus); + } + } + /** + * Processes a given start tag. + * + * `onStartTag` checks if a self-closing tag was recognized. When a token + * is moved inbetween multiple insertion modes, this check for self-closing + * could lead to false positives. To avoid this, `_processStartTag` is used + * for nested calls. + * + * @param token The token to process. + */ + _processStartTag(token) { + if (this.shouldProcessStartTagTokenInForeignContent(token)) { + startTagInForeignContent(this, token); + } else { + this._startTagOutsideForeignContent(token); + } + } + _startTagOutsideForeignContent(token) { + switch (this.insertionMode) { + case InsertionMode.INITIAL: { + tokenInInitialMode(this, token); + break; + } + case InsertionMode.BEFORE_HTML: { + startTagBeforeHtml(this, token); + break; + } + case InsertionMode.BEFORE_HEAD: { + startTagBeforeHead(this, token); + break; + } + case InsertionMode.IN_HEAD: { + startTagInHead(this, token); + break; + } + case InsertionMode.IN_HEAD_NO_SCRIPT: { + startTagInHeadNoScript(this, token); + break; + } + case InsertionMode.AFTER_HEAD: { + startTagAfterHead(this, token); + break; + } + case InsertionMode.IN_BODY: { + startTagInBody(this, token); + break; + } + case InsertionMode.IN_TABLE: { + startTagInTable(this, token); + break; + } + case InsertionMode.IN_TABLE_TEXT: { + tokenInTableText(this, token); + break; + } + case InsertionMode.IN_CAPTION: { + startTagInCaption(this, token); + break; + } + case InsertionMode.IN_COLUMN_GROUP: { + startTagInColumnGroup(this, token); + break; + } + case InsertionMode.IN_TABLE_BODY: { + startTagInTableBody(this, token); + break; + } + case InsertionMode.IN_ROW: { + startTagInRow(this, token); + break; + } + case InsertionMode.IN_CELL: { + startTagInCell(this, token); + break; + } + case InsertionMode.IN_SELECT: { + startTagInSelect(this, token); + break; + } + case InsertionMode.IN_SELECT_IN_TABLE: { + startTagInSelectInTable(this, token); + break; + } + case InsertionMode.IN_TEMPLATE: { + startTagInTemplate(this, token); + break; + } + case InsertionMode.AFTER_BODY: { + startTagAfterBody(this, token); + break; + } + case InsertionMode.IN_FRAMESET: { + startTagInFrameset(this, token); + break; + } + case InsertionMode.AFTER_FRAMESET: { + startTagAfterFrameset(this, token); + break; + } + case InsertionMode.AFTER_AFTER_BODY: { + startTagAfterAfterBody(this, token); + break; + } + case InsertionMode.AFTER_AFTER_FRAMESET: { + startTagAfterAfterFrameset(this, token); + break; + } + default: + } + } + onEndTag(token) { + this.skipNextNewLine = false; + this.currentToken = token; + if (this.currentNotInHTML) { + endTagInForeignContent(this, token); + } else { + this._endTagOutsideForeignContent(token); + } + } + _endTagOutsideForeignContent(token) { + switch (this.insertionMode) { + case InsertionMode.INITIAL: { + tokenInInitialMode(this, token); + break; + } + case InsertionMode.BEFORE_HTML: { + endTagBeforeHtml(this, token); + break; + } + case InsertionMode.BEFORE_HEAD: { + endTagBeforeHead(this, token); + break; + } + case InsertionMode.IN_HEAD: { + endTagInHead(this, token); + break; + } + case InsertionMode.IN_HEAD_NO_SCRIPT: { + endTagInHeadNoScript(this, token); + break; + } + case InsertionMode.AFTER_HEAD: { + endTagAfterHead(this, token); + break; + } + case InsertionMode.IN_BODY: { + endTagInBody(this, token); + break; + } + case InsertionMode.TEXT: { + endTagInText(this, token); + break; + } + case InsertionMode.IN_TABLE: { + endTagInTable(this, token); + break; + } + case InsertionMode.IN_TABLE_TEXT: { + tokenInTableText(this, token); + break; + } + case InsertionMode.IN_CAPTION: { + endTagInCaption(this, token); + break; + } + case InsertionMode.IN_COLUMN_GROUP: { + endTagInColumnGroup(this, token); + break; + } + case InsertionMode.IN_TABLE_BODY: { + endTagInTableBody(this, token); + break; + } + case InsertionMode.IN_ROW: { + endTagInRow(this, token); + break; + } + case InsertionMode.IN_CELL: { + endTagInCell(this, token); + break; + } + case InsertionMode.IN_SELECT: { + endTagInSelect(this, token); + break; + } + case InsertionMode.IN_SELECT_IN_TABLE: { + endTagInSelectInTable(this, token); + break; + } + case InsertionMode.IN_TEMPLATE: { + endTagInTemplate(this, token); + break; + } + case InsertionMode.AFTER_BODY: { + endTagAfterBody(this, token); + break; + } + case InsertionMode.IN_FRAMESET: { + endTagInFrameset(this, token); + break; + } + case InsertionMode.AFTER_FRAMESET: { + endTagAfterFrameset(this, token); + break; + } + case InsertionMode.AFTER_AFTER_BODY: { + tokenAfterAfterBody(this, token); + break; + } + default: + } + } + onEof(token) { + switch (this.insertionMode) { + case InsertionMode.INITIAL: { + tokenInInitialMode(this, token); + break; + } + case InsertionMode.BEFORE_HTML: { + tokenBeforeHtml(this, token); + break; + } + case InsertionMode.BEFORE_HEAD: { + tokenBeforeHead(this, token); + break; + } + case InsertionMode.IN_HEAD: { + tokenInHead(this, token); + break; + } + case InsertionMode.IN_HEAD_NO_SCRIPT: { + tokenInHeadNoScript(this, token); + break; + } + case InsertionMode.AFTER_HEAD: { + tokenAfterHead(this, token); + break; + } + case InsertionMode.IN_BODY: + case InsertionMode.IN_TABLE: + case InsertionMode.IN_CAPTION: + case InsertionMode.IN_COLUMN_GROUP: + case InsertionMode.IN_TABLE_BODY: + case InsertionMode.IN_ROW: + case InsertionMode.IN_CELL: + case InsertionMode.IN_SELECT: + case InsertionMode.IN_SELECT_IN_TABLE: { + eofInBody(this, token); + break; + } + case InsertionMode.TEXT: { + eofInText(this, token); + break; + } + case InsertionMode.IN_TABLE_TEXT: { + tokenInTableText(this, token); + break; + } + case InsertionMode.IN_TEMPLATE: { + eofInTemplate(this, token); + break; + } + case InsertionMode.AFTER_BODY: + case InsertionMode.IN_FRAMESET: + case InsertionMode.AFTER_FRAMESET: + case InsertionMode.AFTER_AFTER_BODY: + case InsertionMode.AFTER_AFTER_FRAMESET: { + stopParsing(this, token); + break; + } + default: + } + } + onWhitespaceCharacter(token) { + if (this.skipNextNewLine) { + this.skipNextNewLine = false; + if (token.chars.charCodeAt(0) === CODE_POINTS.LINE_FEED) { + if (token.chars.length === 1) { + return; + } + token.chars = token.chars.substr(1); + } + } + if (this.tokenizer.inForeignNode) { + this._insertCharacters(token); + return; + } + switch (this.insertionMode) { + case InsertionMode.IN_HEAD: + case InsertionMode.IN_HEAD_NO_SCRIPT: + case InsertionMode.AFTER_HEAD: + case InsertionMode.TEXT: + case InsertionMode.IN_COLUMN_GROUP: + case InsertionMode.IN_SELECT: + case InsertionMode.IN_SELECT_IN_TABLE: + case InsertionMode.IN_FRAMESET: + case InsertionMode.AFTER_FRAMESET: { + this._insertCharacters(token); + break; + } + case InsertionMode.IN_BODY: + case InsertionMode.IN_CAPTION: + case InsertionMode.IN_CELL: + case InsertionMode.IN_TEMPLATE: + case InsertionMode.AFTER_BODY: + case InsertionMode.AFTER_AFTER_BODY: + case InsertionMode.AFTER_AFTER_FRAMESET: { + whitespaceCharacterInBody(this, token); + break; + } + case InsertionMode.IN_TABLE: + case InsertionMode.IN_TABLE_BODY: + case InsertionMode.IN_ROW: { + characterInTable(this, token); + break; + } + case InsertionMode.IN_TABLE_TEXT: { + whitespaceCharacterInTableText(this, token); + break; + } + default: + } + } + }; + 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.tagID)) { + formattingElementEntry = null; + } + } else { + genericEndTagInBody(p, token); + } + return formattingElementEntry; + } + function aaObtainFurthestBlock(p, formattingElementEntry) { + let furthestBlock = null; + let idx = p.openElements.stackTop; + for (; idx >= 0; idx--) { + const element = p.openElements.items[idx]; + if (element === formattingElementEntry.element) { + break; + } + if (p._isSpecialElement(element, p.openElements.tagIDs[idx])) { + furthestBlock = element; + } + } + if (!furthestBlock) { + p.openElements.shortenToLength(idx < 0 ? 0 : idx); + p.activeFormattingElements.removeEntry(formattingElementEntry); + } + return furthestBlock; + } + 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) { + 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; + } + 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; + } + function aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement) { + const tn = p.treeAdapter.getTagName(commonAncestor); + const tid = getTagID(tn); + if (p._isElementCausesFosterParenting(tid)) { + p._fosterParentElement(lastElement); + } else { + const ns = p.treeAdapter.getNamespaceURI(commonAncestor); + if (tid === TAG_ID.TEMPLATE && ns === NS.HTML) { + commonAncestor = p.treeAdapter.getTemplateContent(commonAncestor); + } + p.treeAdapter.appendChild(commonAncestor, lastElement); + } + } + function aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry) { + const ns = p.treeAdapter.getNamespaceURI(formattingElementEntry.element); + const { token } = formattingElementEntry; + const newElement = p.treeAdapter.createElement(token.tagName, ns, token.attrs); + p._adoptNodes(furthestBlock, newElement); + p.treeAdapter.appendChild(furthestBlock, newElement); + p.activeFormattingElements.insertElementAfterBookmark(newElement, token); + p.activeFormattingElements.removeEntry(formattingElementEntry); + p.openElements.remove(formattingElementEntry.element); + p.openElements.insertAfter(furthestBlock, newElement, token.tagID); + } + function callAdoptionAgency(p, token) { + for (let i = 0; i < AA_OUTER_LOOP_ITER; i++) { + const 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); + if (commonAncestor) + aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement); + aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry); + } + } + function appendComment(p, token) { + p._appendCommentNode(token, p.openElements.currentTmplContentOrNode); + } + function appendCommentToRootHtmlElement(p, token) { + p._appendCommentNode(token, p.openElements.items[0]); + } + function appendCommentToDocument(p, token) { + p._appendCommentNode(token, p.document); + } + function stopParsing(p, token) { + p.stopped = true; + if (token.location) { + const target = p.fragmentContext ? 0 : 2; + for (let i = p.openElements.stackTop; i >= target; i--) { + p._setEndLocation(p.openElements.items[i], token); + } + if (!p.fragmentContext && p.openElements.stackTop >= 0) { + const htmlElement = p.openElements.items[0]; + const htmlLocation = p.treeAdapter.getNodeSourceCodeLocation(htmlElement); + if (htmlLocation && !htmlLocation.endTag) { + p._setEndLocation(htmlElement, token); + if (p.openElements.stackTop >= 1) { + const bodyElement = p.openElements.items[1]; + const bodyLocation = p.treeAdapter.getNodeSourceCodeLocation(bodyElement); + if (bodyLocation && !bodyLocation.endTag) { + p._setEndLocation(bodyElement, token); + } + } + } + } + } + } + function doctypeInInitialMode(p, token) { + p._setDocumentType(token); + const mode = token.forceQuirks ? DOCUMENT_MODE.QUIRKS : getDocumentMode(token); + if (!isConforming(token)) { + p._err(token, ERR.nonConformingDoctype); + } + p.treeAdapter.setDocumentMode(p.document, mode); + p.insertionMode = InsertionMode.BEFORE_HTML; + } + function tokenInInitialMode(p, token) { + p._err(token, ERR.missingDoctype, true); + p.treeAdapter.setDocumentMode(p.document, DOCUMENT_MODE.QUIRKS); + p.insertionMode = InsertionMode.BEFORE_HTML; + p._processToken(token); + } + function startTagBeforeHtml(p, token) { + if (token.tagID === TAG_ID.HTML) { + p._insertElement(token, NS.HTML); + p.insertionMode = InsertionMode.BEFORE_HEAD; + } else { + tokenBeforeHtml(p, token); + } + } + function endTagBeforeHtml(p, token) { + const tn = token.tagID; + if (tn === TAG_ID.HTML || tn === TAG_ID.HEAD || tn === TAG_ID.BODY || tn === TAG_ID.BR) { + tokenBeforeHtml(p, token); + } + } + function tokenBeforeHtml(p, token) { + p._insertFakeRootElement(); + p.insertionMode = InsertionMode.BEFORE_HEAD; + p._processToken(token); + } + function startTagBeforeHead(p, token) { + switch (token.tagID) { + case TAG_ID.HTML: { + startTagInBody(p, token); + break; + } + case TAG_ID.HEAD: { + p._insertElement(token, NS.HTML); + p.headElement = p.openElements.current; + p.insertionMode = InsertionMode.IN_HEAD; + break; + } + default: { + tokenBeforeHead(p, token); + } + } + } + function endTagBeforeHead(p, token) { + const tn = token.tagID; + if (tn === TAG_ID.HEAD || tn === TAG_ID.BODY || tn === TAG_ID.HTML || tn === TAG_ID.BR) { + tokenBeforeHead(p, token); + } else { + p._err(token, ERR.endTagWithoutMatchingOpenElement); + } + } + function tokenBeforeHead(p, token) { + p._insertFakeElement(TAG_NAMES.HEAD, TAG_ID.HEAD); + p.headElement = p.openElements.current; + p.insertionMode = InsertionMode.IN_HEAD; + p._processToken(token); + } + function startTagInHead(p, token) { + switch (token.tagID) { + case TAG_ID.HTML: { + startTagInBody(p, token); + break; + } + case TAG_ID.BASE: + case TAG_ID.BASEFONT: + case TAG_ID.BGSOUND: + case TAG_ID.LINK: + case TAG_ID.META: { + p._appendElement(token, NS.HTML); + token.ackSelfClosing = true; + break; + } + case TAG_ID.TITLE: { + p._switchToTextParsing(token, TokenizerMode.RCDATA); + break; + } + case TAG_ID.NOSCRIPT: { + if (p.options.scriptingEnabled) { + p._switchToTextParsing(token, TokenizerMode.RAWTEXT); + } else { + p._insertElement(token, NS.HTML); + p.insertionMode = InsertionMode.IN_HEAD_NO_SCRIPT; + } + break; + } + case TAG_ID.NOFRAMES: + case TAG_ID.STYLE: { + p._switchToTextParsing(token, TokenizerMode.RAWTEXT); + break; + } + case TAG_ID.SCRIPT: { + p._switchToTextParsing(token, TokenizerMode.SCRIPT_DATA); + break; + } + case TAG_ID.TEMPLATE: { + p._insertTemplate(token); + p.activeFormattingElements.insertMarker(); + p.framesetOk = false; + p.insertionMode = InsertionMode.IN_TEMPLATE; + p.tmplInsertionModeStack.unshift(InsertionMode.IN_TEMPLATE); + break; + } + case TAG_ID.HEAD: { + p._err(token, ERR.misplacedStartTagForHeadElement); + break; + } + default: { + tokenInHead(p, token); + } + } + } + function endTagInHead(p, token) { + switch (token.tagID) { + case TAG_ID.HEAD: { + p.openElements.pop(); + p.insertionMode = InsertionMode.AFTER_HEAD; + break; + } + case TAG_ID.BODY: + case TAG_ID.BR: + case TAG_ID.HTML: { + tokenInHead(p, token); + break; + } + case TAG_ID.TEMPLATE: { + templateEndTagInHead(p, token); + break; + } + default: { + p._err(token, ERR.endTagWithoutMatchingOpenElement); + } + } + } + function templateEndTagInHead(p, token) { + if (p.openElements.tmplCount > 0) { + p.openElements.generateImpliedEndTagsThoroughly(); + if (p.openElements.currentTagId !== TAG_ID.TEMPLATE) { + p._err(token, ERR.closingOfElementWithOpenChildElements); + } + p.openElements.popUntilTagNamePopped(TAG_ID.TEMPLATE); + p.activeFormattingElements.clearToLastMarker(); + p.tmplInsertionModeStack.shift(); + p._resetInsertionMode(); + } else { + p._err(token, ERR.endTagWithoutMatchingOpenElement); + } + } + function tokenInHead(p, token) { + p.openElements.pop(); + p.insertionMode = InsertionMode.AFTER_HEAD; + p._processToken(token); + } + function startTagInHeadNoScript(p, token) { + switch (token.tagID) { + case TAG_ID.HTML: { + startTagInBody(p, token); + break; + } + case TAG_ID.BASEFONT: + case TAG_ID.BGSOUND: + case TAG_ID.HEAD: + case TAG_ID.LINK: + case TAG_ID.META: + case TAG_ID.NOFRAMES: + case TAG_ID.STYLE: { + startTagInHead(p, token); + break; + } + case TAG_ID.NOSCRIPT: { + p._err(token, ERR.nestedNoscriptInHead); + break; + } + default: { + tokenInHeadNoScript(p, token); + } + } + } + function endTagInHeadNoScript(p, token) { + switch (token.tagID) { + case TAG_ID.NOSCRIPT: { + p.openElements.pop(); + p.insertionMode = InsertionMode.IN_HEAD; + break; + } + case TAG_ID.BR: { + tokenInHeadNoScript(p, token); + break; + } + default: { + p._err(token, ERR.endTagWithoutMatchingOpenElement); + } + } + } + function tokenInHeadNoScript(p, token) { + const errCode = token.type === TokenType.EOF ? ERR.openElementsLeftAfterEof : ERR.disallowedContentInNoscriptInHead; + p._err(token, errCode); + p.openElements.pop(); + p.insertionMode = InsertionMode.IN_HEAD; + p._processToken(token); + } + function startTagAfterHead(p, token) { + switch (token.tagID) { + case TAG_ID.HTML: { + startTagInBody(p, token); + break; + } + case TAG_ID.BODY: { + p._insertElement(token, NS.HTML); + p.framesetOk = false; + p.insertionMode = InsertionMode.IN_BODY; + break; + } + case TAG_ID.FRAMESET: { + p._insertElement(token, NS.HTML); + p.insertionMode = InsertionMode.IN_FRAMESET; + break; + } + case TAG_ID.BASE: + case TAG_ID.BASEFONT: + case TAG_ID.BGSOUND: + case TAG_ID.LINK: + case TAG_ID.META: + case TAG_ID.NOFRAMES: + case TAG_ID.SCRIPT: + case TAG_ID.STYLE: + case TAG_ID.TEMPLATE: + case TAG_ID.TITLE: { + p._err(token, ERR.abandonedHeadElementChild); + p.openElements.push(p.headElement, TAG_ID.HEAD); + startTagInHead(p, token); + p.openElements.remove(p.headElement); + break; + } + case TAG_ID.HEAD: { + p._err(token, ERR.misplacedStartTagForHeadElement); + break; + } + default: { + tokenAfterHead(p, token); + } + } + } + function endTagAfterHead(p, token) { + switch (token.tagID) { + case TAG_ID.BODY: + case TAG_ID.HTML: + case TAG_ID.BR: { + tokenAfterHead(p, token); + break; + } + case TAG_ID.TEMPLATE: { + templateEndTagInHead(p, token); + break; + } + default: { + p._err(token, ERR.endTagWithoutMatchingOpenElement); + } + } + } + function tokenAfterHead(p, token) { + p._insertFakeElement(TAG_NAMES.BODY, TAG_ID.BODY); + p.insertionMode = InsertionMode.IN_BODY; + modeInBody(p, token); + } + function modeInBody(p, token) { + switch (token.type) { + case TokenType.CHARACTER: { + characterInBody(p, token); + break; + } + case TokenType.WHITESPACE_CHARACTER: { + whitespaceCharacterInBody(p, token); + break; + } + case TokenType.COMMENT: { + appendComment(p, token); + break; + } + case TokenType.START_TAG: { + startTagInBody(p, token); + break; + } + case TokenType.END_TAG: { + endTagInBody(p, token); + break; + } + case TokenType.EOF: { + eofInBody(p, token); + break; + } + default: + } + } + 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 = InsertionMode.IN_FRAMESET; + } + } + function addressStartTagInBody(p, token) { + if (p.openElements.hasInButtonScope(TAG_ID.P)) { + p._closePElement(); + } + p._insertElement(token, NS.HTML); + } + function numberedHeaderStartTagInBody(p, token) { + if (p.openElements.hasInButtonScope(TAG_ID.P)) { + p._closePElement(); + } + if (isNumberedHeader(p.openElements.currentTagId)) { + p.openElements.pop(); + } + p._insertElement(token, NS.HTML); + } + function preStartTagInBody(p, token) { + if (p.openElements.hasInButtonScope(TAG_ID.P)) { + p._closePElement(); + } + p._insertElement(token, NS.HTML); + p.skipNextNewLine = true; + p.framesetOk = false; + } + function formStartTagInBody(p, token) { + const inTemplate = p.openElements.tmplCount > 0; + if (!p.formElement || inTemplate) { + if (p.openElements.hasInButtonScope(TAG_ID.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.tagID; + for (let i = p.openElements.stackTop; i >= 0; i--) { + const elementId = p.openElements.tagIDs[i]; + if (tn === TAG_ID.LI && elementId === TAG_ID.LI || (tn === TAG_ID.DD || tn === TAG_ID.DT) && (elementId === TAG_ID.DD || elementId === TAG_ID.DT)) { + p.openElements.generateImpliedEndTagsWithExclusion(elementId); + p.openElements.popUntilTagNamePopped(elementId); + break; + } + if (elementId !== TAG_ID.ADDRESS && elementId !== TAG_ID.DIV && elementId !== TAG_ID.P && p._isSpecialElement(p.openElements.items[i], elementId)) { + break; + } + } + if (p.openElements.hasInButtonScope(TAG_ID.P)) { + p._closePElement(); + } + p._insertElement(token, NS.HTML); + } + function plaintextStartTagInBody(p, token) { + if (p.openElements.hasInButtonScope(TAG_ID.P)) { + p._closePElement(); + } + p._insertElement(token, NS.HTML); + p.tokenizer.state = TokenizerMode.PLAINTEXT; + } + function buttonStartTagInBody(p, token) { + if (p.openElements.hasInScope(TAG_ID.BUTTON)) { + p.openElements.generateImpliedEndTags(); + p.openElements.popUntilTagNamePopped(TAG_ID.BUTTON); + } + p._reconstructActiveFormattingElements(); + p._insertElement(token, NS.HTML); + p.framesetOk = false; + } + function aStartTagInBody(p, token) { + const activeElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName(TAG_NAMES.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(TAG_ID.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) !== DOCUMENT_MODE.QUIRKS && p.openElements.hasInButtonScope(TAG_ID.P)) { + p._closePElement(); + } + p._insertElement(token, NS.HTML); + p.framesetOk = false; + p.insertionMode = InsertionMode.IN_TABLE; + } + function areaStartTagInBody(p, token) { + p._reconstructActiveFormattingElements(); + p._appendElement(token, NS.HTML); + p.framesetOk = false; + token.ackSelfClosing = true; + } + function isHiddenInput(token) { + const inputType = getTokenAttr(token, ATTRS.TYPE); + return inputType != null && inputType.toLowerCase() === HIDDEN_INPUT_TYPE; + } + function inputStartTagInBody(p, token) { + p._reconstructActiveFormattingElements(); + p._appendElement(token, NS.HTML); + if (!isHiddenInput(token)) { + 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(TAG_ID.P)) { + p._closePElement(); + } + p._appendElement(token, NS.HTML); + p.framesetOk = false; + token.ackSelfClosing = true; + } + function imageStartTagInBody(p, token) { + token.tagName = TAG_NAMES.IMG; + token.tagID = TAG_ID.IMG; + areaStartTagInBody(p, token); + } + function textareaStartTagInBody(p, token) { + p._insertElement(token, NS.HTML); + p.skipNextNewLine = true; + p.tokenizer.state = TokenizerMode.RCDATA; + p.originalInsertionMode = p.insertionMode; + p.framesetOk = false; + p.insertionMode = InsertionMode.TEXT; + } + function xmpStartTagInBody(p, token) { + if (p.openElements.hasInButtonScope(TAG_ID.P)) { + p._closePElement(); + } + p._reconstructActiveFormattingElements(); + p.framesetOk = false; + p._switchToTextParsing(token, TokenizerMode.RAWTEXT); + } + function iframeStartTagInBody(p, token) { + p.framesetOk = false; + p._switchToTextParsing(token, TokenizerMode.RAWTEXT); + } + function noembedStartTagInBody(p, token) { + p._switchToTextParsing(token, TokenizerMode.RAWTEXT); + } + function selectStartTagInBody(p, token) { + p._reconstructActiveFormattingElements(); + p._insertElement(token, NS.HTML); + p.framesetOk = false; + p.insertionMode = p.insertionMode === InsertionMode.IN_TABLE || p.insertionMode === InsertionMode.IN_CAPTION || p.insertionMode === InsertionMode.IN_TABLE_BODY || p.insertionMode === InsertionMode.IN_ROW || p.insertionMode === InsertionMode.IN_CELL ? InsertionMode.IN_SELECT_IN_TABLE : InsertionMode.IN_SELECT; + } + function optgroupStartTagInBody(p, token) { + if (p.openElements.currentTagId === TAG_ID.OPTION) { + p.openElements.pop(); + } + p._reconstructActiveFormattingElements(); + p._insertElement(token, NS.HTML); + } + function rbStartTagInBody(p, token) { + if (p.openElements.hasInScope(TAG_ID.RUBY)) { + p.openElements.generateImpliedEndTags(); + } + p._insertElement(token, NS.HTML); + } + function rtStartTagInBody(p, token) { + if (p.openElements.hasInScope(TAG_ID.RUBY)) { + p.openElements.generateImpliedEndTagsWithExclusion(TAG_ID.RTC); + } + p._insertElement(token, NS.HTML); + } + function mathStartTagInBody(p, token) { + p._reconstructActiveFormattingElements(); + adjustTokenMathMLAttrs(token); + 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(); + adjustTokenSVGAttrs(token); + 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); + } + function startTagInBody(p, token) { + switch (token.tagID) { + case TAG_ID.I: + case TAG_ID.S: + case TAG_ID.B: + case TAG_ID.U: + case TAG_ID.EM: + case TAG_ID.TT: + case TAG_ID.BIG: + case TAG_ID.CODE: + case TAG_ID.FONT: + case TAG_ID.SMALL: + case TAG_ID.STRIKE: + case TAG_ID.STRONG: { + bStartTagInBody(p, token); + break; + } + case TAG_ID.A: { + aStartTagInBody(p, token); + break; + } + case TAG_ID.H1: + case TAG_ID.H2: + case TAG_ID.H3: + case TAG_ID.H4: + case TAG_ID.H5: + case TAG_ID.H6: { + numberedHeaderStartTagInBody(p, token); + break; + } + case TAG_ID.P: + case TAG_ID.DL: + case TAG_ID.OL: + case TAG_ID.UL: + case TAG_ID.DIV: + case TAG_ID.DIR: + case TAG_ID.NAV: + case TAG_ID.MAIN: + case TAG_ID.MENU: + case TAG_ID.ASIDE: + case TAG_ID.CENTER: + case TAG_ID.FIGURE: + case TAG_ID.FOOTER: + case TAG_ID.HEADER: + case TAG_ID.HGROUP: + case TAG_ID.DIALOG: + case TAG_ID.DETAILS: + case TAG_ID.ADDRESS: + case TAG_ID.ARTICLE: + case TAG_ID.SECTION: + case TAG_ID.SUMMARY: + case TAG_ID.FIELDSET: + case TAG_ID.BLOCKQUOTE: + case TAG_ID.FIGCAPTION: { + addressStartTagInBody(p, token); + break; + } + case TAG_ID.LI: + case TAG_ID.DD: + case TAG_ID.DT: { + listItemStartTagInBody(p, token); + break; + } + case TAG_ID.BR: + case TAG_ID.IMG: + case TAG_ID.WBR: + case TAG_ID.AREA: + case TAG_ID.EMBED: + case TAG_ID.KEYGEN: { + areaStartTagInBody(p, token); + break; + } + case TAG_ID.HR: { + hrStartTagInBody(p, token); + break; + } + case TAG_ID.RB: + case TAG_ID.RTC: { + rbStartTagInBody(p, token); + break; + } + case TAG_ID.RT: + case TAG_ID.RP: { + rtStartTagInBody(p, token); + break; + } + case TAG_ID.PRE: + case TAG_ID.LISTING: { + preStartTagInBody(p, token); + break; + } + case TAG_ID.XMP: { + xmpStartTagInBody(p, token); + break; + } + case TAG_ID.SVG: { + svgStartTagInBody(p, token); + break; + } + case TAG_ID.HTML: { + htmlStartTagInBody(p, token); + break; + } + case TAG_ID.BASE: + case TAG_ID.LINK: + case TAG_ID.META: + case TAG_ID.STYLE: + case TAG_ID.TITLE: + case TAG_ID.SCRIPT: + case TAG_ID.BGSOUND: + case TAG_ID.BASEFONT: + case TAG_ID.TEMPLATE: { + startTagInHead(p, token); + break; + } + case TAG_ID.BODY: { + bodyStartTagInBody(p, token); + break; + } + case TAG_ID.FORM: { + formStartTagInBody(p, token); + break; + } + case TAG_ID.NOBR: { + nobrStartTagInBody(p, token); + break; + } + case TAG_ID.MATH: { + mathStartTagInBody(p, token); + break; + } + case TAG_ID.TABLE: { + tableStartTagInBody(p, token); + break; + } + case TAG_ID.INPUT: { + inputStartTagInBody(p, token); + break; + } + case TAG_ID.PARAM: + case TAG_ID.TRACK: + case TAG_ID.SOURCE: { + paramStartTagInBody(p, token); + break; + } + case TAG_ID.IMAGE: { + imageStartTagInBody(p, token); + break; + } + case TAG_ID.BUTTON: { + buttonStartTagInBody(p, token); + break; + } + case TAG_ID.APPLET: + case TAG_ID.OBJECT: + case TAG_ID.MARQUEE: { + appletStartTagInBody(p, token); + break; + } + case TAG_ID.IFRAME: { + iframeStartTagInBody(p, token); + break; + } + case TAG_ID.SELECT: { + selectStartTagInBody(p, token); + break; + } + case TAG_ID.OPTION: + case TAG_ID.OPTGROUP: { + optgroupStartTagInBody(p, token); + break; + } + case TAG_ID.NOEMBED: { + noembedStartTagInBody(p, token); + break; + } + case TAG_ID.FRAMESET: { + framesetStartTagInBody(p, token); + break; + } + case TAG_ID.TEXTAREA: { + textareaStartTagInBody(p, token); + break; + } + case TAG_ID.NOSCRIPT: { + if (p.options.scriptingEnabled) { + noembedStartTagInBody(p, token); + } else { + genericStartTagInBody(p, token); + } + break; + } + case TAG_ID.PLAINTEXT: { + plaintextStartTagInBody(p, token); + break; + } + case TAG_ID.COL: + case TAG_ID.TH: + case TAG_ID.TD: + case TAG_ID.TR: + case TAG_ID.HEAD: + case TAG_ID.FRAME: + case TAG_ID.TBODY: + case TAG_ID.TFOOT: + case TAG_ID.THEAD: + case TAG_ID.CAPTION: + case TAG_ID.COLGROUP: { + break; + } + default: { + genericStartTagInBody(p, token); + } + } + } + function bodyEndTagInBody(p, token) { + if (p.openElements.hasInScope(TAG_ID.BODY)) { + p.insertionMode = InsertionMode.AFTER_BODY; + if (p.options.sourceCodeLocationInfo) { + const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement(); + if (bodyElement) { + p._setEndLocation(bodyElement, token); + } + } + } + } + function htmlEndTagInBody(p, token) { + if (p.openElements.hasInScope(TAG_ID.BODY)) { + p.insertionMode = InsertionMode.AFTER_BODY; + endTagAfterBody(p, token); + } + } + function addressEndTagInBody(p, token) { + const tn = token.tagID; + if (p.openElements.hasInScope(tn)) { + p.openElements.generateImpliedEndTags(); + p.openElements.popUntilTagNamePopped(tn); + } + } + function formEndTagInBody(p) { + const inTemplate = p.openElements.tmplCount > 0; + const { formElement } = p; + if (!inTemplate) { + p.formElement = null; + } + if ((formElement || inTemplate) && p.openElements.hasInScope(TAG_ID.FORM)) { + p.openElements.generateImpliedEndTags(); + if (inTemplate) { + p.openElements.popUntilTagNamePopped(TAG_ID.FORM); + } else if (formElement) { + p.openElements.remove(formElement); + } + } + } + function pEndTagInBody(p) { + if (!p.openElements.hasInButtonScope(TAG_ID.P)) { + p._insertFakeElement(TAG_NAMES.P, TAG_ID.P); + } + p._closePElement(); + } + function liEndTagInBody(p) { + if (p.openElements.hasInListItemScope(TAG_ID.LI)) { + p.openElements.generateImpliedEndTagsWithExclusion(TAG_ID.LI); + p.openElements.popUntilTagNamePopped(TAG_ID.LI); + } + } + function ddEndTagInBody(p, token) { + const tn = token.tagID; + 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.tagID; + if (p.openElements.hasInScope(tn)) { + p.openElements.generateImpliedEndTags(); + p.openElements.popUntilTagNamePopped(tn); + p.activeFormattingElements.clearToLastMarker(); + } + } + function brEndTagInBody(p) { + p._reconstructActiveFormattingElements(); + p._insertFakeElement(TAG_NAMES.BR, TAG_ID.BR); + p.openElements.pop(); + p.framesetOk = false; + } + function genericEndTagInBody(p, token) { + const tn = token.tagName; + const tid = token.tagID; + for (let i = p.openElements.stackTop; i > 0; i--) { + const element = p.openElements.items[i]; + const elementId = p.openElements.tagIDs[i]; + if (tid === elementId && (tid !== TAG_ID.UNKNOWN || p.treeAdapter.getTagName(element) === tn)) { + p.openElements.generateImpliedEndTagsWithExclusion(tid); + if (p.openElements.stackTop >= i) + p.openElements.shortenToLength(i); + break; + } + if (p._isSpecialElement(element, elementId)) { + break; + } + } + } + function endTagInBody(p, token) { + switch (token.tagID) { + case TAG_ID.A: + case TAG_ID.B: + case TAG_ID.I: + case TAG_ID.S: + case TAG_ID.U: + case TAG_ID.EM: + case TAG_ID.TT: + case TAG_ID.BIG: + case TAG_ID.CODE: + case TAG_ID.FONT: + case TAG_ID.NOBR: + case TAG_ID.SMALL: + case TAG_ID.STRIKE: + case TAG_ID.STRONG: { + callAdoptionAgency(p, token); + break; + } + case TAG_ID.P: { + pEndTagInBody(p); + break; + } + case TAG_ID.DL: + case TAG_ID.UL: + case TAG_ID.OL: + case TAG_ID.DIR: + case TAG_ID.DIV: + case TAG_ID.NAV: + case TAG_ID.PRE: + case TAG_ID.MAIN: + case TAG_ID.MENU: + case TAG_ID.ASIDE: + case TAG_ID.BUTTON: + case TAG_ID.CENTER: + case TAG_ID.FIGURE: + case TAG_ID.FOOTER: + case TAG_ID.HEADER: + case TAG_ID.HGROUP: + case TAG_ID.DIALOG: + case TAG_ID.ADDRESS: + case TAG_ID.ARTICLE: + case TAG_ID.DETAILS: + case TAG_ID.SECTION: + case TAG_ID.SUMMARY: + case TAG_ID.LISTING: + case TAG_ID.FIELDSET: + case TAG_ID.BLOCKQUOTE: + case TAG_ID.FIGCAPTION: { + addressEndTagInBody(p, token); + break; + } + case TAG_ID.LI: { + liEndTagInBody(p); + break; + } + case TAG_ID.DD: + case TAG_ID.DT: { + ddEndTagInBody(p, token); + break; + } + case TAG_ID.H1: + case TAG_ID.H2: + case TAG_ID.H3: + case TAG_ID.H4: + case TAG_ID.H5: + case TAG_ID.H6: { + numberedHeaderEndTagInBody(p); + break; + } + case TAG_ID.BR: { + brEndTagInBody(p); + break; + } + case TAG_ID.BODY: { + bodyEndTagInBody(p, token); + break; + } + case TAG_ID.HTML: { + htmlEndTagInBody(p, token); + break; + } + case TAG_ID.FORM: { + formEndTagInBody(p); + break; + } + case TAG_ID.APPLET: + case TAG_ID.OBJECT: + case TAG_ID.MARQUEE: { + appletEndTagInBody(p, token); + break; + } + case TAG_ID.TEMPLATE: { + templateEndTagInHead(p, token); + break; + } + default: { + genericEndTagInBody(p, token); + } + } + } + function eofInBody(p, token) { + if (p.tmplInsertionModeStack.length > 0) { + eofInTemplate(p, token); + } else { + stopParsing(p, token); + } + } + function endTagInText(p, token) { + var _a2; + if (token.tagID === TAG_ID.SCRIPT) { + (_a2 = p.scriptHandler) === null || _a2 === void 0 ? void 0 : _a2.call(p, p.openElements.current); + } + p.openElements.pop(); + p.insertionMode = p.originalInsertionMode; + } + function eofInText(p, token) { + p._err(token, ERR.eofInElementThatCanContainOnlyText); + p.openElements.pop(); + p.insertionMode = p.originalInsertionMode; + p.onEof(token); + } + function characterInTable(p, token) { + if (TABLE_STRUCTURE_TAGS.has(p.openElements.currentTagId)) { + p.pendingCharacterTokens.length = 0; + p.hasNonWhitespacePendingCharacterToken = false; + p.originalInsertionMode = p.insertionMode; + p.insertionMode = InsertionMode.IN_TABLE_TEXT; + switch (token.type) { + case TokenType.CHARACTER: { + characterInTableText(p, token); + break; + } + case TokenType.WHITESPACE_CHARACTER: { + whitespaceCharacterInTableText(p, token); + break; + } + } + } else { + tokenInTable(p, token); + } + } + function captionStartTagInTable(p, token) { + p.openElements.clearBackToTableContext(); + p.activeFormattingElements.insertMarker(); + p._insertElement(token, NS.HTML); + p.insertionMode = InsertionMode.IN_CAPTION; + } + function colgroupStartTagInTable(p, token) { + p.openElements.clearBackToTableContext(); + p._insertElement(token, NS.HTML); + p.insertionMode = InsertionMode.IN_COLUMN_GROUP; + } + function colStartTagInTable(p, token) { + p.openElements.clearBackToTableContext(); + p._insertFakeElement(TAG_NAMES.COLGROUP, TAG_ID.COLGROUP); + p.insertionMode = InsertionMode.IN_COLUMN_GROUP; + startTagInColumnGroup(p, token); + } + function tbodyStartTagInTable(p, token) { + p.openElements.clearBackToTableContext(); + p._insertElement(token, NS.HTML); + p.insertionMode = InsertionMode.IN_TABLE_BODY; + } + function tdStartTagInTable(p, token) { + p.openElements.clearBackToTableContext(); + p._insertFakeElement(TAG_NAMES.TBODY, TAG_ID.TBODY); + p.insertionMode = InsertionMode.IN_TABLE_BODY; + startTagInTableBody(p, token); + } + function tableStartTagInTable(p, token) { + if (p.openElements.hasInTableScope(TAG_ID.TABLE)) { + p.openElements.popUntilTagNamePopped(TAG_ID.TABLE); + p._resetInsertionMode(); + p._processStartTag(token); + } + } + function inputStartTagInTable(p, token) { + if (isHiddenInput(token)) { + 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) { + switch (token.tagID) { + case TAG_ID.TD: + case TAG_ID.TH: + case TAG_ID.TR: { + tdStartTagInTable(p, token); + break; + } + case TAG_ID.STYLE: + case TAG_ID.SCRIPT: + case TAG_ID.TEMPLATE: { + startTagInHead(p, token); + break; + } + case TAG_ID.COL: { + colStartTagInTable(p, token); + break; + } + case TAG_ID.FORM: { + formStartTagInTable(p, token); + break; + } + case TAG_ID.TABLE: { + tableStartTagInTable(p, token); + break; + } + case TAG_ID.TBODY: + case TAG_ID.TFOOT: + case TAG_ID.THEAD: { + tbodyStartTagInTable(p, token); + break; + } + case TAG_ID.INPUT: { + inputStartTagInTable(p, token); + break; + } + case TAG_ID.CAPTION: { + captionStartTagInTable(p, token); + break; + } + case TAG_ID.COLGROUP: { + colgroupStartTagInTable(p, token); + break; + } + default: { + tokenInTable(p, token); + } + } + } + function endTagInTable(p, token) { + switch (token.tagID) { + case TAG_ID.TABLE: { + if (p.openElements.hasInTableScope(TAG_ID.TABLE)) { + p.openElements.popUntilTagNamePopped(TAG_ID.TABLE); + p._resetInsertionMode(); + } + break; + } + case TAG_ID.TEMPLATE: { + templateEndTagInHead(p, token); + break; + } + case TAG_ID.BODY: + case TAG_ID.CAPTION: + case TAG_ID.COL: + case TAG_ID.COLGROUP: + case TAG_ID.HTML: + case TAG_ID.TBODY: + case TAG_ID.TD: + case TAG_ID.TFOOT: + case TAG_ID.TH: + case TAG_ID.THEAD: + case TAG_ID.TR: { + break; + } + default: { + tokenInTable(p, token); + } + } + } + function tokenInTable(p, token) { + const savedFosterParentingState = p.fosterParentingEnabled; + p.fosterParentingEnabled = true; + modeInBody(p, token); + p.fosterParentingEnabled = savedFosterParentingState; + } + 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); + } + var TABLE_VOID_ELEMENTS = /* @__PURE__ */ new Set([TAG_ID.CAPTION, TAG_ID.COL, TAG_ID.COLGROUP, TAG_ID.TBODY, TAG_ID.TD, TAG_ID.TFOOT, TAG_ID.TH, TAG_ID.THEAD, TAG_ID.TR]); + function startTagInCaption(p, token) { + const tn = token.tagID; + if (TABLE_VOID_ELEMENTS.has(tn)) { + if (p.openElements.hasInTableScope(TAG_ID.CAPTION)) { + p.openElements.generateImpliedEndTags(); + p.openElements.popUntilTagNamePopped(TAG_ID.CAPTION); + p.activeFormattingElements.clearToLastMarker(); + p.insertionMode = InsertionMode.IN_TABLE; + startTagInTable(p, token); + } + } else { + startTagInBody(p, token); + } + } + function endTagInCaption(p, token) { + const tn = token.tagID; + switch (tn) { + case TAG_ID.CAPTION: + case TAG_ID.TABLE: { + if (p.openElements.hasInTableScope(TAG_ID.CAPTION)) { + p.openElements.generateImpliedEndTags(); + p.openElements.popUntilTagNamePopped(TAG_ID.CAPTION); + p.activeFormattingElements.clearToLastMarker(); + p.insertionMode = InsertionMode.IN_TABLE; + if (tn === TAG_ID.TABLE) { + endTagInTable(p, token); + } + } + break; + } + case TAG_ID.BODY: + case TAG_ID.COL: + case TAG_ID.COLGROUP: + case TAG_ID.HTML: + case TAG_ID.TBODY: + case TAG_ID.TD: + case TAG_ID.TFOOT: + case TAG_ID.TH: + case TAG_ID.THEAD: + case TAG_ID.TR: { + break; + } + default: { + endTagInBody(p, token); + } + } + } + function startTagInColumnGroup(p, token) { + switch (token.tagID) { + case TAG_ID.HTML: { + startTagInBody(p, token); + break; + } + case TAG_ID.COL: { + p._appendElement(token, NS.HTML); + token.ackSelfClosing = true; + break; + } + case TAG_ID.TEMPLATE: { + startTagInHead(p, token); + break; + } + default: { + tokenInColumnGroup(p, token); + } + } + } + function endTagInColumnGroup(p, token) { + switch (token.tagID) { + case TAG_ID.COLGROUP: { + if (p.openElements.currentTagId === TAG_ID.COLGROUP) { + p.openElements.pop(); + p.insertionMode = InsertionMode.IN_TABLE; + } + break; + } + case TAG_ID.TEMPLATE: { + templateEndTagInHead(p, token); + break; + } + case TAG_ID.COL: { + break; + } + default: { + tokenInColumnGroup(p, token); + } + } + } + function tokenInColumnGroup(p, token) { + if (p.openElements.currentTagId === TAG_ID.COLGROUP) { + p.openElements.pop(); + p.insertionMode = InsertionMode.IN_TABLE; + p._processToken(token); + } + } + function startTagInTableBody(p, token) { + switch (token.tagID) { + case TAG_ID.TR: { + p.openElements.clearBackToTableBodyContext(); + p._insertElement(token, NS.HTML); + p.insertionMode = InsertionMode.IN_ROW; + break; + } + case TAG_ID.TH: + case TAG_ID.TD: { + p.openElements.clearBackToTableBodyContext(); + p._insertFakeElement(TAG_NAMES.TR, TAG_ID.TR); + p.insertionMode = InsertionMode.IN_ROW; + startTagInRow(p, token); + break; + } + case TAG_ID.CAPTION: + case TAG_ID.COL: + case TAG_ID.COLGROUP: + case TAG_ID.TBODY: + case TAG_ID.TFOOT: + case TAG_ID.THEAD: { + if (p.openElements.hasTableBodyContextInTableScope()) { + p.openElements.clearBackToTableBodyContext(); + p.openElements.pop(); + p.insertionMode = InsertionMode.IN_TABLE; + startTagInTable(p, token); + } + break; + } + default: { + startTagInTable(p, token); + } + } + } + function endTagInTableBody(p, token) { + const tn = token.tagID; + switch (token.tagID) { + case TAG_ID.TBODY: + case TAG_ID.TFOOT: + case TAG_ID.THEAD: { + if (p.openElements.hasInTableScope(tn)) { + p.openElements.clearBackToTableBodyContext(); + p.openElements.pop(); + p.insertionMode = InsertionMode.IN_TABLE; + } + break; + } + case TAG_ID.TABLE: { + if (p.openElements.hasTableBodyContextInTableScope()) { + p.openElements.clearBackToTableBodyContext(); + p.openElements.pop(); + p.insertionMode = InsertionMode.IN_TABLE; + endTagInTable(p, token); + } + break; + } + case TAG_ID.BODY: + case TAG_ID.CAPTION: + case TAG_ID.COL: + case TAG_ID.COLGROUP: + case TAG_ID.HTML: + case TAG_ID.TD: + case TAG_ID.TH: + case TAG_ID.TR: { + break; + } + default: { + endTagInTable(p, token); + } + } + } + function startTagInRow(p, token) { + switch (token.tagID) { + case TAG_ID.TH: + case TAG_ID.TD: { + p.openElements.clearBackToTableRowContext(); + p._insertElement(token, NS.HTML); + p.insertionMode = InsertionMode.IN_CELL; + p.activeFormattingElements.insertMarker(); + break; + } + case TAG_ID.CAPTION: + case TAG_ID.COL: + case TAG_ID.COLGROUP: + case TAG_ID.TBODY: + case TAG_ID.TFOOT: + case TAG_ID.THEAD: + case TAG_ID.TR: { + if (p.openElements.hasInTableScope(TAG_ID.TR)) { + p.openElements.clearBackToTableRowContext(); + p.openElements.pop(); + p.insertionMode = InsertionMode.IN_TABLE_BODY; + startTagInTableBody(p, token); + } + break; + } + default: { + startTagInTable(p, token); + } + } + } + function endTagInRow(p, token) { + switch (token.tagID) { + case TAG_ID.TR: { + if (p.openElements.hasInTableScope(TAG_ID.TR)) { + p.openElements.clearBackToTableRowContext(); + p.openElements.pop(); + p.insertionMode = InsertionMode.IN_TABLE_BODY; + } + break; + } + case TAG_ID.TABLE: { + if (p.openElements.hasInTableScope(TAG_ID.TR)) { + p.openElements.clearBackToTableRowContext(); + p.openElements.pop(); + p.insertionMode = InsertionMode.IN_TABLE_BODY; + endTagInTableBody(p, token); + } + break; + } + case TAG_ID.TBODY: + case TAG_ID.TFOOT: + case TAG_ID.THEAD: { + if (p.openElements.hasInTableScope(token.tagID) || p.openElements.hasInTableScope(TAG_ID.TR)) { + p.openElements.clearBackToTableRowContext(); + p.openElements.pop(); + p.insertionMode = InsertionMode.IN_TABLE_BODY; + endTagInTableBody(p, token); + } + break; + } + case TAG_ID.BODY: + case TAG_ID.CAPTION: + case TAG_ID.COL: + case TAG_ID.COLGROUP: + case TAG_ID.HTML: + case TAG_ID.TD: + case TAG_ID.TH: { + break; + } + default: { + endTagInTable(p, token); + } + } + } + function startTagInCell(p, token) { + const tn = token.tagID; + if (TABLE_VOID_ELEMENTS.has(tn)) { + if (p.openElements.hasInTableScope(TAG_ID.TD) || p.openElements.hasInTableScope(TAG_ID.TH)) { + p._closeTableCell(); + startTagInRow(p, token); + } + } else { + startTagInBody(p, token); + } + } + function endTagInCell(p, token) { + const tn = token.tagID; + switch (tn) { + case TAG_ID.TD: + case TAG_ID.TH: { + if (p.openElements.hasInTableScope(tn)) { + p.openElements.generateImpliedEndTags(); + p.openElements.popUntilTagNamePopped(tn); + p.activeFormattingElements.clearToLastMarker(); + p.insertionMode = InsertionMode.IN_ROW; + } + break; + } + case TAG_ID.TABLE: + case TAG_ID.TBODY: + case TAG_ID.TFOOT: + case TAG_ID.THEAD: + case TAG_ID.TR: { + if (p.openElements.hasInTableScope(tn)) { + p._closeTableCell(); + endTagInRow(p, token); + } + break; + } + case TAG_ID.BODY: + case TAG_ID.CAPTION: + case TAG_ID.COL: + case TAG_ID.COLGROUP: + case TAG_ID.HTML: { + break; + } + default: { + endTagInBody(p, token); + } + } + } + function startTagInSelect(p, token) { + switch (token.tagID) { + case TAG_ID.HTML: { + startTagInBody(p, token); + break; + } + case TAG_ID.OPTION: { + if (p.openElements.currentTagId === TAG_ID.OPTION) { + p.openElements.pop(); + } + p._insertElement(token, NS.HTML); + break; + } + case TAG_ID.OPTGROUP: { + if (p.openElements.currentTagId === TAG_ID.OPTION) { + p.openElements.pop(); + } + if (p.openElements.currentTagId === TAG_ID.OPTGROUP) { + p.openElements.pop(); + } + p._insertElement(token, NS.HTML); + break; + } + case TAG_ID.INPUT: + case TAG_ID.KEYGEN: + case TAG_ID.TEXTAREA: + case TAG_ID.SELECT: { + if (p.openElements.hasInSelectScope(TAG_ID.SELECT)) { + p.openElements.popUntilTagNamePopped(TAG_ID.SELECT); + p._resetInsertionMode(); + if (token.tagID !== TAG_ID.SELECT) { + p._processStartTag(token); + } + } + break; + } + case TAG_ID.SCRIPT: + case TAG_ID.TEMPLATE: { + startTagInHead(p, token); + break; + } + default: + } + } + function endTagInSelect(p, token) { + switch (token.tagID) { + case TAG_ID.OPTGROUP: { + if (p.openElements.stackTop > 0 && p.openElements.currentTagId === TAG_ID.OPTION && p.openElements.tagIDs[p.openElements.stackTop - 1] === TAG_ID.OPTGROUP) { + p.openElements.pop(); + } + if (p.openElements.currentTagId === TAG_ID.OPTGROUP) { + p.openElements.pop(); + } + break; + } + case TAG_ID.OPTION: { + if (p.openElements.currentTagId === TAG_ID.OPTION) { + p.openElements.pop(); + } + break; + } + case TAG_ID.SELECT: { + if (p.openElements.hasInSelectScope(TAG_ID.SELECT)) { + p.openElements.popUntilTagNamePopped(TAG_ID.SELECT); + p._resetInsertionMode(); + } + break; + } + case TAG_ID.TEMPLATE: { + templateEndTagInHead(p, token); + break; + } + default: + } + } + function startTagInSelectInTable(p, token) { + const tn = token.tagID; + if (tn === TAG_ID.CAPTION || tn === TAG_ID.TABLE || tn === TAG_ID.TBODY || tn === TAG_ID.TFOOT || tn === TAG_ID.THEAD || tn === TAG_ID.TR || tn === TAG_ID.TD || tn === TAG_ID.TH) { + p.openElements.popUntilTagNamePopped(TAG_ID.SELECT); + p._resetInsertionMode(); + p._processStartTag(token); + } else { + startTagInSelect(p, token); + } + } + function endTagInSelectInTable(p, token) { + const tn = token.tagID; + if (tn === TAG_ID.CAPTION || tn === TAG_ID.TABLE || tn === TAG_ID.TBODY || tn === TAG_ID.TFOOT || tn === TAG_ID.THEAD || tn === TAG_ID.TR || tn === TAG_ID.TD || tn === TAG_ID.TH) { + if (p.openElements.hasInTableScope(tn)) { + p.openElements.popUntilTagNamePopped(TAG_ID.SELECT); + p._resetInsertionMode(); + p.onEndTag(token); + } + } else { + endTagInSelect(p, token); + } + } + function startTagInTemplate(p, token) { + switch (token.tagID) { + case TAG_ID.BASE: + case TAG_ID.BASEFONT: + case TAG_ID.BGSOUND: + case TAG_ID.LINK: + case TAG_ID.META: + case TAG_ID.NOFRAMES: + case TAG_ID.SCRIPT: + case TAG_ID.STYLE: + case TAG_ID.TEMPLATE: + case TAG_ID.TITLE: { + startTagInHead(p, token); + break; + } + case TAG_ID.CAPTION: + case TAG_ID.COLGROUP: + case TAG_ID.TBODY: + case TAG_ID.TFOOT: + case TAG_ID.THEAD: { + p.tmplInsertionModeStack[0] = InsertionMode.IN_TABLE; + p.insertionMode = InsertionMode.IN_TABLE; + startTagInTable(p, token); + break; + } + case TAG_ID.COL: { + p.tmplInsertionModeStack[0] = InsertionMode.IN_COLUMN_GROUP; + p.insertionMode = InsertionMode.IN_COLUMN_GROUP; + startTagInColumnGroup(p, token); + break; + } + case TAG_ID.TR: { + p.tmplInsertionModeStack[0] = InsertionMode.IN_TABLE_BODY; + p.insertionMode = InsertionMode.IN_TABLE_BODY; + startTagInTableBody(p, token); + break; + } + case TAG_ID.TD: + case TAG_ID.TH: { + p.tmplInsertionModeStack[0] = InsertionMode.IN_ROW; + p.insertionMode = InsertionMode.IN_ROW; + startTagInRow(p, token); + break; + } + default: { + p.tmplInsertionModeStack[0] = InsertionMode.IN_BODY; + p.insertionMode = InsertionMode.IN_BODY; + startTagInBody(p, token); + } + } + } + function endTagInTemplate(p, token) { + if (token.tagID === TAG_ID.TEMPLATE) { + templateEndTagInHead(p, token); + } + } + function eofInTemplate(p, token) { + if (p.openElements.tmplCount > 0) { + p.openElements.popUntilTagNamePopped(TAG_ID.TEMPLATE); + p.activeFormattingElements.clearToLastMarker(); + p.tmplInsertionModeStack.shift(); + p._resetInsertionMode(); + p.onEof(token); + } else { + stopParsing(p, token); + } + } + function startTagAfterBody(p, token) { + if (token.tagID === TAG_ID.HTML) { + startTagInBody(p, token); + } else { + tokenAfterBody(p, token); + } + } + function endTagAfterBody(p, token) { + var _a2; + if (token.tagID === TAG_ID.HTML) { + if (!p.fragmentContext) { + p.insertionMode = InsertionMode.AFTER_AFTER_BODY; + } + if (p.options.sourceCodeLocationInfo && p.openElements.tagIDs[0] === TAG_ID.HTML) { + p._setEndLocation(p.openElements.items[0], token); + const bodyElement = p.openElements.items[1]; + if (bodyElement && !((_a2 = p.treeAdapter.getNodeSourceCodeLocation(bodyElement)) === null || _a2 === void 0 ? void 0 : _a2.endTag)) { + p._setEndLocation(bodyElement, token); + } + } + } else { + tokenAfterBody(p, token); + } + } + function tokenAfterBody(p, token) { + p.insertionMode = InsertionMode.IN_BODY; + modeInBody(p, token); + } + function startTagInFrameset(p, token) { + switch (token.tagID) { + case TAG_ID.HTML: { + startTagInBody(p, token); + break; + } + case TAG_ID.FRAMESET: { + p._insertElement(token, NS.HTML); + break; + } + case TAG_ID.FRAME: { + p._appendElement(token, NS.HTML); + token.ackSelfClosing = true; + break; + } + case TAG_ID.NOFRAMES: { + startTagInHead(p, token); + break; + } + default: + } + } + function endTagInFrameset(p, token) { + if (token.tagID === TAG_ID.FRAMESET && !p.openElements.isRootHtmlElementCurrent()) { + p.openElements.pop(); + if (!p.fragmentContext && p.openElements.currentTagId !== TAG_ID.FRAMESET) { + p.insertionMode = InsertionMode.AFTER_FRAMESET; + } + } + } + function startTagAfterFrameset(p, token) { + switch (token.tagID) { + case TAG_ID.HTML: { + startTagInBody(p, token); + break; + } + case TAG_ID.NOFRAMES: { + startTagInHead(p, token); + break; + } + default: + } + } + function endTagAfterFrameset(p, token) { + if (token.tagID === TAG_ID.HTML) { + p.insertionMode = InsertionMode.AFTER_AFTER_FRAMESET; + } + } + function startTagAfterAfterBody(p, token) { + if (token.tagID === TAG_ID.HTML) { + startTagInBody(p, token); + } else { + tokenAfterAfterBody(p, token); + } + } + function tokenAfterAfterBody(p, token) { + p.insertionMode = InsertionMode.IN_BODY; + modeInBody(p, token); + } + function startTagAfterAfterFrameset(p, token) { + switch (token.tagID) { + case TAG_ID.HTML: { + startTagInBody(p, token); + break; + } + case TAG_ID.NOFRAMES: { + startTagInHead(p, token); + break; + } + default: + } + } + function nullCharacterInForeignContent(p, token) { + token.chars = REPLACEMENT_CHARACTER; + p._insertCharacters(token); + } + function characterInForeignContent(p, token) { + p._insertCharacters(token); + p.framesetOk = false; + } + function popUntilHtmlOrIntegrationPoint(p) { + while (p.treeAdapter.getNamespaceURI(p.openElements.current) !== NS.HTML && !p._isIntegrationPoint(p.openElements.currentTagId, p.openElements.current)) { + p.openElements.pop(); + } + } + function startTagInForeignContent(p, token) { + if (causesExit(token)) { + popUntilHtmlOrIntegrationPoint(p); + p._startTagOutsideForeignContent(token); + } else { + const current = p._getAdjustedCurrentElement(); + const currentNs = p.treeAdapter.getNamespaceURI(current); + if (currentNs === NS.MATHML) { + adjustTokenMathMLAttrs(token); + } else if (currentNs === NS.SVG) { + adjustTokenSVGTagName(token); + adjustTokenSVGAttrs(token); + } + adjustTokenXMLAttrs(token); + if (token.selfClosing) { + p._appendElement(token, currentNs); + } else { + p._insertElement(token, currentNs); + } + token.ackSelfClosing = true; + } + } + function endTagInForeignContent(p, token) { + if (token.tagID === TAG_ID.P || token.tagID === TAG_ID.BR) { + popUntilHtmlOrIntegrationPoint(p); + p._endTagOutsideForeignContent(token); + return; + } + for (let i = p.openElements.stackTop; i > 0; i--) { + const element = p.openElements.items[i]; + if (p.treeAdapter.getNamespaceURI(element) === NS.HTML) { + p._endTagOutsideForeignContent(token); + break; + } + const tagName = p.treeAdapter.getTagName(element); + if (tagName.toLowerCase() === token.tagName) { + token.tagName = tagName; + p.openElements.shortenToLength(i); + break; + } + } + } + + // node_modules/entities/lib/esm/escape.js + var xmlCodeMap = /* @__PURE__ */ new Map([ + [34, """], + [38, "&"], + [39, "'"], + [60, "<"], + [62, ">"] + ]); + var getCodePoint = ( + // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition + String.prototype.codePointAt != null ? (str, index) => str.codePointAt(index) : ( + // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + (c, index) => (c.charCodeAt(index) & 64512) === 55296 ? (c.charCodeAt(index) - 55296) * 1024 + c.charCodeAt(index + 1) - 56320 + 65536 : c.charCodeAt(index) + ) + ); + function getEscaper(regex, map) { + return function escape(data) { + let match; + let lastIdx = 0; + let result = ""; + while (match = regex.exec(data)) { + if (lastIdx !== match.index) { + result += data.substring(lastIdx, match.index); + } + result += map.get(match[0].charCodeAt(0)); + lastIdx = match.index + 1; + } + return result + data.substring(lastIdx); + }; + } + var escapeUTF8 = getEscaper(/[&<>'"]/g, xmlCodeMap); + var escapeAttribute = getEscaper(/["&\u00A0]/g, /* @__PURE__ */ new Map([ + [34, """], + [38, "&"], + [160, " "] + ])); + var escapeText = getEscaper(/[&<>\u00A0]/g, /* @__PURE__ */ new Map([ + [38, "&"], + [60, "<"], + [62, ">"], + [160, " "] + ])); + + // node_modules/parse5/dist/serializer/index.js + var VOID_ELEMENTS = /* @__PURE__ */ new Set([ + TAG_NAMES.AREA, + TAG_NAMES.BASE, + TAG_NAMES.BASEFONT, + TAG_NAMES.BGSOUND, + TAG_NAMES.BR, + TAG_NAMES.COL, + TAG_NAMES.EMBED, + TAG_NAMES.FRAME, + TAG_NAMES.HR, + TAG_NAMES.IMG, + TAG_NAMES.INPUT, + TAG_NAMES.KEYGEN, + TAG_NAMES.LINK, + TAG_NAMES.META, + TAG_NAMES.PARAM, + TAG_NAMES.SOURCE, + TAG_NAMES.TRACK, + TAG_NAMES.WBR + ]); + function isVoidElement(node, options) { + return options.treeAdapter.isElementNode(node) && options.treeAdapter.getNamespaceURI(node) === NS.HTML && VOID_ELEMENTS.has(options.treeAdapter.getTagName(node)); + } + var defaultOpts = { treeAdapter: defaultTreeAdapter, scriptingEnabled: true }; + function serialize(node, options) { + const opts = { ...defaultOpts, ...options }; + if (isVoidElement(node, opts)) { + return ""; + } + return serializeChildNodes(node, opts); + } + function serializeChildNodes(parentNode, options) { + let html = ""; + const container = options.treeAdapter.isElementNode(parentNode) && options.treeAdapter.getTagName(parentNode) === TAG_NAMES.TEMPLATE && options.treeAdapter.getNamespaceURI(parentNode) === NS.HTML ? options.treeAdapter.getTemplateContent(parentNode) : parentNode; + const childNodes = options.treeAdapter.getChildNodes(container); + if (childNodes) { + for (const currentNode of childNodes) { + html += serializeNode(currentNode, options); + } + } + return html; + } + function serializeNode(node, options) { + if (options.treeAdapter.isElementNode(node)) { + return serializeElement(node, options); + } + if (options.treeAdapter.isTextNode(node)) { + return serializeTextNode(node, options); + } + if (options.treeAdapter.isCommentNode(node)) { + return serializeCommentNode(node, options); + } + if (options.treeAdapter.isDocumentTypeNode(node)) { + return serializeDocumentTypeNode(node, options); + } + return ""; + } + function serializeElement(node, options) { + const tn = options.treeAdapter.getTagName(node); + return `<${tn}${serializeAttributes(node, options)}>${isVoidElement(node, options) ? "" : `${serializeChildNodes(node, options)}`}`; + } + function serializeAttributes(node, { treeAdapter }) { + let html = ""; + for (const attr of treeAdapter.getAttrList(node)) { + html += " "; + if (!attr.namespace) { + html += attr.name; + } else + switch (attr.namespace) { + case NS.XML: { + html += `xml:${attr.name}`; + break; + } + case NS.XMLNS: { + if (attr.name !== "xmlns") { + html += "xmlns:"; + } + html += attr.name; + break; + } + case NS.XLINK: { + html += `xlink:${attr.name}`; + break; + } + default: { + html += `${attr.prefix}:${attr.name}`; + } + } + html += `="${escapeAttribute(attr.value)}"`; + } + return html; + } + function serializeTextNode(node, options) { + const { treeAdapter } = options; + const content = treeAdapter.getTextNodeContent(node); + const parent = treeAdapter.getParentNode(node); + const parentTn = parent && treeAdapter.isElementNode(parent) && treeAdapter.getTagName(parent); + return parentTn && treeAdapter.getNamespaceURI(parent) === NS.HTML && hasUnescapedText(parentTn, options.scriptingEnabled) ? content : escapeText(content); + } + function serializeCommentNode(node, { treeAdapter }) { + return ``; + } + function serializeDocumentTypeNode(node, { treeAdapter }) { + return ``; + } + + // node_modules/parse5/dist/index.js + function parse(html, options) { + return Parser.parse(html, options); + } + function parseFragment(fragmentContext, html, options) { + if (typeof fragmentContext === "string") { + options = html; + html = fragmentContext; + fragmentContext = null; + } + const parser = Parser.getFragmentParser(fragmentContext, options); + parser.tokenizer.write(html, true); + return parser.getFragment(); + } + + // src/rewrite/html.js + var HTML = class extends import_events.default { + /** + * + * @param {Ultraviolet} ctx + */ + constructor(ctx) { + super(); + this.ctx = ctx; + this.rewriteUrl = ctx.rewriteUrl; + this.sourceUrl = ctx.sourceUrl; + } + rewrite(str, options = {}) { + if (!str) + return str; + return this.recast( + str, + (node) => { + if (node.tagName) + this.emit("element", node, "rewrite"); + if (node.attr) + this.emit("attr", node, "rewrite"); + if (node.nodeName === "#text") + this.emit("text", node, "rewrite"); + }, + options + ); + } + source(str, options = {}) { + if (!str) + return str; + return this.recast( + str, + (node) => { + if (node.tagName) + this.emit("element", node, "source"); + if (node.attr) + this.emit("attr", node, "source"); + if (node.nodeName === "#text") + this.emit("text", node, "source"); + }, + options + ); + } + recast(str, fn, options = {}) { + try { + const ast = (options.document ? parse : parseFragment)( + new String(str).toString() + ); + this.iterate(ast, fn, options); + return serialize(ast); + } catch (e) { + return str; + } + } + iterate(ast, fn, fnOptions) { + if (!ast) + return ast; + if (ast.tagName) { + const element = new P5Element(ast, false, fnOptions); + fn(element); + if (ast.attrs) { + for (const attr of ast.attrs) { + if (!attr.skip) + fn(new AttributeEvent(element, attr, fnOptions)); + } + } + } + if (ast.childNodes) { + for (const child of ast.childNodes) { + if (!child.skip) + this.iterate(child, fn, fnOptions); + } + } + if (ast.nodeName === "#text") { + fn( + new TextEvent( + ast, + new P5Element(ast.parentNode), + false, + fnOptions + ) + ); + } + return ast; + } + wrapSrcset(str, meta = this.ctx.meta) { + return str.split(",").map((src) => { + const parts = src.trimStart().split(" "); + if (parts[0]) + parts[0] = this.ctx.rewriteUrl(parts[0], meta); + return parts.join(" "); + }).join(", "); + } + unwrapSrcset(str, meta = this.ctx.meta) { + return str.split(",").map((src) => { + const parts = src.trimStart().split(" "); + if (parts[0]) + parts[0] = this.ctx.sourceUrl(parts[0], meta); + return parts.join(" "); + }).join(", "); + } + static parse = parse; + static parseFragment = parseFragment; + static serialize = serialize; + }; + var P5Element = class _P5Element extends import_events.default { + constructor(node, stream = false, options = {}) { + super(); + this.stream = stream; + this.node = node; + this.options = options; + } + setAttribute(name42, value) { + for (const attr of this.attrs) { + if (attr.name === name42) { + attr.value = value; + return true; + } + } + this.attrs.push({ + name: name42, + value + }); + } + getAttribute(name42) { + const attr = this.attrs.find((attr2) => attr2.name === name42) || {}; + return attr.value; + } + hasAttribute(name42) { + return !!this.attrs.find((attr) => attr.name === name42); + } + removeAttribute(name42) { + const i = this.attrs.findIndex((attr) => attr.name === name42); + if (typeof i !== "undefined") + this.attrs.splice(i, 1); + } + get tagName() { + return this.node.tagName; + } + set tagName(val) { + this.node.tagName = val; + } + get childNodes() { + return !this.stream ? this.node.childNodes : null; + } + get innerHTML() { + return !this.stream ? serialize({ + nodeName: "#document-fragment", + childNodes: this.childNodes + }) : null; + } + set innerHTML(val) { + if (!this.stream) + this.node.childNodes = parseFragment(val).childNodes; + } + get outerHTML() { + return !this.stream ? serialize({ + nodeName: "#document-fragment", + childNodes: [this] + }) : null; + } + set outerHTML(val) { + if (!this.stream) + this.parentNode.childNodes.splice( + this.parentNode.childNodes.findIndex( + (node) => node === this.node + ), + 1, + ...parseFragment(val).childNodes + ); + } + get textContent() { + if (this.stream) + return null; + let str = ""; + this.iterate(this.node, (node) => { + if (node.nodeName === "#text") + str += node.value; + }); + return str; + } + set textContent(val) { + if (!this.stream) + this.node.childNodes = [ + { + nodeName: "#text", + value: val, + parentNode: this.node + } + ]; + } + get nodeName() { + return this.node.nodeName; + } + get parentNode() { + return this.node.parentNode ? new _P5Element(this.node.parentNode) : null; + } + get attrs() { + return this.node.attrs; + } + get namespaceURI() { + return this.node.namespaceURI; + } + }; + var AttributeEvent = class { + constructor(node, attr, options = {}) { + this.attr = attr; + this.attrs = node.attrs; + this.node = node; + this.options = options; + } + delete() { + const i = this.attrs.findIndex((attr) => attr === this.attr); + this.attrs.splice(i, 1); + Object.defineProperty(this, "deleted", { + get: () => true + }); + return true; + } + get name() { + return this.attr.name; + } + set name(val) { + this.attr.name = val; + } + get value() { + return this.attr.value; + } + set value(val) { + this.attr.value = val; + } + get deleted() { + return false; + } + }; + var TextEvent = class { + constructor(node, element, stream = false, options = {}) { + this.stream = stream; + this.node = node; + this.element = element; + this.options = options; + } + get nodeName() { + return this.node.nodeName; + } + get parentNode() { + return this.element; + } + get value() { + return this.stream ? this.node.text : this.node.value; + } + set value(val) { + if (this.stream) + this.node.text = val; + else + this.node.value = val; + } + }; + var html_default = HTML; + + // node_modules/css-tree/lib/tokenizer/types.js + var EOF = 0; + var Ident = 1; + var Function2 = 2; + var AtKeyword = 3; + var Hash = 4; + var String2 = 5; + var BadString = 6; + var Url = 7; + var BadUrl = 8; + var Delim = 9; + var Number2 = 10; + var Percentage = 11; + var Dimension = 12; + var WhiteSpace = 13; + var CDO = 14; + var CDC = 15; + var Colon = 16; + var Semicolon = 17; + var Comma = 18; + var LeftSquareBracket = 19; + var RightSquareBracket = 20; + var LeftParenthesis = 21; + var RightParenthesis = 22; + var LeftCurlyBracket = 23; + var RightCurlyBracket = 24; + var Comment = 25; + + // node_modules/css-tree/lib/tokenizer/char-code-definitions.js + var EOF2 = 0; + function isDigit(code2) { + return code2 >= 48 && code2 <= 57; + } + function isHexDigit(code2) { + return isDigit(code2) || // 0 .. 9 + code2 >= 65 && code2 <= 70 || // A .. F + code2 >= 97 && code2 <= 102; + } + function isUppercaseLetter(code2) { + return code2 >= 65 && code2 <= 90; + } + function isLowercaseLetter(code2) { + return code2 >= 97 && code2 <= 122; + } + function isLetter(code2) { + return isUppercaseLetter(code2) || isLowercaseLetter(code2); + } + function isNonAscii(code2) { + return code2 >= 128; + } + function isNameStart(code2) { + return isLetter(code2) || isNonAscii(code2) || code2 === 95; + } + function isName(code2) { + return isNameStart(code2) || isDigit(code2) || code2 === 45; + } + function isNonPrintable(code2) { + return code2 >= 0 && code2 <= 8 || code2 === 11 || code2 >= 14 && code2 <= 31 || code2 === 127; + } + function isNewline(code2) { + return code2 === 10 || code2 === 13 || code2 === 12; + } + function isWhiteSpace(code2) { + return isNewline(code2) || code2 === 32 || code2 === 9; + } + function isValidEscape(first, second) { + if (first !== 92) { + return false; + } + if (isNewline(second) || second === EOF2) { + return false; + } + return true; + } + function isIdentifierStart(first, second, third) { + if (first === 45) { + return isNameStart(second) || second === 45 || isValidEscape(second, third); + } + if (isNameStart(first)) { + return true; + } + if (first === 92) { + return isValidEscape(first, second); + } + return false; + } + function isNumberStart(first, second, third) { + if (first === 43 || first === 45) { + if (isDigit(second)) { + return 2; + } + return second === 46 && isDigit(third) ? 3 : 0; + } + if (first === 46) { + return isDigit(second) ? 2 : 0; + } + if (isDigit(first)) { + return 1; + } + return 0; + } + function isBOM(code2) { + if (code2 === 65279) { + return 1; + } + if (code2 === 65534) { + return 1; + } + return 0; + } + var CATEGORY = new Array(128); + var EofCategory = 128; + var WhiteSpaceCategory = 130; + var DigitCategory = 131; + var NameStartCategory = 132; + var NonPrintableCategory = 133; + for (let i = 0; i < CATEGORY.length; i++) { + CATEGORY[i] = isWhiteSpace(i) && WhiteSpaceCategory || isDigit(i) && DigitCategory || isNameStart(i) && NameStartCategory || isNonPrintable(i) && NonPrintableCategory || i || EofCategory; + } + function charCodeCategory(code2) { + return code2 < 128 ? CATEGORY[code2] : NameStartCategory; + } + + // node_modules/css-tree/lib/tokenizer/utils.js + function getCharCode(source, offset) { + return offset < source.length ? source.charCodeAt(offset) : 0; + } + function getNewlineLength(source, offset, code2) { + if (code2 === 13 && getCharCode(source, offset + 1) === 10) { + return 2; + } + return 1; + } + function cmpChar(testStr, offset, referenceCode) { + let code2 = testStr.charCodeAt(offset); + if (isUppercaseLetter(code2)) { + code2 = code2 | 32; + } + return code2 === referenceCode; + } + function cmpStr(testStr, start, end, referenceStr) { + if (end - start !== referenceStr.length) { + return false; + } + if (start < 0 || end > testStr.length) { + return false; + } + for (let i = start; i < end; i++) { + const referenceCode = referenceStr.charCodeAt(i - start); + let testCode = testStr.charCodeAt(i); + if (isUppercaseLetter(testCode)) { + testCode = testCode | 32; + } + if (testCode !== referenceCode) { + return false; + } + } + return true; + } + function findWhiteSpaceStart(source, offset) { + for (; offset >= 0; offset--) { + if (!isWhiteSpace(source.charCodeAt(offset))) { + break; + } + } + return offset + 1; + } + function findWhiteSpaceEnd(source, offset) { + for (; offset < source.length; offset++) { + if (!isWhiteSpace(source.charCodeAt(offset))) { + break; + } + } + return offset; + } + function findDecimalNumberEnd(source, offset) { + for (; offset < source.length; offset++) { + if (!isDigit(source.charCodeAt(offset))) { + break; + } + } + return offset; + } + function consumeEscaped(source, offset) { + offset += 2; + if (isHexDigit(getCharCode(source, offset - 1))) { + for (const maxOffset = Math.min(source.length, offset + 5); offset < maxOffset; offset++) { + if (!isHexDigit(getCharCode(source, offset))) { + break; + } + } + const code2 = getCharCode(source, offset); + if (isWhiteSpace(code2)) { + offset += getNewlineLength(source, offset, code2); + } + } + return offset; + } + function consumeName(source, offset) { + for (; offset < source.length; offset++) { + const code2 = source.charCodeAt(offset); + if (isName(code2)) { + continue; + } + if (isValidEscape(code2, getCharCode(source, offset + 1))) { + offset = consumeEscaped(source, offset) - 1; + continue; + } + break; + } + return offset; + } + function consumeNumber(source, offset) { + let code2 = source.charCodeAt(offset); + if (code2 === 43 || code2 === 45) { + code2 = source.charCodeAt(offset += 1); + } + if (isDigit(code2)) { + offset = findDecimalNumberEnd(source, offset + 1); + code2 = source.charCodeAt(offset); + } + if (code2 === 46 && isDigit(source.charCodeAt(offset + 1))) { + offset += 2; + offset = findDecimalNumberEnd(source, offset); + } + if (cmpChar( + source, + offset, + 101 + /* e */ + )) { + let sign = 0; + code2 = source.charCodeAt(offset + 1); + if (code2 === 45 || code2 === 43) { + sign = 1; + code2 = source.charCodeAt(offset + 2); + } + if (isDigit(code2)) { + offset = findDecimalNumberEnd(source, offset + 1 + sign + 1); + } + } + return offset; + } + function consumeBadUrlRemnants(source, offset) { + for (; offset < source.length; offset++) { + const code2 = source.charCodeAt(offset); + if (code2 === 41) { + offset++; + break; + } + if (isValidEscape(code2, getCharCode(source, offset + 1))) { + offset = consumeEscaped(source, offset); + } + } + return offset; + } + function decodeEscaped(escaped) { + if (escaped.length === 1 && !isHexDigit(escaped.charCodeAt(0))) { + return escaped[0]; + } + let code2 = parseInt(escaped, 16); + if (code2 === 0 || // If this number is zero, + code2 >= 55296 && code2 <= 57343 || // or is for a surrogate, + code2 > 1114111) { + code2 = 65533; + } + return String.fromCodePoint(code2); + } + + // node_modules/css-tree/lib/tokenizer/names.js + var names_default = [ + "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" + ]; + + // node_modules/css-tree/lib/tokenizer/adopt-buffer.js + var MIN_SIZE = 16 * 1024; + function adoptBuffer(buffer = null, size) { + if (buffer === null || buffer.length < size) { + return new Uint32Array(Math.max(size + 1024, MIN_SIZE)); + } + return buffer; + } + + // node_modules/css-tree/lib/tokenizer/OffsetToLocation.js + var N = 10; + var F = 12; + var R = 13; + function computeLinesAndColumns(host) { + const source = host.source; + const sourceLength = source.length; + const startOffset = source.length > 0 ? isBOM(source.charCodeAt(0)) : 0; + const lines = adoptBuffer(host.lines, sourceLength); + const columns = adoptBuffer(host.columns, sourceLength); + let line = host.startLine; + let column = host.startColumn; + for (let i = startOffset; i < sourceLength; i++) { + const code2 = source.charCodeAt(i); + lines[i] = line; + columns[i] = column++; + if (code2 === N || code2 === R || code2 === F) { + if (code2 === R && i + 1 < sourceLength && source.charCodeAt(i + 1) === N) { + i++; + lines[i] = line; + columns[i] = column; + } + line++; + column = 1; + } + } + lines[sourceLength] = line; + columns[sourceLength] = column; + host.lines = lines; + host.columns = columns; + host.computed = true; + } + var OffsetToLocation = class { + constructor() { + this.lines = null; + this.columns = null; + this.computed = false; + } + setSource(source, startOffset = 0, startLine = 1, startColumn = 1) { + this.source = source; + this.startOffset = startOffset; + this.startLine = startLine; + this.startColumn = startColumn; + this.computed = false; + } + getLocation(offset, filename) { + if (!this.computed) { + computeLinesAndColumns(this); + } + return { + source: filename, + offset: this.startOffset + offset, + line: this.lines[offset], + column: this.columns[offset] + }; + } + getLocationRange(start, end, filename) { + if (!this.computed) { + computeLinesAndColumns(this); + } + return { + source: filename, + start: { + offset: this.startOffset + start, + line: this.lines[start], + column: this.columns[start] + }, + end: { + offset: this.startOffset + end, + line: this.lines[end], + column: this.columns[end] + } + }; + } + }; + + // node_modules/css-tree/lib/tokenizer/TokenStream.js + var OFFSET_MASK = 16777215; + var TYPE_SHIFT = 24; + var balancePair = /* @__PURE__ */ new Map([ + [Function2, RightParenthesis], + [LeftParenthesis, RightParenthesis], + [LeftSquareBracket, RightSquareBracket], + [LeftCurlyBracket, RightCurlyBracket] + ]); + var TokenStream = class { + constructor(source, tokenize3) { + this.setSource(source, tokenize3); + } + reset() { + this.eof = false; + this.tokenIndex = -1; + this.tokenType = 0; + this.tokenStart = this.firstCharOffset; + this.tokenEnd = this.firstCharOffset; + } + setSource(source = "", tokenize3 = () => { + }) { + source = String(source || ""); + const sourceLength = source.length; + const offsetAndType = adoptBuffer(this.offsetAndType, source.length + 1); + const balance = adoptBuffer(this.balance, source.length + 1); + let tokenCount = 0; + let balanceCloseType = 0; + let balanceStart = 0; + let firstCharOffset = -1; + this.offsetAndType = null; + this.balance = null; + tokenize3(source, (type, start, end) => { + switch (type) { + default: + balance[tokenCount] = sourceLength; + break; + case balanceCloseType: { + let balancePrev = balanceStart & OFFSET_MASK; + balanceStart = balance[balancePrev]; + balanceCloseType = balanceStart >> TYPE_SHIFT; + balance[tokenCount] = balancePrev; + balance[balancePrev++] = tokenCount; + for (; balancePrev < tokenCount; balancePrev++) { + if (balance[balancePrev] === sourceLength) { + balance[balancePrev] = tokenCount; + } + } + break; + } + case LeftParenthesis: + case Function2: + case LeftSquareBracket: + case LeftCurlyBracket: + balance[tokenCount] = balanceStart; + balanceCloseType = balancePair.get(type); + balanceStart = balanceCloseType << TYPE_SHIFT | tokenCount; + break; + } + offsetAndType[tokenCount++] = type << TYPE_SHIFT | end; + if (firstCharOffset === -1) { + firstCharOffset = start; + } + }); + offsetAndType[tokenCount] = EOF << TYPE_SHIFT | sourceLength; + balance[tokenCount] = sourceLength; + balance[sourceLength] = sourceLength; + while (balanceStart !== 0) { + const balancePrev = balanceStart & OFFSET_MASK; + balanceStart = balance[balancePrev]; + balance[balancePrev] = sourceLength; + } + this.source = source; + this.firstCharOffset = firstCharOffset === -1 ? 0 : firstCharOffset; + this.tokenCount = tokenCount; + this.offsetAndType = offsetAndType; + this.balance = balance; + this.reset(); + this.next(); + } + lookupType(offset) { + offset += this.tokenIndex; + if (offset < this.tokenCount) { + return this.offsetAndType[offset] >> TYPE_SHIFT; + } + return EOF; + } + lookupOffset(offset) { + offset += this.tokenIndex; + if (offset < this.tokenCount) { + return this.offsetAndType[offset - 1] & OFFSET_MASK; + } + return this.source.length; + } + lookupValue(offset, referenceStr) { + offset += this.tokenIndex; + if (offset < this.tokenCount) { + return cmpStr( + this.source, + this.offsetAndType[offset - 1] & OFFSET_MASK, + this.offsetAndType[offset] & OFFSET_MASK, + referenceStr + ); + } + return false; + } + getTokenStart(tokenIndex) { + if (tokenIndex === this.tokenIndex) { + return this.tokenStart; + } + if (tokenIndex > 0) { + return tokenIndex < this.tokenCount ? this.offsetAndType[tokenIndex - 1] & OFFSET_MASK : this.offsetAndType[this.tokenCount] & OFFSET_MASK; + } + return this.firstCharOffset; + } + substrToCursor(start) { + return this.source.substring(start, this.tokenStart); + } + isBalanceEdge(pos) { + return this.balance[this.tokenIndex] < pos; + } + isDelim(code2, offset) { + if (offset) { + return this.lookupType(offset) === Delim && this.source.charCodeAt(this.lookupOffset(offset)) === code2; + } + return this.tokenType === Delim && this.source.charCodeAt(this.tokenStart) === code2; + } + skip(tokenCount) { + let next = this.tokenIndex + tokenCount; + if (next < this.tokenCount) { + this.tokenIndex = next; + this.tokenStart = this.offsetAndType[next - 1] & OFFSET_MASK; + next = this.offsetAndType[next]; + this.tokenType = next >> TYPE_SHIFT; + this.tokenEnd = next & OFFSET_MASK; + } else { + this.tokenIndex = this.tokenCount; + this.next(); + } + } + next() { + let next = this.tokenIndex + 1; + if (next < this.tokenCount) { + this.tokenIndex = next; + this.tokenStart = this.tokenEnd; + next = this.offsetAndType[next]; + this.tokenType = next >> TYPE_SHIFT; + this.tokenEnd = next & OFFSET_MASK; + } else { + this.eof = true; + this.tokenIndex = this.tokenCount; + this.tokenType = EOF; + this.tokenStart = this.tokenEnd = this.source.length; + } + } + skipSC() { + while (this.tokenType === WhiteSpace || this.tokenType === Comment) { + this.next(); + } + } + skipUntilBalanced(startToken, stopConsume) { + let cursor = startToken; + let balanceEnd; + let offset; + loop: + for (; cursor < this.tokenCount; cursor++) { + balanceEnd = this.balance[cursor]; + if (balanceEnd < startToken) { + break loop; + } + offset = cursor > 0 ? this.offsetAndType[cursor - 1] & OFFSET_MASK : this.firstCharOffset; + switch (stopConsume(this.source.charCodeAt(offset))) { + case 1: + break loop; + case 2: + cursor++; + break loop; + default: + if (this.balance[balanceEnd] === cursor) { + cursor = balanceEnd; + } + } + } + this.skip(cursor - this.tokenIndex); + } + forEachToken(fn) { + for (let i = 0, offset = this.firstCharOffset; i < this.tokenCount; i++) { + const start = offset; + const item = this.offsetAndType[i]; + const end = item & OFFSET_MASK; + const type = item >> TYPE_SHIFT; + offset = end; + fn(type, start, end, i); + } + } + dump() { + const tokens = new Array(this.tokenCount); + this.forEachToken((type, start, end, index) => { + tokens[index] = { + idx: index, + type: names_default[type], + chunk: this.source.substring(start, end), + balance: this.balance[index] + }; + }); + return tokens; + } + }; + + // node_modules/css-tree/lib/tokenizer/index.js + function tokenize(source, onToken) { + function getCharCode2(offset2) { + return offset2 < sourceLength ? source.charCodeAt(offset2) : 0; + } + function consumeNumericToken() { + offset = consumeNumber(source, offset); + if (isIdentifierStart(getCharCode2(offset), getCharCode2(offset + 1), getCharCode2(offset + 2))) { + type = Dimension; + offset = consumeName(source, offset); + return; + } + if (getCharCode2(offset) === 37) { + type = Percentage; + offset++; + return; + } + type = Number2; + } + function consumeIdentLikeToken() { + const nameStartOffset = offset; + offset = consumeName(source, offset); + if (cmpStr(source, nameStartOffset, offset, "url") && getCharCode2(offset) === 40) { + offset = findWhiteSpaceEnd(source, offset + 1); + if (getCharCode2(offset) === 34 || getCharCode2(offset) === 39) { + type = Function2; + offset = nameStartOffset + 4; + return; + } + consumeUrlToken(); + return; + } + if (getCharCode2(offset) === 40) { + type = Function2; + offset++; + return; + } + type = Ident; + } + function consumeStringToken(endingCodePoint) { + if (!endingCodePoint) { + endingCodePoint = getCharCode2(offset++); + } + type = String2; + for (; offset < source.length; offset++) { + const code2 = source.charCodeAt(offset); + switch (charCodeCategory(code2)) { + case endingCodePoint: + offset++; + return; + case WhiteSpaceCategory: + if (isNewline(code2)) { + offset += getNewlineLength(source, offset, code2); + type = BadString; + return; + } + break; + case 92: + if (offset === source.length - 1) { + break; + } + const nextCode = getCharCode2(offset + 1); + if (isNewline(nextCode)) { + offset += getNewlineLength(source, offset + 1, nextCode); + } else if (isValidEscape(code2, nextCode)) { + offset = consumeEscaped(source, offset) - 1; + } + break; + } + } + } + function consumeUrlToken() { + type = Url; + offset = findWhiteSpaceEnd(source, offset); + for (; offset < source.length; offset++) { + const code2 = source.charCodeAt(offset); + switch (charCodeCategory(code2)) { + case 41: + offset++; + return; + case WhiteSpaceCategory: + offset = findWhiteSpaceEnd(source, offset); + if (getCharCode2(offset) === 41 || offset >= source.length) { + if (offset < source.length) { + offset++; + } + return; + } + offset = consumeBadUrlRemnants(source, offset); + type = BadUrl; + return; + case 34: + case 39: + case 40: + case NonPrintableCategory: + offset = consumeBadUrlRemnants(source, offset); + type = BadUrl; + return; + case 92: + if (isValidEscape(code2, getCharCode2(offset + 1))) { + offset = consumeEscaped(source, offset) - 1; + break; + } + offset = consumeBadUrlRemnants(source, offset); + type = BadUrl; + return; + } + } + } + source = String(source || ""); + const sourceLength = source.length; + let start = isBOM(getCharCode2(0)); + let offset = start; + let type; + while (offset < sourceLength) { + const code2 = source.charCodeAt(offset); + switch (charCodeCategory(code2)) { + case WhiteSpaceCategory: + type = WhiteSpace; + offset = findWhiteSpaceEnd(source, offset + 1); + break; + case 34: + consumeStringToken(); + break; + case 35: + if (isName(getCharCode2(offset + 1)) || isValidEscape(getCharCode2(offset + 1), getCharCode2(offset + 2))) { + type = Hash; + offset = consumeName(source, offset + 1); + } else { + type = Delim; + offset++; + } + break; + case 39: + consumeStringToken(); + break; + case 40: + type = LeftParenthesis; + offset++; + break; + case 41: + type = RightParenthesis; + offset++; + break; + case 43: + if (isNumberStart(code2, getCharCode2(offset + 1), getCharCode2(offset + 2))) { + consumeNumericToken(); + } else { + type = Delim; + offset++; + } + break; + case 44: + type = Comma; + offset++; + break; + case 45: + if (isNumberStart(code2, getCharCode2(offset + 1), getCharCode2(offset + 2))) { + consumeNumericToken(); + } else { + if (getCharCode2(offset + 1) === 45 && getCharCode2(offset + 2) === 62) { + type = CDC; + offset = offset + 3; + } else { + if (isIdentifierStart(code2, getCharCode2(offset + 1), getCharCode2(offset + 2))) { + consumeIdentLikeToken(); + } else { + type = Delim; + offset++; + } + } + } + break; + case 46: + if (isNumberStart(code2, getCharCode2(offset + 1), getCharCode2(offset + 2))) { + consumeNumericToken(); + } else { + type = Delim; + offset++; + } + break; + case 47: + if (getCharCode2(offset + 1) === 42) { + type = Comment; + offset = source.indexOf("*/", offset + 2); + offset = offset === -1 ? source.length : offset + 2; + } else { + type = Delim; + offset++; + } + break; + case 58: + type = Colon; + offset++; + break; + case 59: + type = Semicolon; + offset++; + break; + case 60: + if (getCharCode2(offset + 1) === 33 && getCharCode2(offset + 2) === 45 && getCharCode2(offset + 3) === 45) { + type = CDO; + offset = offset + 4; + } else { + type = Delim; + offset++; + } + break; + case 64: + if (isIdentifierStart(getCharCode2(offset + 1), getCharCode2(offset + 2), getCharCode2(offset + 3))) { + type = AtKeyword; + offset = consumeName(source, offset + 1); + } else { + type = Delim; + offset++; + } + break; + case 91: + type = LeftSquareBracket; + offset++; + break; + case 92: + if (isValidEscape(code2, getCharCode2(offset + 1))) { + consumeIdentLikeToken(); + } else { + type = Delim; + offset++; + } + break; + case 93: + type = RightSquareBracket; + offset++; + break; + case 123: + type = LeftCurlyBracket; + offset++; + break; + case 125: + type = RightCurlyBracket; + offset++; + break; + case DigitCategory: + consumeNumericToken(); + break; + case NameStartCategory: + consumeIdentLikeToken(); + break; + default: + type = Delim; + offset++; + } + onToken(type, start, start = offset); + } + } + + // node_modules/css-tree/lib/utils/List.js + var releasedCursors = null; + var List = class _List { + static createItem(data) { + return { + prev: null, + next: null, + data + }; + } + constructor() { + this.head = null; + this.tail = null; + this.cursor = null; + } + createItem(data) { + return _List.createItem(data); + } + // cursor helpers + allocateCursor(prev, next) { + let cursor; + if (releasedCursors !== null) { + cursor = releasedCursors; + releasedCursors = releasedCursors.cursor; + cursor.prev = prev; + cursor.next = next; + cursor.cursor = this.cursor; + } else { + cursor = { + prev, + next, + cursor: this.cursor + }; + } + this.cursor = cursor; + return cursor; + } + releaseCursor() { + const { cursor } = this; + this.cursor = cursor.cursor; + cursor.prev = null; + cursor.next = null; + cursor.cursor = releasedCursors; + releasedCursors = cursor; + } + updateCursors(prevOld, prevNew, nextOld, nextNew) { + let { cursor } = this; + while (cursor !== null) { + if (cursor.prev === prevOld) { + cursor.prev = prevNew; + } + if (cursor.next === nextOld) { + cursor.next = nextNew; + } + cursor = cursor.cursor; + } + } + *[Symbol.iterator]() { + for (let cursor = this.head; cursor !== null; cursor = cursor.next) { + yield cursor.data; + } + } + // getters + get size() { + let size = 0; + for (let cursor = this.head; cursor !== null; cursor = cursor.next) { + size++; + } + return size; + } + get isEmpty() { + return this.head === null; + } + get first() { + return this.head && this.head.data; + } + get last() { + return this.tail && this.tail.data; + } + // convertors + fromArray(array) { + let cursor = null; + this.head = null; + for (let data of array) { + const item = _List.createItem(data); + if (cursor !== null) { + cursor.next = item; + } else { + this.head = item; + } + item.prev = cursor; + cursor = item; + } + this.tail = cursor; + return this; + } + toArray() { + return [...this]; + } + toJSON() { + return [...this]; + } + // array-like methods + forEach(fn, thisArg = this) { + const cursor = this.allocateCursor(null, this.head); + while (cursor.next !== null) { + const item = cursor.next; + cursor.next = item.next; + fn.call(thisArg, item.data, item, this); + } + this.releaseCursor(); + } + forEachRight(fn, thisArg = this) { + const cursor = this.allocateCursor(this.tail, null); + while (cursor.prev !== null) { + const item = cursor.prev; + cursor.prev = item.prev; + fn.call(thisArg, item.data, item, this); + } + this.releaseCursor(); + } + reduce(fn, initialValue, thisArg = this) { + let cursor = this.allocateCursor(null, this.head); + let acc = initialValue; + let item; + while (cursor.next !== null) { + item = cursor.next; + cursor.next = item.next; + acc = fn.call(thisArg, acc, item.data, item, this); + } + this.releaseCursor(); + return acc; + } + reduceRight(fn, initialValue, thisArg = this) { + let cursor = this.allocateCursor(this.tail, null); + let acc = initialValue; + let item; + while (cursor.prev !== null) { + item = cursor.prev; + cursor.prev = item.prev; + acc = fn.call(thisArg, acc, item.data, item, this); + } + this.releaseCursor(); + return acc; + } + some(fn, thisArg = this) { + for (let cursor = this.head; cursor !== null; cursor = cursor.next) { + if (fn.call(thisArg, cursor.data, cursor, this)) { + return true; + } + } + return false; + } + map(fn, thisArg = this) { + const result = new _List(); + for (let cursor = this.head; cursor !== null; cursor = cursor.next) { + result.appendData(fn.call(thisArg, cursor.data, cursor, this)); + } + return result; + } + filter(fn, thisArg = this) { + const result = new _List(); + for (let cursor = this.head; cursor !== null; cursor = cursor.next) { + if (fn.call(thisArg, cursor.data, cursor, this)) { + result.appendData(cursor.data); + } + } + return result; + } + nextUntil(start, fn, thisArg = this) { + if (start === null) { + return; + } + const cursor = this.allocateCursor(null, start); + while (cursor.next !== null) { + const item = cursor.next; + cursor.next = item.next; + if (fn.call(thisArg, item.data, item, this)) { + break; + } + } + this.releaseCursor(); + } + prevUntil(start, fn, thisArg = this) { + if (start === null) { + return; + } + const cursor = this.allocateCursor(start, null); + while (cursor.prev !== null) { + const item = cursor.prev; + cursor.prev = item.prev; + if (fn.call(thisArg, item.data, item, this)) { + break; + } + } + this.releaseCursor(); + } + // mutation + clear() { + this.head = null; + this.tail = null; + } + copy() { + const result = new _List(); + for (let data of this) { + result.appendData(data); + } + return result; + } + prepend(item) { + this.updateCursors(null, item, this.head, item); + if (this.head !== null) { + this.head.prev = item; + item.next = this.head; + } else { + this.tail = item; + } + this.head = item; + return this; + } + prependData(data) { + return this.prepend(_List.createItem(data)); + } + append(item) { + return this.insert(item); + } + appendData(data) { + return this.insert(_List.createItem(data)); + } + insert(item, before = null) { + if (before !== null) { + this.updateCursors(before.prev, item, before, item); + if (before.prev === null) { + if (this.head !== before) { + throw new Error("before doesn't belong to list"); + } + this.head = item; + before.prev = item; + item.next = before; + this.updateCursors(null, item); + } else { + before.prev.next = item; + item.prev = before.prev; + before.prev = item; + item.next = before; + } + } else { + this.updateCursors(this.tail, item, null, item); + if (this.tail !== null) { + this.tail.next = item; + item.prev = this.tail; + } else { + this.head = item; + } + this.tail = item; + } + return this; + } + insertData(data, before) { + return this.insert(_List.createItem(data), before); + } + remove(item) { + this.updateCursors(item, item.prev, item, item.next); + if (item.prev !== null) { + item.prev.next = item.next; + } else { + if (this.head !== item) { + throw new Error("item doesn't belong to list"); + } + this.head = item.next; + } + if (item.next !== null) { + item.next.prev = item.prev; + } else { + if (this.tail !== item) { + throw new Error("item doesn't belong to list"); + } + this.tail = item.prev; + } + item.prev = null; + item.next = null; + return item; + } + push(data) { + this.insert(_List.createItem(data)); + } + pop() { + return this.tail !== null ? this.remove(this.tail) : null; + } + unshift(data) { + this.prepend(_List.createItem(data)); + } + shift() { + return this.head !== null ? this.remove(this.head) : null; + } + prependList(list) { + return this.insertList(list, this.head); + } + appendList(list) { + return this.insertList(list); + } + insertList(list, before) { + if (list.head === null) { + return this; + } + if (before !== void 0 && before !== null) { + this.updateCursors(before.prev, list.tail, before, list.head); + if (before.prev !== null) { + before.prev.next = list.head; + list.head.prev = before.prev; + } else { + this.head = list.head; + } + before.prev = list.tail; + list.tail.next = before; + } else { + this.updateCursors(this.tail, list.tail, null, list.head); + if (this.tail !== null) { + this.tail.next = list.head; + list.head.prev = this.tail; + } else { + this.head = list.head; + } + this.tail = list.tail; + } + list.head = null; + list.tail = null; + return this; + } + replace(oldItem, newItemOrList) { + if ("head" in newItemOrList) { + this.insertList(newItemOrList, oldItem); + } else { + this.insert(newItemOrList, oldItem); + } + this.remove(oldItem); + } + }; + + // node_modules/css-tree/lib/utils/create-custom-error.js + function createCustomError(name42, message) { + const error = Object.create(SyntaxError.prototype); + const errorStack = new Error(); + return Object.assign(error, { + name: name42, + message, + get stack() { + return (errorStack.stack || "").replace(/^(.+\n){1,3}/, `${name42}: ${message} +`); + } + }); + } + + // node_modules/css-tree/lib/parser/SyntaxError.js + var MAX_LINE_LENGTH = 100; + var OFFSET_CORRECTION = 60; + var TAB_REPLACEMENT = " "; + function sourceFragment({ source, line, column }, extraLines) { + function processLines(start, end) { + return lines.slice(start, end).map( + (line2, idx) => String(start + idx + 1).padStart(maxNumLength) + " |" + line2 + ).join("\n"); + } + const lines = source.split(/\r\n?|\n|\f/); + const startLine = Math.max(1, line - extraLines) - 1; + const endLine = Math.min(line + extraLines, lines.length + 1); + const maxNumLength = Math.max(4, String(endLine).length) + 1; + let cutLeft = 0; + column += (TAB_REPLACEMENT.length - 1) * (lines[line - 1].substr(0, column - 1).match(/\t/g) || []).length; + if (column > MAX_LINE_LENGTH) { + cutLeft = column - OFFSET_CORRECTION + 3; + column = OFFSET_CORRECTION - 2; + } + for (let i = startLine; i <= endLine; i++) { + if (i >= 0 && i < lines.length) { + lines[i] = lines[i].replace(/\t/g, TAB_REPLACEMENT); + lines[i] = (cutLeft > 0 && lines[i].length > cutLeft ? "\u2026" : "") + lines[i].substr(cutLeft, MAX_LINE_LENGTH - 2) + (lines[i].length > cutLeft + MAX_LINE_LENGTH - 1 ? "\u2026" : ""); + } + } + return [ + processLines(startLine, line), + new Array(column + maxNumLength + 2).join("-") + "^", + processLines(line, endLine) + ].filter(Boolean).join("\n"); + } + function SyntaxError2(message, source, offset, line, column) { + const error = Object.assign(createCustomError("SyntaxError", message), { + source, + offset, + line, + column, + sourceFragment(extraLines) { + return sourceFragment({ source, line, column }, isNaN(extraLines) ? 0 : extraLines); + }, + get formattedMessage() { + return `Parse error: ${message} +` + sourceFragment({ source, line, column }, 2); + } + }); + return error; + } + + // node_modules/css-tree/lib/parser/sequence.js + function readSequence(recognizer) { + const children = this.createList(); + let space = false; + const context = { + recognizer + }; + while (!this.eof) { + switch (this.tokenType) { + case Comment: + this.next(); + continue; + case WhiteSpace: + space = true; + this.next(); + continue; + } + let child = recognizer.getNode.call(this, context); + if (child === void 0) { + break; + } + if (space) { + if (recognizer.onWhiteSpace) { + recognizer.onWhiteSpace.call(this, child, children, context); + } + space = false; + } + children.push(child); + } + if (space && recognizer.onWhiteSpace) { + recognizer.onWhiteSpace.call(this, null, children, context); + } + return children; + } + + // node_modules/css-tree/lib/parser/create.js + var NOOP = () => { + }; + var EXCLAMATIONMARK = 33; + var NUMBERSIGN = 35; + var SEMICOLON = 59; + var LEFTCURLYBRACKET = 123; + var NULL = 0; + function createParseContext(name42) { + return function() { + return this[name42](); + }; + } + function fetchParseValues(dict) { + const result = /* @__PURE__ */ Object.create(null); + for (const name42 in dict) { + const item = dict[name42]; + const fn = item.parse || item; + if (fn) { + result[name42] = fn; + } + } + return result; + } + function processConfig(config) { + const parseConfig = { + context: /* @__PURE__ */ Object.create(null), + scope: Object.assign(/* @__PURE__ */ Object.create(null), config.scope), + atrule: fetchParseValues(config.atrule), + pseudo: fetchParseValues(config.pseudo), + node: fetchParseValues(config.node) + }; + for (const name42 in config.parseContext) { + switch (typeof config.parseContext[name42]) { + case "function": + parseConfig.context[name42] = config.parseContext[name42]; + break; + case "string": + parseConfig.context[name42] = createParseContext(config.parseContext[name42]); + break; + } + } + return { + config: parseConfig, + ...parseConfig, + ...parseConfig.node + }; + } + function createParser(config) { + let source = ""; + let filename = ""; + let needPositions = false; + let onParseError = NOOP; + let onParseErrorThrow = false; + const locationMap = new OffsetToLocation(); + const parser = Object.assign(new TokenStream(), processConfig(config || {}), { + parseAtrulePrelude: true, + parseRulePrelude: true, + parseValue: true, + parseCustomProperty: false, + readSequence, + consumeUntilBalanceEnd: () => 0, + consumeUntilLeftCurlyBracket(code2) { + return code2 === LEFTCURLYBRACKET ? 1 : 0; + }, + consumeUntilLeftCurlyBracketOrSemicolon(code2) { + return code2 === LEFTCURLYBRACKET || code2 === SEMICOLON ? 1 : 0; + }, + consumeUntilExclamationMarkOrSemicolon(code2) { + return code2 === EXCLAMATIONMARK || code2 === SEMICOLON ? 1 : 0; + }, + consumeUntilSemicolonIncluded(code2) { + return code2 === SEMICOLON ? 2 : 0; + }, + createList() { + return new List(); + }, + createSingleNodeList(node) { + return new List().appendData(node); + }, + getFirstListNode(list) { + return list && list.first; + }, + getLastListNode(list) { + return list && list.last; + }, + parseWithFallback(consumer, fallback) { + const startToken = this.tokenIndex; + try { + return consumer.call(this); + } catch (e) { + if (onParseErrorThrow) { + throw e; + } + const fallbackNode = fallback.call(this, startToken); + onParseErrorThrow = true; + onParseError(e, fallbackNode); + onParseErrorThrow = false; + return fallbackNode; + } + }, + lookupNonWSType(offset) { + let type; + do { + type = this.lookupType(offset++); + if (type !== WhiteSpace) { + return type; + } + } while (type !== NULL); + return NULL; + }, + charCodeAt(offset) { + return offset >= 0 && offset < source.length ? source.charCodeAt(offset) : 0; + }, + substring(offsetStart, offsetEnd) { + return source.substring(offsetStart, offsetEnd); + }, + substrToCursor(start) { + return this.source.substring(start, this.tokenStart); + }, + cmpChar(offset, charCode) { + return cmpChar(source, offset, charCode); + }, + cmpStr(offsetStart, offsetEnd, str) { + return cmpStr(source, offsetStart, offsetEnd, str); + }, + consume(tokenType2) { + const start = this.tokenStart; + this.eat(tokenType2); + return this.substrToCursor(start); + }, + consumeFunctionName() { + const name42 = source.substring(this.tokenStart, this.tokenEnd - 1); + this.eat(Function2); + return name42; + }, + consumeNumber(type) { + const number2 = source.substring(this.tokenStart, consumeNumber(source, this.tokenStart)); + this.eat(type); + return number2; + }, + eat(tokenType2) { + if (this.tokenType !== tokenType2) { + const tokenName = names_default[tokenType2].slice(0, -6).replace(/-/g, " ").replace(/^./, (m) => m.toUpperCase()); + let message = `${/[[\](){}]/.test(tokenName) ? `"${tokenName}"` : tokenName} is expected`; + let offset = this.tokenStart; + switch (tokenType2) { + case Ident: + if (this.tokenType === Function2 || this.tokenType === Url) { + offset = this.tokenEnd - 1; + message = "Identifier is expected but function found"; + } else { + message = "Identifier is expected"; + } + break; + case Hash: + if (this.isDelim(NUMBERSIGN)) { + this.next(); + offset++; + message = "Name is expected"; + } + break; + case Percentage: + if (this.tokenType === Number2) { + offset = this.tokenEnd; + message = "Percent sign is expected"; + } + break; + } + this.error(message, offset); + } + this.next(); + }, + eatIdent(name42) { + if (this.tokenType !== Ident || this.lookupValue(0, name42) === false) { + this.error(`Identifier "${name42}" is expected`); + } + this.next(); + }, + eatDelim(code2) { + if (!this.isDelim(code2)) { + this.error(`Delim "${String.fromCharCode(code2)}" is expected`); + } + this.next(); + }, + getLocation(start, end) { + if (needPositions) { + return locationMap.getLocationRange( + start, + end, + filename + ); + } + return null; + }, + getLocationFromList(list) { + if (needPositions) { + const head = this.getFirstListNode(list); + const tail = this.getLastListNode(list); + return locationMap.getLocationRange( + head !== null ? head.loc.start.offset - locationMap.startOffset : this.tokenStart, + tail !== null ? tail.loc.end.offset - locationMap.startOffset : this.tokenStart, + filename + ); + } + return null; + }, + error(message, offset) { + const location = typeof offset !== "undefined" && offset < source.length ? locationMap.getLocation(offset) : this.eof ? locationMap.getLocation(findWhiteSpaceStart(source, source.length - 1)) : locationMap.getLocation(this.tokenStart); + throw new SyntaxError2( + message || "Unexpected input", + source, + location.offset, + location.line, + location.column + ); + } + }); + const parse45 = function(source_, options) { + source = source_; + options = options || {}; + parser.setSource(source, tokenize); + locationMap.setSource( + source, + options.offset, + options.line, + options.column + ); + filename = options.filename || ""; + needPositions = Boolean(options.positions); + onParseError = typeof options.onParseError === "function" ? options.onParseError : NOOP; + onParseErrorThrow = false; + parser.parseAtrulePrelude = "parseAtrulePrelude" in options ? Boolean(options.parseAtrulePrelude) : true; + parser.parseRulePrelude = "parseRulePrelude" in options ? Boolean(options.parseRulePrelude) : true; + parser.parseValue = "parseValue" in options ? Boolean(options.parseValue) : true; + parser.parseCustomProperty = "parseCustomProperty" in options ? Boolean(options.parseCustomProperty) : false; + const { context = "default", onComment } = options; + if (context in parser.context === false) { + throw new Error("Unknown context `" + context + "`"); + } + if (typeof onComment === "function") { + parser.forEachToken((type, start, end) => { + if (type === Comment) { + const loc = parser.getLocation(start, end); + const value = cmpStr(source, end - 2, end, "*/") ? source.slice(start + 2, end - 2) : source.slice(start + 2, end); + onComment(value, loc); + } + }); + } + const ast = parser.context[context].call(parser, options); + if (!parser.eof) { + parser.error(); + } + return ast; + }; + return Object.assign(parse45, { + SyntaxError: SyntaxError2, + config: parser.config + }); + } + + // node_modules/css-tree/lib/generator/sourceMap.js + var import_source_map_generator = __toESM(require_source_map_generator(), 1); + var trackNodes = /* @__PURE__ */ new Set(["Atrule", "Selector", "Declaration"]); + function generateSourceMap(handlers) { + const map = new import_source_map_generator.SourceMapGenerator(); + const generated = { + line: 1, + column: 0 + }; + const original = { + line: 0, + // should be zero to add first mapping + column: 0 + }; + const activatedGenerated = { + line: 1, + column: 0 + }; + const activatedMapping = { + generated: activatedGenerated + }; + let line = 1; + let column = 0; + let sourceMappingActive = false; + const origHandlersNode = handlers.node; + handlers.node = function(node) { + if (node.loc && node.loc.start && trackNodes.has(node.type)) { + const nodeLine = node.loc.start.line; + const nodeColumn = node.loc.start.column - 1; + if (original.line !== nodeLine || original.column !== nodeColumn) { + original.line = nodeLine; + original.column = nodeColumn; + generated.line = line; + generated.column = column; + if (sourceMappingActive) { + sourceMappingActive = false; + if (generated.line !== activatedGenerated.line || generated.column !== activatedGenerated.column) { + map.addMapping(activatedMapping); + } + } + sourceMappingActive = true; + map.addMapping({ + source: node.loc.source, + original, + generated + }); + } + } + origHandlersNode.call(this, node); + if (sourceMappingActive && trackNodes.has(node.type)) { + activatedGenerated.line = line; + activatedGenerated.column = column; + } + }; + const origHandlersEmit = handlers.emit; + handlers.emit = function(value, type, auto) { + for (let i = 0; i < value.length; i++) { + if (value.charCodeAt(i) === 10) { + line++; + column = 0; + } else { + column++; + } + } + origHandlersEmit(value, type, auto); + }; + const origHandlersResult = handlers.result; + handlers.result = function() { + if (sourceMappingActive) { + map.addMapping(activatedMapping); + } + return { + css: origHandlersResult(), + map + }; + }; + return handlers; + } + + // node_modules/css-tree/lib/generator/token-before.js + var token_before_exports = {}; + __export(token_before_exports, { + safe: () => safe, + spec: () => spec + }); + var PLUSSIGN = 43; + var HYPHENMINUS = 45; + var code = (type, value) => { + if (type === Delim) { + type = value; + } + if (typeof type === "string") { + const charCode = type.charCodeAt(0); + return charCode > 127 ? 32768 : charCode << 8; + } + return type; + }; + var specPairs = [ + [Ident, Ident], + [Ident, Function2], + [Ident, Url], + [Ident, BadUrl], + [Ident, "-"], + [Ident, Number2], + [Ident, Percentage], + [Ident, Dimension], + [Ident, CDC], + [Ident, LeftParenthesis], + [AtKeyword, Ident], + [AtKeyword, Function2], + [AtKeyword, Url], + [AtKeyword, BadUrl], + [AtKeyword, "-"], + [AtKeyword, Number2], + [AtKeyword, Percentage], + [AtKeyword, Dimension], + [AtKeyword, CDC], + [Hash, Ident], + [Hash, Function2], + [Hash, Url], + [Hash, BadUrl], + [Hash, "-"], + [Hash, Number2], + [Hash, Percentage], + [Hash, Dimension], + [Hash, CDC], + [Dimension, Ident], + [Dimension, Function2], + [Dimension, Url], + [Dimension, BadUrl], + [Dimension, "-"], + [Dimension, Number2], + [Dimension, Percentage], + [Dimension, Dimension], + [Dimension, CDC], + ["#", Ident], + ["#", Function2], + ["#", Url], + ["#", BadUrl], + ["#", "-"], + ["#", Number2], + ["#", Percentage], + ["#", Dimension], + ["#", CDC], + // https://github.com/w3c/csswg-drafts/pull/6874 + ["-", Ident], + ["-", Function2], + ["-", Url], + ["-", BadUrl], + ["-", "-"], + ["-", Number2], + ["-", Percentage], + ["-", Dimension], + ["-", CDC], + // https://github.com/w3c/csswg-drafts/pull/6874 + [Number2, Ident], + [Number2, Function2], + [Number2, Url], + [Number2, BadUrl], + [Number2, Number2], + [Number2, Percentage], + [Number2, Dimension], + [Number2, "%"], + [Number2, CDC], + // https://github.com/w3c/csswg-drafts/pull/6874 + ["@", Ident], + ["@", Function2], + ["@", Url], + ["@", BadUrl], + ["@", "-"], + ["@", CDC], + // https://github.com/w3c/csswg-drafts/pull/6874 + [".", Number2], + [".", Percentage], + [".", Dimension], + ["+", Number2], + ["+", Percentage], + ["+", Dimension], + ["/", "*"] + ]; + var safePairs = specPairs.concat([ + [Ident, Hash], + [Dimension, Hash], + [Hash, Hash], + [AtKeyword, LeftParenthesis], + [AtKeyword, String2], + [AtKeyword, Colon], + [Percentage, Percentage], + [Percentage, Dimension], + [Percentage, Function2], + [Percentage, "-"], + [RightParenthesis, Ident], + [RightParenthesis, Function2], + [RightParenthesis, Percentage], + [RightParenthesis, Dimension], + [RightParenthesis, Hash], + [RightParenthesis, "-"] + ]); + function createMap(pairs) { + const isWhiteSpaceRequired = new Set( + pairs.map(([prev, next]) => code(prev) << 16 | code(next)) + ); + return function(prevCode, type, value) { + const nextCode = code(type, value); + const nextCharCode = value.charCodeAt(0); + const emitWs = nextCharCode === HYPHENMINUS && type !== Ident && type !== Function2 && type !== CDC || nextCharCode === PLUSSIGN ? isWhiteSpaceRequired.has(prevCode << 16 | nextCharCode << 8) : isWhiteSpaceRequired.has(prevCode << 16 | nextCode); + if (emitWs) { + this.emit(" ", WhiteSpace, true); + } + return nextCode; + }; + } + var spec = createMap(specPairs); + var safe = createMap(safePairs); + + // node_modules/css-tree/lib/generator/create.js + var REVERSESOLIDUS = 92; + function processChildren(node, delimeter) { + if (typeof delimeter === "function") { + let prev = null; + node.children.forEach((node2) => { + if (prev !== null) { + delimeter.call(this, prev); + } + this.node(node2); + prev = node2; + }); + return; + } + node.children.forEach(this.node, this); + } + function processChunk(chunk) { + tokenize(chunk, (type, start, end) => { + this.token(type, chunk.slice(start, end)); + }); + } + function createGenerator(config) { + const types2 = /* @__PURE__ */ new Map(); + for (let name42 in config.node) { + const item = config.node[name42]; + const fn = item.generate || item; + if (typeof fn === "function") { + types2.set(name42, item.generate || item); + } + } + return function(node, options) { + let buffer = ""; + let prevCode = 0; + let handlers = { + node(node2) { + if (types2.has(node2.type)) { + types2.get(node2.type).call(publicApi, node2); + } else { + throw new Error("Unknown node type: " + node2.type); + } + }, + tokenBefore: safe, + token(type, value) { + prevCode = this.tokenBefore(prevCode, type, value); + this.emit(value, type, false); + if (type === Delim && value.charCodeAt(0) === REVERSESOLIDUS) { + this.emit("\n", WhiteSpace, true); + } + }, + emit(value) { + buffer += value; + }, + result() { + return buffer; + } + }; + if (options) { + if (typeof options.decorator === "function") { + handlers = options.decorator(handlers); + } + if (options.sourceMap) { + handlers = generateSourceMap(handlers); + } + if (options.mode in token_before_exports) { + handlers.tokenBefore = token_before_exports[options.mode]; + } + } + const publicApi = { + node: (node2) => handlers.node(node2), + children: processChildren, + token: (type, value) => handlers.token(type, value), + tokenize: processChunk + }; + handlers.node(node); + return handlers.result(); + }; + } + + // node_modules/css-tree/lib/convertor/create.js + function createConvertor(walk3) { + return { + fromPlainObject(ast) { + walk3(ast, { + enter(node) { + if (node.children && node.children instanceof List === false) { + node.children = new List().fromArray(node.children); + } + } + }); + return ast; + }, + toPlainObject(ast) { + walk3(ast, { + leave(node) { + if (node.children && node.children instanceof List) { + node.children = node.children.toArray(); + } + } + }); + return ast; + } + }; + } + + // node_modules/css-tree/lib/walker/create.js + var { hasOwnProperty: hasOwnProperty2 } = Object.prototype; + var noop = function() { + }; + function ensureFunction(value) { + return typeof value === "function" ? value : noop; + } + function invokeForType(fn, type) { + return function(node, item, list) { + if (node.type === type) { + fn.call(this, node, item, list); + } + }; + } + function getWalkersFromStructure(name42, nodeType) { + const structure42 = nodeType.structure; + const walkers = []; + for (const key in structure42) { + if (hasOwnProperty2.call(structure42, key) === false) { + continue; + } + let fieldTypes = structure42[key]; + const walker = { + name: key, + type: false, + nullable: false + }; + if (!Array.isArray(fieldTypes)) { + fieldTypes = [fieldTypes]; + } + for (const fieldType of fieldTypes) { + if (fieldType === null) { + walker.nullable = true; + } else if (typeof fieldType === "string") { + walker.type = "node"; + } else if (Array.isArray(fieldType)) { + walker.type = "list"; + } + } + if (walker.type) { + walkers.push(walker); + } + } + if (walkers.length) { + return { + context: nodeType.walkContext, + fields: walkers + }; + } + return null; + } + function getTypesFromConfig(config) { + const types2 = {}; + for (const name42 in config.node) { + if (hasOwnProperty2.call(config.node, name42)) { + const nodeType = config.node[name42]; + if (!nodeType.structure) { + throw new Error("Missed `structure` field in `" + name42 + "` node type definition"); + } + types2[name42] = getWalkersFromStructure(name42, nodeType); + } + } + return types2; + } + function createTypeIterator(config, reverse) { + const fields = config.fields.slice(); + const contextName = config.context; + const useContext = typeof contextName === "string"; + if (reverse) { + fields.reverse(); + } + return function(node, context, walk3, walkReducer) { + let prevContextValue; + if (useContext) { + prevContextValue = context[contextName]; + context[contextName] = node; + } + for (const field of fields) { + const ref = node[field.name]; + if (!field.nullable || ref) { + if (field.type === "list") { + const breakWalk = reverse ? ref.reduceRight(walkReducer, false) : ref.reduce(walkReducer, false); + if (breakWalk) { + return true; + } + } else if (walk3(ref)) { + return true; + } + } + } + if (useContext) { + context[contextName] = prevContextValue; + } + }; + } + function createFastTraveralMap({ + StyleSheet, + Atrule, + Rule, + Block, + DeclarationList + }) { + return { + Atrule: { + StyleSheet, + Atrule, + Rule, + Block + }, + Rule: { + StyleSheet, + Atrule, + Rule, + Block + }, + Declaration: { + StyleSheet, + Atrule, + Rule, + Block, + DeclarationList + } + }; + } + function createWalker(config) { + const types2 = getTypesFromConfig(config); + const iteratorsNatural = {}; + const iteratorsReverse = {}; + const breakWalk = Symbol("break-walk"); + const skipNode = Symbol("skip-node"); + for (const name42 in types2) { + if (hasOwnProperty2.call(types2, name42) && types2[name42] !== null) { + iteratorsNatural[name42] = createTypeIterator(types2[name42], false); + iteratorsReverse[name42] = createTypeIterator(types2[name42], true); + } + } + const fastTraversalIteratorsNatural = createFastTraveralMap(iteratorsNatural); + const fastTraversalIteratorsReverse = createFastTraveralMap(iteratorsReverse); + const walk3 = function(root, options) { + function walkNode(node, item, list) { + const enterRet = enter.call(context, node, item, list); + if (enterRet === breakWalk) { + return true; + } + if (enterRet === skipNode) { + return false; + } + if (iterators.hasOwnProperty(node.type)) { + if (iterators[node.type](node, context, walkNode, walkReducer)) { + return true; + } + } + if (leave.call(context, node, item, list) === breakWalk) { + return true; + } + return false; + } + let enter = noop; + let leave = noop; + let iterators = iteratorsNatural; + let walkReducer = (ret, data, item, list) => ret || walkNode(data, item, list); + const context = { + break: breakWalk, + skip: skipNode, + root, + stylesheet: null, + atrule: null, + atrulePrelude: null, + rule: null, + selector: null, + block: null, + declaration: null, + function: null + }; + if (typeof options === "function") { + enter = options; + } else if (options) { + enter = ensureFunction(options.enter); + leave = ensureFunction(options.leave); + if (options.reverse) { + iterators = iteratorsReverse; + } + if (options.visit) { + if (fastTraversalIteratorsNatural.hasOwnProperty(options.visit)) { + iterators = options.reverse ? fastTraversalIteratorsReverse[options.visit] : fastTraversalIteratorsNatural[options.visit]; + } else if (!types2.hasOwnProperty(options.visit)) { + throw new Error("Bad value `" + options.visit + "` for `visit` option (should be: " + Object.keys(types2).sort().join(", ") + ")"); + } + enter = invokeForType(enter, options.visit); + leave = invokeForType(leave, options.visit); + } + } + if (enter === noop && leave === noop) { + throw new Error("Neither `enter` nor `leave` walker handler is set or both aren't a function"); + } + walkNode(root); + }; + walk3.break = breakWalk; + walk3.skip = skipNode; + walk3.find = function(ast, fn) { + let found = null; + walk3(ast, function(node, item, list) { + if (fn.call(this, node, item, list)) { + found = node; + return breakWalk; + } + }); + return found; + }; + walk3.findLast = function(ast, fn) { + let found = null; + walk3(ast, { + reverse: true, + enter(node, item, list) { + if (fn.call(this, node, item, list)) { + found = node; + return breakWalk; + } + } + }); + return found; + }; + walk3.findAll = function(ast, fn) { + const found = []; + walk3(ast, function(node, item, list) { + if (fn.call(this, node, item, list)) { + found.push(node); + } + }); + return found; + }; + return walk3; + } + + // node_modules/css-tree/lib/definition-syntax/generate.js + function noop2(value) { + return value; + } + function generateMultiplier(multiplier) { + const { min, max, comma } = multiplier; + if (min === 0 && max === 0) { + return comma ? "#?" : "*"; + } + if (min === 0 && max === 1) { + return "?"; + } + if (min === 1 && max === 0) { + return comma ? "#" : "+"; + } + if (min === 1 && max === 1) { + return ""; + } + return (comma ? "#" : "") + (min === max ? "{" + min + "}" : "{" + min + "," + (max !== 0 ? max : "") + "}"); + } + function generateTypeOpts(node) { + switch (node.type) { + case "Range": + return " [" + (node.min === null ? "-\u221E" : node.min) + "," + (node.max === null ? "\u221E" : node.max) + "]"; + default: + throw new Error("Unknown node type `" + node.type + "`"); + } + } + function generateSequence(node, decorate, forceBraces, compact) { + const combinator = node.combinator === " " || compact ? node.combinator : " " + node.combinator + " "; + const result = node.terms.map((term) => internalGenerate(term, decorate, forceBraces, compact)).join(combinator); + if (node.explicit || forceBraces) { + return (compact || result[0] === "," ? "[" : "[ ") + result + (compact ? "]" : " ]"); + } + return result; + } + function internalGenerate(node, decorate, forceBraces, compact) { + let result; + switch (node.type) { + case "Group": + result = generateSequence(node, decorate, forceBraces, compact) + (node.disallowEmpty ? "!" : ""); + break; + case "Multiplier": + return internalGenerate(node.term, decorate, forceBraces, compact) + decorate(generateMultiplier(node), node); + case "Type": + result = "<" + node.name + (node.opts ? decorate(generateTypeOpts(node.opts), node.opts) : "") + ">"; + break; + case "Property": + result = "<'" + node.name + "'>"; + break; + case "Keyword": + result = node.name; + break; + case "AtKeyword": + result = "@" + node.name; + break; + case "Function": + result = node.name + "("; + break; + case "String": + case "Token": + result = node.value; + break; + case "Comma": + result = ","; + break; + default: + throw new Error("Unknown node type `" + node.type + "`"); + } + return decorate(result, node); + } + function generate(node, options) { + let decorate = noop2; + let forceBraces = false; + let compact = false; + if (typeof options === "function") { + decorate = options; + } else if (options) { + forceBraces = Boolean(options.forceBraces); + compact = Boolean(options.compact); + if (typeof options.decorate === "function") { + decorate = options.decorate; + } + } + return internalGenerate(node, decorate, forceBraces, compact); + } + + // node_modules/css-tree/lib/lexer/error.js + var defaultLoc = { offset: 0, line: 1, column: 1 }; + function locateMismatch(matchResult, node) { + const tokens = matchResult.tokens; + const longestMatch = matchResult.longestMatch; + const mismatchNode = longestMatch < tokens.length ? tokens[longestMatch].node || null : null; + const badNode = mismatchNode !== node ? mismatchNode : null; + let mismatchOffset = 0; + let mismatchLength = 0; + let entries = 0; + let css = ""; + let start; + let end; + for (let i = 0; i < tokens.length; i++) { + const token = tokens[i].value; + if (i === longestMatch) { + mismatchLength = token.length; + mismatchOffset = css.length; + } + if (badNode !== null && tokens[i].node === badNode) { + if (i <= longestMatch) { + entries++; + } else { + entries = 0; + } + } + css += token; + } + if (longestMatch === tokens.length || entries > 1) { + start = fromLoc(badNode || node, "end") || buildLoc(defaultLoc, css); + end = buildLoc(start); + } else { + start = fromLoc(badNode, "start") || buildLoc(fromLoc(node, "start") || defaultLoc, css.slice(0, mismatchOffset)); + end = fromLoc(badNode, "end") || buildLoc(start, css.substr(mismatchOffset, mismatchLength)); + } + return { + css, + mismatchOffset, + mismatchLength, + start, + end + }; + } + function fromLoc(node, point) { + const value = node && node.loc && node.loc[point]; + if (value) { + return "line" in value ? buildLoc(value) : value; + } + return null; + } + function buildLoc({ offset, line, column }, extra) { + const loc = { + offset, + line, + column + }; + if (extra) { + const lines = extra.split(/\n|\r\n?|\f/); + loc.offset += extra.length; + loc.line += lines.length - 1; + loc.column = lines.length === 1 ? loc.column + extra.length : lines.pop().length + 1; + } + return loc; + } + var SyntaxReferenceError = function(type, referenceName) { + const error = createCustomError( + "SyntaxReferenceError", + type + (referenceName ? " `" + referenceName + "`" : "") + ); + error.reference = referenceName; + return error; + }; + var SyntaxMatchError = function(message, syntax, node, matchResult) { + const error = createCustomError("SyntaxMatchError", message); + const { + css, + mismatchOffset, + mismatchLength, + start, + end + } = locateMismatch(matchResult, node); + error.rawMessage = message; + error.syntax = syntax ? generate(syntax) : ""; + error.css = css; + error.mismatchOffset = mismatchOffset; + error.mismatchLength = mismatchLength; + error.message = message + "\n syntax: " + error.syntax + "\n value: " + (css || "") + "\n --------" + new Array(error.mismatchOffset + 1).join("-") + "^"; + Object.assign(error, start); + error.loc = { + source: node && node.loc && node.loc.source || "", + start, + end + }; + return error; + }; + + // node_modules/css-tree/lib/utils/names.js + var keywords = /* @__PURE__ */ new Map(); + var properties = /* @__PURE__ */ new Map(); + var HYPHENMINUS2 = 45; + var keyword = getKeywordDescriptor; + var property = getPropertyDescriptor; + function isCustomProperty(str, offset) { + offset = offset || 0; + return str.length - offset >= 2 && str.charCodeAt(offset) === HYPHENMINUS2 && str.charCodeAt(offset + 1) === HYPHENMINUS2; + } + function getVendorPrefix(str, offset) { + offset = offset || 0; + if (str.length - offset >= 3) { + if (str.charCodeAt(offset) === HYPHENMINUS2 && str.charCodeAt(offset + 1) !== HYPHENMINUS2) { + const secondDashIndex = str.indexOf("-", offset + 2); + if (secondDashIndex !== -1) { + return str.substring(offset, secondDashIndex + 1); + } + } + } + return ""; + } + function getKeywordDescriptor(keyword2) { + if (keywords.has(keyword2)) { + return keywords.get(keyword2); + } + const name42 = keyword2.toLowerCase(); + let descriptor = keywords.get(name42); + if (descriptor === void 0) { + const custom = isCustomProperty(name42, 0); + const vendor = !custom ? getVendorPrefix(name42, 0) : ""; + descriptor = Object.freeze({ + basename: name42.substr(vendor.length), + name: name42, + prefix: vendor, + vendor, + custom + }); + } + keywords.set(keyword2, descriptor); + return descriptor; + } + function getPropertyDescriptor(property3) { + if (properties.has(property3)) { + return properties.get(property3); + } + let name42 = property3; + let hack = property3[0]; + if (hack === "/") { + hack = property3[1] === "/" ? "//" : "/"; + } else if (hack !== "_" && hack !== "*" && hack !== "$" && hack !== "#" && hack !== "+" && hack !== "&") { + hack = ""; + } + const custom = isCustomProperty(name42, hack.length); + if (!custom) { + name42 = name42.toLowerCase(); + if (properties.has(name42)) { + const descriptor2 = properties.get(name42); + properties.set(property3, descriptor2); + return descriptor2; + } + } + const vendor = !custom ? getVendorPrefix(name42, hack.length) : ""; + const prefix = name42.substr(0, hack.length + vendor.length); + const descriptor = Object.freeze({ + basename: name42.substr(prefix.length), + name: name42.substr(hack.length), + hack, + vendor, + prefix, + custom + }); + properties.set(property3, descriptor); + return descriptor; + } + + // node_modules/css-tree/lib/lexer/generic-const.js + var cssWideKeywords = [ + "initial", + "inherit", + "unset", + "revert", + "revert-layer" + ]; + + // node_modules/css-tree/lib/lexer/generic-an-plus-b.js + var PLUSSIGN2 = 43; + var HYPHENMINUS3 = 45; + var N2 = 110; + var DISALLOW_SIGN = true; + var ALLOW_SIGN = false; + function isDelim(token, code2) { + return token !== null && token.type === Delim && token.value.charCodeAt(0) === code2; + } + function skipSC(token, offset, getNextToken) { + while (token !== null && (token.type === WhiteSpace || token.type === Comment)) { + token = getNextToken(++offset); + } + return offset; + } + function checkInteger(token, valueOffset, disallowSign, offset) { + if (!token) { + return 0; + } + const code2 = token.value.charCodeAt(valueOffset); + if (code2 === PLUSSIGN2 || code2 === HYPHENMINUS3) { + if (disallowSign) { + return 0; + } + valueOffset++; + } + for (; valueOffset < token.value.length; valueOffset++) { + if (!isDigit(token.value.charCodeAt(valueOffset))) { + return 0; + } + } + return offset + 1; + } + function consumeB(token, offset_, getNextToken) { + let sign = false; + let offset = skipSC(token, offset_, getNextToken); + token = getNextToken(offset); + if (token === null) { + return offset_; + } + if (token.type !== Number2) { + if (isDelim(token, PLUSSIGN2) || isDelim(token, HYPHENMINUS3)) { + sign = true; + offset = skipSC(getNextToken(++offset), offset, getNextToken); + token = getNextToken(offset); + if (token === null || token.type !== Number2) { + return 0; + } + } else { + return offset_; + } + } + if (!sign) { + const code2 = token.value.charCodeAt(0); + if (code2 !== PLUSSIGN2 && code2 !== HYPHENMINUS3) { + return 0; + } + } + return checkInteger(token, sign ? 0 : 1, sign, offset); + } + function anPlusB(token, getNextToken) { + let offset = 0; + if (!token) { + return 0; + } + if (token.type === Number2) { + return checkInteger(token, 0, ALLOW_SIGN, offset); + } else if (token.type === Ident && token.value.charCodeAt(0) === HYPHENMINUS3) { + if (!cmpChar(token.value, 1, N2)) { + return 0; + } + switch (token.value.length) { + case 2: + return consumeB(getNextToken(++offset), offset, getNextToken); + case 3: + if (token.value.charCodeAt(2) !== HYPHENMINUS3) { + return 0; + } + offset = skipSC(getNextToken(++offset), offset, getNextToken); + token = getNextToken(offset); + return checkInteger(token, 0, DISALLOW_SIGN, offset); + default: + if (token.value.charCodeAt(2) !== HYPHENMINUS3) { + return 0; + } + return checkInteger(token, 3, DISALLOW_SIGN, offset); + } + } else if (token.type === Ident || isDelim(token, PLUSSIGN2) && getNextToken(offset + 1).type === Ident) { + if (token.type !== Ident) { + token = getNextToken(++offset); + } + if (token === null || !cmpChar(token.value, 0, N2)) { + return 0; + } + switch (token.value.length) { + case 1: + return consumeB(getNextToken(++offset), offset, getNextToken); + case 2: + if (token.value.charCodeAt(1) !== HYPHENMINUS3) { + return 0; + } + offset = skipSC(getNextToken(++offset), offset, getNextToken); + token = getNextToken(offset); + return checkInteger(token, 0, DISALLOW_SIGN, offset); + default: + if (token.value.charCodeAt(1) !== HYPHENMINUS3) { + return 0; + } + return checkInteger(token, 2, DISALLOW_SIGN, offset); + } + } else if (token.type === Dimension) { + let code2 = token.value.charCodeAt(0); + let sign = code2 === PLUSSIGN2 || code2 === HYPHENMINUS3 ? 1 : 0; + let i = sign; + for (; i < token.value.length; i++) { + if (!isDigit(token.value.charCodeAt(i))) { + break; + } + } + if (i === sign) { + return 0; + } + if (!cmpChar(token.value, i, N2)) { + return 0; + } + if (i + 1 === token.value.length) { + return consumeB(getNextToken(++offset), offset, getNextToken); + } else { + if (token.value.charCodeAt(i + 1) !== HYPHENMINUS3) { + return 0; + } + if (i + 2 === token.value.length) { + offset = skipSC(getNextToken(++offset), offset, getNextToken); + token = getNextToken(offset); + return checkInteger(token, 0, DISALLOW_SIGN, offset); + } else { + return checkInteger(token, i + 2, DISALLOW_SIGN, offset); + } + } + } + return 0; + } + + // node_modules/css-tree/lib/lexer/generic-urange.js + var PLUSSIGN3 = 43; + var HYPHENMINUS4 = 45; + var QUESTIONMARK = 63; + var U = 117; + function isDelim2(token, code2) { + return token !== null && token.type === Delim && token.value.charCodeAt(0) === code2; + } + function startsWith(token, code2) { + return token.value.charCodeAt(0) === code2; + } + function hexSequence(token, offset, allowDash) { + let hexlen = 0; + for (let pos = offset; pos < token.value.length; pos++) { + const code2 = token.value.charCodeAt(pos); + if (code2 === HYPHENMINUS4 && allowDash && hexlen !== 0) { + hexSequence(token, offset + hexlen + 1, false); + return 6; + } + if (!isHexDigit(code2)) { + return 0; + } + if (++hexlen > 6) { + return 0; + } + ; + } + return hexlen; + } + function withQuestionMarkSequence(consumed, length2, getNextToken) { + if (!consumed) { + return 0; + } + while (isDelim2(getNextToken(length2), QUESTIONMARK)) { + if (++consumed > 6) { + return 0; + } + length2++; + } + return length2; + } + function urange(token, getNextToken) { + let length2 = 0; + if (token === null || token.type !== Ident || !cmpChar(token.value, 0, U)) { + return 0; + } + token = getNextToken(++length2); + if (token === null) { + return 0; + } + if (isDelim2(token, PLUSSIGN3)) { + token = getNextToken(++length2); + if (token === null) { + return 0; + } + if (token.type === Ident) { + return withQuestionMarkSequence(hexSequence(token, 0, true), ++length2, getNextToken); + } + if (isDelim2(token, QUESTIONMARK)) { + return withQuestionMarkSequence(1, ++length2, getNextToken); + } + return 0; + } + if (token.type === Number2) { + const consumedHexLength = hexSequence(token, 1, true); + if (consumedHexLength === 0) { + return 0; + } + token = getNextToken(++length2); + if (token === null) { + return length2; + } + if (token.type === Dimension || token.type === Number2) { + if (!startsWith(token, HYPHENMINUS4) || !hexSequence(token, 1, false)) { + return 0; + } + return length2 + 1; + } + return withQuestionMarkSequence(consumedHexLength, length2, getNextToken); + } + if (token.type === Dimension) { + return withQuestionMarkSequence(hexSequence(token, 1, true), ++length2, getNextToken); + } + return 0; + } + + // node_modules/css-tree/lib/lexer/generic.js + var calcFunctionNames = ["calc(", "-moz-calc(", "-webkit-calc("]; + var balancePair2 = /* @__PURE__ */ new Map([ + [Function2, RightParenthesis], + [LeftParenthesis, RightParenthesis], + [LeftSquareBracket, RightSquareBracket], + [LeftCurlyBracket, RightCurlyBracket] + ]); + function charCodeAt(str, index) { + return index < str.length ? str.charCodeAt(index) : 0; + } + function eqStr(actual, expected) { + return cmpStr(actual, 0, actual.length, expected); + } + function eqStrAny(actual, expected) { + for (let i = 0; i < expected.length; i++) { + if (eqStr(actual, expected[i])) { + return true; + } + } + return false; + } + function isPostfixIeHack(str, offset) { + if (offset !== str.length - 2) { + return false; + } + return charCodeAt(str, offset) === 92 && // U+005C REVERSE SOLIDUS (\) + isDigit(charCodeAt(str, offset + 1)); + } + function outOfRange(opts, value, numEnd) { + if (opts && opts.type === "Range") { + const num = Number( + numEnd !== void 0 && numEnd !== value.length ? value.substr(0, numEnd) : value + ); + if (isNaN(num)) { + return true; + } + if (opts.min !== null && num < opts.min && typeof opts.min !== "string") { + return true; + } + if (opts.max !== null && num > opts.max && typeof opts.max !== "string") { + return true; + } + } + return false; + } + function consumeFunction(token, getNextToken) { + let balanceCloseType = 0; + let balanceStash = []; + let length2 = 0; + scan: + do { + switch (token.type) { + case RightCurlyBracket: + case RightParenthesis: + case RightSquareBracket: + if (token.type !== balanceCloseType) { + break scan; + } + balanceCloseType = balanceStash.pop(); + if (balanceStash.length === 0) { + length2++; + break scan; + } + break; + case Function2: + case LeftParenthesis: + case LeftSquareBracket: + case LeftCurlyBracket: + balanceStash.push(balanceCloseType); + balanceCloseType = balancePair2.get(token.type); + break; + } + length2++; + } while (token = getNextToken(length2)); + return length2; + } + function calc(next) { + return function(token, getNextToken, opts) { + if (token === null) { + return 0; + } + if (token.type === Function2 && eqStrAny(token.value, calcFunctionNames)) { + return consumeFunction(token, getNextToken); + } + return next(token, getNextToken, opts); + }; + } + function tokenType(expectedTokenType) { + return function(token) { + if (token === null || token.type !== expectedTokenType) { + return 0; + } + return 1; + }; + } + function customIdent(token) { + if (token === null || token.type !== Ident) { + return 0; + } + const name42 = token.value.toLowerCase(); + if (eqStrAny(name42, cssWideKeywords)) { + return 0; + } + if (eqStr(name42, "default")) { + return 0; + } + return 1; + } + function customPropertyName(token) { + if (token === null || token.type !== Ident) { + return 0; + } + if (charCodeAt(token.value, 0) !== 45 || charCodeAt(token.value, 1) !== 45) { + return 0; + } + return 1; + } + function hexColor(token) { + if (token === null || token.type !== Hash) { + return 0; + } + const length2 = token.value.length; + if (length2 !== 4 && length2 !== 5 && length2 !== 7 && length2 !== 9) { + return 0; + } + for (let i = 1; i < length2; i++) { + if (!isHexDigit(charCodeAt(token.value, i))) { + return 0; + } + } + return 1; + } + function idSelector(token) { + if (token === null || token.type !== Hash) { + return 0; + } + if (!isIdentifierStart(charCodeAt(token.value, 1), charCodeAt(token.value, 2), charCodeAt(token.value, 3))) { + return 0; + } + return 1; + } + function declarationValue(token, getNextToken) { + if (!token) { + return 0; + } + let balanceCloseType = 0; + let balanceStash = []; + let length2 = 0; + scan: + do { + switch (token.type) { + case BadString: + case BadUrl: + break scan; + case RightCurlyBracket: + case RightParenthesis: + case RightSquareBracket: + if (token.type !== balanceCloseType) { + break scan; + } + balanceCloseType = balanceStash.pop(); + break; + case Semicolon: + if (balanceCloseType === 0) { + break scan; + } + break; + case Delim: + if (balanceCloseType === 0 && token.value === "!") { + break scan; + } + break; + case Function2: + case LeftParenthesis: + case LeftSquareBracket: + case LeftCurlyBracket: + balanceStash.push(balanceCloseType); + balanceCloseType = balancePair2.get(token.type); + break; + } + length2++; + } while (token = getNextToken(length2)); + return length2; + } + function anyValue(token, getNextToken) { + if (!token) { + return 0; + } + let balanceCloseType = 0; + let balanceStash = []; + let length2 = 0; + scan: + do { + switch (token.type) { + case BadString: + case BadUrl: + break scan; + case RightCurlyBracket: + case RightParenthesis: + case RightSquareBracket: + if (token.type !== balanceCloseType) { + break scan; + } + balanceCloseType = balanceStash.pop(); + break; + case Function2: + case LeftParenthesis: + case LeftSquareBracket: + case LeftCurlyBracket: + balanceStash.push(balanceCloseType); + balanceCloseType = balancePair2.get(token.type); + break; + } + length2++; + } while (token = getNextToken(length2)); + return length2; + } + function dimension(type) { + if (type) { + type = new Set(type); + } + return function(token, getNextToken, opts) { + if (token === null || token.type !== Dimension) { + return 0; + } + const numberEnd = consumeNumber(token.value, 0); + if (type !== null) { + const reverseSolidusOffset = token.value.indexOf("\\", numberEnd); + const unit = reverseSolidusOffset === -1 || !isPostfixIeHack(token.value, reverseSolidusOffset) ? token.value.substr(numberEnd) : token.value.substring(numberEnd, reverseSolidusOffset); + if (type.has(unit.toLowerCase()) === false) { + return 0; + } + } + if (outOfRange(opts, token.value, numberEnd)) { + return 0; + } + return 1; + }; + } + function percentage(token, getNextToken, opts) { + if (token === null || token.type !== Percentage) { + return 0; + } + if (outOfRange(opts, token.value, token.value.length - 1)) { + return 0; + } + return 1; + } + function zero(next) { + if (typeof next !== "function") { + next = function() { + return 0; + }; + } + return function(token, getNextToken, opts) { + if (token !== null && token.type === Number2) { + if (Number(token.value) === 0) { + return 1; + } + } + return next(token, getNextToken, opts); + }; + } + function number(token, getNextToken, opts) { + if (token === null) { + return 0; + } + const numberEnd = consumeNumber(token.value, 0); + const isNumber = numberEnd === token.value.length; + if (!isNumber && !isPostfixIeHack(token.value, numberEnd)) { + return 0; + } + if (outOfRange(opts, token.value, numberEnd)) { + return 0; + } + return 1; + } + function integer(token, getNextToken, opts) { + if (token === null || token.type !== Number2) { + return 0; + } + let i = charCodeAt(token.value, 0) === 43 || // U+002B PLUS SIGN (+) + charCodeAt(token.value, 0) === 45 ? 1 : 0; + for (; i < token.value.length; i++) { + if (!isDigit(charCodeAt(token.value, i))) { + return 0; + } + } + if (outOfRange(opts, token.value, i)) { + return 0; + } + return 1; + } + var tokenTypes = { + "ident-token": tokenType(Ident), + "function-token": tokenType(Function2), + "at-keyword-token": tokenType(AtKeyword), + "hash-token": tokenType(Hash), + "string-token": tokenType(String2), + "bad-string-token": tokenType(BadString), + "url-token": tokenType(Url), + "bad-url-token": tokenType(BadUrl), + "delim-token": tokenType(Delim), + "number-token": tokenType(Number2), + "percentage-token": tokenType(Percentage), + "dimension-token": tokenType(Dimension), + "whitespace-token": tokenType(WhiteSpace), + "CDO-token": tokenType(CDO), + "CDC-token": tokenType(CDC), + "colon-token": tokenType(Colon), + "semicolon-token": tokenType(Semicolon), + "comma-token": tokenType(Comma), + "[-token": tokenType(LeftSquareBracket), + "]-token": tokenType(RightSquareBracket), + "(-token": tokenType(LeftParenthesis), + ")-token": tokenType(RightParenthesis), + "{-token": tokenType(LeftCurlyBracket), + "}-token": tokenType(RightCurlyBracket) + }; + var productionTypes = { + // token type aliases + "string": tokenType(String2), + "ident": tokenType(Ident), + // percentage + "percentage": calc(percentage), + // numeric + "zero": zero(), + "number": calc(number), + "integer": calc(integer), + // complex types + "custom-ident": customIdent, + "custom-property-name": customPropertyName, + "hex-color": hexColor, + "id-selector": idSelector, + // element( ) + "an-plus-b": anPlusB, + "urange": urange, + "declaration-value": declarationValue, + "any-value": anyValue + }; + function createDemensionTypes(units) { + const { + angle: angle2, + decibel: decibel2, + frequency: frequency2, + flex: flex2, + length: length2, + resolution: resolution2, + semitones: semitones2, + time: time2 + } = units || {}; + return { + "dimension": calc(dimension(null)), + "angle": calc(dimension(angle2)), + "decibel": calc(dimension(decibel2)), + "frequency": calc(dimension(frequency2)), + "flex": calc(dimension(flex2)), + "length": calc(zero(dimension(length2))), + "resolution": calc(dimension(resolution2)), + "semitones": calc(dimension(semitones2)), + "time": calc(dimension(time2)) + }; + } + function createGenericTypes(units) { + return { + ...tokenTypes, + ...productionTypes, + ...createDemensionTypes(units) + }; + } + + // node_modules/css-tree/lib/lexer/units.js + var units_exports = {}; + __export(units_exports, { + angle: () => angle, + decibel: () => decibel, + flex: () => flex, + frequency: () => frequency, + length: () => length, + resolution: () => resolution, + semitones: () => semitones, + time: () => time + }); + var length = [ + // absolute length units https://www.w3.org/TR/css-values-3/#lengths + "cm", + "mm", + "q", + "in", + "pt", + "pc", + "px", + // font-relative length units https://drafts.csswg.org/css-values-4/#font-relative-lengths + "em", + "rem", + "ex", + "rex", + "cap", + "rcap", + "ch", + "rch", + "ic", + "ric", + "lh", + "rlh", + // viewport-percentage lengths https://drafts.csswg.org/css-values-4/#viewport-relative-lengths + "vw", + "svw", + "lvw", + "dvw", + "vh", + "svh", + "lvh", + "dvh", + "vi", + "svi", + "lvi", + "dvi", + "vb", + "svb", + "lvb", + "dvb", + "vmin", + "svmin", + "lvmin", + "dvmin", + "vmax", + "svmax", + "lvmax", + "dvmax", + // container relative lengths https://drafts.csswg.org/css-contain-3/#container-lengths + "cqw", + "cqh", + "cqi", + "cqb", + "cqmin", + "cqmax" + ]; + var angle = ["deg", "grad", "rad", "turn"]; + var time = ["s", "ms"]; + var frequency = ["hz", "khz"]; + var resolution = ["dpi", "dpcm", "dppx", "x"]; + var flex = ["fr"]; + var decibel = ["db"]; + var semitones = ["st"]; + + // node_modules/css-tree/lib/definition-syntax/SyntaxError.js + function SyntaxError3(message, input, offset) { + return Object.assign(createCustomError("SyntaxError", message), { + input, + offset, + rawMessage: message, + message: message + "\n " + input + "\n--" + new Array((offset || input.length) + 1).join("-") + "^" + }); + } + + // node_modules/css-tree/lib/definition-syntax/tokenizer.js + var TAB = 9; + var N3 = 10; + var F2 = 12; + var R2 = 13; + var SPACE = 32; + var Tokenizer2 = class { + constructor(str) { + this.str = str; + this.pos = 0; + } + charCodeAt(pos) { + return pos < this.str.length ? this.str.charCodeAt(pos) : 0; + } + charCode() { + return this.charCodeAt(this.pos); + } + nextCharCode() { + return this.charCodeAt(this.pos + 1); + } + nextNonWsCode(pos) { + return this.charCodeAt(this.findWsEnd(pos)); + } + findWsEnd(pos) { + for (; pos < this.str.length; pos++) { + const code2 = this.str.charCodeAt(pos); + if (code2 !== R2 && code2 !== N3 && code2 !== F2 && code2 !== SPACE && code2 !== TAB) { + break; + } + } + return pos; + } + substringToPos(end) { + return this.str.substring(this.pos, this.pos = end); + } + eat(code2) { + if (this.charCode() !== code2) { + this.error("Expect `" + String.fromCharCode(code2) + "`"); + } + this.pos++; + } + peek() { + return this.pos < this.str.length ? this.str.charAt(this.pos++) : ""; + } + error(message) { + throw new SyntaxError3(message, this.str, this.pos); + } + }; + + // node_modules/css-tree/lib/definition-syntax/parse.js + var TAB2 = 9; + var N4 = 10; + var F3 = 12; + var R3 = 13; + var SPACE2 = 32; + var EXCLAMATIONMARK2 = 33; + var NUMBERSIGN2 = 35; + var AMPERSAND = 38; + var APOSTROPHE = 39; + var LEFTPARENTHESIS = 40; + var RIGHTPARENTHESIS = 41; + var ASTERISK = 42; + var PLUSSIGN4 = 43; + var COMMA = 44; + var HYPERMINUS = 45; + var LESSTHANSIGN = 60; + var GREATERTHANSIGN = 62; + var QUESTIONMARK2 = 63; + var COMMERCIALAT = 64; + var LEFTSQUAREBRACKET = 91; + var RIGHTSQUAREBRACKET = 93; + var LEFTCURLYBRACKET2 = 123; + var VERTICALLINE = 124; + var RIGHTCURLYBRACKET = 125; + var INFINITY = 8734; + var NAME_CHAR = new Uint8Array(128).map( + (_, idx) => /[a-zA-Z0-9\-]/.test(String.fromCharCode(idx)) ? 1 : 0 + ); + var COMBINATOR_PRECEDENCE = { + " ": 1, + "&&": 2, + "||": 3, + "|": 4 + }; + function scanSpaces(tokenizer) { + return tokenizer.substringToPos( + tokenizer.findWsEnd(tokenizer.pos) + ); + } + function scanWord(tokenizer) { + let end = tokenizer.pos; + for (; end < tokenizer.str.length; end++) { + const code2 = tokenizer.str.charCodeAt(end); + if (code2 >= 128 || NAME_CHAR[code2] === 0) { + break; + } + } + if (tokenizer.pos === end) { + tokenizer.error("Expect a keyword"); + } + return tokenizer.substringToPos(end); + } + function scanNumber(tokenizer) { + let end = tokenizer.pos; + for (; end < tokenizer.str.length; end++) { + const code2 = tokenizer.str.charCodeAt(end); + if (code2 < 48 || code2 > 57) { + break; + } + } + if (tokenizer.pos === end) { + tokenizer.error("Expect a number"); + } + return tokenizer.substringToPos(end); + } + function scanString(tokenizer) { + const end = tokenizer.str.indexOf("'", tokenizer.pos + 1); + if (end === -1) { + tokenizer.pos = tokenizer.str.length; + tokenizer.error("Expect an apostrophe"); + } + return tokenizer.substringToPos(end + 1); + } + function readMultiplierRange(tokenizer) { + let min = null; + let max = null; + tokenizer.eat(LEFTCURLYBRACKET2); + min = scanNumber(tokenizer); + if (tokenizer.charCode() === COMMA) { + tokenizer.pos++; + if (tokenizer.charCode() !== RIGHTCURLYBRACKET) { + max = scanNumber(tokenizer); + } + } else { + max = min; + } + tokenizer.eat(RIGHTCURLYBRACKET); + return { + min: Number(min), + max: max ? Number(max) : 0 + }; + } + function readMultiplier(tokenizer) { + let range = null; + let comma = false; + switch (tokenizer.charCode()) { + case ASTERISK: + tokenizer.pos++; + range = { + min: 0, + max: 0 + }; + break; + case PLUSSIGN4: + tokenizer.pos++; + range = { + min: 1, + max: 0 + }; + break; + case QUESTIONMARK2: + tokenizer.pos++; + range = { + min: 0, + max: 1 + }; + break; + case NUMBERSIGN2: + tokenizer.pos++; + comma = true; + if (tokenizer.charCode() === LEFTCURLYBRACKET2) { + range = readMultiplierRange(tokenizer); + } else if (tokenizer.charCode() === QUESTIONMARK2) { + tokenizer.pos++; + range = { + min: 0, + max: 0 + }; + } else { + range = { + min: 1, + max: 0 + }; + } + break; + case LEFTCURLYBRACKET2: + range = readMultiplierRange(tokenizer); + break; + default: + return null; + } + return { + type: "Multiplier", + comma, + min: range.min, + max: range.max, + term: null + }; + } + function maybeMultiplied(tokenizer, node) { + const multiplier = readMultiplier(tokenizer); + if (multiplier !== null) { + multiplier.term = node; + if (tokenizer.charCode() === NUMBERSIGN2 && tokenizer.charCodeAt(tokenizer.pos - 1) === PLUSSIGN4) { + return maybeMultiplied(tokenizer, multiplier); + } + return multiplier; + } + return node; + } + function maybeToken(tokenizer) { + const ch = tokenizer.peek(); + if (ch === "") { + return null; + } + return { + type: "Token", + value: ch + }; + } + function readProperty(tokenizer) { + let name42; + tokenizer.eat(LESSTHANSIGN); + tokenizer.eat(APOSTROPHE); + name42 = scanWord(tokenizer); + tokenizer.eat(APOSTROPHE); + tokenizer.eat(GREATERTHANSIGN); + return maybeMultiplied(tokenizer, { + type: "Property", + name: name42 + }); + } + function readTypeRange(tokenizer) { + let min = null; + let max = null; + let sign = 1; + tokenizer.eat(LEFTSQUAREBRACKET); + if (tokenizer.charCode() === HYPERMINUS) { + tokenizer.peek(); + sign = -1; + } + if (sign == -1 && tokenizer.charCode() === INFINITY) { + tokenizer.peek(); + } else { + min = sign * Number(scanNumber(tokenizer)); + if (NAME_CHAR[tokenizer.charCode()] !== 0) { + min += scanWord(tokenizer); + } + } + scanSpaces(tokenizer); + tokenizer.eat(COMMA); + scanSpaces(tokenizer); + if (tokenizer.charCode() === INFINITY) { + tokenizer.peek(); + } else { + sign = 1; + if (tokenizer.charCode() === HYPERMINUS) { + tokenizer.peek(); + sign = -1; + } + max = sign * Number(scanNumber(tokenizer)); + if (NAME_CHAR[tokenizer.charCode()] !== 0) { + max += scanWord(tokenizer); + } + } + tokenizer.eat(RIGHTSQUAREBRACKET); + return { + type: "Range", + min, + max + }; + } + function readType(tokenizer) { + let name42; + let opts = null; + tokenizer.eat(LESSTHANSIGN); + name42 = scanWord(tokenizer); + if (tokenizer.charCode() === LEFTPARENTHESIS && tokenizer.nextCharCode() === RIGHTPARENTHESIS) { + tokenizer.pos += 2; + name42 += "()"; + } + if (tokenizer.charCodeAt(tokenizer.findWsEnd(tokenizer.pos)) === LEFTSQUAREBRACKET) { + scanSpaces(tokenizer); + opts = readTypeRange(tokenizer); + } + tokenizer.eat(GREATERTHANSIGN); + return maybeMultiplied(tokenizer, { + type: "Type", + name: name42, + opts + }); + } + function readKeywordOrFunction(tokenizer) { + const name42 = scanWord(tokenizer); + if (tokenizer.charCode() === LEFTPARENTHESIS) { + tokenizer.pos++; + return { + type: "Function", + name: name42 + }; + } + return maybeMultiplied(tokenizer, { + type: "Keyword", + name: name42 + }); + } + function regroupTerms(terms, combinators) { + function createGroup(terms2, combinator2) { + return { + type: "Group", + terms: terms2, + combinator: combinator2, + disallowEmpty: false, + explicit: false + }; + } + let combinator; + combinators = Object.keys(combinators).sort((a, b) => COMBINATOR_PRECEDENCE[a] - COMBINATOR_PRECEDENCE[b]); + while (combinators.length > 0) { + combinator = combinators.shift(); + let i = 0; + let subgroupStart = 0; + for (; i < terms.length; i++) { + const term = terms[i]; + if (term.type === "Combinator") { + if (term.value === combinator) { + if (subgroupStart === -1) { + subgroupStart = i - 1; + } + terms.splice(i, 1); + i--; + } else { + if (subgroupStart !== -1 && i - subgroupStart > 1) { + terms.splice( + subgroupStart, + i - subgroupStart, + createGroup(terms.slice(subgroupStart, i), combinator) + ); + i = subgroupStart + 1; + } + subgroupStart = -1; + } + } + } + if (subgroupStart !== -1 && combinators.length) { + terms.splice( + subgroupStart, + i - subgroupStart, + createGroup(terms.slice(subgroupStart, i), combinator) + ); + } + } + return combinator; + } + function readImplicitGroup(tokenizer) { + const terms = []; + const combinators = {}; + let token; + let prevToken = null; + let prevTokenPos = tokenizer.pos; + while (token = peek(tokenizer)) { + if (token.type !== "Spaces") { + if (token.type === "Combinator") { + if (prevToken === null || prevToken.type === "Combinator") { + tokenizer.pos = prevTokenPos; + tokenizer.error("Unexpected combinator"); + } + combinators[token.value] = true; + } else if (prevToken !== null && prevToken.type !== "Combinator") { + combinators[" "] = true; + terms.push({ + type: "Combinator", + value: " " + }); + } + terms.push(token); + prevToken = token; + prevTokenPos = tokenizer.pos; + } + } + if (prevToken !== null && prevToken.type === "Combinator") { + tokenizer.pos -= prevTokenPos; + tokenizer.error("Unexpected combinator"); + } + return { + type: "Group", + terms, + combinator: regroupTerms(terms, combinators) || " ", + disallowEmpty: false, + explicit: false + }; + } + function readGroup(tokenizer) { + let result; + tokenizer.eat(LEFTSQUAREBRACKET); + result = readImplicitGroup(tokenizer); + tokenizer.eat(RIGHTSQUAREBRACKET); + result.explicit = true; + if (tokenizer.charCode() === EXCLAMATIONMARK2) { + tokenizer.pos++; + result.disallowEmpty = true; + } + return result; + } + function peek(tokenizer) { + let code2 = tokenizer.charCode(); + if (code2 < 128 && NAME_CHAR[code2] === 1) { + return readKeywordOrFunction(tokenizer); + } + switch (code2) { + case RIGHTSQUAREBRACKET: + break; + case LEFTSQUAREBRACKET: + return maybeMultiplied(tokenizer, readGroup(tokenizer)); + case LESSTHANSIGN: + return tokenizer.nextCharCode() === APOSTROPHE ? readProperty(tokenizer) : readType(tokenizer); + case VERTICALLINE: + return { + type: "Combinator", + value: tokenizer.substringToPos( + tokenizer.pos + (tokenizer.nextCharCode() === VERTICALLINE ? 2 : 1) + ) + }; + case AMPERSAND: + tokenizer.pos++; + tokenizer.eat(AMPERSAND); + return { + type: "Combinator", + value: "&&" + }; + case COMMA: + tokenizer.pos++; + return { + type: "Comma" + }; + case APOSTROPHE: + return maybeMultiplied(tokenizer, { + type: "String", + value: scanString(tokenizer) + }); + case SPACE2: + case TAB2: + case N4: + case R3: + case F3: + return { + type: "Spaces", + value: scanSpaces(tokenizer) + }; + case COMMERCIALAT: + code2 = tokenizer.nextCharCode(); + if (code2 < 128 && NAME_CHAR[code2] === 1) { + tokenizer.pos++; + return { + type: "AtKeyword", + name: scanWord(tokenizer) + }; + } + return maybeToken(tokenizer); + case ASTERISK: + case PLUSSIGN4: + case QUESTIONMARK2: + case NUMBERSIGN2: + case EXCLAMATIONMARK2: + break; + case LEFTCURLYBRACKET2: + code2 = tokenizer.nextCharCode(); + if (code2 < 48 || code2 > 57) { + return maybeToken(tokenizer); + } + break; + default: + return maybeToken(tokenizer); + } + } + function parse2(source) { + const tokenizer = new Tokenizer2(source); + const result = readImplicitGroup(tokenizer); + if (tokenizer.pos !== source.length) { + tokenizer.error("Unexpected input"); + } + if (result.terms.length === 1 && result.terms[0].type === "Group") { + return result.terms[0]; + } + return result; + } + + // node_modules/css-tree/lib/definition-syntax/walk.js + var noop3 = function() { + }; + function ensureFunction2(value) { + return typeof value === "function" ? value : noop3; + } + function walk(node, options, context) { + function walk3(node2) { + enter.call(context, node2); + switch (node2.type) { + case "Group": + node2.terms.forEach(walk3); + break; + case "Multiplier": + walk3(node2.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: " + node2.type); + } + leave.call(context, node2); + } + let enter = noop3; + let leave = noop3; + if (typeof options === "function") { + enter = options; + } else if (options) { + enter = ensureFunction2(options.enter); + leave = ensureFunction2(options.leave); + } + if (enter === noop3 && leave === noop3) { + throw new Error("Neither `enter` nor `leave` walker handler is set or both aren't a function"); + } + walk3(node, context); + } + + // node_modules/css-tree/lib/lexer/prepare-tokens.js + var astToTokens = { + decorator(handlers) { + const tokens = []; + let curNode = null; + return { + ...handlers, + node(node) { + const tmp = curNode; + curNode = node; + handlers.node.call(this, node); + curNode = tmp; + }, + emit(value, type, auto) { + tokens.push({ + type, + value, + node: auto ? null : curNode + }); + }, + result() { + return tokens; + } + }; + } + }; + function stringToTokens(str) { + const tokens = []; + tokenize( + str, + (type, start, end) => tokens.push({ + type, + value: str.slice(start, end), + node: null + }) + ); + return tokens; + } + function prepare_tokens_default(value, syntax) { + if (typeof value === "string") { + return stringToTokens(value); + } + return syntax.generate(value, astToTokens); + } + + // node_modules/css-tree/lib/lexer/match-graph.js + var MATCH = { type: "Match" }; + var MISMATCH = { type: "Mismatch" }; + var DISALLOW_EMPTY = { type: "DisallowEmpty" }; + var LEFTPARENTHESIS2 = 40; + var RIGHTPARENTHESIS2 = 41; + function createCondition(match, thenBranch, elseBranch) { + if (thenBranch === MATCH && elseBranch === MISMATCH) { + return match; + } + if (match === MATCH && thenBranch === MATCH && elseBranch === MATCH) { + return match; + } + if (match.type === "If" && match.else === MISMATCH && thenBranch === MATCH) { + thenBranch = match.then; + match = match.match; + } + return { + type: "If", + match, + then: thenBranch, + else: elseBranch + }; + } + function isFunctionType(name42) { + return name42.length > 2 && name42.charCodeAt(name42.length - 2) === LEFTPARENTHESIS2 && name42.charCodeAt(name42.length - 1) === RIGHTPARENTHESIS2; + } + function isEnumCapatible(term) { + return term.type === "Keyword" || term.type === "AtKeyword" || term.type === "Function" || term.type === "Type" && isFunctionType(term.name); + } + function buildGroupMatchGraph(combinator, terms, atLeastOneTermMatched) { + switch (combinator) { + case " ": { + let result = MATCH; + for (let i = terms.length - 1; i >= 0; i--) { + const term = terms[i]; + result = createCondition( + term, + result, + MISMATCH + ); + } + ; + return result; + } + case "|": { + let result = MISMATCH; + let map = null; + for (let i = terms.length - 1; i >= 0; i--) { + let term = terms[i]; + if (isEnumCapatible(term)) { + if (map === null && i > 0 && isEnumCapatible(terms[i - 1])) { + map = /* @__PURE__ */ Object.create(null); + result = createCondition( + { + type: "Enum", + map + }, + MATCH, + result + ); + } + if (map !== null) { + const key = (isFunctionType(term.name) ? term.name.slice(0, -1) : term.name).toLowerCase(); + if (key in map === false) { + map[key] = term; + continue; + } + } + } + map = null; + result = createCondition( + term, + MATCH, + result + ); + } + ; + return result; + } + case "&&": { + if (terms.length > 5) { + return { + type: "MatchOnce", + terms, + all: true + }; + } + let result = MISMATCH; + for (let i = terms.length - 1; i >= 0; i--) { + const term = terms[i]; + let thenClause; + if (terms.length > 1) { + thenClause = buildGroupMatchGraph( + combinator, + terms.filter(function(newGroupTerm) { + return newGroupTerm !== term; + }), + false + ); + } else { + thenClause = MATCH; + } + result = createCondition( + term, + thenClause, + result + ); + } + ; + return result; + } + case "||": { + if (terms.length > 5) { + return { + type: "MatchOnce", + terms, + all: false + }; + } + let result = atLeastOneTermMatched ? MATCH : MISMATCH; + for (let i = terms.length - 1; i >= 0; i--) { + const term = terms[i]; + let thenClause; + if (terms.length > 1) { + thenClause = buildGroupMatchGraph( + combinator, + terms.filter(function(newGroupTerm) { + return newGroupTerm !== term; + }), + true + ); + } else { + thenClause = MATCH; + } + result = createCondition( + term, + thenClause, + result + ); + } + ; + return result; + } + } + } + function buildMultiplierMatchGraph(node) { + let result = MATCH; + let matchTerm = buildMatchGraphInternal(node.term); + if (node.max === 0) { + matchTerm = createCondition( + matchTerm, + DISALLOW_EMPTY, + MISMATCH + ); + result = createCondition( + matchTerm, + null, + // will be a loop + MISMATCH + ); + result.then = createCondition( + MATCH, + MATCH, + result + // make a loop + ); + if (node.comma) { + result.then.else = createCondition( + { type: "Comma", syntax: node }, + result, + MISMATCH + ); + } + } else { + for (let i = node.min || 1; i <= node.max; i++) { + if (node.comma && result !== MATCH) { + result = createCondition( + { type: "Comma", syntax: node }, + result, + MISMATCH + ); + } + result = createCondition( + matchTerm, + createCondition( + MATCH, + MATCH, + result + ), + MISMATCH + ); + } + } + if (node.min === 0) { + result = createCondition( + MATCH, + MATCH, + result + ); + } else { + for (let i = 0; i < node.min - 1; i++) { + if (node.comma && result !== MATCH) { + result = createCondition( + { type: "Comma", syntax: node }, + result, + MISMATCH + ); + } + result = createCondition( + matchTerm, + result, + MISMATCH + ); + } + } + return result; + } + function buildMatchGraphInternal(node) { + if (typeof node === "function") { + return { + type: "Generic", + fn: node + }; + } + switch (node.type) { + case "Group": { + let result = buildGroupMatchGraph( + node.combinator, + node.terms.map(buildMatchGraphInternal), + false + ); + if (node.disallowEmpty) { + result = createCondition( + result, + DISALLOW_EMPTY, + MISMATCH + ); + } + return result; + } + case "Multiplier": + return buildMultiplierMatchGraph(node); + case "Type": + case "Property": + return { + type: node.type, + name: node.name, + syntax: node + }; + case "Keyword": + return { + type: node.type, + name: node.name.toLowerCase(), + syntax: node + }; + case "AtKeyword": + return { + type: node.type, + name: "@" + node.name.toLowerCase(), + syntax: node + }; + case "Function": + return { + type: node.type, + name: node.name.toLowerCase() + "(", + syntax: node + }; + case "String": + if (node.value.length === 3) { + return { + type: "Token", + value: node.value.charAt(1), + syntax: node + }; + } + return { + type: node.type, + value: node.value.substr(1, node.value.length - 2).replace(/\\'/g, "'"), + syntax: node + }; + case "Token": + return { + type: node.type, + value: node.value, + syntax: node + }; + case "Comma": + return { + type: node.type, + syntax: node + }; + default: + throw new Error("Unknown node type:", node.type); + } + } + function buildMatchGraph(syntaxTree, ref) { + if (typeof syntaxTree === "string") { + syntaxTree = parse2(syntaxTree); + } + return { + type: "MatchGraph", + match: buildMatchGraphInternal(syntaxTree), + syntax: ref || null, + source: syntaxTree + }; + } + + // node_modules/css-tree/lib/lexer/match.js + var { hasOwnProperty: hasOwnProperty3 } = Object.prototype; + var STUB = 0; + var TOKEN = 1; + var OPEN_SYNTAX = 2; + var CLOSE_SYNTAX = 3; + var EXIT_REASON_MATCH = "Match"; + var EXIT_REASON_MISMATCH = "Mismatch"; + var EXIT_REASON_ITERATION_LIMIT = "Maximum iteration number exceeded (please fill an issue on https://github.com/csstree/csstree/issues)"; + var ITERATION_LIMIT = 15e3; + var totalIterationCount = 0; + function reverseList(list) { + let prev = null; + let next = null; + let item = list; + while (item !== null) { + next = item.prev; + item.prev = prev; + prev = item; + item = next; + } + return prev; + } + function areStringsEqualCaseInsensitive(testStr, referenceStr) { + if (testStr.length !== referenceStr.length) { + return false; + } + for (let i = 0; i < testStr.length; i++) { + const referenceCode = referenceStr.charCodeAt(i); + let testCode = testStr.charCodeAt(i); + if (testCode >= 65 && testCode <= 90) { + testCode = testCode | 32; + } + if (testCode !== referenceCode) { + return false; + } + } + return true; + } + function isContextEdgeDelim(token) { + if (token.type !== Delim) { + return false; + } + return token.value !== "?"; + } + function isCommaContextStart(token) { + if (token === null) { + return true; + } + return token.type === Comma || token.type === Function2 || token.type === LeftParenthesis || token.type === LeftSquareBracket || token.type === LeftCurlyBracket || isContextEdgeDelim(token); + } + function isCommaContextEnd(token) { + if (token === null) { + return true; + } + return token.type === RightParenthesis || token.type === RightSquareBracket || token.type === RightCurlyBracket || token.type === Delim && token.value === "/"; + } + function internalMatch(tokens, state, syntaxes) { + function moveToNextToken() { + do { + tokenIndex++; + token = tokenIndex < tokens.length ? tokens[tokenIndex] : null; + } while (token !== null && (token.type === WhiteSpace || token.type === Comment)); + } + function getNextToken(offset) { + const nextIndex = tokenIndex + offset; + return nextIndex < tokens.length ? tokens[nextIndex] : null; + } + function stateSnapshotFromSyntax(nextState, prev) { + return { + nextState, + matchStack, + syntaxStack, + thenStack, + tokenIndex, + prev + }; + } + function pushThenStack(nextState) { + thenStack = { + nextState, + matchStack, + syntaxStack, + prev: thenStack + }; + } + function pushElseStack(nextState) { + elseStack = stateSnapshotFromSyntax(nextState, elseStack); + } + function addTokenToMatch() { + matchStack = { + type: TOKEN, + syntax: state.syntax, + token, + prev: matchStack + }; + moveToNextToken(); + syntaxStash = null; + if (tokenIndex > longestMatch) { + longestMatch = tokenIndex; + } + } + function openSyntax() { + syntaxStack = { + syntax: state.syntax, + opts: state.syntax.opts || syntaxStack !== null && syntaxStack.opts || null, + prev: syntaxStack + }; + matchStack = { + type: OPEN_SYNTAX, + syntax: state.syntax, + token: matchStack.token, + prev: matchStack + }; + } + function closeSyntax() { + if (matchStack.type === OPEN_SYNTAX) { + matchStack = matchStack.prev; + } else { + matchStack = { + type: CLOSE_SYNTAX, + syntax: syntaxStack.syntax, + token: matchStack.token, + prev: matchStack + }; + } + syntaxStack = syntaxStack.prev; + } + let syntaxStack = null; + let thenStack = null; + let elseStack = null; + let syntaxStash = null; + let iterationCount = 0; + let exitReason = null; + let token = null; + let tokenIndex = -1; + let longestMatch = 0; + let matchStack = { + type: STUB, + syntax: null, + token: null, + prev: null + }; + moveToNextToken(); + while (exitReason === null && ++iterationCount < ITERATION_LIMIT) { + switch (state.type) { + case "Match": + if (thenStack === null) { + if (token !== null) { + if (tokenIndex !== tokens.length - 1 || token.value !== "\\0" && token.value !== "\\9") { + state = MISMATCH; + break; + } + } + exitReason = EXIT_REASON_MATCH; + break; + } + state = thenStack.nextState; + if (state === DISALLOW_EMPTY) { + if (thenStack.matchStack === matchStack) { + state = MISMATCH; + break; + } else { + state = MATCH; + } + } + while (thenStack.syntaxStack !== syntaxStack) { + closeSyntax(); + } + thenStack = thenStack.prev; + break; + case "Mismatch": + if (syntaxStash !== null && syntaxStash !== false) { + if (elseStack === null || tokenIndex > elseStack.tokenIndex) { + elseStack = syntaxStash; + syntaxStash = false; + } + } else if (elseStack === null) { + exitReason = EXIT_REASON_MISMATCH; + break; + } + state = elseStack.nextState; + thenStack = elseStack.thenStack; + syntaxStack = elseStack.syntaxStack; + matchStack = elseStack.matchStack; + tokenIndex = elseStack.tokenIndex; + token = tokenIndex < tokens.length ? tokens[tokenIndex] : null; + elseStack = elseStack.prev; + break; + case "MatchGraph": + state = state.match; + break; + case "If": + if (state.else !== MISMATCH) { + pushElseStack(state.else); + } + if (state.then !== MATCH) { + pushThenStack(state.then); + } + state = state.match; + break; + case "MatchOnce": + state = { + type: "MatchOnceBuffer", + syntax: state, + index: 0, + mask: 0 + }; + break; + case "MatchOnceBuffer": { + const terms = state.syntax.terms; + if (state.index === terms.length) { + if (state.mask === 0 || state.syntax.all) { + state = MISMATCH; + break; + } + state = MATCH; + break; + } + if (state.mask === (1 << terms.length) - 1) { + state = MATCH; + break; + } + for (; state.index < terms.length; state.index++) { + const matchFlag = 1 << state.index; + if ((state.mask & matchFlag) === 0) { + pushElseStack(state); + pushThenStack({ + type: "AddMatchOnce", + syntax: state.syntax, + mask: state.mask | matchFlag + }); + state = terms[state.index++]; + break; + } + } + break; + } + case "AddMatchOnce": + state = { + type: "MatchOnceBuffer", + syntax: state.syntax, + index: 0, + mask: state.mask + }; + break; + case "Enum": + if (token !== null) { + let name42 = token.value.toLowerCase(); + if (name42.indexOf("\\") !== -1) { + name42 = name42.replace(/\\[09].*$/, ""); + } + if (hasOwnProperty3.call(state.map, name42)) { + state = state.map[name42]; + break; + } + } + state = MISMATCH; + break; + case "Generic": { + const opts = syntaxStack !== null ? syntaxStack.opts : null; + const lastTokenIndex2 = tokenIndex + Math.floor(state.fn(token, getNextToken, opts)); + if (!isNaN(lastTokenIndex2) && lastTokenIndex2 > tokenIndex) { + while (tokenIndex < lastTokenIndex2) { + addTokenToMatch(); + } + state = MATCH; + } else { + state = MISMATCH; + } + break; + } + case "Type": + case "Property": { + const syntaxDict = state.type === "Type" ? "types" : "properties"; + const dictSyntax = hasOwnProperty3.call(syntaxes, syntaxDict) ? syntaxes[syntaxDict][state.name] : null; + if (!dictSyntax || !dictSyntax.match) { + throw new Error( + "Bad syntax reference: " + (state.type === "Type" ? "<" + state.name + ">" : "<'" + state.name + "'>") + ); + } + if (syntaxStash !== false && token !== null && state.type === "Type") { + const lowPriorityMatching = ( + // https://drafts.csswg.org/css-values-4/#custom-idents + // When parsing positionally-ambiguous keywords in a property value, a production + // can only claim the keyword if no other unfulfilled production can claim it. + state.name === "custom-ident" && token.type === Ident || // https://drafts.csswg.org/css-values-4/#lengths + // ... if a `0` could be parsed as either a or a in a property (such as line-height), + // it must parse as a + state.name === "length" && token.value === "0" + ); + if (lowPriorityMatching) { + if (syntaxStash === null) { + syntaxStash = stateSnapshotFromSyntax(state, elseStack); + } + state = MISMATCH; + break; + } + } + openSyntax(); + state = dictSyntax.match; + break; + } + case "Keyword": { + const name42 = state.name; + if (token !== null) { + let keywordName = token.value; + if (keywordName.indexOf("\\") !== -1) { + keywordName = keywordName.replace(/\\[09].*$/, ""); + } + if (areStringsEqualCaseInsensitive(keywordName, name42)) { + addTokenToMatch(); + state = MATCH; + break; + } + } + state = MISMATCH; + break; + } + case "AtKeyword": + case "Function": + if (token !== null && areStringsEqualCaseInsensitive(token.value, state.name)) { + addTokenToMatch(); + state = MATCH; + break; + } + state = MISMATCH; + break; + case "Token": + if (token !== null && token.value === state.value) { + addTokenToMatch(); + state = MATCH; + break; + } + state = MISMATCH; + break; + case "Comma": + if (token !== null && token.type === Comma) { + if (isCommaContextStart(matchStack.token)) { + state = MISMATCH; + } else { + addTokenToMatch(); + state = isCommaContextEnd(token) ? MISMATCH : MATCH; + } + } else { + state = isCommaContextStart(matchStack.token) || isCommaContextEnd(token) ? MATCH : MISMATCH; + } + break; + case "String": + let string = ""; + let lastTokenIndex = tokenIndex; + for (; lastTokenIndex < tokens.length && string.length < state.value.length; lastTokenIndex++) { + string += tokens[lastTokenIndex].value; + } + if (areStringsEqualCaseInsensitive(string, state.value)) { + while (tokenIndex < lastTokenIndex) { + addTokenToMatch(); + } + state = MATCH; + } else { + state = MISMATCH; + } + break; + default: + throw new Error("Unknown node type: " + state.type); + } + } + totalIterationCount += iterationCount; + switch (exitReason) { + case null: + console.warn("[csstree-match] BREAK after " + ITERATION_LIMIT + " iterations"); + exitReason = EXIT_REASON_ITERATION_LIMIT; + matchStack = null; + break; + case EXIT_REASON_MATCH: + while (syntaxStack !== null) { + closeSyntax(); + } + break; + default: + matchStack = null; + } + return { + tokens, + reason: exitReason, + iterations: iterationCount, + match: matchStack, + longestMatch + }; + } + function matchAsTree(tokens, matchGraph, syntaxes) { + const matchResult = internalMatch(tokens, matchGraph, syntaxes || {}); + if (matchResult.match === null) { + return matchResult; + } + let item = matchResult.match; + let host = matchResult.match = { + syntax: matchGraph.syntax || null, + match: [] + }; + const hostStack = [host]; + item = reverseList(item).prev; + while (item !== null) { + switch (item.type) { + case OPEN_SYNTAX: + host.match.push(host = { + syntax: item.syntax, + match: [] + }); + hostStack.push(host); + break; + case CLOSE_SYNTAX: + hostStack.pop(); + host = hostStack[hostStack.length - 1]; + break; + default: + host.match.push({ + syntax: item.syntax || null, + token: item.token.value, + node: item.token.node + }); + } + item = item.prev; + } + return matchResult; + } + + // node_modules/css-tree/lib/lexer/trace.js + var trace_exports = {}; + __export(trace_exports, { + getTrace: () => getTrace, + isKeyword: () => isKeyword, + isProperty: () => isProperty, + isType: () => isType + }); + function getTrace(node) { + function shouldPutToTrace(syntax) { + if (syntax === null) { + return false; + } + return syntax.type === "Type" || syntax.type === "Property" || syntax.type === "Keyword"; + } + function hasMatch(matchNode) { + if (Array.isArray(matchNode.match)) { + for (let i = 0; i < matchNode.match.length; i++) { + if (hasMatch(matchNode.match[i])) { + if (shouldPutToTrace(matchNode.syntax)) { + result.unshift(matchNode.syntax); + } + return true; + } + } + } else if (matchNode.node === node) { + result = shouldPutToTrace(matchNode.syntax) ? [matchNode.syntax] : []; + return true; + } + return false; + } + let result = null; + if (this.matched !== null) { + hasMatch(this.matched); + } + return result; + } + function isType(node, type) { + return testNode(this, node, (match) => match.type === "Type" && match.name === type); + } + function isProperty(node, property3) { + return testNode(this, node, (match) => match.type === "Property" && match.name === property3); + } + function isKeyword(node) { + return testNode(this, node, (match) => match.type === "Keyword"); + } + function testNode(match, node, fn) { + const trace = getTrace.call(match, node); + if (trace === null) { + return false; + } + return trace.some(fn); + } + + // node_modules/css-tree/lib/lexer/search.js + function getFirstMatchNode(matchNode) { + if ("node" in matchNode) { + return matchNode.node; + } + return getFirstMatchNode(matchNode.match[0]); + } + function getLastMatchNode(matchNode) { + if ("node" in matchNode) { + return matchNode.node; + } + return getLastMatchNode(matchNode.match[matchNode.match.length - 1]); + } + function matchFragments(lexer2, ast, match, type, name42) { + function findFragments(matchNode) { + if (matchNode.syntax !== null && matchNode.syntax.type === type && matchNode.syntax.name === name42) { + const start = getFirstMatchNode(matchNode); + const end = getLastMatchNode(matchNode); + lexer2.syntax.walk(ast, function(node, item, list) { + if (node === start) { + const nodes = new List(); + do { + nodes.appendData(item.data); + if (item.data === end) { + break; + } + item = item.next; + } while (item !== null); + fragments.push({ + parent: list, + nodes + }); + } + }); + } + if (Array.isArray(matchNode.match)) { + matchNode.match.forEach(findFragments); + } + } + const fragments = []; + if (match.matched !== null) { + findFragments(match.matched); + } + return fragments; + } + + // node_modules/css-tree/lib/lexer/structure.js + var { hasOwnProperty: hasOwnProperty4 } = Object.prototype; + function isValidNumber(value) { + return typeof value === "number" && isFinite(value) && Math.floor(value) === value && value >= 0; + } + function isValidLocation(loc) { + return Boolean(loc) && isValidNumber(loc.offset) && isValidNumber(loc.line) && isValidNumber(loc.column); + } + function createNodeStructureChecker(type, fields) { + return function checkNode(node, warn) { + if (!node || node.constructor !== Object) { + return warn(node, "Type of node should be an Object"); + } + for (let key in node) { + let valid = true; + if (hasOwnProperty4.call(node, key) === false) { + continue; + } + if (key === "type") { + if (node.type !== type) { + warn(node, "Wrong node type `" + node.type + "`, expected `" + type + "`"); + } + } else if (key === "loc") { + if (node.loc === null) { + continue; + } else if (node.loc && node.loc.constructor === Object) { + if (typeof node.loc.source !== "string") { + key += ".source"; + } else if (!isValidLocation(node.loc.start)) { + key += ".start"; + } else if (!isValidLocation(node.loc.end)) { + key += ".end"; + } else { + continue; + } + } + valid = false; + } else if (fields.hasOwnProperty(key)) { + valid = false; + for (let i = 0; !valid && i < fields[key].length; i++) { + const fieldType = fields[key][i]; + switch (fieldType) { + case String: + valid = typeof node[key] === "string"; + break; + case Boolean: + valid = typeof node[key] === "boolean"; + break; + case null: + valid = node[key] === null; + break; + default: + if (typeof fieldType === "string") { + valid = node[key] && node[key].type === fieldType; + } else if (Array.isArray(fieldType)) { + valid = node[key] instanceof List; + } + } + } + } else { + warn(node, "Unknown field `" + key + "` for " + type + " node type"); + } + if (!valid) { + warn(node, "Bad value for `" + type + "." + key + "`"); + } + } + for (const key in fields) { + if (hasOwnProperty4.call(fields, key) && hasOwnProperty4.call(node, key) === false) { + warn(node, "Field `" + type + "." + key + "` is missed"); + } + } + }; + } + function processStructure(name42, nodeType) { + const structure42 = nodeType.structure; + const fields = { + type: String, + loc: true + }; + const docs = { + type: '"' + name42 + '"' + }; + for (const key in structure42) { + if (hasOwnProperty4.call(structure42, key) === false) { + continue; + } + const docsTypes = []; + const fieldTypes = fields[key] = Array.isArray(structure42[key]) ? structure42[key].slice() : [structure42[key]]; + for (let i = 0; i < fieldTypes.length; i++) { + const fieldType = fieldTypes[i]; + if (fieldType === String || fieldType === Boolean) { + docsTypes.push(fieldType.name); + } else if (fieldType === null) { + docsTypes.push("null"); + } else if (typeof fieldType === "string") { + docsTypes.push("<" + fieldType + ">"); + } else if (Array.isArray(fieldType)) { + docsTypes.push("List"); + } else { + throw new Error("Wrong value `" + fieldType + "` in `" + name42 + "." + key + "` structure definition"); + } + } + docs[key] = docsTypes.join(" | "); + } + return { + docs, + check: createNodeStructureChecker(name42, fields) + }; + } + function getStructureFromConfig(config) { + const structure42 = {}; + if (config.node) { + for (const name42 in config.node) { + if (hasOwnProperty4.call(config.node, name42)) { + const nodeType = config.node[name42]; + if (nodeType.structure) { + structure42[name42] = processStructure(name42, nodeType); + } else { + throw new Error("Missed `structure` field in `" + name42 + "` node type definition"); + } + } + } + } + return structure42; + } + + // node_modules/css-tree/lib/lexer/Lexer.js + var cssWideKeywordsSyntax = buildMatchGraph(cssWideKeywords.join(" | ")); + function dumpMapSyntax(map, compact, syntaxAsAst) { + const result = {}; + for (const name42 in map) { + if (map[name42].syntax) { + result[name42] = syntaxAsAst ? map[name42].syntax : generate(map[name42].syntax, { compact }); + } + } + return result; + } + function dumpAtruleMapSyntax(map, compact, syntaxAsAst) { + const result = {}; + for (const [name42, atrule] of Object.entries(map)) { + result[name42] = { + prelude: atrule.prelude && (syntaxAsAst ? atrule.prelude.syntax : generate(atrule.prelude.syntax, { compact })), + descriptors: atrule.descriptors && dumpMapSyntax(atrule.descriptors, compact, syntaxAsAst) + }; + } + return result; + } + function valueHasVar(tokens) { + for (let i = 0; i < tokens.length; i++) { + if (tokens[i].value.toLowerCase() === "var(") { + return true; + } + } + return false; + } + function buildMatchResult(matched, error, iterations) { + return { + matched, + iterations, + error, + ...trace_exports + }; + } + function matchSyntax(lexer2, syntax, value, useCssWideKeywords) { + const tokens = prepare_tokens_default(value, lexer2.syntax); + let result; + if (valueHasVar(tokens)) { + return buildMatchResult(null, new Error("Matching for a tree with var() is not supported")); + } + if (useCssWideKeywords) { + result = matchAsTree(tokens, lexer2.cssWideKeywordsSyntax, lexer2); + } + if (!useCssWideKeywords || !result.match) { + result = matchAsTree(tokens, syntax.match, lexer2); + if (!result.match) { + return buildMatchResult( + null, + new SyntaxMatchError(result.reason, syntax.syntax, value, result), + result.iterations + ); + } + } + return buildMatchResult(result.match, null, result.iterations); + } + var Lexer = class { + constructor(config, syntax, structure42) { + this.cssWideKeywordsSyntax = cssWideKeywordsSyntax; + this.syntax = syntax; + this.generic = false; + this.units = { ...units_exports }; + this.atrules = /* @__PURE__ */ Object.create(null); + this.properties = /* @__PURE__ */ Object.create(null); + this.types = /* @__PURE__ */ Object.create(null); + this.structure = structure42 || getStructureFromConfig(config); + if (config) { + if (config.units) { + for (const group of Object.keys(units_exports)) { + if (Array.isArray(config.units[group])) { + this.units[group] = config.units[group]; + } + } + } + if (config.types) { + for (const name42 in config.types) { + this.addType_(name42, config.types[name42]); + } + } + if (config.generic) { + this.generic = true; + for (const [name42, value] of Object.entries(createGenericTypes(this.units))) { + this.addType_(name42, value); + } + } + if (config.atrules) { + for (const name42 in config.atrules) { + this.addAtrule_(name42, config.atrules[name42]); + } + } + if (config.properties) { + for (const name42 in config.properties) { + this.addProperty_(name42, config.properties[name42]); + } + } + } + } + checkStructure(ast) { + function collectWarning(node, message) { + warns.push({ node, message }); + } + const structure42 = this.structure; + const warns = []; + this.syntax.walk(ast, function(node) { + if (structure42.hasOwnProperty(node.type)) { + structure42[node.type].check(node, collectWarning); + } else { + collectWarning(node, "Unknown node type `" + node.type + "`"); + } + }); + return warns.length ? warns : false; + } + createDescriptor(syntax, type, name42, parent = null) { + const ref = { + type, + name: name42 + }; + const descriptor = { + type, + name: name42, + parent, + serializable: typeof syntax === "string" || syntax && typeof syntax.type === "string", + syntax: null, + match: null + }; + if (typeof syntax === "function") { + descriptor.match = buildMatchGraph(syntax, ref); + } else { + if (typeof syntax === "string") { + Object.defineProperty(descriptor, "syntax", { + get() { + Object.defineProperty(descriptor, "syntax", { + value: parse2(syntax) + }); + return descriptor.syntax; + } + }); + } else { + descriptor.syntax = syntax; + } + Object.defineProperty(descriptor, "match", { + get() { + Object.defineProperty(descriptor, "match", { + value: buildMatchGraph(descriptor.syntax, ref) + }); + return descriptor.match; + } + }); + } + return descriptor; + } + addAtrule_(name42, syntax) { + if (!syntax) { + return; + } + this.atrules[name42] = { + type: "Atrule", + name: name42, + prelude: syntax.prelude ? this.createDescriptor(syntax.prelude, "AtrulePrelude", name42) : null, + descriptors: syntax.descriptors ? Object.keys(syntax.descriptors).reduce( + (map, descName) => { + map[descName] = this.createDescriptor(syntax.descriptors[descName], "AtruleDescriptor", descName, name42); + return map; + }, + /* @__PURE__ */ Object.create(null) + ) : null + }; + } + addProperty_(name42, syntax) { + if (!syntax) { + return; + } + this.properties[name42] = this.createDescriptor(syntax, "Property", name42); + } + addType_(name42, syntax) { + if (!syntax) { + return; + } + this.types[name42] = this.createDescriptor(syntax, "Type", name42); + } + checkAtruleName(atruleName) { + if (!this.getAtrule(atruleName)) { + return new SyntaxReferenceError("Unknown at-rule", "@" + atruleName); + } + } + checkAtrulePrelude(atruleName, prelude) { + const error = this.checkAtruleName(atruleName); + if (error) { + return error; + } + const atrule = this.getAtrule(atruleName); + if (!atrule.prelude && prelude) { + return new SyntaxError("At-rule `@" + atruleName + "` should not contain a prelude"); + } + if (atrule.prelude && !prelude) { + if (!matchSyntax(this, atrule.prelude, "", false).matched) { + return new SyntaxError("At-rule `@" + atruleName + "` should contain a prelude"); + } + } + } + checkAtruleDescriptorName(atruleName, descriptorName) { + const error = this.checkAtruleName(atruleName); + if (error) { + return error; + } + const atrule = this.getAtrule(atruleName); + const descriptor = keyword(descriptorName); + if (!atrule.descriptors) { + return new SyntaxError("At-rule `@" + atruleName + "` has no known descriptors"); + } + if (!atrule.descriptors[descriptor.name] && !atrule.descriptors[descriptor.basename]) { + return new SyntaxReferenceError("Unknown at-rule descriptor", descriptorName); + } + } + checkPropertyName(propertyName) { + if (!this.getProperty(propertyName)) { + return new SyntaxReferenceError("Unknown property", propertyName); + } + } + matchAtrulePrelude(atruleName, prelude) { + const error = this.checkAtrulePrelude(atruleName, prelude); + if (error) { + return buildMatchResult(null, error); + } + const atrule = this.getAtrule(atruleName); + if (!atrule.prelude) { + return buildMatchResult(null, null); + } + return matchSyntax(this, atrule.prelude, prelude || "", false); + } + matchAtruleDescriptor(atruleName, descriptorName, value) { + const error = this.checkAtruleDescriptorName(atruleName, descriptorName); + if (error) { + return buildMatchResult(null, error); + } + const atrule = this.getAtrule(atruleName); + const descriptor = keyword(descriptorName); + return matchSyntax(this, atrule.descriptors[descriptor.name] || atrule.descriptors[descriptor.basename], value, false); + } + matchDeclaration(node) { + if (node.type !== "Declaration") { + return buildMatchResult(null, new Error("Not a Declaration node")); + } + return this.matchProperty(node.property, node.value); + } + matchProperty(propertyName, value) { + if (property(propertyName).custom) { + return buildMatchResult(null, new Error("Lexer matching doesn't applicable for custom properties")); + } + const error = this.checkPropertyName(propertyName); + if (error) { + return buildMatchResult(null, error); + } + return matchSyntax(this, this.getProperty(propertyName), value, true); + } + matchType(typeName, value) { + const typeSyntax = this.getType(typeName); + if (!typeSyntax) { + return buildMatchResult(null, new SyntaxReferenceError("Unknown type", typeName)); + } + return matchSyntax(this, typeSyntax, value, false); + } + match(syntax, value) { + if (typeof syntax !== "string" && (!syntax || !syntax.type)) { + return buildMatchResult(null, new SyntaxReferenceError("Bad syntax")); + } + if (typeof syntax === "string" || !syntax.match) { + syntax = this.createDescriptor(syntax, "Type", "anonymous"); + } + return matchSyntax(this, syntax, value, false); + } + findValueFragments(propertyName, value, type, name42) { + return matchFragments(this, value, this.matchProperty(propertyName, value), type, name42); + } + findDeclarationValueFragments(declaration, type, name42) { + return matchFragments(this, declaration.value, this.matchDeclaration(declaration), type, name42); + } + findAllFragments(ast, type, name42) { + const result = []; + this.syntax.walk(ast, { + visit: "Declaration", + enter: (declaration) => { + result.push.apply(result, this.findDeclarationValueFragments(declaration, type, name42)); + } + }); + return result; + } + getAtrule(atruleName, fallbackBasename = true) { + const atrule = keyword(atruleName); + const atruleEntry = atrule.vendor && fallbackBasename ? this.atrules[atrule.name] || this.atrules[atrule.basename] : this.atrules[atrule.name]; + return atruleEntry || null; + } + getAtrulePrelude(atruleName, fallbackBasename = true) { + const atrule = this.getAtrule(atruleName, fallbackBasename); + return atrule && atrule.prelude || null; + } + getAtruleDescriptor(atruleName, name42) { + return this.atrules.hasOwnProperty(atruleName) && this.atrules.declarators ? this.atrules[atruleName].declarators[name42] || null : null; + } + getProperty(propertyName, fallbackBasename = true) { + const property3 = property(propertyName); + const propertyEntry = property3.vendor && fallbackBasename ? this.properties[property3.name] || this.properties[property3.basename] : this.properties[property3.name]; + return propertyEntry || null; + } + getType(name42) { + return hasOwnProperty.call(this.types, name42) ? this.types[name42] : null; + } + validate() { + function validate2(syntax, name42, broken, descriptor) { + if (broken.has(name42)) { + return broken.get(name42); + } + broken.set(name42, false); + if (descriptor.syntax !== null) { + walk(descriptor.syntax, function(node) { + if (node.type !== "Type" && node.type !== "Property") { + return; + } + const map = node.type === "Type" ? syntax.types : syntax.properties; + const brokenMap = node.type === "Type" ? brokenTypes : brokenProperties; + if (!hasOwnProperty.call(map, node.name) || validate2(syntax, node.name, brokenMap, map[node.name])) { + broken.set(name42, true); + } + }, this); + } + } + let brokenTypes = /* @__PURE__ */ new Map(); + let brokenProperties = /* @__PURE__ */ new Map(); + for (const key in this.types) { + validate2(this, key, brokenTypes, this.types[key]); + } + for (const key in this.properties) { + validate2(this, key, brokenProperties, this.properties[key]); + } + brokenTypes = [...brokenTypes.keys()].filter((name42) => brokenTypes.get(name42)); + brokenProperties = [...brokenProperties.keys()].filter((name42) => brokenProperties.get(name42)); + if (brokenTypes.length || brokenProperties.length) { + return { + types: brokenTypes, + properties: brokenProperties + }; + } + return null; + } + dump(syntaxAsAst, pretty) { + return { + generic: this.generic, + units: this.units, + types: dumpMapSyntax(this.types, !pretty, syntaxAsAst), + properties: dumpMapSyntax(this.properties, !pretty, syntaxAsAst), + atrules: dumpAtruleMapSyntax(this.atrules, !pretty, syntaxAsAst) + }; + } + toString() { + return JSON.stringify(this.dump()); + } + }; + + // node_modules/css-tree/lib/syntax/config/mix.js + function appendOrSet(a, b) { + if (typeof b === "string" && /^\s*\|/.test(b)) { + return typeof a === "string" ? a + b : b.replace(/^\s*\|\s*/, ""); + } + return b || null; + } + function sliceProps(obj, props) { + const result = /* @__PURE__ */ Object.create(null); + for (const [key, value] of Object.entries(obj)) { + if (value) { + result[key] = {}; + for (const prop of Object.keys(value)) { + if (props.includes(prop)) { + result[key][prop] = value[prop]; + } + } + } + } + return result; + } + function mix(dest, src) { + const result = { ...dest }; + for (const [prop, value] of Object.entries(src)) { + switch (prop) { + case "generic": + result[prop] = Boolean(value); + break; + case "units": + result[prop] = { ...dest[prop] }; + for (const [name42, patch] of Object.entries(value)) { + result[prop][name42] = Array.isArray(patch) ? patch : []; + } + break; + case "atrules": + result[prop] = { ...dest[prop] }; + for (const [name42, atrule] of Object.entries(value)) { + const exists = result[prop][name42] || {}; + const current = result[prop][name42] = { + prelude: exists.prelude || null, + descriptors: { + ...exists.descriptors + } + }; + if (!atrule) { + continue; + } + current.prelude = atrule.prelude ? appendOrSet(current.prelude, atrule.prelude) : current.prelude || null; + for (const [descriptorName, descriptorValue] of Object.entries(atrule.descriptors || {})) { + current.descriptors[descriptorName] = descriptorValue ? appendOrSet(current.descriptors[descriptorName], descriptorValue) : null; + } + if (!Object.keys(current.descriptors).length) { + current.descriptors = null; + } + } + break; + case "types": + case "properties": + result[prop] = { ...dest[prop] }; + for (const [name42, syntax] of Object.entries(value)) { + result[prop][name42] = appendOrSet(result[prop][name42], syntax); + } + break; + case "scope": + result[prop] = { ...dest[prop] }; + for (const [name42, props] of Object.entries(value)) { + result[prop][name42] = { ...result[prop][name42], ...props }; + } + break; + case "parseContext": + result[prop] = { + ...dest[prop], + ...value + }; + break; + case "atrule": + case "pseudo": + result[prop] = { + ...dest[prop], + ...sliceProps(value, ["parse"]) + }; + break; + case "node": + result[prop] = { + ...dest[prop], + ...sliceProps(value, ["name", "structure", "parse", "generate", "walkContext"]) + }; + break; + } + } + return result; + } + + // node_modules/css-tree/lib/syntax/create.js + function createSyntax(config) { + const parse45 = createParser(config); + const walk3 = createWalker(config); + const generate45 = createGenerator(config); + const { fromPlainObject: fromPlainObject2, toPlainObject: toPlainObject2 } = createConvertor(walk3); + const syntax = { + lexer: null, + createLexer: (config2) => new Lexer(config2, syntax, syntax.lexer.structure), + tokenize, + parse: parse45, + generate: generate45, + walk: walk3, + find: walk3.find, + findLast: walk3.findLast, + findAll: walk3.findAll, + fromPlainObject: fromPlainObject2, + toPlainObject: toPlainObject2, + fork(extension2) { + const base = mix({}, config); + return createSyntax( + typeof extension2 === "function" ? extension2(base, Object.assign) : mix(base, extension2) + ); + } + }; + syntax.lexer = new Lexer({ + generic: true, + units: config.units, + types: config.types, + atrules: config.atrules, + properties: config.properties, + node: config.node + }, syntax); + return syntax; + } + var create_default = (config) => createSyntax(mix({}, config)); + + // node_modules/css-tree/dist/data.js + var data_default = { + "generic": true, + "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( )", + "absolute-size": "xx-small|x-small|small|medium|large|x-large|xx-large|xxx-large", + "acos()": "acos( )", + "alpha-value": "|", + "angle-percentage": "|", + "angular-color-hint": "", + "angular-color-stop": "&&?", + "angular-color-stop-list": "[ [, ]?]# , ", + "animateable-feature": "scroll-position|contents|", + "asin()": "asin( )", + "atan()": "atan( )", + "atan2()": "atan2( , )", + "attachment": "scroll|fixed|local", + "attr()": "attr( ? [, ]? )", + "attr-matcher": "['~'|'|'|'^'|'$'|'*']? '='", + "attr-modifier": "i|s", + "attribute-selector": "'[' ']'|'[' [|] ? ']'", + "auto-repeat": "repeat( [auto-fill|auto-fit] , [? ]+ ? )", + "auto-track-list": "[? [|]]* ? [? [|]]* ?", + "axis": "block|inline|vertical|horizontal", + "baseline-position": "[first|last]? baseline", + "basic-shape": "||||", + "bg-image": "none|", + "bg-layer": "|| [/ ]?||||||||", + "bg-position": "[[left|center|right|top|bottom|]|[left|center|right|] [top|center|bottom|]|[center|[left|right] ?]&&[center|[top|bottom] ?]]", + "bg-size": "[|auto]{1,2}|cover|contain", + "blur()": "blur( )", + "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( )", + "calc()": "calc( )", + "calc-sum": " [['+'|'-'] ]*", + "calc-product": " ['*' |'/' ]*", + "calc-value": "||||( )", + "calc-constant": "e|pi|infinity|-infinity|NaN", + "cf-final-image": "|", + "cf-mixing-image": "?&&", + "circle()": "circle( []? [at ]? )", + "clamp()": "clamp( #{3} )", + "class-selector": "'.' ", + "clip-source": "", + "color": "|||||||||currentcolor|", + "color-stop": "|", + "color-stop-angle": "{1,2}", + "color-stop-length": "{1,2}", + "color-stop-list": "[ [, ]?]# , ", + "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": "[? * [ *]*]!", + "compound-selector-list": "#", + "complex-selector": " [? ]*", + "complex-selector-list": "#", + "conic-gradient()": "conic-gradient( [from ]? [at ]? , )", + "contextual-alt-values": "[contextual|no-contextual]", + "content-distribution": "space-between|space-around|space-evenly|stretch", + "content-list": "[|contents||||||]+", + "content-position": "center|start|end|flex-start|flex-end", + "content-replacement": "", + "contrast()": "contrast( [] )", + "cos()": "cos( )", + "counter": "|", + "counter()": "counter( , ? )", + "counter-name": "", + "counter-style": "|symbols( )", + "counter-style-name": "", + "counters()": "counters( , , ? )", + "cross-fade()": "cross-fade( , ? )", + "cubic-bezier-timing-function": "ease|ease-in|ease-out|ease-in-out|cubic-bezier( , , , )", + "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": "?&&[flow|flow-root]?&&list-item", + "display-outside": "block|inline|run-in", + "drop-shadow()": "drop-shadow( {2,3} ? )", + "east-asian-variant-values": "[jis78|jis83|jis90|jis04|simplified|traditional]", + "east-asian-width-values": "[full-width|proportional-width]", + "element()": "element( , [first|start|last|first-except]? )|element( )", + "ellipse()": "ellipse( [{2}]? [at ]? )", + "ending-shape": "circle|ellipse", + "env()": "env( , ? )", + "exp()": "exp( )", + "explicit-track-list": "[? ]+ ?", + "family-name": "|+", + "feature-tag-value": " [|on|off]?", + "feature-type": "@stylistic|@historical-forms|@styleset|@character-variant|@swash|@ornaments|@annotation", + "feature-value-block": " '{' '}'", + "feature-value-block-list": "+", + "feature-value-declaration": " : + ;", + "feature-value-declaration-list": "", + "feature-value-name": "", + "fill-rule": "nonzero|evenodd", + "filter-function": "|||||||||", + "filter-function-list": "[|]+", + "final-bg-layer": "<'background-color'>|||| [/ ]?||||||||", + "fixed-breadth": "", + "fixed-repeat": "repeat( [] , [? ]+ ? )", + "fixed-size": "|minmax( , )|minmax( , )", + "font-stretch-absolute": "normal|ultra-condensed|extra-condensed|condensed|semi-condensed|semi-expanded|expanded|extra-expanded|ultra-expanded|", + "font-variant-css21": "[normal|small-caps]", + "font-weight-absolute": "normal|bold|", + "frequency-percentage": "|", + "general-enclosed": "[ )]|( )", + "generic-family": "serif|sans-serif|cursive|fantasy|monospace|-apple-system", + "generic-name": "serif|sans-serif|cursive|fantasy|monospace", + "geometry-box": "|fill-box|stroke-box|view-box", + "gradient": "||||||<-legacy-gradient>", + "grayscale()": "grayscale( )", + "grid-line": "auto||[&&?]|[span&&[||]]", + "historical-lig-values": "[historical-ligatures|no-historical-ligatures]", + "hsl()": "hsl( [/ ]? )|hsl( , , , ? )", + "hsla()": "hsla( [/ ]? )|hsla( , , , ? )", + "hue": "|", + "hue-rotate()": "hue-rotate( )", + "hwb()": "hwb( [|none] [|none] [|none] [/ [|none]]? )", + "hypot()": "hypot( # )", + "image": "||||||", + "image()": "image( ? [? , ?]! )", + "image-set()": "image-set( # )", + "image-set-option": "[|] [||type( )]", + "image-src": "|", + "image-tags": "ltr|rtl", + "inflexible-breadth": "|min-content|max-content|auto", + "inset()": "inset( {1,4} [round <'border-radius'>]? )", + "invert()": "invert( )", + "keyframes-name": "|", + "keyframe-block": "# { }", + "keyframe-block-list": "+", + "keyframe-selector": "from|to|", + "lab()": "lab( [||none] [||none] [||none] [/ [|none]]? )", + "layer()": "layer( )", + "layer-name": " ['.' ]*", + "lch()": "lch( [||none] [||none] [|none] [/ [|none]]? )", + "leader()": "leader( )", + "leader-type": "dotted|solid|space|", + "length-percentage": "|", + "line-names": "'[' * ']'", + "line-name-list": "[|]+", + "line-style": "none|hidden|dotted|dashed|solid|double|groove|ridge|inset|outset", + "line-width": "|thin|medium|thick", + "linear-color-hint": "", + "linear-color-stop": " ?", + "linear-gradient()": "linear-gradient( [|to ]? , )", + "log()": "log( , ? )", + "mask-layer": "|| [/ ]?||||||[|no-clip]||||", + "mask-position": "[|left|center|right] [|top|center|bottom]?", + "mask-reference": "none||", + "mask-source": "", + "masking-mode": "alpha|luminance|match-source", + "matrix()": "matrix( #{6} )", + "matrix3d()": "matrix3d( #{16} )", + "max()": "max( # )", + "media-and": " [and ]+", + "media-condition": "|||", + "media-condition-without-or": "||", + "media-feature": "( [||] )", + "media-in-parens": "( )||", + "media-not": "not ", + "media-or": " [or ]+", + "media-query": "|[not|only]? [and ]?", + "media-query-list": "#", + "media-type": "", + "mf-boolean": "", + "mf-name": "", + "mf-plain": " : ", + "mf-range": " ['<'|'>']? '='? | ['<'|'>']? '='? | '<' '='? '<' '='? | '>' '='? '>' '='? ", + "mf-value": "|||", + "min()": "min( # )", + "minmax()": "minmax( [|min-content|max-content|auto] , [||min-content|max-content|auto] )", + "mod()": "mod( , )", + "name-repeat": "repeat( [|auto-fill] , + )", + "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": "", + "ns-prefix": "[|'*']? '|'", + "number-percentage": "|", + "numeric-figure-values": "[lining-nums|oldstyle-nums]", + "numeric-fraction-values": "[diagonal-fractions|stacked-fractions]", + "numeric-spacing-values": "[proportional-nums|tabular-nums]", + "nth": "|even|odd", + "opacity()": "opacity( [] )", + "overflow-position": "unsafe|safe", + "outline-radius": "|", + "page-body": "? [; ]?| ", + "page-margin-box": " '{' '}'", + "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-size": "A5|A4|A3|B5|B4|JIS-B5|JIS-B4|letter|legal|ledger", + "path()": "path( [ ,]? )", + "paint()": "paint( , ? )", + "perspective()": "perspective( [|none] )", + "polygon()": "polygon( ? , [ ]# )", + "position": "[[left|center|right]||[top|center|bottom]|[left|center|right|] [top|center|bottom|]?|[[left|right] ]&&[[top|bottom] ]]", + "pow()": "pow( , )", + "pseudo-class-selector": "':' |':' ')'", + "pseudo-element-selector": "':' ", + "pseudo-page": ": [left|right|first|blank]", + "quote": "open-quote|close-quote|no-open-quote|no-close-quote", + "radial-gradient()": "radial-gradient( [||]? [at ]? , )", + "ratio": " [/ ]?", + "relative-selector": "? ", + "relative-selector-list": "#", + "relative-size": "larger|smaller", + "rem()": "rem( , )", + "repeat-style": "repeat-x|repeat-y|[repeat|space|round|no-repeat]{1,2}", + "repeating-conic-gradient()": "repeating-conic-gradient( [from ]? [at ]? , )", + "repeating-linear-gradient()": "repeating-linear-gradient( [|to ]? , )", + "repeating-radial-gradient()": "repeating-radial-gradient( [||]? [at ]? , )", + "reversed-counter-name": "reversed( )", + "rgb()": "rgb( {3} [/ ]? )|rgb( {3} [/ ]? )|rgb( #{3} , ? )|rgb( #{3} , ? )", + "rgba()": "rgba( {3} [/ ]? )|rgba( {3} [/ ]? )|rgba( #{3} , ? )|rgba( #{3} , ? )", + "rotate()": "rotate( [|] )", + "rotate3d()": "rotate3d( , , , [|] )", + "rotateX()": "rotateX( [|] )", + "rotateY()": "rotateY( [|] )", + "rotateZ()": "rotateZ( [|] )", + "round()": "round( ? , , )", + "rounding-strategy": "nearest|up|down|to-zero", + "saturate()": "saturate( )", + "scale()": "scale( [|]#{1,2} )", + "scale3d()": "scale3d( [|]#{3} )", + "scaleX()": "scaleX( [|] )", + "scaleY()": "scaleY( [|] )", + "scaleZ()": "scaleZ( [|] )", + "scroller": "root|nearest", + "self-position": "center|start|end|self-start|self-end|flex-start|flex-end", + "shape-radius": "|closest-side|farthest-side", + "sign()": "sign( )", + "skew()": "skew( [|] , [|]? )", + "skewX()": "skewX( [|] )", + "skewY()": "skewY( [|] )", + "sepia()": "sepia( )", + "shadow": "inset?&&{2,4}&&?", + "shadow-t": "[{2,3}&&?]", + "shape": "rect( , , , )|rect( )", + "shape-box": "|margin-box", + "side-or-corner": "[left|right]||[top|bottom]", + "sin()": "sin( )", + "single-animation": "

This site can\u2019t be reached

\u2019s server IP address could not be found.

Try:

Ultraviolet v

` +\n '' +\n ''\n );\n}\n\n/**\n *\n * @param {string} title\n * @param {string} code\n * @param {string} id\n * @param {string} message\n * @param {string} trace\n * @param {string} fetchedURL\n * @param {string} bareServer\n * @returns\n */\nfunction errorTemplate(\n title,\n code,\n id,\n message,\n trace,\n fetchedURL,\n bareServer\n) {\n // produced by bare-server-node\n if (message === 'The specified host could not be resolved.')\n return hostnameErrorTemplate(fetchedURL, bareServer);\n\n // turn script into a data URI so we don't have to escape any HTML values\n const script =\n `errorTitle.textContent = ${JSON.stringify(title)};` +\n `errorCode.textContent = ${JSON.stringify(code)};` +\n (id ? `errorId.textContent = ${JSON.stringify(id)};` : '') +\n `errorMessage.textContent = ${JSON.stringify(message)};` +\n `errorTrace.value = ${JSON.stringify(trace)};` +\n `fetchedURL.textContent = ${JSON.stringify(fetchedURL)};` +\n `bareServer.href = ${JSON.stringify(bareServer)};` +\n `for (const node of document.querySelectorAll(\"#uvHostname\")) node.textContent = ${JSON.stringify(\n location.hostname\n )};` +\n `reload.addEventListener(\"click\", () => location.reload());` +\n `uvVersion.textContent = ${JSON.stringify(\n process.env.ULTRAVIOLET_VERSION\n )};`;\n\n return (\n '' +\n '' +\n '' +\n \"\" +\n 'Error' +\n '' +\n '' +\n \"

\" +\n '
' +\n '

Failed to load

' +\n '

' +\n '' +\n '' +\n (id ? '' : '') +\n '
Code:
ID:
' +\n '' +\n '

Try:

' +\n '' +\n '

If you\\'re the administrator of , try:

' +\n '' +\n '' +\n '
' +\n '

Ultraviolet v

' +\n `` +\n '' +\n ''\n );\n}\n\n/**\n * @typedef {import(\"@tomphttp/bare-client\").BareError} BareError\n */\n\n/**\n *\n * @param {unknown} err\n * @returns {err is BareError}\n */\nfunction isBareError(err) {\n return err instanceof Error && typeof err.body === 'object';\n}\n\n/**\n *\n * @param {unknown} err\n * @param {string} fetchedURL\n * @param {string} bareServer\n */\nfunction renderError(err, fetchedURL, bareServer) {\n /**\n * @type {number}\n */\n let status;\n /**\n * @type {string}\n */\n let title;\n /**\n * @type {string}\n */\n let code;\n let id = '';\n /**\n * @type {string}\n */\n let message;\n\n if (isBareError(err)) {\n status = err.status;\n title = 'Error communicating with the Bare server';\n message = err.body.message;\n code = err.body.code;\n id = err.body.id;\n } else {\n status = 500;\n title = 'Error processing your request';\n message = 'Internal Server Error';\n code = err instanceof Error ? err.name : 'UNKNOWN';\n }\n\n return new Response(\n errorTemplate(\n title,\n code,\n id,\n message,\n String(err),\n fetchedURL,\n bareServer\n ),\n {\n status,\n headers: {\n 'content-type': 'text/html',\n },\n }\n );\n}\n"], + "mappings": ";;AAOA,MAAM,cAAc,KAAK;AAEzB,MAAM,aAAa;AAAA,IACf;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACJ;AACA,MAAM,eAAe,CAAC,OAAO,MAAM;AAEnC,MAAM,kBAAN,cAA8B,YAAY,aAAa;AAAA,IACnD,YAAY,SAAS,aAAa;AAC9B,YAAM;AACN,UAAI,CAAC,OAAO;AAAM,eAAO,OAAO;AAChC,UAAI,CAAC,OAAO;AAAQ,eAAO,SAAS;AACpC,WAAK,SAAS;AACd,YAAM,aACF,MAAM,QAAQ,OAAO,IAAI,IAAI,OAAO,OAAO,CAAC,OAAO,IAAI,GACzD,IAAI,CAAC,QAAQ,IAAI,IAAI,KAAK,QAAQ,EAAE,SAAS,CAAC;AAChD,WAAK,UAAU,UAAU,CAAC,EAAE,KAAK,OAAO,IAAI,UAAU,OAAO;AAI7D,WAAK,aAAa,IAAI,YAAY,WAAW,KAAK,OAAO;AAAA,IAC7D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA,MAAM,MAAM,EAAE,QAAQ,GAAG;AAIrB,UAAI;AAEJ,UAAI;AACA,YAAI,CAAC,QAAQ,IAAI,WAAW,SAAS,SAAS,KAAK,OAAO,MAAM;AAC5D,iBAAO,MAAM,MAAM,OAAO;AAE9B,cAAM,cAAc,IAAI,YAAY,KAAK,QAAQ,KAAK,OAAO;AAE7D,YAAI,OAAO,KAAK,OAAO,cAAc,YAAY;AAC7C,eAAK,OAAO,UAAU,aAAa,SAAS;AAAA,QAChD;AAEA,cAAM,KAAK,MAAM,YAAY,OAAO,GAAG;AAEvC,oBAAY,KAAK,SAAS,SAAS;AACnC,oBAAY,KAAK,OAAO,YAAY,KAAK,MAAM,IAAI;AAAA,UAC/C,YAAY,UAAU,QAAQ,GAAG;AAAA,QACrC;AAEA,cAAM,aAAa,IAAI;AAAA,UACnB;AAAA,UACA;AAAA,UACA;AAAA,UACA,CAAC,aAAa,SAAS,QAAQ,OAAO,YAAY,CAAC,IAC7C,MAAM,QAAQ,KAAK,IACnB;AAAA,QACV;AAEA,YAAI,YAAY,KAAK,IAAI,aAAa,SAAS;AAC3C,qBAAW,OAAO;AAClB,qBAAW,OAAO,WAAW,MAAM,IAAI;AAAA,YACnC,WAAW,IAAI;AAAA,UACnB;AAAA,QACJ;AAEA,YACI,QAAQ,YACR,QAAQ,SAAS,WAAW,SAAS,MAAM,GAC7C;AACE,gBAAM,UAAU,IAAI;AAAA,YAChB,YAAY,UAAU,QAAQ,QAAQ;AAAA,UAC1C;AAEA,cACI,WAAW,QAAQ,UAClB,YAAY,KAAK,IAAI,WAAW,QAAQ,UACrC,QAAQ,SAAS,QACvB;AACE,uBAAW,QAAQ,SAAS,QAAQ;AAAA,UACxC;AAEA,qBAAW,QAAQ,UAAU,QAAQ;AAAA,QACzC;AAEA,cAAM,UAAW,MAAM,YAAY,OAAO,WAAW,EAAE,KAAM,CAAC;AAC9D,cAAM,YAAY,YAAY,OAAO;AAAA,UACjC;AAAA,UACA,YAAY;AAAA,UACZ;AAAA,QACJ;AAEA,mBAAW,QAAQ,YAAY,IAAI,UAAU;AAE7C,YAAI;AAAW,qBAAW,QAAQ,SAAS;AAE3C,cAAM,WAAW,IAAI,UAAU,YAAY,MAAM,IAAI;AACrD,aAAK,KAAK,WAAW,QAAQ;AAE7B,YAAI,SAAS;AAAa,iBAAO,SAAS;AAE1C,qBAAa,WAAW,OAClB,UAAU,SAAS,SAAS,WAAW,IAAI,WAC3C,WAAW;AAEjB,cAAM,WAAW,MAAM,KAAK,WAAW,MAAM,YAAY;AAAA,UACrD,SAAS,WAAW;AAAA,UACpB,QAAQ,WAAW;AAAA,UACnB,MAAM,WAAW;AAAA,UACjB,aAAa,WAAW;AAAA,UACxB,MACI,SAAS,WAAW,WAAW,QAAQ,SACjC,SACA,WAAW;AAAA,UACrB,OAAO,WAAW;AAAA,UAClB,UAAU,WAAW;AAAA,QACzB,CAAC;AAED,cAAM,cAAc,IAAI,gBAAgB,YAAY,QAAQ;AAC5D,cAAM,WAAW,IAAI,UAAU,aAAa,MAAM,IAAI;AAEtD,aAAK,KAAK,aAAa,QAAQ;AAC/B,YAAI,SAAS;AAAa,iBAAO,SAAS;AAE1C,mBAAW,QAAQ,YAAY;AAC3B,cAAI,YAAY,QAAQ,IAAI;AAAG,mBAAO,YAAY,QAAQ,IAAI;AAAA,QAClE;AAEA,YAAI,YAAY,QAAQ,UAAU;AAC9B,sBAAY,QAAQ,WAAW,YAAY;AAAA,YACvC,YAAY,QAAQ;AAAA,UACxB;AAAA,QACJ;AAGA,YAAI,QAAQ,gBAAgB,YAAY;AACpC,gBAAM,SAAS,YAAY,QAAQ,qBAAqB;AAGxD,cAAI,CAAC,2CAA2C,KAAK,MAAM,GAAG;AAG1D,kBAAM,OAAO,mBAAmB,KAAK,MAAM,IACrC,eACA;AAGN,kBAAM,CAAC,QAAQ,IAAI,IAAI,IAAI,SAAS,QAAQ,EAAE,SACzC,MAAM,GAAG,EACT,MAAM,EAAE;AAEb,wBAAY,QACR,qBACJ,IAAI,GAAG,IAAI,cAAc,KAAK,UAAU,QAAQ,CAAC;AAAA,UACrD;AAAA,QACJ;AAEA,YAAI,YAAY,QAAQ,YAAY,GAAG;AACnC,kBAAQ;AAAA,YACJ,YAAY,OAAO;AAAA,cACf,YAAY,QAAQ,YAAY;AAAA,cAChC;AAAA,cACA,YAAY;AAAA,YAChB;AAAA,UACJ,EAAE,KAAK,MAAM;AACT,iBAAK,QAAQ,SAAS,EAAE,KAAK,SAAU,SAAS;AAC5C,sBAAQ,QAAQ,SAAU,QAAQ;AAC9B,uBAAO,YAAY;AAAA,kBACf,KAAK;AAAA,kBACL,KAAK,YAAY,KAAK,IAAI;AAAA,gBAC9B,CAAC;AAAA,cACL,CAAC;AAAA,YACL,CAAC;AAAA,UACL,CAAC;AACD,iBAAO,YAAY,QAAQ,YAAY;AAAA,QAC3C;AAEA,YAAI,YAAY,MAAM;AAClB,kBAAQ,QAAQ,aAAa;AAAA,YACzB,KAAK;AAAA,YACL,KAAK;AACD;AAEI,sBAAM,UAAU;AAAA,kBACZ,YAAY;AAAA,kBACZ,YAAY;AAAA,kBACZ,YAAY;AAAA,kBACZ,YAAY;AAAA,gBAChB,EACK,IAAI,CAAC,WAAW,KAAK,UAAU,MAAM,CAAC,EACtC,KAAK,GAAG;AACb,4BAAY,OAAO,2CAA2C,YAAY;AAAA,kBACtE,KAAK;AAAA,kBACL,KAAK,WAAW;AAAA,kBAChB,YAAY,OAAO;AAAA,oBACf;AAAA,oBACA,YAAY;AAAA,oBACZ;AAAA,kBACJ;AAAA,kBACA,QAAQ;AAAA,gBACZ,CAAC,kBAAkB,OAAO;AAAA;AAC1B,4BAAY,QAAQ,YAAY,GAAG;AAAA,kBAC/B,MAAM,SAAS,KAAK;AAAA,gBACxB;AAAA,cACJ;AACA;AAAA,YACJ,KAAK;AACD,0BAAY,OAAO,YAAY;AAAA,gBAC3B,MAAM,SAAS,KAAK;AAAA,cACxB;AACA;AAAA,YACJ,KAAK;AAAA,YACL,KAAK;AACD,kBACI;AAAA,gBACI,YAAY,KAAK;AAAA,gBACjB,YAAY,QAAQ,cAAc,KAAK;AAAA,cAC3C,GACF;AACE,4BAAY,OAAO,YAAY;AAAA,kBAC3B,MAAM,SAAS,KAAK;AAAA,kBACpB;AAAA,oBACI,UAAU;AAAA,oBACV,YAAY,YAAY;AAAA,sBACpB,YAAY;AAAA,sBACZ,YAAY;AAAA,sBACZ,YAAY;AAAA,sBACZ,YAAY;AAAA,sBACZ,KAAK;AAAA,sBACL,KAAK,WAAW;AAAA,sBAChB,YAAY,OAAO;AAAA,wBACf;AAAA,wBACA,YAAY;AAAA,wBACZ;AAAA,sBACJ;AAAA,sBACA,QAAQ;AAAA,oBACZ;AAAA,kBACJ;AAAA,gBACJ;AAAA,cACJ;AAAA,UACR;AAAA,QACJ;AAEA,YAAI,WAAW,QAAQ,WAAW,qBAAqB;AACnD,sBAAY,QAAQ,cAAc,IAAI;AAAA,QAC1C;AACA,YAAI,qBAAqB;AACrB,sBAAY,QAAQ,8BAA8B,IAC9C;AAAA,QACR;AAEA,aAAK,KAAK,YAAY,QAAQ;AAC9B,YAAI,SAAS;AAAa,iBAAO,SAAS;AAE1C,eAAO,IAAI,SAAS,YAAY,MAAM;AAAA,UAClC,SAAS,YAAY;AAAA,UACrB,QAAQ,YAAY;AAAA,UACpB,YAAY,YAAY;AAAA,QAC5B,CAAC;AAAA,MACL,SAAS,KAAK;AACV,YAAI,CAAC,CAAC,YAAY,QAAQ,EAAE,SAAS,QAAQ,WAAW;AACpD,iBAAO,IAAI,SAAS,QAAW,EAAE,QAAQ,IAAI,CAAC;AAElD,gBAAQ,MAAM,GAAG;AAEjB,eAAO,YAAY,KAAK,YAAY,KAAK,OAAO;AAAA,MACpD;AAAA,IACJ;AAAA,IACA,OAAO,cAAc;AAAA,EACzB;AAEA,OAAK,kBAAkB;AAEvB,MAAM,kBAAN,MAAsB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMlB,YAAY,SAAS,UAAU;AAC3B,WAAK,UAAU;AACf,WAAK,MAAM;AACX,WAAK,cAAc,QAAQ;AAC3B,WAAK,UAAU,CAAC;AAEhB,iBAAW,OAAO,SAAS;AACvB,aAAK,QAAQ,IAAI,YAAY,CAAC,IAAI,SAAS,WAAW,GAAG;AAC7D,WAAK,SAAS,SAAS;AACvB,WAAK,aAAa,SAAS;AAC3B,WAAK,OAAO,SAAS;AAAA,IACzB;AAAA,IACA,IAAI,MAAM;AACN,aAAO,KAAK,QAAQ;AAAA,IACxB;AAAA,IACA,IAAI,OAAO;AACP,aAAO,KAAK,QAAQ;AAAA,IACxB;AAAA,IACA,IAAI,KAAK,KAAK;AACV,WAAK,QAAQ,OAAO;AAAA,IACxB;AAAA,EACJ;AAEA,MAAM,iBAAN,MAAqB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQjB,YAAY,SAAS,QAAQ,aAAa,OAAO,MAAM;AACnD,WAAK,cAAc;AACnB,WAAK,UAAU;AACf,WAAK,UAAU,OAAO,YAAY,QAAQ,QAAQ,QAAQ,CAAC;AAC3D,WAAK,SAAS,QAAQ;AACtB,WAAK,UAAU,OAAO;AACtB,WAAK,OAAO,QAAQ;AACpB,WAAK,QAAQ,QAAQ;AACrB,WAAK,WAAW,QAAQ;AACxB,WAAK,cAAc;AACnB,WAAK,OAAO,QAAQ,SAAS,SAAS,QAAQ,OAAO;AACrD,WAAK,OAAO;AAAA,IAChB;AAAA,IACA,IAAI,MAAM;AACN,aAAO,KAAK,YAAY,KAAK;AAAA,IACjC;AAAA,IACA,IAAI,IAAI,KAAK;AACT,WAAK,YAAY,KAAK,MAAM;AAAA,IAChC;AAAA,IACA,IAAI,OAAO;AACP,aAAO,KAAK,YAAY,KAAK;AAAA,IACjC;AAAA,IACA,IAAI,KAAK,KAAK;AACV,WAAK,YAAY,KAAK,OAAO;AAAA,IACjC;AAAA,EACJ;AAEA,WAAS,OAAO,KAAK,cAAc,IAAI;AACnC,YAEQ,YAAY,KAAK,YAAY,eAAe,IAAI,QAAQ,KACxD,aACF,MAAM,GAAG,EAAE,CAAC,MAAM;AAAA,EAE5B;AAEA,MAAM,YAAN,MAAgB;AAAA,IACZ;AAAA,IACA;AAAA,IACA,YAAY,OAAO,CAAC,GAAG,SAAS,MAAM,OAAO,MAAM;AAC/C,WAAK,eAAe;AACpB,WAAK,eAAe;AACpB,WAAK,OAAO;AACZ,WAAK,SAAS;AACd,WAAK,OAAO;AAAA,IAChB;AAAA,IACA,IAAI,cAAc;AACd,aAAO,KAAK;AAAA,IAChB;AAAA,IACA,IAAI,cAAc;AACd,aAAO,KAAK;AAAA,IAChB;AAAA,IACA,YAAY,OAAO;AACf,WAAK,eAAe;AACpB,WAAK,eAAe;AAAA,IACxB;AAAA,EACJ;AAQA,WAAS,sBAAsB,YAAY,YAAY;AACnD,UAAM,mBAAmB,IAAI,IAAI,UAAU;AAC3C,UAAM,SACF,gCAAgC,KAAK;AAAA,MACjC,iBAAiB;AAAA,IACrB,CAAC,sBACoB,KAAK,UAAU,UAAU,CAAC,6BACnB,KAAK,UAAU,SAAS,QAAQ,CAAC,sFAElC,KAAK;AAAA,MAC5B;AAAA,IACJ,CAAC;AAEL,WACI,6jBAqBI,iCAAiC,mBAAmB,MAAM,CAC9D;AAAA,EAIR;AAaA,WAAS,cACL,OACA,MACA,IACA,SACA,OACA,YACA,YACF;AAEE,QAAI,YAAY;AACZ,aAAO,sBAAsB,YAAY,UAAU;AAGvD,UAAM,SACF,4BAA4B,KAAK,UAAU,KAAK,CAAC,4BACtB,KAAK,UAAU,IAAI,CAAC,OAC9C,KAAK,yBAAyB,KAAK,UAAU,EAAE,CAAC,MAAM,MACvD,+BAA+B,KAAK,UAAU,OAAO,CAAC,uBAChC,KAAK,UAAU,KAAK,CAAC,6BACf,KAAK,UAAU,UAAU,CAAC,sBACjC,KAAK,UAAU,UAAU,CAAC,oFACoC,KAAK;AAAA,MACpF,SAAS;AAAA,IACb,CAAC,sFAE0B,KAAK;AAAA,MAC5B;AAAA,IACJ,CAAC;AAEL,WACI,4PAaC,KAAK,gDAAgD,MACtD,8vBAoBI,iCAAiC,mBAAmB,MAAM,CAC9D;AAAA,EAIR;AAWA,WAAS,YAAY,KAAK;AACtB,WAAO,eAAe,SAAS,OAAO,IAAI,SAAS;AAAA,EACvD;AAQA,WAAS,YAAY,KAAK,YAAY,YAAY;AAI9C,QAAI;AAIJ,QAAI;AAIJ,QAAI;AACJ,QAAI,KAAK;AAIT,QAAI;AAEJ,QAAI,YAAY,GAAG,GAAG;AAClB,eAAS,IAAI;AACb,cAAQ;AACR,gBAAU,IAAI,KAAK;AACnB,aAAO,IAAI,KAAK;AAChB,WAAK,IAAI,KAAK;AAAA,IAClB,OAAO;AACH,eAAS;AACT,cAAQ;AACR,gBAAU;AACV,aAAO,eAAe,QAAQ,IAAI,OAAO;AAAA,IAC7C;AAEA,WAAO,IAAI;AAAA,MACP;AAAA,QACI;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,OAAO,GAAG;AAAA,QACV;AAAA,QACA;AAAA,MACJ;AAAA,MACA;AAAA,QACI;AAAA,QACA,SAAS;AAAA,UACL,gBAAgB;AAAA,QACpB;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;", + "names": [] +} diff --git a/public/uv/uv.bundle.js b/public/uv/uv.bundle.js deleted file mode 100644 index f440917..0000000 --- a/public/uv/uv.bundle.js +++ /dev/null @@ -1,39306 +0,0 @@ -/******/ (() => { // webpackBootstrap -/******/ var __webpack_modules__ = ([ -/* 0 */, -/* 1 */ -/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { - - "use strict"; - __webpack_require__.r(__webpack_exports__); - /* harmony export */ __webpack_require__.d(__webpack_exports__, { - /* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) - /* harmony export */ }); - /* harmony import */ var _events_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2); - /* harmony import */ var parse5__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3); - - - - class HTML extends _events_js__WEBPACK_IMPORTED_MODULE_0__["default"] { - constructor(ctx) { - super(); - this.ctx = ctx; - this.rewriteUrl = ctx.rewriteUrl; - this.sourceUrl = ctx.sourceUrl; - }; - rewrite(str, options = {}) { - if (!str) return str; - return this.recast(str, node => { - if (node.tagName) this.emit('element', node, 'rewrite'); - if (node.attr) this.emit('attr', node, 'rewrite'); - if (node.nodeName === '#text') this.emit('text', node, 'rewrite'); - }, options) - }; - source(str, options = {}) { - if (!str) return str; - return this.recast(str, node => { - if (node.tagName) this.emit('element', node, 'source'); - if (node.attr) this.emit('attr', node, 'source'); - if (node.nodeName === '#text') this.emit('text', node, 'source'); - }, options) - }; - recast(str, fn, options = {}) { - try { - const ast = (options.document ? parse5__WEBPACK_IMPORTED_MODULE_1__.parse : parse5__WEBPACK_IMPORTED_MODULE_1__.parseFragment)(new String(str).toString()); - this.iterate(ast, fn, options); - return (0,parse5__WEBPACK_IMPORTED_MODULE_1__.serialize)(ast); - } catch(e) { - return str; - }; - }; - iterate(ast, fn, fnOptions) { - if (!ast) return ast; - - if (ast.tagName) { - const element = new P5Element(ast, false, fnOptions); - fn(element); - if (ast.attrs) { - for (const attr of ast.attrs) { - if (!attr.skip) fn(new AttributeEvent(element, attr, fnOptions)); - }; - }; - }; - - if (ast.childNodes) { - for (const child of ast.childNodes) { - if (!child.skip) this.iterate(child, fn, fnOptions); - }; - }; - - if (ast.nodeName === '#text') { - fn(new TextEvent(ast, new P5Element(ast.parentNode), false, fnOptions)); - }; - - return ast; - }; - wrapSrcset(str, meta = this.ctx.meta) { - return str.split(',').map(src => { - const parts = src.trimStart().split(' '); - if (parts[0]) parts[0] = this.ctx.rewriteUrl(parts[0], meta); - return parts.join(' '); - }).join(', '); - }; - unwrapSrcset(str, meta = this.ctx.meta) { - return str.split(',').map(src => { - const parts = src.trimStart().split(' '); - if (parts[0]) parts[0] = this.ctx.sourceUrl(parts[0], meta); - return parts.join(' '); - }).join(', '); - }; - static parse = parse5__WEBPACK_IMPORTED_MODULE_1__.parse; - static parseFragment = parse5__WEBPACK_IMPORTED_MODULE_1__.parseFragment; - static serialize = parse5__WEBPACK_IMPORTED_MODULE_1__.serialize; - }; - - class P5Element extends _events_js__WEBPACK_IMPORTED_MODULE_0__["default"] { - constructor(node, stream = false, options = {}) { - super(); - this.stream = stream; - this.node = node; - this.options = options; - }; - setAttribute(name, value) { - for (const attr of this.attrs) { - if (attr.name === name) { - attr.value = value; - return true; - }; - }; - - this.attrs.push( - { - name, - value, - } - ); - }; - getAttribute(name) { - const attr = this.attrs.find(attr => attr.name === name) || {}; - return attr.value; - }; - hasAttribute(name) { - return !!this.attrs.find(attr => attr.name === name); - }; - removeAttribute(name) { - const i = this.attrs.findIndex(attr => attr.name === name); - if (typeof i !== 'undefined') this.attrs.splice(i, 1); - }; - get tagName() { - return this.node.tagName; - }; - set tagName(val) { - this.node.tagName = val; - }; - get childNodes() { - return !this.stream ? this.node.childNodes : null; - }; - get innerHTML() { - return !this.stream ? (0,parse5__WEBPACK_IMPORTED_MODULE_1__.serialize)( - { - nodeName: '#document-fragment', - childNodes: this.childNodes, - } - ) : null; - }; - set innerHTML(val) { - if (!this.stream) this.node.childNodes = (0,parse5__WEBPACK_IMPORTED_MODULE_1__.parseFragment)(val).childNodes; - }; - get outerHTML() { - return !this.stream ? (0,parse5__WEBPACK_IMPORTED_MODULE_1__.serialize)( - { - nodeName: '#document-fragment', - childNodes: [ this ], - } - ) : null; - }; - set outerHTML(val) { - if (!this.stream) this.parentNode.childNodes.splice(this.parentNode.childNodes.findIndex(node => node === this.node), 1, ...(0,parse5__WEBPACK_IMPORTED_MODULE_1__.parseFragment)(val).childNodes); - }; - get textContent() { - if (this.stream) return null; - - let str = ''; - iterate(this.node, node => { - if (node.nodeName === '#text') str += node.value; - }); - - return str; - }; - set textContent(val) { - if (!this.stream) this.node.childNodes = [ - { - nodeName: '#text', - value: val, - parentNode: this.node - } - ]; - }; - get nodeName() { - return this.node.nodeName; - } - get parentNode() { - return this.node.parentNode ? new P5Element(this.node.parentNode) : null; - }; - get attrs() { - return this.node.attrs; - } - get namespaceURI() { - return this.node.namespaceURI; - } - }; - - class AttributeEvent { - constructor(node, attr, options = {}) { - this.attr = attr; - this.attrs = node.attrs; - this.node = node; - this.options = options; - }; - delete() { - const i = this.attrs.findIndex(attr => attr === this.attr); - - this.attrs.splice(i, 1); - - Object.defineProperty(this, 'deleted', { - get: () => true, - }); - - return true; - }; - get name() { - return this.attr.name; - }; - - set name(val) { - this.attr.name = val; - }; - get value() { - return this.attr.value; - }; - - set value(val) { - this.attr.value = val; - }; - get deleted() { - return false; - }; - }; - - class TextEvent { - constructor(node, element, stream = false, options = {}) { - this.stream = stream; - this.node = node; - this.element = element; - this.options = options; - }; - get nodeName() { - return this.node.nodeName; - } - get parentNode() { - return this.element; - }; - get value() { - return this.stream ? this.node.text : this.node.value; - }; - set value(val) { - - if (this.stream) this.node.text = val; - else this.node.value = val; - }; - }; - - /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (HTML); - - /***/ }), - /* 2 */ - /***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { - - "use strict"; - __webpack_require__.r(__webpack_exports__); - /* harmony export */ __webpack_require__.d(__webpack_exports__, { - /* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) - /* harmony export */ }); - // 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. - - - - var R = typeof Reflect === 'object' ? Reflect : null - var ReflectApply = R && typeof R.apply === 'function' - ? R.apply - : function ReflectApply(target, receiver, args) { - return Function.prototype.apply.call(target, receiver, args); - } - - var ReflectOwnKeys - if (R && typeof R.ownKeys === 'function') { - ReflectOwnKeys = R.ownKeys - } else if (Object.getOwnPropertySymbols) { - ReflectOwnKeys = function ReflectOwnKeys(target) { - return Object.getOwnPropertyNames(target) - .concat(Object.getOwnPropertySymbols(target)); - }; - } else { - ReflectOwnKeys = function ReflectOwnKeys(target) { - return Object.getOwnPropertyNames(target); - }; - } - - function ProcessEmitWarning(warning) { - if (console && console.warn) console.warn(warning); - } - - var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) { - return value !== value; - } - - function EventEmitter() { - EventEmitter.init.call(this); - } - - /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (EventEmitter); - - // Backwards-compat with node 0.10.x - EventEmitter.EventEmitter = EventEmitter; - - EventEmitter.prototype._events = undefined; - EventEmitter.prototype._eventsCount = 0; - EventEmitter.prototype._maxListeners = undefined; - - // By default EventEmitters will print a warning if more than 10 listeners are - // added to it. This is a useful default which helps finding memory leaks. - var defaultMaxListeners = 10; - - function checkListener(listener) { - if (typeof listener !== 'function') { - throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener); - } - } - - Object.defineProperty(EventEmitter, 'defaultMaxListeners', { - enumerable: true, - get: function() { - return defaultMaxListeners; - }, - set: function(arg) { - if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) { - throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.'); - } - defaultMaxListeners = arg; - } - }); - - EventEmitter.init = function() { - - if (this._events === undefined || - this._events === Object.getPrototypeOf(this)._events) { - this._events = Object.create(null); - this._eventsCount = 0; - } - - this._maxListeners = this._maxListeners || undefined; - }; - - // Obviously not all Emitters should be limited to 10. This function allows - // that to be increased. Set to zero for unlimited. - EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { - if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) { - throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.'); - } - this._maxListeners = n; - return this; - }; - - function _getMaxListeners(that) { - if (that._maxListeners === undefined) - return EventEmitter.defaultMaxListeners; - return that._maxListeners; - } - - EventEmitter.prototype.getMaxListeners = function getMaxListeners() { - return _getMaxListeners(this); - }; - - EventEmitter.prototype.emit = function emit(type) { - var args = []; - for (var i = 1; i < arguments.length; i++) args.push(arguments[i]); - var doError = (type === 'error'); - - var events = this._events; - if (events !== undefined) - doError = (doError && events.error === undefined); - else if (!doError) - return false; - - // If there is no 'error' event listener then throw. - if (doError) { - var er; - if (args.length > 0) - er = args[0]; - if (er instanceof Error) { - // Note: The comments on the `throw` lines are intentional, they show - // up in Node's output if this results in an unhandled exception. - throw er; // Unhandled 'error' event - } - // At least give some kind of context to the user - var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : '')); - err.context = er; - throw err; // Unhandled 'error' event - } - - var handler = events[type]; - - if (handler === undefined) - return false; - - if (typeof handler === 'function') { - ReflectApply(handler, this, args); - } else { - var len = handler.length; - var listeners = arrayClone(handler, len); - for (var i = 0; i < len; ++i) - ReflectApply(listeners[i], this, args); - } - - return true; - }; - - function _addListener(target, type, listener, prepend) { - var m; - var events; - var existing; - - checkListener(listener); - - events = target._events; - if (events === undefined) { - events = target._events = Object.create(null); - target._eventsCount = 0; - } else { - // To avoid recursion in the case that type === "newListener"! Before - // adding it to the listeners, first emit "newListener". - if (events.newListener !== undefined) { - target.emit('newListener', type, - listener.listener ? listener.listener : listener); - - // Re-assign `events` because a newListener handler could have caused the - // this._events to be assigned to a new object - events = target._events; - } - existing = events[type]; - } - - if (existing === undefined) { - // Optimize the case of one listener. Don't need the extra array object. - existing = events[type] = listener; - ++target._eventsCount; - } else { - if (typeof existing === 'function') { - // Adding the second element, need to change to array. - existing = events[type] = - prepend ? [listener, existing] : [existing, listener]; - // If we've already got an array, just append. - } else if (prepend) { - existing.unshift(listener); - } else { - existing.push(listener); - } - - // Check for listener leak - m = _getMaxListeners(target); - if (m > 0 && existing.length > m && !existing.warned) { - existing.warned = true; - // No error code for this since it is a Warning - // eslint-disable-next-line no-restricted-syntax - var w = new Error('Possible EventEmitter memory leak detected. ' + - existing.length + ' ' + String(type) + ' listeners ' + - 'added. Use emitter.setMaxListeners() to ' + - 'increase limit'); - w.name = 'MaxListenersExceededWarning'; - w.emitter = target; - w.type = type; - w.count = existing.length; - ProcessEmitWarning(w); - } - } - - return target; - } - - EventEmitter.prototype.addListener = function addListener(type, listener) { - return _addListener(this, type, listener, false); - }; - - EventEmitter.prototype.on = EventEmitter.prototype.addListener; - - EventEmitter.prototype.prependListener = - function prependListener(type, listener) { - return _addListener(this, type, listener, true); - }; - - function onceWrapper() { - if (!this.fired) { - this.target.removeListener(this.type, this.wrapFn); - this.fired = true; - if (arguments.length === 0) - return this.listener.call(this.target); - return this.listener.apply(this.target, arguments); - } - } - - function _onceWrap(target, type, listener) { - var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener }; - var wrapped = onceWrapper.bind(state); - wrapped.listener = listener; - state.wrapFn = wrapped; - return wrapped; - } - - EventEmitter.prototype.once = function once(type, listener) { - checkListener(listener); - this.on(type, _onceWrap(this, type, listener)); - return this; - }; - - EventEmitter.prototype.prependOnceListener = - function prependOnceListener(type, listener) { - checkListener(listener); - this.prependListener(type, _onceWrap(this, type, listener)); - return this; - }; - - // Emits a 'removeListener' event if and only if the listener was removed. - EventEmitter.prototype.removeListener = - function removeListener(type, listener) { - var list, events, position, i, originalListener; - - checkListener(listener); - - events = this._events; - if (events === undefined) - return this; - - list = events[type]; - if (list === undefined) - return this; - - if (list === listener || list.listener === listener) { - if (--this._eventsCount === 0) - this._events = Object.create(null); - else { - delete events[type]; - if (events.removeListener) - this.emit('removeListener', type, list.listener || listener); - } - } else if (typeof list !== 'function') { - position = -1; - - for (i = list.length - 1; i >= 0; i--) { - if (list[i] === listener || list[i].listener === listener) { - originalListener = list[i].listener; - position = i; - break; - } - } - - if (position < 0) - return this; - - if (position === 0) - list.shift(); - else { - spliceOne(list, position); - } - - if (list.length === 1) - events[type] = list[0]; - - if (events.removeListener !== undefined) - this.emit('removeListener', type, originalListener || listener); - } - - return this; - }; - - EventEmitter.prototype.off = EventEmitter.prototype.removeListener; - - EventEmitter.prototype.removeAllListeners = - function removeAllListeners(type) { - var listeners, events, i; - - events = this._events; - if (events === undefined) - return this; - - // not listening for removeListener, no need to emit - if (events.removeListener === undefined) { - if (arguments.length === 0) { - this._events = Object.create(null); - this._eventsCount = 0; - } else if (events[type] !== undefined) { - if (--this._eventsCount === 0) - this._events = Object.create(null); - else - delete events[type]; - } - return this; - } - - // emit removeListener for all listeners on all events - if (arguments.length === 0) { - var keys = Object.keys(events); - var key; - for (i = 0; i < keys.length; ++i) { - key = keys[i]; - if (key === 'removeListener') continue; - this.removeAllListeners(key); - } - this.removeAllListeners('removeListener'); - this._events = Object.create(null); - this._eventsCount = 0; - return this; - } - - listeners = events[type]; - - if (typeof listeners === 'function') { - this.removeListener(type, listeners); - } else if (listeners !== undefined) { - // LIFO order - for (i = listeners.length - 1; i >= 0; i--) { - this.removeListener(type, listeners[i]); - } - } - - return this; - }; - - function _listeners(target, type, unwrap) { - var events = target._events; - - if (events === undefined) - return []; - - var evlistener = events[type]; - if (evlistener === undefined) - return []; - - if (typeof evlistener === 'function') - return unwrap ? [evlistener.listener || evlistener] : [evlistener]; - - return unwrap ? - unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length); - } - - EventEmitter.prototype.listeners = function listeners(type) { - return _listeners(this, type, true); - }; - - EventEmitter.prototype.rawListeners = function rawListeners(type) { - return _listeners(this, type, false); - }; - - EventEmitter.listenerCount = function(emitter, type) { - if (typeof emitter.listenerCount === 'function') { - return emitter.listenerCount(type); - } else { - return listenerCount.call(emitter, type); - } - }; - - EventEmitter.prototype.listenerCount = listenerCount; - function listenerCount(type) { - var events = this._events; - - if (events !== undefined) { - var evlistener = events[type]; - - if (typeof evlistener === 'function') { - return 1; - } else if (evlistener !== undefined) { - return evlistener.length; - } - } - - return 0; - } - - EventEmitter.prototype.eventNames = function eventNames() { - return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : []; - }; - - function arrayClone(arr, n) { - var copy = new Array(n); - for (var i = 0; i < n; ++i) - copy[i] = arr[i]; - return copy; - } - - function spliceOne(list, index) { - for (; index + 1 < list.length; index++) - list[index] = list[index + 1]; - list.pop(); - } - - function unwrapListeners(arr) { - var ret = new Array(arr.length); - for (var i = 0; i < ret.length; ++i) { - ret[i] = arr[i].listener || arr[i]; - } - return ret; - } - - function once(emitter, name) { - return new Promise(function (resolve, reject) { - function errorListener(err) { - emitter.removeListener(name, resolver); - reject(err); - } - - function resolver() { - if (typeof emitter.removeListener === 'function') { - emitter.removeListener('error', errorListener); - } - resolve([].slice.call(arguments)); - }; - - eventTargetAgnosticAddListener(emitter, name, resolver, { once: true }); - if (name !== 'error') { - addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true }); - } - }); - } - - function addErrorHandlerIfEventEmitter(emitter, handler, flags) { - if (typeof emitter.on === 'function') { - eventTargetAgnosticAddListener(emitter, 'error', handler, flags); - } - } - - function eventTargetAgnosticAddListener(emitter, name, listener, flags) { - if (typeof emitter.on === 'function') { - if (flags.once) { - emitter.once(name, listener); - } else { - emitter.on(name, listener); - } - } else if (typeof emitter.addEventListener === 'function') { - // EventTarget does not have `error` event semantics like Node - // EventEmitters, we do not listen for `error` events here. - emitter.addEventListener(name, function wrapListener(arg) { - // IE does not have builtin `{ once: true }` support so we - // have to do it manually. - if (flags.once) { - emitter.removeEventListener(name, wrapListener); - } - listener(arg); - }); - } else { - throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter); - } - } - - /***/ }), - /* 3 */ - /***/ ((__unused_webpack_module, exports, __webpack_require__) => { - - "use strict"; - - - const Parser = __webpack_require__(4); - const Serializer = __webpack_require__(26); - - // Shorthands - exports.parse = function parse(html, options) { - const parser = new Parser(options); - - return parser.parse(html); - }; - - exports.parseFragment = function parseFragment(fragmentContext, html, options) { - if (typeof fragmentContext === 'string') { - options = html; - html = fragmentContext; - fragmentContext = null; - } - - const parser = new Parser(options); - - return parser.parseFragment(html, fragmentContext); - }; - - exports.serialize = function(node, options) { - const serializer = new Serializer(node, options); - - return serializer.serialize(); - }; - - - /***/ }), - /* 4 */ - /***/ ((module, __unused_webpack_exports, __webpack_require__) => { - - "use strict"; - - - const Tokenizer = __webpack_require__(5); - const OpenElementStack = __webpack_require__(10); - const FormattingElementList = __webpack_require__(12); - const LocationInfoParserMixin = __webpack_require__(13); - const ErrorReportingParserMixin = __webpack_require__(18); - const Mixin = __webpack_require__(14); - const defaultTreeAdapter = __webpack_require__(22); - const mergeOptions = __webpack_require__(23); - const doctype = __webpack_require__(24); - const foreignContent = __webpack_require__(25); - const ERR = __webpack_require__(8); - const unicode = __webpack_require__(7); - const HTML = __webpack_require__(11); - - //Aliases - const $ = 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 = { - [$.TR]: IN_ROW_MODE, - [$.TBODY]: IN_TABLE_BODY_MODE, - [$.THEAD]: IN_TABLE_BODY_MODE, - [$.TFOOT]: IN_TABLE_BODY_MODE, - [$.CAPTION]: IN_CAPTION_MODE, - [$.COLGROUP]: IN_COLUMN_GROUP_MODE, - [$.TABLE]: IN_TABLE_MODE, - [$.BODY]: IN_BODY_MODE, - [$.FRAMESET]: IN_FRAMESET_MODE - }; - - //Template insertion mode switch map - const TEMPLATE_INSERTION_MODE_SWITCH_MAP = { - [$.CAPTION]: IN_TABLE_MODE, - [$.COLGROUP]: IN_TABLE_MODE, - [$.TBODY]: IN_TABLE_MODE, - [$.TFOOT]: IN_TABLE_MODE, - [$.THEAD]: IN_TABLE_MODE, - [$.COL]: IN_COLUMN_GROUP_MODE, - [$.TR]: IN_TABLE_BODY_MODE, - [$.TD]: IN_ROW_MODE, - [$.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