diff --git a/entry b/entry index 76988f0..c1ba7f8 100755 --- a/entry +++ b/entry @@ -74358,6 +74358,17390 @@ var init_index_CLFto6T2 = __esm({ } }); +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Event.js +var require_Event = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Event.js"(exports, module) { + "use strict"; + module.exports = Event2; + Event2.CAPTURING_PHASE = 1; + Event2.AT_TARGET = 2; + Event2.BUBBLING_PHASE = 3; + function Event2(type2, dictionary) { + this.type = ""; + this.target = null; + this.currentTarget = null; + this.eventPhase = Event2.AT_TARGET; + this.bubbles = false; + this.cancelable = false; + this.isTrusted = false; + this.defaultPrevented = false; + this.timeStamp = Date.now(); + this._propagationStopped = false; + this._immediatePropagationStopped = false; + this._initialized = true; + this._dispatching = false; + if (type2) this.type = type2; + if (dictionary) { + for (var p in dictionary) { + this[p] = dictionary[p]; + } + } + } + Event2.prototype = Object.create(Object.prototype, { + constructor: { value: Event2 }, + stopPropagation: { value: function stopPropagation() { + this._propagationStopped = true; + } }, + stopImmediatePropagation: { value: function stopImmediatePropagation() { + this._propagationStopped = true; + this._immediatePropagationStopped = true; + } }, + preventDefault: { value: function preventDefault() { + if (this.cancelable) this.defaultPrevented = true; + } }, + initEvent: { value: function initEvent(type2, bubbles, cancelable) { + this._initialized = true; + if (this._dispatching) return; + this._propagationStopped = false; + this._immediatePropagationStopped = false; + this.defaultPrevented = false; + this.isTrusted = false; + this.target = null; + this.type = type2; + this.bubbles = bubbles; + this.cancelable = cancelable; + } } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/UIEvent.js +var require_UIEvent = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/UIEvent.js"(exports, module) { + "use strict"; + var Event2 = require_Event(); + module.exports = UIEvent; + function UIEvent() { + Event2.call(this); + this.view = null; + this.detail = 0; + } + UIEvent.prototype = Object.create(Event2.prototype, { + constructor: { value: UIEvent }, + initUIEvent: { value: function(type2, bubbles, cancelable, view, detail) { + this.initEvent(type2, bubbles, cancelable); + this.view = view; + this.detail = detail; + } } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/MouseEvent.js +var require_MouseEvent = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/MouseEvent.js"(exports, module) { + "use strict"; + var UIEvent = require_UIEvent(); + module.exports = MouseEvent; + function MouseEvent() { + UIEvent.call(this); + this.screenX = this.screenY = this.clientX = this.clientY = 0; + this.ctrlKey = this.altKey = this.shiftKey = this.metaKey = false; + this.button = 0; + this.buttons = 1; + this.relatedTarget = null; + } + MouseEvent.prototype = Object.create(UIEvent.prototype, { + constructor: { value: MouseEvent }, + initMouseEvent: { value: function(type2, bubbles, cancelable, view, detail, screenX, screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey, button, relatedTarget) { + this.initEvent(type2, bubbles, cancelable, view, detail); + this.screenX = screenX; + this.screenY = screenY; + this.clientX = clientX; + this.clientY = clientY; + this.ctrlKey = ctrlKey; + this.altKey = altKey; + this.shiftKey = shiftKey; + this.metaKey = metaKey; + this.button = button; + switch (button) { + case 0: + this.buttons = 1; + break; + case 1: + this.buttons = 4; + break; + case 2: + this.buttons = 2; + break; + default: + this.buttons = 0; + break; + } + this.relatedTarget = relatedTarget; + } }, + getModifierState: { value: function(key) { + switch (key) { + case "Alt": + return this.altKey; + case "Control": + return this.ctrlKey; + case "Shift": + return this.shiftKey; + case "Meta": + return this.metaKey; + default: + return false; + } + } } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/DOMException.js +var require_DOMException = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/DOMException.js"(exports, module) { + "use strict"; + module.exports = DOMException2; + var INDEX_SIZE_ERR = 1; + var HIERARCHY_REQUEST_ERR = 3; + var WRONG_DOCUMENT_ERR = 4; + var INVALID_CHARACTER_ERR = 5; + var NO_MODIFICATION_ALLOWED_ERR = 7; + var NOT_FOUND_ERR = 8; + var NOT_SUPPORTED_ERR = 9; + var INVALID_STATE_ERR = 11; + var SYNTAX_ERR = 12; + var INVALID_MODIFICATION_ERR = 13; + var NAMESPACE_ERR = 14; + var INVALID_ACCESS_ERR = 15; + var TYPE_MISMATCH_ERR = 17; + var SECURITY_ERR = 18; + var NETWORK_ERR = 19; + var ABORT_ERR = 20; + var URL_MISMATCH_ERR = 21; + var QUOTA_EXCEEDED_ERR = 22; + var TIMEOUT_ERR = 23; + var INVALID_NODE_TYPE_ERR = 24; + var DATA_CLONE_ERR = 25; + var names = [ + null, + // No error with code 0 + "INDEX_SIZE_ERR", + null, + // historical + "HIERARCHY_REQUEST_ERR", + "WRONG_DOCUMENT_ERR", + "INVALID_CHARACTER_ERR", + null, + // historical + "NO_MODIFICATION_ALLOWED_ERR", + "NOT_FOUND_ERR", + "NOT_SUPPORTED_ERR", + "INUSE_ATTRIBUTE_ERR", + // historical + "INVALID_STATE_ERR", + "SYNTAX_ERR", + "INVALID_MODIFICATION_ERR", + "NAMESPACE_ERR", + "INVALID_ACCESS_ERR", + null, + // historical + "TYPE_MISMATCH_ERR", + "SECURITY_ERR", + "NETWORK_ERR", + "ABORT_ERR", + "URL_MISMATCH_ERR", + "QUOTA_EXCEEDED_ERR", + "TIMEOUT_ERR", + "INVALID_NODE_TYPE_ERR", + "DATA_CLONE_ERR" + ]; + var messages = [ + null, + // No error with code 0 + "INDEX_SIZE_ERR (1): the index is not in the allowed range", + null, + "HIERARCHY_REQUEST_ERR (3): the operation would yield an incorrect nodes model", + "WRONG_DOCUMENT_ERR (4): the object is in the wrong Document, a call to importNode is required", + "INVALID_CHARACTER_ERR (5): the string contains invalid characters", + null, + "NO_MODIFICATION_ALLOWED_ERR (7): the object can not be modified", + "NOT_FOUND_ERR (8): the object can not be found here", + "NOT_SUPPORTED_ERR (9): this operation is not supported", + "INUSE_ATTRIBUTE_ERR (10): setAttributeNode called on owned Attribute", + "INVALID_STATE_ERR (11): the object is in an invalid state", + "SYNTAX_ERR (12): the string did not match the expected pattern", + "INVALID_MODIFICATION_ERR (13): the object can not be modified in this way", + "NAMESPACE_ERR (14): the operation is not allowed by Namespaces in XML", + "INVALID_ACCESS_ERR (15): the object does not support the operation or argument", + null, + "TYPE_MISMATCH_ERR (17): the type of the object does not match the expected type", + "SECURITY_ERR (18): the operation is insecure", + "NETWORK_ERR (19): a network error occurred", + "ABORT_ERR (20): the user aborted an operation", + "URL_MISMATCH_ERR (21): the given URL does not match another URL", + "QUOTA_EXCEEDED_ERR (22): the quota has been exceeded", + "TIMEOUT_ERR (23): a timeout occurred", + "INVALID_NODE_TYPE_ERR (24): the supplied node is invalid or has an invalid ancestor for this operation", + "DATA_CLONE_ERR (25): the object can not be cloned." + ]; + var constants = { + INDEX_SIZE_ERR, + DOMSTRING_SIZE_ERR: 2, + // historical + HIERARCHY_REQUEST_ERR, + WRONG_DOCUMENT_ERR, + INVALID_CHARACTER_ERR, + NO_DATA_ALLOWED_ERR: 6, + // historical + NO_MODIFICATION_ALLOWED_ERR, + NOT_FOUND_ERR, + NOT_SUPPORTED_ERR, + INUSE_ATTRIBUTE_ERR: 10, + // historical + INVALID_STATE_ERR, + SYNTAX_ERR, + INVALID_MODIFICATION_ERR, + NAMESPACE_ERR, + INVALID_ACCESS_ERR, + VALIDATION_ERR: 16, + // historical + TYPE_MISMATCH_ERR, + SECURITY_ERR, + NETWORK_ERR, + ABORT_ERR, + URL_MISMATCH_ERR, + QUOTA_EXCEEDED_ERR, + TIMEOUT_ERR, + INVALID_NODE_TYPE_ERR, + DATA_CLONE_ERR + }; + function DOMException2(code) { + Error.call(this); + Error.captureStackTrace(this, this.constructor); + this.code = code; + this.message = messages[code]; + this.name = names[code]; + } + DOMException2.prototype.__proto__ = Error.prototype; + for (c in constants) { + v = { value: constants[c] }; + Object.defineProperty(DOMException2, c, v); + Object.defineProperty(DOMException2.prototype, c, v); + } + var v; + var c; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/config.js +var require_config = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/config.js"(exports) { + exports.isApiWritable = !globalThis.__domino_frozen__; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/utils.js +var require_utils8 = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/utils.js"(exports) { + "use strict"; + var DOMException2 = require_DOMException(); + var ERR = DOMException2; + var isApiWritable = require_config().isApiWritable; + exports.NAMESPACE = { + HTML: "http://www.w3.org/1999/xhtml", + XML: "http://www.w3.org/XML/1998/namespace", + XMLNS: "http://www.w3.org/2000/xmlns/", + MATHML: "http://www.w3.org/1998/Math/MathML", + SVG: "http://www.w3.org/2000/svg", + XLINK: "http://www.w3.org/1999/xlink" + }; + exports.IndexSizeError = function() { + throw new DOMException2(ERR.INDEX_SIZE_ERR); + }; + exports.HierarchyRequestError = function() { + throw new DOMException2(ERR.HIERARCHY_REQUEST_ERR); + }; + exports.WrongDocumentError = function() { + throw new DOMException2(ERR.WRONG_DOCUMENT_ERR); + }; + exports.InvalidCharacterError = function() { + throw new DOMException2(ERR.INVALID_CHARACTER_ERR); + }; + exports.NoModificationAllowedError = function() { + throw new DOMException2(ERR.NO_MODIFICATION_ALLOWED_ERR); + }; + exports.NotFoundError = function() { + throw new DOMException2(ERR.NOT_FOUND_ERR); + }; + exports.NotSupportedError = function() { + throw new DOMException2(ERR.NOT_SUPPORTED_ERR); + }; + exports.InvalidStateError = function() { + throw new DOMException2(ERR.INVALID_STATE_ERR); + }; + exports.SyntaxError = function() { + throw new DOMException2(ERR.SYNTAX_ERR); + }; + exports.InvalidModificationError = function() { + throw new DOMException2(ERR.INVALID_MODIFICATION_ERR); + }; + exports.NamespaceError = function() { + throw new DOMException2(ERR.NAMESPACE_ERR); + }; + exports.InvalidAccessError = function() { + throw new DOMException2(ERR.INVALID_ACCESS_ERR); + }; + exports.TypeMismatchError = function() { + throw new DOMException2(ERR.TYPE_MISMATCH_ERR); + }; + exports.SecurityError = function() { + throw new DOMException2(ERR.SECURITY_ERR); + }; + exports.NetworkError = function() { + throw new DOMException2(ERR.NETWORK_ERR); + }; + exports.AbortError = function() { + throw new DOMException2(ERR.ABORT_ERR); + }; + exports.UrlMismatchError = function() { + throw new DOMException2(ERR.URL_MISMATCH_ERR); + }; + exports.QuotaExceededError = function() { + throw new DOMException2(ERR.QUOTA_EXCEEDED_ERR); + }; + exports.TimeoutError = function() { + throw new DOMException2(ERR.TIMEOUT_ERR); + }; + exports.InvalidNodeTypeError = function() { + throw new DOMException2(ERR.INVALID_NODE_TYPE_ERR); + }; + exports.DataCloneError = function() { + throw new DOMException2(ERR.DATA_CLONE_ERR); + }; + exports.nyi = function() { + throw new Error("NotYetImplemented"); + }; + exports.shouldOverride = function() { + throw new Error("Abstract function; should be overriding in subclass."); + }; + exports.assert = function(expr, msg) { + if (!expr) { + throw new Error("Assertion failed: " + (msg || "") + "\n" + new Error().stack); + } + }; + exports.expose = function(src, c) { + for (var n in src) { + Object.defineProperty(c.prototype, n, { value: src[n], writable: isApiWritable }); + } + }; + exports.merge = function(a, b) { + for (var n in b) { + a[n] = b[n]; + } + }; + exports.documentOrder = function(n, m) { + return 3 - (n.compareDocumentPosition(m) & 6); + }; + exports.toASCIILowerCase = function(s) { + return s.replace(/[A-Z]+/g, function(c) { + return c.toLowerCase(); + }); + }; + exports.toASCIIUpperCase = function(s) { + return s.replace(/[a-z]+/g, function(c) { + return c.toUpperCase(); + }); + }; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/EventTarget.js +var require_EventTarget = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/EventTarget.js"(exports, module) { + "use strict"; + var Event2 = require_Event(); + var MouseEvent = require_MouseEvent(); + var utils = require_utils8(); + module.exports = EventTarget2; + function EventTarget2() { + } + EventTarget2.prototype = { + // XXX + // See WebIDL §4.8 for details on object event handlers + // and how they should behave. We actually have to accept + // any object to addEventListener... Can't type check it. + // on registration. + // XXX: + // Capturing event listeners are sort of rare. I think I can optimize + // them so that dispatchEvent can skip the capturing phase (or much of + // it). Each time a capturing listener is added, increment a flag on + // the target node and each of its ancestors. Decrement when removed. + // And update the counter when nodes are added and removed from the + // tree as well. Then, in dispatch event, the capturing phase can + // abort if it sees any node with a zero count. + addEventListener: function addEventListener(type2, listener, capture) { + if (!listener) return; + if (capture === void 0) capture = false; + if (!this._listeners) this._listeners = /* @__PURE__ */ Object.create(null); + if (!this._listeners[type2]) this._listeners[type2] = []; + var list = this._listeners[type2]; + for (var i = 0, n = list.length; i < n; i++) { + var l = list[i]; + if (l.listener === listener && l.capture === capture) + return; + } + var obj = { listener, capture }; + if (typeof listener === "function") obj.f = listener; + list.push(obj); + }, + removeEventListener: function removeEventListener(type2, listener, capture) { + if (capture === void 0) capture = false; + if (this._listeners) { + var list = this._listeners[type2]; + if (list) { + for (var i = 0, n = list.length; i < n; i++) { + var l = list[i]; + if (l.listener === listener && l.capture === capture) { + if (list.length === 1) { + this._listeners[type2] = void 0; + } else { + list.splice(i, 1); + } + return; + } + } + } + } + }, + // This is the public API for dispatching untrusted public events. + // See _dispatchEvent for the implementation + dispatchEvent: function dispatchEvent(event) { + return this._dispatchEvent(event, false); + }, + // + // See DOMCore §4.4 + // XXX: I'll probably need another version of this method for + // internal use, one that does not set isTrusted to false. + // XXX: see Document._dispatchEvent: perhaps that and this could + // call a common internal function with different settings of + // a trusted boolean argument + // + // XXX: + // The spec has changed in how to deal with handlers registered + // on idl or content attributes rather than with addEventListener. + // Used to say that they always ran first. That's how webkit does it + // Spec now says that they run in a position determined by + // when they were first set. FF does it that way. See: + // http://www.whatwg.org/specs/web-apps/current-work/multipage/webappapis.html#event-handlers + // + _dispatchEvent: function _dispatchEvent(event, trusted) { + if (typeof trusted !== "boolean") trusted = false; + function invoke(target, event2) { + var type2 = event2.type, phase = event2.eventPhase; + event2.currentTarget = target; + if (phase !== Event2.CAPTURING_PHASE && target._handlers && target._handlers[type2]) { + var handler2 = target._handlers[type2]; + var rv; + if (typeof handler2 === "function") { + rv = handler2.call(event2.currentTarget, event2); + } else { + var f = handler2.handleEvent; + if (typeof f !== "function") + throw new TypeError("handleEvent property of event handler object isnot a function."); + rv = f.call(handler2, event2); + } + switch (event2.type) { + case "mouseover": + if (rv === true) + event2.preventDefault(); + break; + case "beforeunload": + // XXX: eventually we need a special case here + /* falls through */ + default: + if (rv === false) + event2.preventDefault(); + break; + } + } + var list = target._listeners && target._listeners[type2]; + if (!list) return; + list = list.slice(); + for (var i2 = 0, n2 = list.length; i2 < n2; i2++) { + if (event2._immediatePropagationStopped) return; + var l = list[i2]; + if (phase === Event2.CAPTURING_PHASE && !l.capture || phase === Event2.BUBBLING_PHASE && l.capture) + continue; + if (l.f) { + l.f.call(event2.currentTarget, event2); + } else { + var fn2 = l.listener.handleEvent; + if (typeof fn2 !== "function") + throw new TypeError("handleEvent property of event listener object is not a function."); + fn2.call(l.listener, event2); + } + } + } + if (!event._initialized || event._dispatching) utils.InvalidStateError(); + event.isTrusted = trusted; + event._dispatching = true; + event.target = this; + var ancestors = []; + for (var n = this.parentNode; n; n = n.parentNode) + ancestors.push(n); + event.eventPhase = Event2.CAPTURING_PHASE; + for (var i = ancestors.length - 1; i >= 0; i--) { + invoke(ancestors[i], event); + if (event._propagationStopped) break; + } + if (!event._propagationStopped) { + event.eventPhase = Event2.AT_TARGET; + invoke(this, event); + } + if (event.bubbles && !event._propagationStopped) { + event.eventPhase = Event2.BUBBLING_PHASE; + for (var ii = 0, nn = ancestors.length; ii < nn; ii++) { + invoke(ancestors[ii], event); + if (event._propagationStopped) break; + } + } + event._dispatching = false; + event.eventPhase = Event2.AT_TARGET; + event.currentTarget = null; + if (trusted && !event.defaultPrevented && event instanceof MouseEvent) { + switch (event.type) { + case "mousedown": + this._armed = { + x: event.clientX, + y: event.clientY, + t: event.timeStamp + }; + break; + case "mouseout": + case "mouseover": + this._armed = null; + break; + case "mouseup": + if (this._isClick(event)) this._doClick(event); + this._armed = null; + break; + } + } + return !event.defaultPrevented; + }, + // Determine whether a click occurred + // XXX We don't support double clicks for now + _isClick: function(event) { + return this._armed !== null && event.type === "mouseup" && event.isTrusted && event.button === 0 && event.timeStamp - this._armed.t < 1e3 && Math.abs(event.clientX - this._armed.x) < 10 && Math.abs(event.clientY - this._armed.Y) < 10; + }, + // Clicks are handled like this: + // http://www.whatwg.org/specs/web-apps/current-work/multipage/elements.html#interactive-content-0 + // + // Note that this method is similar to the HTMLElement.click() method + // The event argument must be the trusted mouseup event + _doClick: function(event) { + if (this._click_in_progress) return; + this._click_in_progress = true; + var activated = this; + while (activated && !activated._post_click_activation_steps) + activated = activated.parentNode; + if (activated && activated._pre_click_activation_steps) { + activated._pre_click_activation_steps(); + } + var click = this.ownerDocument.createEvent("MouseEvent"); + click.initMouseEvent( + "click", + true, + true, + this.ownerDocument.defaultView, + 1, + event.screenX, + event.screenY, + event.clientX, + event.clientY, + event.ctrlKey, + event.altKey, + event.shiftKey, + event.metaKey, + event.button, + null + ); + var result = this._dispatchEvent(click, true); + if (activated) { + if (result) { + if (activated._post_click_activation_steps) + activated._post_click_activation_steps(click); + } else { + if (activated._cancelled_activation_steps) + activated._cancelled_activation_steps(); + } + } + }, + // + // An event handler is like an event listener, but it registered + // by setting an IDL or content attribute like onload or onclick. + // There can only be one of these at a time for any event type. + // This is an internal method for the attribute accessors and + // content attribute handlers that need to register events handlers. + // The type argument is the same as in addEventListener(). + // The handler argument is the same as listeners in addEventListener: + // it can be a function or an object. Pass null to remove any existing + // handler. Handlers are always invoked before any listeners of + // the same type. They are not invoked during the capturing phase + // of event dispatch. + // + _setEventHandler: function _setEventHandler(type2, handler2) { + if (!this._handlers) this._handlers = /* @__PURE__ */ Object.create(null); + this._handlers[type2] = handler2; + }, + _getEventHandler: function _getEventHandler(type2) { + return this._handlers && this._handlers[type2] || null; + } + }; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/LinkedList.js +var require_LinkedList = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/LinkedList.js"(exports, module) { + "use strict"; + var utils = require_utils8(); + var LinkedList = module.exports = { + // basic validity tests on a circular linked list a + valid: function(a) { + utils.assert(a, "list falsy"); + utils.assert(a._previousSibling, "previous falsy"); + utils.assert(a._nextSibling, "next falsy"); + return true; + }, + // insert a before b + insertBefore: function(a, b) { + utils.assert(LinkedList.valid(a) && LinkedList.valid(b)); + var a_first = a, a_last = a._previousSibling; + var b_first = b, b_last = b._previousSibling; + a_first._previousSibling = b_last; + a_last._nextSibling = b_first; + b_last._nextSibling = a_first; + b_first._previousSibling = a_last; + utils.assert(LinkedList.valid(a) && LinkedList.valid(b)); + }, + // replace a single node a with a list b (which could be null) + replace: function(a, b) { + utils.assert(LinkedList.valid(a) && (b === null || LinkedList.valid(b))); + if (b !== null) { + LinkedList.insertBefore(b, a); + } + LinkedList.remove(a); + utils.assert(LinkedList.valid(a) && (b === null || LinkedList.valid(b))); + }, + // remove single node a from its list + remove: function(a) { + utils.assert(LinkedList.valid(a)); + var prev = a._previousSibling; + if (prev === a) { + return; + } + var next2 = a._nextSibling; + prev._nextSibling = next2; + next2._previousSibling = prev; + a._previousSibling = a._nextSibling = a; + utils.assert(LinkedList.valid(a)); + } + }; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NodeUtils.js +var require_NodeUtils = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NodeUtils.js"(exports, module) { + "use strict"; + module.exports = { + // NOTE: The `serializeOne()` function used to live on the `Node.prototype` + // as a private method `Node#_serializeOne(child)`, however that requires + // a megamorphic property access `this._serializeOne` just to get to the + // method, and this is being done on lots of different `Node` subclasses, + // which puts a lot of pressure on V8's megamorphic stub cache. So by + // moving the helper off of the `Node.prototype` and into a separate + // function in this helper module, we get a monomorphic property access + // `NodeUtils.serializeOne` to get to the function and reduce pressure + // on the megamorphic stub cache. + // See https://github.com/fgnass/domino/pull/142 for more information. + serializeOne, + // Export util functions so that we can run extra test for them. + // Note: we prefix function names with `ɵ`, similar to what we do + // with internal functions in Angular packages. + \u0275escapeMatchingClosingTag: escapeMatchingClosingTag, + \u0275escapeClosingCommentTag: escapeClosingCommentTag, + \u0275escapeProcessingInstructionContent: escapeProcessingInstructionContent + }; + var utils = require_utils8(); + var NAMESPACE = utils.NAMESPACE; + var hasRawContent = { + STYLE: true, + SCRIPT: true, + XMP: true, + IFRAME: true, + NOEMBED: true, + NOFRAMES: true, + PLAINTEXT: true + }; + var emptyElements = { + area: true, + base: true, + basefont: true, + bgsound: true, + br: true, + col: true, + embed: true, + frame: true, + hr: true, + img: true, + input: true, + keygen: true, + link: true, + meta: true, + param: true, + source: true, + track: true, + wbr: true + }; + var extraNewLine = { + /* Removed in https://github.com/whatwg/html/issues/944 + pre: true, + textarea: true, + listing: true + */ + }; + var ESCAPE_REGEXP = /[&<>\u00A0]/g; + var ESCAPE_ATTR_REGEXP = /[&"<>\u00A0]/g; + function escape2(s) { + if (!ESCAPE_REGEXP.test(s)) { + return s; + } + return s.replace(ESCAPE_REGEXP, (c) => { + switch (c) { + case "&": + return "&"; + case "<": + return "<"; + case ">": + return ">"; + case "\xA0": + return " "; + } + }); + } + function escapeAttr(s) { + if (!ESCAPE_ATTR_REGEXP.test(s)) { + return s; + } + return s.replace(ESCAPE_ATTR_REGEXP, (c) => { + switch (c) { + case "<": + return "<"; + case ">": + return ">"; + case "&": + return "&"; + case '"': + return """; + case "\xA0": + return " "; + } + }); + } + function attrname(a) { + var ns = a.namespaceURI; + if (!ns) + return a.localName; + if (ns === NAMESPACE.XML) + return "xml:" + a.localName; + if (ns === NAMESPACE.XLINK) + return "xlink:" + a.localName; + if (ns === NAMESPACE.XMLNS) { + if (a.localName === "xmlns") return "xmlns"; + else return "xmlns:" + a.localName; + } + return a.name; + } + function escapeMatchingClosingTag(rawText, parentTag) { + const parentClosingTag = "/; + function escapeClosingCommentTag(rawContent) { + if (!CLOSING_COMMENT_REGEXP.test(rawContent)) { + return rawContent; + } + return rawContent.replace(/(--\!?)>/g, "$1>"); + } + function escapeProcessingInstructionContent(rawContent) { + return rawContent.includes(">") ? rawContent.replaceAll(">", ">") : rawContent; + } + function serializeOne(kid, parent) { + var s = ""; + switch (kid.nodeType) { + case 1: + var ns = kid.namespaceURI; + var html = ns === NAMESPACE.HTML; + var tagname = html || ns === NAMESPACE.SVG || ns === NAMESPACE.MATHML ? kid.localName : kid.tagName; + s += "<" + tagname; + for (var j = 0, k = kid._numattrs; j < k; j++) { + var a = kid._attr(j); + s += " " + attrname(a); + if (a.value !== void 0) s += '="' + escapeAttr(a.value) + '"'; + } + s += ">"; + if (!(html && emptyElements[tagname])) { + var ss = kid.serialize(); + if (hasRawContent[tagname.toUpperCase()]) { + ss = escapeMatchingClosingTag(ss, tagname); + } + if (html && extraNewLine[tagname] && ss.charAt(0) === "\n") s += "\n"; + s += ss; + s += ""; + } + break; + case 3: + //TEXT_NODE + case 4: + var parenttag; + if (parent.nodeType === 1 && parent.namespaceURI === NAMESPACE.HTML) + parenttag = parent.tagName; + else + parenttag = ""; + if (hasRawContent[parenttag] || parenttag === "NOSCRIPT" && parent.ownerDocument._scripting_enabled) { + s += kid.data; + } else { + s += escape2(kid.data); + } + break; + case 8: + s += ""; + break; + case 7: + const content = escapeProcessingInstructionContent(kid.data); + s += ""; + break; + case 10: + s += ""; + break; + default: + utils.InvalidStateError(); + } + return s; + } + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Node.js +var require_Node = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Node.js"(exports, module) { + "use strict"; + module.exports = Node; + var EventTarget2 = require_EventTarget(); + var LinkedList = require_LinkedList(); + var NodeUtils = require_NodeUtils(); + var utils = require_utils8(); + function Node() { + EventTarget2.call(this); + this.parentNode = null; + this._nextSibling = this._previousSibling = this; + this._index = void 0; + } + var ELEMENT_NODE = Node.ELEMENT_NODE = 1; + var ATTRIBUTE_NODE = Node.ATTRIBUTE_NODE = 2; + var TEXT_NODE = Node.TEXT_NODE = 3; + var CDATA_SECTION_NODE = Node.CDATA_SECTION_NODE = 4; + var ENTITY_REFERENCE_NODE = Node.ENTITY_REFERENCE_NODE = 5; + var ENTITY_NODE = Node.ENTITY_NODE = 6; + var PROCESSING_INSTRUCTION_NODE = Node.PROCESSING_INSTRUCTION_NODE = 7; + var COMMENT_NODE = Node.COMMENT_NODE = 8; + var DOCUMENT_NODE = Node.DOCUMENT_NODE = 9; + var DOCUMENT_TYPE_NODE = Node.DOCUMENT_TYPE_NODE = 10; + var DOCUMENT_FRAGMENT_NODE = Node.DOCUMENT_FRAGMENT_NODE = 11; + var NOTATION_NODE = Node.NOTATION_NODE = 12; + var DOCUMENT_POSITION_DISCONNECTED = Node.DOCUMENT_POSITION_DISCONNECTED = 1; + var DOCUMENT_POSITION_PRECEDING = Node.DOCUMENT_POSITION_PRECEDING = 2; + var DOCUMENT_POSITION_FOLLOWING = Node.DOCUMENT_POSITION_FOLLOWING = 4; + var DOCUMENT_POSITION_CONTAINS = Node.DOCUMENT_POSITION_CONTAINS = 8; + var DOCUMENT_POSITION_CONTAINED_BY = Node.DOCUMENT_POSITION_CONTAINED_BY = 16; + var DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = Node.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 32; + Node.prototype = Object.create(EventTarget2.prototype, { + // Node that are not inserted into the tree inherit a null parent + // XXX: the baseURI attribute is defined by dom core, but + // a correct implementation of it requires HTML features, so + // we'll come back to this later. + baseURI: { get: utils.nyi }, + parentElement: { get: function() { + return this.parentNode && this.parentNode.nodeType === ELEMENT_NODE ? this.parentNode : null; + } }, + hasChildNodes: { value: utils.shouldOverride }, + firstChild: { get: utils.shouldOverride }, + lastChild: { get: utils.shouldOverride }, + isConnected: { + get: function() { + let node2 = this; + while (node2 != null) { + if (node2.nodeType === Node.DOCUMENT_NODE) { + return true; + } + node2 = node2.parentNode; + if (node2 != null && node2.nodeType === Node.DOCUMENT_FRAGMENT_NODE) { + node2 = node2.host; + } + } + return false; + } + }, + previousSibling: { get: function() { + var parent = this.parentNode; + if (!parent) return null; + if (this === parent.firstChild) return null; + return this._previousSibling; + } }, + nextSibling: { get: function() { + var parent = this.parentNode, next2 = this._nextSibling; + if (!parent) return null; + if (next2 === parent.firstChild) return null; + return next2; + } }, + textContent: { + // Should override for DocumentFragment/Element/Attr/Text/PI/Comment + get: function() { + return null; + }, + set: function(v) { + } + }, + innerText: { + // Should override for DocumentFragment/Element/Attr/Text/PI/Comment + get: function() { + return null; + }, + set: function(v) { + } + }, + _countChildrenOfType: { value: function(type2) { + var sum = 0; + for (var kid = this.firstChild; kid !== null; kid = kid.nextSibling) { + if (kid.nodeType === type2) sum++; + } + return sum; + } }, + _ensureInsertValid: { value: function _ensureInsertValid(node2, child, isPreinsert) { + var parent = this, i, kid; + if (!node2.nodeType) throw new TypeError("not a node"); + switch (parent.nodeType) { + case DOCUMENT_NODE: + case DOCUMENT_FRAGMENT_NODE: + case ELEMENT_NODE: + break; + default: + utils.HierarchyRequestError(); + } + if (node2.isAncestor(parent)) utils.HierarchyRequestError(); + if (child !== null || !isPreinsert) { + if (child.parentNode !== parent) utils.NotFoundError(); + } + switch (node2.nodeType) { + case DOCUMENT_FRAGMENT_NODE: + case DOCUMENT_TYPE_NODE: + case ELEMENT_NODE: + case TEXT_NODE: + case PROCESSING_INSTRUCTION_NODE: + case COMMENT_NODE: + break; + default: + utils.HierarchyRequestError(); + } + if (parent.nodeType === DOCUMENT_NODE) { + switch (node2.nodeType) { + case TEXT_NODE: + utils.HierarchyRequestError(); + break; + case DOCUMENT_FRAGMENT_NODE: + if (node2._countChildrenOfType(TEXT_NODE) > 0) + utils.HierarchyRequestError(); + switch (node2._countChildrenOfType(ELEMENT_NODE)) { + case 0: + break; + case 1: + if (child !== null) { + if (isPreinsert && child.nodeType === DOCUMENT_TYPE_NODE) + utils.HierarchyRequestError(); + for (kid = child.nextSibling; kid !== null; kid = kid.nextSibling) { + if (kid.nodeType === DOCUMENT_TYPE_NODE) + utils.HierarchyRequestError(); + } + } + i = parent._countChildrenOfType(ELEMENT_NODE); + if (isPreinsert) { + if (i > 0) + utils.HierarchyRequestError(); + } else { + if (i > 1 || i === 1 && child.nodeType !== ELEMENT_NODE) + utils.HierarchyRequestError(); + } + break; + default: + utils.HierarchyRequestError(); + } + break; + case ELEMENT_NODE: + if (child !== null) { + if (isPreinsert && child.nodeType === DOCUMENT_TYPE_NODE) + utils.HierarchyRequestError(); + for (kid = child.nextSibling; kid !== null; kid = kid.nextSibling) { + if (kid.nodeType === DOCUMENT_TYPE_NODE) + utils.HierarchyRequestError(); + } + } + i = parent._countChildrenOfType(ELEMENT_NODE); + if (isPreinsert) { + if (i > 0) + utils.HierarchyRequestError(); + } else { + if (i > 1 || i === 1 && child.nodeType !== ELEMENT_NODE) + utils.HierarchyRequestError(); + } + break; + case DOCUMENT_TYPE_NODE: + if (child === null) { + if (parent._countChildrenOfType(ELEMENT_NODE)) + utils.HierarchyRequestError(); + } else { + for (kid = parent.firstChild; kid !== null; kid = kid.nextSibling) { + if (kid === child) break; + if (kid.nodeType === ELEMENT_NODE) + utils.HierarchyRequestError(); + } + } + i = parent._countChildrenOfType(DOCUMENT_TYPE_NODE); + if (isPreinsert) { + if (i > 0) + utils.HierarchyRequestError(); + } else { + if (i > 1 || i === 1 && child.nodeType !== DOCUMENT_TYPE_NODE) + utils.HierarchyRequestError(); + } + break; + } + } else { + if (node2.nodeType === DOCUMENT_TYPE_NODE) utils.HierarchyRequestError(); + } + } }, + insertBefore: { value: function insertBefore(node2, child) { + var parent = this; + parent._ensureInsertValid(node2, child, true); + var refChild = child; + if (refChild === node2) { + refChild = node2.nextSibling; + } + parent.doc.adoptNode(node2); + node2._insertOrReplace(parent, refChild, false); + return node2; + } }, + appendChild: { value: function(child) { + return this.insertBefore(child, null); + } }, + _appendChild: { value: function(child) { + child._insertOrReplace(this, null, false); + } }, + removeChild: { value: function removeChild(child) { + var parent = this; + if (!child.nodeType) throw new TypeError("not a node"); + if (child.parentNode !== parent) utils.NotFoundError(); + child.remove(); + return child; + } }, + // To replace a `child` with `node` within a `parent` (this) + replaceChild: { value: function replaceChild(node2, child) { + var parent = this; + parent._ensureInsertValid(node2, child, false); + if (node2.doc !== parent.doc) { + parent.doc.adoptNode(node2); + } + node2._insertOrReplace(parent, child, true); + return child; + } }, + // See: http://ejohn.org/blog/comparing-document-position/ + contains: { value: function contains(node2) { + if (node2 === null) { + return false; + } + if (this === node2) { + return true; + } + return (this.compareDocumentPosition(node2) & DOCUMENT_POSITION_CONTAINED_BY) !== 0; + } }, + compareDocumentPosition: { value: function compareDocumentPosition(that) { + if (this === that) return 0; + if (this.doc !== that.doc || this.rooted !== that.rooted) + return DOCUMENT_POSITION_DISCONNECTED + DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC; + var these = [], those = []; + for (var n = this; n !== null; n = n.parentNode) these.push(n); + for (n = that; n !== null; n = n.parentNode) those.push(n); + these.reverse(); + those.reverse(); + if (these[0] !== those[0]) + return DOCUMENT_POSITION_DISCONNECTED + DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC; + n = Math.min(these.length, those.length); + for (var i = 1; i < n; i++) { + if (these[i] !== those[i]) { + if (these[i].index < those[i].index) + return DOCUMENT_POSITION_FOLLOWING; + else + return DOCUMENT_POSITION_PRECEDING; + } + } + if (these.length < those.length) + return DOCUMENT_POSITION_FOLLOWING + DOCUMENT_POSITION_CONTAINED_BY; + else + return DOCUMENT_POSITION_PRECEDING + DOCUMENT_POSITION_CONTAINS; + } }, + isSameNode: { value: function isSameNode(node2) { + return this === node2; + } }, + // This method implements the generic parts of node equality testing + // and defers to the (non-recursive) type-specific isEqual() method + // defined by subclasses + isEqualNode: { value: function isEqualNode(node2) { + if (!node2) return false; + if (node2.nodeType !== this.nodeType) return false; + if (!this.isEqual(node2)) return false; + for (var c1 = this.firstChild, c2 = node2.firstChild; c1 && c2; c1 = c1.nextSibling, c2 = c2.nextSibling) { + if (!c1.isEqualNode(c2)) return false; + } + return c1 === null && c2 === null; + } }, + // This method delegates shallow cloning to a clone() method + // that each concrete subclass must implement + cloneNode: { value: function(deep) { + var clone4 = this.clone(); + if (deep) { + for (var kid = this.firstChild; kid !== null; kid = kid.nextSibling) { + clone4._appendChild(kid.cloneNode(true)); + } + } + return clone4; + } }, + lookupPrefix: { value: function lookupPrefix(ns) { + var e; + if (ns === "" || ns === null || ns === void 0) return null; + switch (this.nodeType) { + case ELEMENT_NODE: + return this._lookupNamespacePrefix(ns, this); + case DOCUMENT_NODE: + e = this.documentElement; + return e ? e.lookupPrefix(ns) : null; + case ENTITY_NODE: + case NOTATION_NODE: + case DOCUMENT_FRAGMENT_NODE: + case DOCUMENT_TYPE_NODE: + return null; + case ATTRIBUTE_NODE: + e = this.ownerElement; + return e ? e.lookupPrefix(ns) : null; + default: + e = this.parentElement; + return e ? e.lookupPrefix(ns) : null; + } + } }, + lookupNamespaceURI: { value: function lookupNamespaceURI(prefix) { + if (prefix === "" || prefix === void 0) { + prefix = null; + } + var e; + switch (this.nodeType) { + case ELEMENT_NODE: + return utils.shouldOverride(); + case DOCUMENT_NODE: + e = this.documentElement; + return e ? e.lookupNamespaceURI(prefix) : null; + case ENTITY_NODE: + case NOTATION_NODE: + case DOCUMENT_TYPE_NODE: + case DOCUMENT_FRAGMENT_NODE: + return null; + case ATTRIBUTE_NODE: + e = this.ownerElement; + return e ? e.lookupNamespaceURI(prefix) : null; + default: + e = this.parentElement; + return e ? e.lookupNamespaceURI(prefix) : null; + } + } }, + isDefaultNamespace: { value: function isDefaultNamespace(ns) { + if (ns === "" || ns === void 0) { + ns = null; + } + var defaultNamespace = this.lookupNamespaceURI(null); + return defaultNamespace === ns; + } }, + // Utility methods for nodes. Not part of the DOM + // Return the index of this node in its parent. + // Throw if no parent, or if this node is not a child of its parent + index: { get: function() { + var parent = this.parentNode; + if (this === parent.firstChild) return 0; + var kids = parent.childNodes; + if (this._index === void 0 || kids[this._index] !== this) { + for (var i = 0; i < kids.length; i++) { + kids[i]._index = i; + } + utils.assert(kids[this._index] === this); + } + return this._index; + } }, + // Return true if this node is equal to or is an ancestor of that node + // Note that nodes are considered to be ancestors of themselves + isAncestor: { value: function(that) { + if (this.doc !== that.doc) return false; + if (this.rooted !== that.rooted) return false; + for (var e = that; e; e = e.parentNode) { + if (e === this) return true; + } + return false; + } }, + // DOMINO Changed the behavior to conform with the specs. See: + // https://groups.google.com/d/topic/mozilla.dev.platform/77sIYcpdDmc/discussion + ensureSameDoc: { value: function(that) { + if (that.ownerDocument === null) { + that.ownerDocument = this.doc; + } else if (that.ownerDocument !== this.doc) { + utils.WrongDocumentError(); + } + } }, + removeChildren: { value: utils.shouldOverride }, + // Insert this node as a child of parent before the specified child, + // or insert as the last child of parent if specified child is null, + // or replace the specified child with this node, firing mutation events as + // necessary + _insertOrReplace: { value: function _insertOrReplace(parent, before, isReplace) { + var child = this, before_index, i; + if (child.nodeType === DOCUMENT_FRAGMENT_NODE && child.rooted) { + utils.HierarchyRequestError(); + } + if (parent._childNodes) { + before_index = before === null ? parent._childNodes.length : before.index; + if (child.parentNode === parent) { + var child_index = child.index; + if (child_index < before_index) { + before_index--; + } + } + } + if (isReplace) { + if (before.rooted) before.doc.mutateRemove(before); + before.parentNode = null; + } + var n = before; + if (n === null) { + n = parent.firstChild; + } + var bothRooted = child.rooted && parent.rooted; + if (child.nodeType === DOCUMENT_FRAGMENT_NODE) { + var spliceArgs = [0, isReplace ? 1 : 0], next2; + for (var kid = child.firstChild; kid !== null; kid = next2) { + next2 = kid.nextSibling; + spliceArgs.push(kid); + kid.parentNode = parent; + } + var len = spliceArgs.length; + if (isReplace) { + LinkedList.replace(n, len > 2 ? spliceArgs[2] : null); + } else if (len > 2 && n !== null) { + LinkedList.insertBefore(spliceArgs[2], n); + } + if (parent._childNodes) { + spliceArgs[0] = before === null ? parent._childNodes.length : before._index; + parent._childNodes.splice.apply(parent._childNodes, spliceArgs); + for (i = 2; i < len; i++) { + spliceArgs[i]._index = spliceArgs[0] + (i - 2); + } + } else if (parent._firstChild === before) { + if (len > 2) { + parent._firstChild = spliceArgs[2]; + } else if (isReplace) { + parent._firstChild = null; + } + } + if (child._childNodes) { + child._childNodes.length = 0; + } else { + child._firstChild = null; + } + if (parent.rooted) { + parent.modify(); + for (i = 2; i < len; i++) { + parent.doc.mutateInsert(spliceArgs[i]); + } + } + } else { + if (before === child) { + return; + } + if (bothRooted) { + child._remove(); + } else if (child.parentNode) { + child.remove(); + } + child.parentNode = parent; + if (isReplace) { + LinkedList.replace(n, child); + if (parent._childNodes) { + child._index = before_index; + parent._childNodes[before_index] = child; + } else if (parent._firstChild === before) { + parent._firstChild = child; + } + } else { + if (n !== null) { + LinkedList.insertBefore(child, n); + } + if (parent._childNodes) { + child._index = before_index; + parent._childNodes.splice(before_index, 0, child); + } else if (parent._firstChild === before) { + parent._firstChild = child; + } + } + if (bothRooted) { + parent.modify(); + parent.doc.mutateMove(child); + } else if (parent.rooted) { + parent.modify(); + parent.doc.mutateInsert(child); + } + } + } }, + // Return the lastModTime value for this node. (For use as a + // cache invalidation mechanism. If the node does not already + // have one, initialize it from the owner document's modclock + // property. (Note that modclock does not return the actual + // time; it is simply a counter incremented on each document + // modification) + lastModTime: { get: function() { + if (!this._lastModTime) { + this._lastModTime = this.doc.modclock; + } + return this._lastModTime; + } }, + // Increment the owner document's modclock and use the new + // value to update the lastModTime value for this node and + // all of its ancestors. Nodes that have never had their + // lastModTime value queried do not need to have a + // lastModTime property set on them since there is no + // previously queried value to ever compare the new value + // against, so only update nodes that already have a + // _lastModTime property. + modify: { value: function() { + if (this.doc.modclock) { + var time5 = ++this.doc.modclock; + for (var n = this; n; n = n.parentElement) { + if (n._lastModTime) { + n._lastModTime = time5; + } + } + } + } }, + // This attribute is not part of the DOM but is quite helpful. + // It returns the document with which a node is associated. Usually + // this is the ownerDocument. But ownerDocument is null for the + // document object itself, so this is a handy way to get the document + // regardless of the node type + doc: { get: function() { + return this.ownerDocument || this; + } }, + // If the node has a nid (node id), then it is rooted in a document + rooted: { get: function() { + return !!this._nid; + } }, + normalize: { value: function() { + var next2; + for (var child = this.firstChild; child !== null; child = next2) { + next2 = child.nextSibling; + if (child.normalize) { + child.normalize(); + } + if (child.nodeType !== Node.TEXT_NODE) { + continue; + } + if (child.nodeValue === "") { + this.removeChild(child); + continue; + } + var prevChild = child.previousSibling; + if (prevChild === null) { + continue; + } else if (prevChild.nodeType === Node.TEXT_NODE) { + prevChild.appendData(child.nodeValue); + this.removeChild(child); + } + } + } }, + // Convert the children of a node to an HTML string. + // This is used by the innerHTML getter + // The serialization spec is at: + // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#serializing-html-fragments + // + // The serialization logic is intentionally implemented in a separate + // `NodeUtils` helper instead of the more obvious choice of a private + // `_serializeOne()` method on the `Node.prototype` in order to avoid + // the megamorphic `this._serializeOne` property access, which reduces + // performance unnecessarily. If you need specialized behavior for a + // certain subclass, you'll need to implement that in `NodeUtils`. + // See https://github.com/fgnass/domino/pull/142 for more information. + serialize: { value: function() { + if (this._innerHTML) { + return this._innerHTML; + } + var s = ""; + for (var kid = this.firstChild; kid !== null; kid = kid.nextSibling) { + s += NodeUtils.serializeOne(kid, this); + } + return s; + } }, + // Non-standard, but often useful for debugging. + outerHTML: { + get: function() { + return NodeUtils.serializeOne(this, { nodeType: 0 }); + }, + set: utils.nyi + }, + // mirror node type properties in the prototype, so they are present + // in instances of Node (and subclasses) + ELEMENT_NODE: { value: ELEMENT_NODE }, + ATTRIBUTE_NODE: { value: ATTRIBUTE_NODE }, + TEXT_NODE: { value: TEXT_NODE }, + CDATA_SECTION_NODE: { value: CDATA_SECTION_NODE }, + ENTITY_REFERENCE_NODE: { value: ENTITY_REFERENCE_NODE }, + ENTITY_NODE: { value: ENTITY_NODE }, + PROCESSING_INSTRUCTION_NODE: { value: PROCESSING_INSTRUCTION_NODE }, + COMMENT_NODE: { value: COMMENT_NODE }, + DOCUMENT_NODE: { value: DOCUMENT_NODE }, + DOCUMENT_TYPE_NODE: { value: DOCUMENT_TYPE_NODE }, + DOCUMENT_FRAGMENT_NODE: { value: DOCUMENT_FRAGMENT_NODE }, + NOTATION_NODE: { value: NOTATION_NODE }, + DOCUMENT_POSITION_DISCONNECTED: { value: DOCUMENT_POSITION_DISCONNECTED }, + DOCUMENT_POSITION_PRECEDING: { value: DOCUMENT_POSITION_PRECEDING }, + DOCUMENT_POSITION_FOLLOWING: { value: DOCUMENT_POSITION_FOLLOWING }, + DOCUMENT_POSITION_CONTAINS: { value: DOCUMENT_POSITION_CONTAINS }, + DOCUMENT_POSITION_CONTAINED_BY: { value: DOCUMENT_POSITION_CONTAINED_BY }, + DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: { value: DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NodeList.es6.js +var require_NodeList_es6 = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NodeList.es6.js"(exports, module) { + "use strict"; + module.exports = class NodeList extends Array { + constructor(a) { + super(a && a.length || 0); + if (a) { + for (var idx in a) { + this[idx] = a[idx]; + } + } + } + item(i) { + return this[i] || null; + } + }; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NodeList.es5.js +var require_NodeList_es5 = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NodeList.es5.js"(exports, module) { + "use strict"; + function item(i) { + return this[i] || null; + } + function NodeList(a) { + if (!a) a = []; + a.item = item; + return a; + } + module.exports = NodeList; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NodeList.js +var require_NodeList = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NodeList.js"(exports, module) { + "use strict"; + var NodeList; + try { + NodeList = require_NodeList_es6(); + } catch (e) { + NodeList = require_NodeList_es5(); + } + module.exports = NodeList; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/ContainerNode.js +var require_ContainerNode = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/ContainerNode.js"(exports, module) { + "use strict"; + module.exports = ContainerNode; + var Node = require_Node(); + var NodeList = require_NodeList(); + function ContainerNode() { + Node.call(this); + this._firstChild = this._childNodes = null; + } + ContainerNode.prototype = Object.create(Node.prototype, { + hasChildNodes: { value: function() { + if (this._childNodes) { + return this._childNodes.length > 0; + } + return this._firstChild !== null; + } }, + childNodes: { get: function() { + this._ensureChildNodes(); + return this._childNodes; + } }, + firstChild: { get: function() { + if (this._childNodes) { + return this._childNodes.length === 0 ? null : this._childNodes[0]; + } + return this._firstChild; + } }, + lastChild: { get: function() { + var kids = this._childNodes, first; + if (kids) { + return kids.length === 0 ? null : kids[kids.length - 1]; + } + first = this._firstChild; + if (first === null) { + return null; + } + return first._previousSibling; + } }, + _ensureChildNodes: { value: function() { + if (this._childNodes) { + return; + } + var first = this._firstChild, kid = first, childNodes = this._childNodes = new NodeList(); + if (first) do { + childNodes.push(kid); + kid = kid._nextSibling; + } while (kid !== first); + this._firstChild = null; + } }, + // Remove all of this node's children. This is a minor + // optimization that only calls modify() once. + removeChildren: { value: function removeChildren() { + var root2 = this.rooted ? this.ownerDocument : null, next2 = this.firstChild, kid; + while (next2 !== null) { + kid = next2; + next2 = kid.nextSibling; + if (root2) root2.mutateRemove(kid); + kid.parentNode = null; + } + if (this._childNodes) { + this._childNodes.length = 0; + } else { + this._firstChild = null; + } + this.modify(); + } } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/xmlnames.js +var require_xmlnames = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/xmlnames.js"(exports) { + "use strict"; + exports.isValidName = isValidName; + exports.isValidQName = isValidQName; + var simplename = /^[_:A-Za-z][-.:\w]+$/; + var simpleqname = /^([_A-Za-z][-.\w]+|[_A-Za-z][-.\w]+:[_A-Za-z][-.\w]+)$/; + var ncnamestartchars = "_A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD"; + var ncnamechars = "-._A-Za-z0-9\xB7\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0300-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD"; + var ncname = "[" + ncnamestartchars + "][" + ncnamechars + "]*"; + var namestartchars = ncnamestartchars + ":"; + var namechars = ncnamechars + ":"; + var name = new RegExp("^[" + namestartchars + "][" + namechars + "]*$"); + var qname = new RegExp("^(" + ncname + "|" + ncname + ":" + ncname + ")$"); + var hassurrogates = /[\uD800-\uDB7F\uDC00-\uDFFF]/; + var surrogatechars = /[\uD800-\uDB7F\uDC00-\uDFFF]/g; + var surrogatepairs = /[\uD800-\uDB7F][\uDC00-\uDFFF]/g; + ncnamestartchars += "\uD800-\u{EFC00}-\uDFFF"; + ncnamechars += "\uD800-\u{EFC00}-\uDFFF"; + ncname = "[" + ncnamestartchars + "][" + ncnamechars + "]*"; + namestartchars = ncnamestartchars + ":"; + namechars = ncnamechars + ":"; + var surrogatename = new RegExp("^[" + namestartchars + "][" + namechars + "]*$"); + var surrogateqname = new RegExp("^(" + ncname + "|" + ncname + ":" + ncname + ")$"); + function isValidName(s) { + if (simplename.test(s)) return true; + if (name.test(s)) return true; + if (!hassurrogates.test(s)) return false; + if (!surrogatename.test(s)) return false; + var chars = s.match(surrogatechars), pairs = s.match(surrogatepairs); + return pairs !== null && 2 * pairs.length === chars.length; + } + function isValidQName(s) { + if (simpleqname.test(s)) return true; + if (qname.test(s)) return true; + if (!hassurrogates.test(s)) return false; + if (!surrogateqname.test(s)) return false; + var chars = s.match(surrogatechars), pairs = s.match(surrogatepairs); + return pairs !== null && 2 * pairs.length === chars.length; + } + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/attributes.js +var require_attributes = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/attributes.js"(exports) { + "use strict"; + var utils = require_utils8(); + exports.property = function(attr) { + if (Array.isArray(attr.type)) { + var valid = /* @__PURE__ */ Object.create(null); + attr.type.forEach(function(val) { + valid[val.value || val] = val.alias || val; + }); + var missingValueDefault = attr.missing; + if (missingValueDefault === void 0) { + missingValueDefault = null; + } + var invalidValueDefault = attr.invalid; + if (invalidValueDefault === void 0) { + invalidValueDefault = missingValueDefault; + } + return { + get: function() { + var v = this._getattr(attr.name); + if (v === null) return missingValueDefault; + v = valid[v.toLowerCase()]; + if (v !== void 0) return v; + if (invalidValueDefault !== null) return invalidValueDefault; + return v; + }, + set: function(v) { + this._setattr(attr.name, v); + } + }; + } else if (attr.type === Boolean) { + return { + get: function() { + return this.hasAttribute(attr.name); + }, + set: function(v) { + if (v) { + this._setattr(attr.name, ""); + } else { + this.removeAttribute(attr.name); + } + } + }; + } else if (attr.type === Number || attr.type === "long" || attr.type === "unsigned long" || attr.type === "limited unsigned long with fallback") { + return numberPropDesc(attr); + } else if (!attr.type || attr.type === String) { + return { + get: function() { + return this._getattr(attr.name) || ""; + }, + set: function(v) { + if (attr.treatNullAsEmptyString && v === null) { + v = ""; + } + this._setattr(attr.name, v); + } + }; + } else if (typeof attr.type === "function") { + return attr.type(attr.name, attr); + } + throw new Error("Invalid attribute definition"); + }; + function numberPropDesc(a) { + var def; + if (typeof a.default === "function") { + def = a.default; + } else if (typeof a.default === "number") { + def = function() { + return a.default; + }; + } else { + def = function() { + utils.assert(false, typeof a.default); + }; + } + var unsigned_long = a.type === "unsigned long"; + var signed_long = a.type === "long"; + var unsigned_fallback = a.type === "limited unsigned long with fallback"; + var min = a.min, max = a.max, setmin = a.setmin; + if (min === void 0) { + if (unsigned_long) min = 0; + if (signed_long) min = -2147483648; + if (unsigned_fallback) min = 1; + } + if (max === void 0) { + if (unsigned_long || signed_long || unsigned_fallback) max = 2147483647; + } + return { + get: function() { + var v = this._getattr(a.name); + var n = a.float ? parseFloat(v) : parseInt(v, 10); + if (v === null || !isFinite(n) || min !== void 0 && n < min || max !== void 0 && n > max) { + return def.call(this); + } + if (unsigned_long || signed_long || unsigned_fallback) { + if (!/^[ \t\n\f\r]*[-+]?[0-9]/.test(v)) { + return def.call(this); + } + n = n | 0; + } + return n; + }, + set: function(v) { + if (!a.float) { + v = Math.floor(v); + } + if (setmin !== void 0 && v < setmin) { + utils.IndexSizeError(a.name + " set to " + v); + } + if (unsigned_long) { + v = v < 0 || v > 2147483647 ? def.call(this) : v | 0; + } else if (unsigned_fallback) { + v = v < 1 || v > 2147483647 ? def.call(this) : v | 0; + } else if (signed_long) { + v = v < -2147483648 || v > 2147483647 ? def.call(this) : v | 0; + } + this._setattr(a.name, String(v)); + } + }; + } + exports.registerChangeHandler = function(c, name, handler2) { + var p = c.prototype; + if (!Object.prototype.hasOwnProperty.call(p, "_attributeChangeHandlers")) { + p._attributeChangeHandlers = Object.create(p._attributeChangeHandlers || null); + } + p._attributeChangeHandlers[name] = handler2; + }; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/FilteredElementList.js +var require_FilteredElementList = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/FilteredElementList.js"(exports, module) { + "use strict"; + module.exports = FilteredElementList; + var Node = require_Node(); + function FilteredElementList(root2, filter) { + this.root = root2; + this.filter = filter; + this.lastModTime = root2.lastModTime; + this.done = false; + this.cache = []; + this.traverse(); + } + FilteredElementList.prototype = Object.create(Object.prototype, { + length: { get: function() { + this.checkcache(); + if (!this.done) this.traverse(); + return this.cache.length; + } }, + item: { value: function(n) { + this.checkcache(); + if (!this.done && n >= this.cache.length) { + this.traverse( + /*n*/ + ); + } + return this.cache[n]; + } }, + checkcache: { value: function() { + if (this.lastModTime !== this.root.lastModTime) { + for (var i = this.cache.length - 1; i >= 0; i--) { + this[i] = void 0; + } + this.cache.length = 0; + this.done = false; + this.lastModTime = this.root.lastModTime; + } + } }, + // If n is specified, then traverse the tree until we've found the nth + // item (or until we've found all items). If n is not specified, + // traverse until we've found all items. + traverse: { value: function(n) { + if (n !== void 0) n++; + var elt; + while ((elt = this.next()) !== null) { + this[this.cache.length] = elt; + this.cache.push(elt); + if (n && this.cache.length === n) return; + } + this.done = true; + } }, + // Return the next element under root that matches filter + next: { value: function() { + var start = this.cache.length === 0 ? this.root : this.cache[this.cache.length - 1]; + var elt; + if (start.nodeType === Node.DOCUMENT_NODE) + elt = start.documentElement; + else + elt = start.nextElement(this.root); + while (elt) { + if (this.filter(elt)) { + return elt; + } + elt = elt.nextElement(this.root); + } + return null; + } } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/DOMTokenList.js +var require_DOMTokenList = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/DOMTokenList.js"(exports, module) { + "use strict"; + var utils = require_utils8(); + module.exports = DOMTokenList; + function DOMTokenList(getter, setter) { + this._getString = getter; + this._setString = setter; + this._length = 0; + this._lastStringValue = ""; + this._update(); + } + Object.defineProperties(DOMTokenList.prototype, { + length: { get: function() { + return this._length; + } }, + item: { value: function(index) { + var list = getList(this); + if (index < 0 || index >= list.length) { + return null; + } + return list[index]; + } }, + contains: { value: function(token) { + token = String(token); + var list = getList(this); + return list.indexOf(token) > -1; + } }, + add: { value: function() { + var list = getList(this); + for (var i = 0, len = arguments.length; i < len; i++) { + var token = handleErrors(arguments[i]); + if (list.indexOf(token) < 0) { + list.push(token); + } + } + this._update(list); + } }, + remove: { value: function() { + var list = getList(this); + for (var i = 0, len = arguments.length; i < len; i++) { + var token = handleErrors(arguments[i]); + var index = list.indexOf(token); + if (index > -1) { + list.splice(index, 1); + } + } + this._update(list); + } }, + toggle: { value: function toggle(token, force) { + token = handleErrors(token); + if (this.contains(token)) { + if (force === void 0 || force === false) { + this.remove(token); + return false; + } + return true; + } else { + if (force === void 0 || force === true) { + this.add(token); + return true; + } + return false; + } + } }, + replace: { value: function replace(token, newToken) { + if (String(newToken) === "") { + utils.SyntaxError(); + } + token = handleErrors(token); + newToken = handleErrors(newToken); + var list = getList(this); + var idx = list.indexOf(token); + if (idx < 0) { + return false; + } + var idx2 = list.indexOf(newToken); + if (idx2 < 0) { + list[idx] = newToken; + } else { + if (idx < idx2) { + list[idx] = newToken; + list.splice(idx2, 1); + } else { + list.splice(idx, 1); + } + } + this._update(list); + return true; + } }, + toString: { value: function() { + return this._getString(); + } }, + value: { + get: function() { + return this._getString(); + }, + set: function(v) { + this._setString(v); + this._update(); + } + }, + // Called when the setter is called from outside this interface. + _update: { value: function(list) { + if (list) { + fixIndex(this, list); + this._setString(list.join(" ").trim()); + } else { + fixIndex(this, getList(this)); + } + this._lastStringValue = this._getString(); + } } + }); + function fixIndex(clist, list) { + var oldLength = clist._length; + var i; + clist._length = list.length; + for (i = 0; i < list.length; i++) { + clist[i] = list[i]; + } + for (; i < oldLength; i++) { + clist[i] = void 0; + } + } + function handleErrors(token) { + token = String(token); + if (token === "") { + utils.SyntaxError(); + } + if (/[ \t\r\n\f]/.test(token)) { + utils.InvalidCharacterError(); + } + return token; + } + function toArray(clist) { + var length = clist._length; + var arr = Array(length); + for (var i = 0; i < length; i++) { + arr[i] = clist[i]; + } + return arr; + } + function getList(clist) { + var strProp = clist._getString(); + if (strProp === clist._lastStringValue) { + return toArray(clist); + } + var str = strProp.replace(/(^[ \t\r\n\f]+)|([ \t\r\n\f]+$)/g, ""); + if (str === "") { + return []; + } else { + var seen = /* @__PURE__ */ Object.create(null); + return str.split(/[ \t\r\n\f]+/g).filter(function(n) { + var key = "$" + n; + if (seen[key]) { + return false; + } + seen[key] = true; + return true; + }); + } + } + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/select.js +var require_select = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/select.js"(exports, module) { + "use strict"; + var window2 = Object.create(null, { + location: { get: function() { + throw new Error("window.location is not supported."); + } } + }); + var compareDocumentPosition = function(a, b) { + return a.compareDocumentPosition(b); + }; + var order = function(a, b) { + return compareDocumentPosition(a, b) & 2 ? 1 : -1; + }; + var next2 = function(el) { + while ((el = el.nextSibling) && el.nodeType !== 1) ; + return el; + }; + var prev = function(el) { + while ((el = el.previousSibling) && el.nodeType !== 1) ; + return el; + }; + var child = function(el) { + if (el = el.firstChild) { + while (el.nodeType !== 1 && (el = el.nextSibling)) ; + } + return el; + }; + var lastChild = function(el) { + if (el = el.lastChild) { + while (el.nodeType !== 1 && (el = el.previousSibling)) ; + } + return el; + }; + var parentIsElement = function(n) { + if (!n.parentNode) { + return false; + } + var nodeType = n.parentNode.nodeType; + return nodeType === 1 || nodeType === 9; + }; + var unquote = function(str) { + if (!str) return str; + var ch = str[0]; + if (ch === '"' || ch === "'") { + if (str[str.length - 1] === ch) { + str = str.slice(1, -1); + } else { + str = str.slice(1); + } + return str.replace(rules.str_escape, function(s) { + var m = /^\\(?:([0-9A-Fa-f]+)|([\r\n\f]+))/.exec(s); + if (!m) { + return s.slice(1); + } + if (m[2]) { + return ""; + } + var cp = parseInt(m[1], 16); + return String.fromCodePoint ? String.fromCodePoint(cp) : ( + // Not all JavaScript implementations have String.fromCodePoint yet. + String.fromCharCode(cp) + ); + }); + } else if (rules.ident.test(str)) { + return decodeid(str); + } else { + return str; + } + }; + var decodeid = function(str) { + return str.replace(rules.escape, function(s) { + var m = /^\\([0-9A-Fa-f]+)/.exec(s); + if (!m) { + return s[1]; + } + var cp = parseInt(m[1], 16); + return String.fromCodePoint ? String.fromCodePoint(cp) : ( + // Not all JavaScript implementations have String.fromCodePoint yet. + String.fromCharCode(cp) + ); + }); + }; + var indexOf = (function() { + if (Array.prototype.indexOf) { + return Array.prototype.indexOf; + } + return function(obj, item) { + var i = this.length; + while (i--) { + if (this[i] === item) return i; + } + return -1; + }; + })(); + var makeInside = function(start, end) { + var regex4 = rules.inside.source.replace(//g, end); + return new RegExp(regex4); + }; + var replace = function(regex4, name, val) { + regex4 = regex4.source; + regex4 = regex4.replace(name, val.source || val); + return new RegExp(regex4); + }; + var truncateUrl = function(url4, num) { + return url4.replace(/^(?:\w+:\/\/|\/+)/, "").replace(/(?:\/+|\/*#.*?)$/, "").split("/", num).join("/"); + }; + var parseNth = function(param_, test) { + var param = param_.replace(/\s+/g, ""), cap; + if (param === "even") { + param = "2n+0"; + } else if (param === "odd") { + param = "2n+1"; + } else if (param.indexOf("n") === -1) { + param = "0n" + param; + } + cap = /^([+-])?(\d+)?n([+-])?(\d+)?$/.exec(param); + return { + group: cap[1] === "-" ? -(cap[2] || 1) : +(cap[2] || 1), + offset: cap[4] ? cap[3] === "-" ? -cap[4] : +cap[4] : 0 + }; + }; + var nth = function(param_, test, last) { + var param = parseNth(param_), group2 = param.group, offset = param.offset, find2 = !last ? child : lastChild, advance = !last ? next2 : prev; + return function(el) { + if (!parentIsElement(el)) return; + var rel = find2(el.parentNode), pos = 0; + while (rel) { + if (test(rel, el)) pos++; + if (rel === el) { + pos -= offset; + return group2 && pos ? pos % group2 === 0 && pos < 0 === group2 < 0 : !pos; + } + rel = advance(rel); + } + }; + }; + var selectors = { + "*": (function() { + if (false) { + return function(el) { + if (el.nodeType === 1) return true; + }; + } + return function() { + return true; + }; + })(), + "type": function(type2) { + type2 = type2.toLowerCase(); + return function(el) { + return el.nodeName.toLowerCase() === type2; + }; + }, + "attr": function(key, op, val, i) { + op = operators[op]; + return function(el) { + var attr; + switch (key) { + case "for": + attr = el.htmlFor; + break; + case "class": + attr = el.className; + if (attr === "" && el.getAttribute("class") == null) { + attr = null; + } + break; + case "href": + case "src": + attr = el.getAttribute(key, 2); + break; + case "title": + attr = el.getAttribute("title") || null; + break; + // careful with attributes with special getter functions + case "id": + case "lang": + case "dir": + case "accessKey": + case "hidden": + case "tabIndex": + case "style": + if (el.getAttribute) { + attr = el.getAttribute(key); + break; + } + /* falls through */ + default: + if (el.hasAttribute && !el.hasAttribute(key)) { + break; + } + attr = el[key] != null ? el[key] : el.getAttribute && el.getAttribute(key); + break; + } + if (attr == null) return; + attr = attr + ""; + if (i) { + attr = attr.toLowerCase(); + val = val.toLowerCase(); + } + return op(attr, val); + }; + }, + ":first-child": function(el) { + return !prev(el) && parentIsElement(el); + }, + ":last-child": function(el) { + return !next2(el) && parentIsElement(el); + }, + ":only-child": function(el) { + return !prev(el) && !next2(el) && parentIsElement(el); + }, + ":nth-child": function(param, last) { + return nth(param, function() { + return true; + }, last); + }, + ":nth-last-child": function(param) { + return selectors[":nth-child"](param, true); + }, + ":root": function(el) { + return el.ownerDocument.documentElement === el; + }, + ":empty": function(el) { + return !el.firstChild; + }, + ":not": function(sel) { + var test = compileGroup(sel); + return function(el) { + return !test(el); + }; + }, + ":first-of-type": function(el) { + if (!parentIsElement(el)) return; + var type2 = el.nodeName; + while (el = prev(el)) { + if (el.nodeName === type2) return; + } + return true; + }, + ":last-of-type": function(el) { + if (!parentIsElement(el)) return; + var type2 = el.nodeName; + while (el = next2(el)) { + if (el.nodeName === type2) return; + } + return true; + }, + ":only-of-type": function(el) { + return selectors[":first-of-type"](el) && selectors[":last-of-type"](el); + }, + ":nth-of-type": function(param, last) { + return nth(param, function(rel, el) { + return rel.nodeName === el.nodeName; + }, last); + }, + ":nth-last-of-type": function(param) { + return selectors[":nth-of-type"](param, true); + }, + ":checked": function(el) { + return !!(el.checked || el.selected); + }, + ":indeterminate": function(el) { + return !selectors[":checked"](el); + }, + ":enabled": function(el) { + return !el.disabled && el.type !== "hidden"; + }, + ":disabled": function(el) { + return !!el.disabled; + }, + ":target": function(el) { + return el.id === window2.location.hash.substring(1); + }, + ":focus": function(el) { + return el === el.ownerDocument.activeElement; + }, + ":is": function(sel) { + return compileGroup(sel); + }, + // :matches is an older name for :is; see + // https://github.com/w3c/csswg-drafts/issues/3258 + ":matches": function(sel) { + return selectors[":is"](sel); + }, + ":nth-match": function(param, last) { + var args3 = param.split(/\s*,\s*/), arg = args3.shift(), test = compileGroup(args3.join(",")); + return nth(arg, test, last); + }, + ":nth-last-match": function(param) { + return selectors[":nth-match"](param, true); + }, + ":links-here": function(el) { + return el + "" === window2.location + ""; + }, + ":lang": function(param) { + return function(el) { + while (el) { + if (el.lang) return el.lang.indexOf(param) === 0; + el = el.parentNode; + } + }; + }, + ":dir": function(param) { + return function(el) { + while (el) { + if (el.dir) return el.dir === param; + el = el.parentNode; + } + }; + }, + ":scope": function(el, con) { + var context = con || el.ownerDocument; + if (context.nodeType === 9) { + return el === context.documentElement; + } + return el === context; + }, + ":any-link": function(el) { + return typeof el.href === "string"; + }, + ":local-link": function(el) { + if (el.nodeName) { + return el.href && el.host === window2.location.host; + } + var param = +el + 1; + return function(el2) { + if (!el2.href) return; + var url4 = window2.location + "", href = el2 + ""; + return truncateUrl(url4, param) === truncateUrl(href, param); + }; + }, + ":default": function(el) { + return !!el.defaultSelected; + }, + ":valid": function(el) { + return el.willValidate || el.validity && el.validity.valid; + }, + ":invalid": function(el) { + return !selectors[":valid"](el); + }, + ":in-range": function(el) { + return el.value > el.min && el.value <= el.max; + }, + ":out-of-range": function(el) { + return !selectors[":in-range"](el); + }, + ":required": function(el) { + return !!el.required; + }, + ":optional": function(el) { + return !el.required; + }, + ":read-only": function(el) { + if (el.readOnly) return true; + var attr = el.getAttribute("contenteditable"), prop = el.contentEditable, name = el.nodeName.toLowerCase(); + name = name !== "input" && name !== "textarea"; + return (name || el.disabled) && attr == null && prop !== "true"; + }, + ":read-write": function(el) { + return !selectors[":read-only"](el); + }, + ":hover": function() { + throw new Error(":hover is not supported."); + }, + ":active": function() { + throw new Error(":active is not supported."); + }, + ":link": function() { + throw new Error(":link is not supported."); + }, + ":visited": function() { + throw new Error(":visited is not supported."); + }, + ":column": function() { + throw new Error(":column is not supported."); + }, + ":nth-column": function() { + throw new Error(":nth-column is not supported."); + }, + ":nth-last-column": function() { + throw new Error(":nth-last-column is not supported."); + }, + ":current": function() { + throw new Error(":current is not supported."); + }, + ":past": function() { + throw new Error(":past is not supported."); + }, + ":future": function() { + throw new Error(":future is not supported."); + }, + // Non-standard, for compatibility purposes. + ":contains": function(param) { + return function(el) { + var text = el.innerText || el.textContent || el.value || ""; + return text.indexOf(param) !== -1; + }; + }, + ":has": function(param) { + return function(el) { + return find(param, el).length > 0; + }; + } + // Potentially add more pseudo selectors for + // compatibility with sizzle and most other + // selector engines (?). + }; + var operators = { + "-": function() { + return true; + }, + "=": function(attr, val) { + return attr === val; + }, + "*=": function(attr, val) { + return attr.indexOf(val) !== -1; + }, + "~=": function(attr, val) { + var i, s, f, l; + for (s = 0; true; s = i + 1) { + i = attr.indexOf(val, s); + if (i === -1) return false; + f = attr[i - 1]; + l = attr[i + val.length]; + if ((!f || f === " ") && (!l || l === " ")) return true; + } + }, + "|=": function(attr, val) { + var i = attr.indexOf(val), l; + if (i !== 0) return; + l = attr[i + val.length]; + return l === "-" || !l; + }, + "^=": function(attr, val) { + return attr.indexOf(val) === 0; + }, + "$=": function(attr, val) { + var i = attr.lastIndexOf(val); + return i !== -1 && i + val.length === attr.length; + }, + // non-standard + "!=": function(attr, val) { + return attr !== val; + } + }; + var combinators = { + " ": function(test) { + return function(el) { + while (el = el.parentNode) { + if (test(el)) return el; + } + }; + }, + ">": function(test) { + return function(el) { + if (el = el.parentNode) { + return test(el) && el; + } + }; + }, + "+": function(test) { + return function(el) { + if (el = prev(el)) { + return test(el) && el; + } + }; + }, + "~": function(test) { + return function(el) { + while (el = prev(el)) { + if (test(el)) return el; + } + }; + }, + "noop": function(test) { + return function(el) { + return test(el) && el; + }; + }, + "ref": function(test, name) { + var node2; + function ref(el) { + var doc = el.ownerDocument, nodes = doc.getElementsByTagName("*"), i = nodes.length; + while (i--) { + node2 = nodes[i]; + if (ref.test(el)) { + node2 = null; + return true; + } + } + node2 = null; + } + ref.combinator = function(el) { + if (!node2 || !node2.getAttribute) return; + var attr = node2.getAttribute(name) || ""; + if (attr[0] === "#") attr = attr.substring(1); + if (attr === el.id && test(node2)) { + return node2; + } + }; + return ref; + } + }; + var rules = { + escape: /\\(?:[^0-9A-Fa-f\r\n]|[0-9A-Fa-f]{1,6}[\r\n\t ]?)/g, + str_escape: /(escape)|\\(\n|\r\n?|\f)/g, + nonascii: /[\u00A0-\uFFFF]/, + cssid: /(?:(?!-?[0-9])(?:escape|nonascii|[-_a-zA-Z0-9])+)/, + qname: /^ *(cssid|\*)/, + simple: /^(?:([.#]cssid)|pseudo|attr)/, + ref: /^ *\/(cssid)\/ */, + combinator: /^(?: +([^ \w*.#\\]) +|( )+|([^ \w*.#\\]))(?! *$)/, + attr: /^\[(cssid)(?:([^\w]?=)(inside))?\]/, + pseudo: /^(:cssid)(?:\((inside)\))?/, + inside: /(?:"(?:\\"|[^"])*"|'(?:\\'|[^'])*'|<[^"'>]*>|\\["'>]|[^"'>])*/, + ident: /^(cssid)$/ + }; + rules.cssid = replace(rules.cssid, "nonascii", rules.nonascii); + rules.cssid = replace(rules.cssid, "escape", rules.escape); + rules.qname = replace(rules.qname, "cssid", rules.cssid); + rules.simple = replace(rules.simple, "cssid", rules.cssid); + rules.ref = replace(rules.ref, "cssid", rules.cssid); + rules.attr = replace(rules.attr, "cssid", rules.cssid); + rules.pseudo = replace(rules.pseudo, "cssid", rules.cssid); + rules.inside = replace(rules.inside, `[^"'>]*`, rules.inside); + rules.attr = replace(rules.attr, "inside", makeInside("\\[", "\\]")); + rules.pseudo = replace(rules.pseudo, "inside", makeInside("\\(", "\\)")); + rules.simple = replace(rules.simple, "pseudo", rules.pseudo); + rules.simple = replace(rules.simple, "attr", rules.attr); + rules.ident = replace(rules.ident, "cssid", rules.cssid); + rules.str_escape = replace(rules.str_escape, "escape", rules.escape); + var compile = function(sel_) { + var sel = sel_.replace(/^\s+|\s+$/g, ""), test, filter = [], buff = [], subject, qname, cap, op, ref; + while (sel) { + if (cap = rules.qname.exec(sel)) { + sel = sel.substring(cap[0].length); + qname = decodeid(cap[1]); + buff.push(tok(qname, true)); + } else if (cap = rules.simple.exec(sel)) { + sel = sel.substring(cap[0].length); + qname = "*"; + buff.push(tok(qname, true)); + buff.push(tok(cap)); + } else { + throw new SyntaxError("Invalid selector."); + } + while (cap = rules.simple.exec(sel)) { + sel = sel.substring(cap[0].length); + buff.push(tok(cap)); + } + if (sel[0] === "!") { + sel = sel.substring(1); + subject = makeSubject(); + subject.qname = qname; + buff.push(subject.simple); + } + if (cap = rules.ref.exec(sel)) { + sel = sel.substring(cap[0].length); + ref = combinators.ref(makeSimple(buff), decodeid(cap[1])); + filter.push(ref.combinator); + buff = []; + continue; + } + if (cap = rules.combinator.exec(sel)) { + sel = sel.substring(cap[0].length); + op = cap[1] || cap[2] || cap[3]; + if (op === ",") { + filter.push(combinators.noop(makeSimple(buff))); + break; + } + } else { + op = "noop"; + } + if (!combinators[op]) { + throw new SyntaxError("Bad combinator."); + } + filter.push(combinators[op](makeSimple(buff))); + buff = []; + } + test = makeTest(filter); + test.qname = qname; + test.sel = sel; + if (subject) { + subject.lname = test.qname; + subject.test = test; + subject.qname = subject.qname; + subject.sel = test.sel; + test = subject; + } + if (ref) { + ref.test = test; + ref.qname = test.qname; + ref.sel = test.sel; + test = ref; + } + return test; + }; + var tok = function(cap, qname) { + if (qname) { + return cap === "*" ? selectors["*"] : selectors.type(cap); + } + if (cap[1]) { + return cap[1][0] === "." ? selectors.attr("class", "~=", decodeid(cap[1].substring(1)), false) : selectors.attr("id", "=", decodeid(cap[1].substring(1)), false); + } + if (cap[2]) { + return cap[3] ? selectors[decodeid(cap[2])](unquote(cap[3])) : selectors[decodeid(cap[2])]; + } + if (cap[4]) { + var value2 = cap[6]; + var i = /["'\s]\s*I$/i.test(value2); + if (i) { + value2 = value2.replace(/\s*I$/i, ""); + } + return selectors.attr(decodeid(cap[4]), cap[5] || "-", unquote(value2), i); + } + throw new SyntaxError("Unknown Selector."); + }; + var makeSimple = function(func) { + var l = func.length, i; + if (l < 2) return func[0]; + return function(el) { + if (!el) return; + for (i = 0; i < l; i++) { + if (!func[i](el)) return; + } + return true; + }; + }; + var makeTest = function(func) { + if (func.length < 2) { + return function(el) { + return !!func[0](el); + }; + } + return function(el) { + var i = func.length; + while (i--) { + if (!(el = func[i](el))) return; + } + return true; + }; + }; + var makeSubject = function() { + var target; + function subject(el) { + var node2 = el.ownerDocument, scope2 = node2.getElementsByTagName(subject.lname), i = scope2.length; + while (i--) { + if (subject.test(scope2[i]) && target === el) { + target = null; + return true; + } + } + target = null; + } + subject.simple = function(el) { + target = el; + return true; + }; + return subject; + }; + var compileGroup = function(sel) { + var test = compile(sel), tests = [test]; + while (test.sel) { + test = compile(test.sel); + tests.push(test); + } + if (tests.length < 2) return test; + return function(el) { + var l = tests.length, i = 0; + for (; i < l; i++) { + if (tests[i](el)) return true; + } + }; + }; + var find = function(sel, node2) { + var results = [], test = compile(sel), scope2 = node2.getElementsByTagName(test.qname), i = 0, el; + while (el = scope2[i++]) { + if (test(el)) results.push(el); + } + if (test.sel) { + while (test.sel) { + test = compile(test.sel); + scope2 = node2.getElementsByTagName(test.qname); + i = 0; + while (el = scope2[i++]) { + if (test(el) && indexOf.call(results, el) === -1) { + results.push(el); + } + } + } + results.sort(order); + } + return results; + }; + module.exports = exports = function(sel, context) { + var id, r; + if (context.nodeType !== 11 && sel.indexOf(" ") === -1) { + if (sel[0] === "#" && context.rooted && /^#[A-Z_][-A-Z0-9_]*$/i.test(sel)) { + if (context.doc._hasMultipleElementsWithId) { + id = sel.substring(1); + if (!context.doc._hasMultipleElementsWithId(id)) { + r = context.doc.getElementById(id); + return r ? [r] : []; + } + } + } + if (sel[0] === "." && /^\.\w+$/.test(sel)) { + return context.getElementsByClassName(sel.substring(1)); + } + if (/^\w+$/.test(sel)) { + return context.getElementsByTagName(sel); + } + } + return find(sel, context); + }; + exports.selectors = selectors; + exports.operators = operators; + exports.combinators = combinators; + exports.matches = function(el, sel) { + var test = { sel }; + do { + test = compile(test.sel); + if (test(el)) { + return true; + } + } while (test.sel); + return false; + }; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/ChildNode.js +var require_ChildNode = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/ChildNode.js"(exports, module) { + "use strict"; + var Node = require_Node(); + var LinkedList = require_LinkedList(); + var createDocumentFragmentFromArguments = function(document, args3) { + var docFrag = document.createDocumentFragment(); + for (var i = 0; i < args3.length; i++) { + var argItem = args3[i]; + var isNode2 = argItem instanceof Node; + docFrag.appendChild(isNode2 ? argItem : document.createTextNode(String(argItem))); + } + return docFrag; + }; + var ChildNode = { + // Inserts a set of Node or String objects in the children list of this + // ChildNode's parent, just after this ChildNode. String objects are + // inserted as the equivalent Text nodes. + after: { value: function after() { + var argArr = Array.prototype.slice.call(arguments); + var parentNode = this.parentNode, nextSibling = this.nextSibling; + if (parentNode === null) { + return; + } + while (nextSibling && argArr.some(function(v) { + return v === nextSibling; + })) + nextSibling = nextSibling.nextSibling; + var docFrag = createDocumentFragmentFromArguments(this.doc, argArr); + parentNode.insertBefore(docFrag, nextSibling); + } }, + // Inserts a set of Node or String objects in the children list of this + // ChildNode's parent, just before this ChildNode. String objects are + // inserted as the equivalent Text nodes. + before: { value: function before() { + var argArr = Array.prototype.slice.call(arguments); + var parentNode = this.parentNode, prevSibling = this.previousSibling; + if (parentNode === null) { + return; + } + while (prevSibling && argArr.some(function(v) { + return v === prevSibling; + })) + prevSibling = prevSibling.previousSibling; + var docFrag = createDocumentFragmentFromArguments(this.doc, argArr); + var nextSibling = prevSibling ? prevSibling.nextSibling : parentNode.firstChild; + parentNode.insertBefore(docFrag, nextSibling); + } }, + // Remove this node from its parent + remove: { value: function remove() { + if (this.parentNode === null) return; + if (this.doc) { + this.doc._preremoveNodeIterators(this); + if (this.rooted) { + this.doc.mutateRemove(this); + } + } + this._remove(); + this.parentNode = null; + } }, + // Remove this node w/o uprooting or sending mutation events + // (But do update the structure id for all ancestors) + _remove: { value: function _remove() { + var parent = this.parentNode; + if (parent === null) return; + if (parent._childNodes) { + parent._childNodes.splice(this.index, 1); + } else if (parent._firstChild === this) { + if (this._nextSibling === this) { + parent._firstChild = null; + } else { + parent._firstChild = this._nextSibling; + } + } + LinkedList.remove(this); + parent.modify(); + } }, + // Replace this node with the nodes or strings provided as arguments. + replaceWith: { value: function replaceWith() { + var argArr = Array.prototype.slice.call(arguments); + var parentNode = this.parentNode, nextSibling = this.nextSibling; + if (parentNode === null) { + return; + } + while (nextSibling && argArr.some(function(v) { + return v === nextSibling; + })) + nextSibling = nextSibling.nextSibling; + var docFrag = createDocumentFragmentFromArguments(this.doc, argArr); + if (this.parentNode === parentNode) { + parentNode.replaceChild(docFrag, this); + } else { + parentNode.insertBefore(docFrag, nextSibling); + } + } } + }; + module.exports = ChildNode; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NonDocumentTypeChildNode.js +var require_NonDocumentTypeChildNode = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NonDocumentTypeChildNode.js"(exports, module) { + "use strict"; + var Node = require_Node(); + var NonDocumentTypeChildNode = { + nextElementSibling: { get: function() { + if (this.parentNode) { + for (var kid = this.nextSibling; kid !== null; kid = kid.nextSibling) { + if (kid.nodeType === Node.ELEMENT_NODE) return kid; + } + } + return null; + } }, + previousElementSibling: { get: function() { + if (this.parentNode) { + for (var kid = this.previousSibling; kid !== null; kid = kid.previousSibling) { + if (kid.nodeType === Node.ELEMENT_NODE) return kid; + } + } + return null; + } } + }; + module.exports = NonDocumentTypeChildNode; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NamedNodeMap.js +var require_NamedNodeMap = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NamedNodeMap.js"(exports, module) { + "use strict"; + module.exports = NamedNodeMap; + var utils = require_utils8(); + function NamedNodeMap(element) { + this.element = element; + } + Object.defineProperties(NamedNodeMap.prototype, { + length: { get: utils.shouldOverride }, + item: { value: utils.shouldOverride }, + getNamedItem: { value: function getNamedItem(qualifiedName) { + return this.element.getAttributeNode(qualifiedName); + } }, + getNamedItemNS: { value: function getNamedItemNS(namespace, localName) { + return this.element.getAttributeNodeNS(namespace, localName); + } }, + setNamedItem: { value: utils.nyi }, + setNamedItemNS: { value: utils.nyi }, + removeNamedItem: { value: function removeNamedItem(qualifiedName) { + var attr = this.element.getAttributeNode(qualifiedName); + if (attr) { + this.element.removeAttribute(qualifiedName); + return attr; + } + utils.NotFoundError(); + } }, + removeNamedItemNS: { value: function removeNamedItemNS(ns, lname) { + var attr = this.element.getAttributeNodeNS(ns, lname); + if (attr) { + this.element.removeAttributeNS(ns, lname); + return attr; + } + utils.NotFoundError(); + } } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Element.js +var require_Element = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Element.js"(exports, module) { + "use strict"; + module.exports = Element; + var xml = require_xmlnames(); + var utils = require_utils8(); + var NAMESPACE = utils.NAMESPACE; + var attributes = require_attributes(); + var Node = require_Node(); + var NodeList = require_NodeList(); + var NodeUtils = require_NodeUtils(); + var FilteredElementList = require_FilteredElementList(); + var DOMException2 = require_DOMException(); + var DOMTokenList = require_DOMTokenList(); + var select = require_select(); + var ContainerNode = require_ContainerNode(); + var ChildNode = require_ChildNode(); + var NonDocumentTypeChildNode = require_NonDocumentTypeChildNode(); + var NamedNodeMap = require_NamedNodeMap(); + var uppercaseCache = /* @__PURE__ */ Object.create(null); + function Element(doc, localName, namespaceURI, prefix) { + ContainerNode.call(this); + this.nodeType = Node.ELEMENT_NODE; + this.ownerDocument = doc; + this.localName = localName; + this.namespaceURI = namespaceURI; + this.prefix = prefix; + this._tagName = void 0; + this._attrsByQName = /* @__PURE__ */ Object.create(null); + this._attrsByLName = /* @__PURE__ */ Object.create(null); + this._attrKeys = []; + } + function recursiveGetText(node2, a) { + if (node2.nodeType === Node.TEXT_NODE) { + a.push(node2._data); + } else { + for (var i = 0, n = node2.childNodes.length; i < n; i++) + recursiveGetText(node2.childNodes[i], a); + } + } + Element.prototype = Object.create(ContainerNode.prototype, { + isHTML: { get: function isHTML() { + return this.namespaceURI === NAMESPACE.HTML && this.ownerDocument.isHTML; + } }, + tagName: { get: function tagName() { + if (this._tagName === void 0) { + var tn; + if (this.prefix === null) { + tn = this.localName; + } else { + tn = this.prefix + ":" + this.localName; + } + if (this.isHTML) { + var up = uppercaseCache[tn]; + if (!up) { + uppercaseCache[tn] = up = utils.toASCIIUpperCase(tn); + } + tn = up; + } + this._tagName = tn; + } + return this._tagName; + } }, + nodeName: { get: function() { + return this.tagName; + } }, + nodeValue: { + get: function() { + return null; + }, + set: function() { + } + }, + textContent: { + get: function() { + var strings = []; + recursiveGetText(this, strings); + return strings.join(""); + }, + set: function(newtext) { + this.removeChildren(); + if (newtext !== null && newtext !== void 0 && newtext !== "") { + this._appendChild(this.ownerDocument.createTextNode(newtext)); + } + } + }, + innerText: { + get: function() { + var strings = []; + recursiveGetText(this, strings); + return strings.join("").replace(/[ \t\n\f\r]+/g, " ").trim(); + }, + set: function(newtext) { + this.removeChildren(); + if (newtext !== null && newtext !== void 0 && newtext !== "") { + this._appendChild(this.ownerDocument.createTextNode(newtext)); + } + } + }, + innerHTML: { + get: function() { + return this.serialize(); + }, + set: utils.nyi + }, + outerHTML: { + get: function() { + return NodeUtils.serializeOne(this, { nodeType: 0 }); + }, + set: function(v) { + var document = this.ownerDocument; + var parent = this.parentNode; + if (parent === null) { + return; + } + if (parent.nodeType === Node.DOCUMENT_NODE) { + utils.NoModificationAllowedError(); + } + if (parent.nodeType === Node.DOCUMENT_FRAGMENT_NODE) { + parent = parent.ownerDocument.createElement("body"); + } + var parser = document.implementation.mozHTMLParser( + document._address, + parent + ); + parser.parse(v === null ? "" : String(v), true); + this.replaceWith(parser._asDocumentFragment()); + } + }, + _insertAdjacent: { value: function _insertAdjacent(position, node2) { + var first = false; + switch (position) { + case "beforebegin": + first = true; + /* falls through */ + case "afterend": + var parent = this.parentNode; + if (parent === null) { + return null; + } + return parent.insertBefore(node2, first ? this : this.nextSibling); + case "afterbegin": + first = true; + /* falls through */ + case "beforeend": + return this.insertBefore(node2, first ? this.firstChild : null); + default: + return utils.SyntaxError(); + } + } }, + insertAdjacentElement: { value: function insertAdjacentElement(position, element) { + if (element.nodeType !== Node.ELEMENT_NODE) { + throw new TypeError("not an element"); + } + position = utils.toASCIILowerCase(String(position)); + return this._insertAdjacent(position, element); + } }, + insertAdjacentText: { value: function insertAdjacentText(position, data) { + var textNode = this.ownerDocument.createTextNode(data); + position = utils.toASCIILowerCase(String(position)); + this._insertAdjacent(position, textNode); + } }, + insertAdjacentHTML: { value: function insertAdjacentHTML(position, text) { + position = utils.toASCIILowerCase(String(position)); + text = String(text); + var context; + switch (position) { + case "beforebegin": + case "afterend": + context = this.parentNode; + if (context === null || context.nodeType === Node.DOCUMENT_NODE) { + utils.NoModificationAllowedError(); + } + break; + case "afterbegin": + case "beforeend": + context = this; + break; + default: + utils.SyntaxError(); + } + if (!(context instanceof Element) || context.ownerDocument.isHTML && context.localName === "html" && context.namespaceURI === NAMESPACE.HTML) { + context = context.ownerDocument.createElementNS(NAMESPACE.HTML, "body"); + } + var parser = this.ownerDocument.implementation.mozHTMLParser( + this.ownerDocument._address, + context + ); + parser.parse(text, true); + this._insertAdjacent(position, parser._asDocumentFragment()); + } }, + children: { get: function() { + if (!this._children) { + this._children = new ChildrenCollection(this); + } + return this._children; + } }, + attributes: { get: function() { + if (!this._attributes) { + this._attributes = new AttributesArray(this); + } + return this._attributes; + } }, + firstElementChild: { get: function() { + for (var kid = this.firstChild; kid !== null; kid = kid.nextSibling) { + if (kid.nodeType === Node.ELEMENT_NODE) return kid; + } + return null; + } }, + lastElementChild: { get: function() { + for (var kid = this.lastChild; kid !== null; kid = kid.previousSibling) { + if (kid.nodeType === Node.ELEMENT_NODE) return kid; + } + return null; + } }, + childElementCount: { get: function() { + return this.children.length; + } }, + // Return the next element, in source order, after this one or + // null if there are no more. If root element is specified, + // then don't traverse beyond its subtree. + // + // This is not a DOM method, but is convenient for + // lazy traversals of the tree. + nextElement: { value: function(root2) { + if (!root2) root2 = this.ownerDocument.documentElement; + var next2 = this.firstElementChild; + if (!next2) { + if (this === root2) return null; + next2 = this.nextElementSibling; + } + if (next2) return next2; + for (var parent = this.parentElement; parent && parent !== root2; parent = parent.parentElement) { + next2 = parent.nextElementSibling; + if (next2) return next2; + } + return null; + } }, + // XXX: + // Tests are currently failing for this function. + // Awaiting resolution of: + // http://lists.w3.org/Archives/Public/www-dom/2011JulSep/0016.html + getElementsByTagName: { value: function getElementsByTagName(lname) { + var filter; + if (!lname) return new NodeList(); + if (lname === "*") + filter = function() { + return true; + }; + else if (this.isHTML) + filter = htmlLocalNameElementFilter(lname); + else + filter = localNameElementFilter(lname); + return new FilteredElementList(this, filter); + } }, + getElementsByTagNameNS: { value: function getElementsByTagNameNS(ns, lname) { + var filter; + if (ns === "*" && lname === "*") + filter = function() { + return true; + }; + else if (ns === "*") + filter = localNameElementFilter(lname); + else if (lname === "*") + filter = namespaceElementFilter(ns); + else + filter = namespaceLocalNameElementFilter(ns, lname); + return new FilteredElementList(this, filter); + } }, + getElementsByClassName: { value: function getElementsByClassName(names) { + names = String(names).trim(); + if (names === "") { + var result = new NodeList(); + return result; + } + names = names.split(/[ \t\r\n\f]+/); + return new FilteredElementList(this, classNamesElementFilter(names)); + } }, + getElementsByName: { value: function getElementsByName(name) { + return new FilteredElementList(this, elementNameFilter(String(name))); + } }, + // Utility methods used by the public API methods above + clone: { value: function clone4() { + var e; + if (this.namespaceURI !== NAMESPACE.HTML || this.prefix || !this.ownerDocument.isHTML) { + e = this.ownerDocument.createElementNS( + this.namespaceURI, + this.prefix !== null ? this.prefix + ":" + this.localName : this.localName + ); + } else { + e = this.ownerDocument.createElement(this.localName); + } + for (var i = 0, n = this._attrKeys.length; i < n; i++) { + var lname = this._attrKeys[i]; + var a = this._attrsByLName[lname]; + var b = a.cloneNode(); + b._setOwnerElement(e); + e._attrsByLName[lname] = b; + e._addQName(b); + } + e._attrKeys = this._attrKeys.concat(); + return e; + } }, + isEqual: { value: function isEqual(that) { + if (this.localName !== that.localName || this.namespaceURI !== that.namespaceURI || this.prefix !== that.prefix || this._numattrs !== that._numattrs) + return false; + for (var i = 0, n = this._numattrs; i < n; i++) { + var a = this._attr(i); + if (!that.hasAttributeNS(a.namespaceURI, a.localName)) + return false; + if (that.getAttributeNS(a.namespaceURI, a.localName) !== a.value) + return false; + } + return true; + } }, + // This is the 'locate a namespace prefix' algorithm from the + // DOM specification. It is used by Node.lookupPrefix() + // (Be sure to compare DOM3 and DOM4 versions of spec.) + _lookupNamespacePrefix: { value: function _lookupNamespacePrefix(ns, originalElement) { + if (this.namespaceURI && this.namespaceURI === ns && this.prefix !== null && originalElement.lookupNamespaceURI(this.prefix) === ns) { + return this.prefix; + } + for (var i = 0, n = this._numattrs; i < n; i++) { + var a = this._attr(i); + if (a.prefix === "xmlns" && a.value === ns && originalElement.lookupNamespaceURI(a.localName) === ns) { + return a.localName; + } + } + var parent = this.parentElement; + return parent ? parent._lookupNamespacePrefix(ns, originalElement) : null; + } }, + // This is the 'locate a namespace' algorithm for Element nodes + // from the DOM Core spec. It is used by Node#lookupNamespaceURI() + lookupNamespaceURI: { value: function lookupNamespaceURI(prefix) { + if (prefix === "" || prefix === void 0) { + prefix = null; + } + if (this.namespaceURI !== null && this.prefix === prefix) + return this.namespaceURI; + for (var i = 0, n = this._numattrs; i < n; i++) { + var a = this._attr(i); + if (a.namespaceURI === NAMESPACE.XMLNS) { + if (a.prefix === "xmlns" && a.localName === prefix || prefix === null && a.prefix === null && a.localName === "xmlns") { + return a.value || null; + } + } + } + var parent = this.parentElement; + return parent ? parent.lookupNamespaceURI(prefix) : null; + } }, + // + // Attribute handling methods and utilities + // + /* + * Attributes in the DOM are tricky: + * + * - there are the 8 basic get/set/has/removeAttribute{NS} methods + * + * - but many HTML attributes are also 'reflected' through IDL + * attributes which means that they can be queried and set through + * regular properties of the element. There is just one attribute + * value, but two ways to get and set it. + * + * - Different HTML element types have different sets of reflected + attributes. + * + * - attributes can also be queried and set through the .attributes + * property of an element. This property behaves like an array of + * Attr objects. The value property of each Attr is writeable, so + * this is a third way to read and write attributes. + * + * - for efficiency, we really want to store attributes in some kind + * of name->attr map. But the attributes[] array is an array, not a + * map, which is kind of unnatural. + * + * - When using namespaces and prefixes, and mixing the NS methods + * with the non-NS methods, it is apparently actually possible for + * an attributes[] array to have more than one attribute with the + * same qualified name. And certain methods must operate on only + * the first attribute with such a name. So for these methods, an + * inefficient array-like data structure would be easier to + * implement. + * + * - The attributes[] array is live, not a snapshot, so changes to the + * attributes must be immediately visible through existing arrays. + * + * - When attributes are queried and set through IDL properties + * (instead of the get/setAttributes() method or the attributes[] + * array) they may be subject to type conversions, URL + * normalization, etc., so some extra processing is required in that + * case. + * + * - But access through IDL properties is probably the most common + * case, so we'd like that to be as fast as possible. + * + * - We can't just store attribute values in their parsed idl form, + * because setAttribute() has to return whatever string is passed to + * getAttribute even if it is not a legal, parseable value. So + * attribute values must be stored in unparsed string form. + * + * - We need to be able to send change notifications or mutation + * events of some sort to the renderer whenever an attribute value + * changes, regardless of the way in which it changes. + * + * - Some attributes, such as id and class affect other parts of the + * DOM API, like getElementById and getElementsByClassName and so + * for efficiency, we need to specially track changes to these + * special attributes. + * + * - Some attributes like class have different names (className) when + * reflected. + * + * - Attributes whose names begin with the string 'data-' are treated + specially. + * + * - Reflected attributes that have a boolean type in IDL have special + * behavior: setting them to false (in IDL) is the same as removing + * them with removeAttribute() + * + * - numeric attributes (like HTMLElement.tabIndex) can have default + * values that must be returned by the idl getter even if the + * content attribute does not exist. (The default tabIndex value + * actually varies based on the type of the element, so that is a + * tricky one). + * + * See + * http://www.whatwg.org/specs/web-apps/current-work/multipage/urls.html#reflect + * for rules on how attributes are reflected. + * + */ + getAttribute: { value: function getAttribute(qname) { + var attr = this.getAttributeNode(qname); + return attr ? attr.value : null; + } }, + getAttributeNS: { value: function getAttributeNS(ns, lname) { + var attr = this.getAttributeNodeNS(ns, lname); + return attr ? attr.value : null; + } }, + getAttributeNode: { value: function getAttributeNode(qname) { + qname = String(qname); + if (/[A-Z]/.test(qname) && this.isHTML) + qname = utils.toASCIILowerCase(qname); + var attr = this._attrsByQName[qname]; + if (!attr) return null; + if (Array.isArray(attr)) + attr = attr[0]; + return attr; + } }, + getAttributeNodeNS: { value: function getAttributeNodeNS(ns, lname) { + ns = ns === void 0 || ns === null ? "" : String(ns); + lname = String(lname); + var attr = this._attrsByLName[ns + "|" + lname]; + return attr ? attr : null; + } }, + hasAttribute: { value: function hasAttribute(qname) { + qname = String(qname); + if (/[A-Z]/.test(qname) && this.isHTML) + qname = utils.toASCIILowerCase(qname); + return this._attrsByQName[qname] !== void 0; + } }, + hasAttributeNS: { value: function hasAttributeNS(ns, lname) { + ns = ns === void 0 || ns === null ? "" : String(ns); + lname = String(lname); + var key = ns + "|" + lname; + return this._attrsByLName[key] !== void 0; + } }, + hasAttributes: { value: function hasAttributes() { + return this._numattrs > 0; + } }, + toggleAttribute: { value: function toggleAttribute(qname, force) { + qname = String(qname); + if (!xml.isValidName(qname)) utils.InvalidCharacterError(); + if (/[A-Z]/.test(qname) && this.isHTML) + qname = utils.toASCIILowerCase(qname); + var a = this._attrsByQName[qname]; + if (a === void 0) { + if (force === void 0 || force === true) { + this._setAttribute(qname, ""); + return true; + } + return false; + } else { + if (force === void 0 || force === false) { + this.removeAttribute(qname); + return false; + } + return true; + } + } }, + // Set the attribute without error checking. The parser uses this. + _setAttribute: { value: function _setAttribute(qname, value2) { + var attr = this._attrsByQName[qname]; + var isnew; + if (!attr) { + attr = this._newattr(qname); + isnew = true; + } else { + if (Array.isArray(attr)) attr = attr[0]; + } + attr.value = value2; + if (this._attributes) this._attributes[qname] = attr; + if (isnew && this._newattrhook) this._newattrhook(qname, value2); + } }, + // Check for errors, and then set the attribute + setAttribute: { value: function setAttribute(qname, value2) { + qname = String(qname); + if (!xml.isValidName(qname)) utils.InvalidCharacterError(); + if (/[A-Z]/.test(qname) && this.isHTML) + qname = utils.toASCIILowerCase(qname); + this._setAttribute(qname, String(value2)); + } }, + // The version with no error checking used by the parser + _setAttributeNS: { value: function _setAttributeNS(ns, qname, value2) { + var pos = qname.indexOf(":"), prefix, lname; + if (pos < 0) { + prefix = null; + lname = qname; + } else { + prefix = qname.substring(0, pos); + lname = qname.substring(pos + 1); + } + if (ns === "" || ns === void 0) ns = null; + var key = (ns === null ? "" : ns) + "|" + lname; + var attr = this._attrsByLName[key]; + var isnew; + if (!attr) { + attr = new Attr(this, lname, prefix, ns); + isnew = true; + this._attrsByLName[key] = attr; + if (this._attributes) { + this._attributes[this._attrKeys.length] = attr; + } + this._attrKeys.push(key); + this._addQName(attr); + } else if (false) { + if (attr.prefix !== prefix) { + this._removeQName(attr); + attr.prefix = prefix; + this._addQName(attr); + } + } + attr.value = value2; + if (isnew && this._newattrhook) this._newattrhook(qname, value2); + } }, + // Do error checking then call _setAttributeNS + setAttributeNS: { value: function setAttributeNS(ns, qname, value2) { + ns = ns === null || ns === void 0 || ns === "" ? null : String(ns); + qname = String(qname); + if (!xml.isValidQName(qname)) utils.InvalidCharacterError(); + var pos = qname.indexOf(":"); + var prefix = pos < 0 ? null : qname.substring(0, pos); + if (prefix !== null && ns === null || prefix === "xml" && ns !== NAMESPACE.XML || (qname === "xmlns" || prefix === "xmlns") && ns !== NAMESPACE.XMLNS || ns === NAMESPACE.XMLNS && !(qname === "xmlns" || prefix === "xmlns")) + utils.NamespaceError(); + this._setAttributeNS(ns, qname, String(value2)); + } }, + setAttributeNode: { value: function setAttributeNode(attr) { + if (attr.ownerElement !== null && attr.ownerElement !== this) { + throw new DOMException2(DOMException2.INUSE_ATTRIBUTE_ERR); + } + var result = null; + var oldAttrs = this._attrsByQName[attr.name]; + if (oldAttrs) { + if (!Array.isArray(oldAttrs)) { + oldAttrs = [oldAttrs]; + } + if (oldAttrs.some(function(a) { + return a === attr; + })) { + return attr; + } else if (attr.ownerElement !== null) { + throw new DOMException2(DOMException2.INUSE_ATTRIBUTE_ERR); + } + oldAttrs.forEach(function(a) { + this.removeAttributeNode(a); + }, this); + result = oldAttrs[0]; + } + this.setAttributeNodeNS(attr); + return result; + } }, + setAttributeNodeNS: { value: function setAttributeNodeNS(attr) { + if (attr.ownerElement !== null) { + throw new DOMException2(DOMException2.INUSE_ATTRIBUTE_ERR); + } + var ns = attr.namespaceURI; + var key = (ns === null ? "" : ns) + "|" + attr.localName; + var oldAttr = this._attrsByLName[key]; + if (oldAttr) { + this.removeAttributeNode(oldAttr); + } + attr._setOwnerElement(this); + this._attrsByLName[key] = attr; + if (this._attributes) { + this._attributes[this._attrKeys.length] = attr; + } + this._attrKeys.push(key); + this._addQName(attr); + if (this._newattrhook) this._newattrhook(attr.name, attr.value); + return oldAttr || null; + } }, + removeAttribute: { value: function removeAttribute(qname) { + qname = String(qname); + if (/[A-Z]/.test(qname) && this.isHTML) + qname = utils.toASCIILowerCase(qname); + var attr = this._attrsByQName[qname]; + if (!attr) return; + if (Array.isArray(attr)) { + if (attr.length > 2) { + attr = attr.shift(); + } else { + this._attrsByQName[qname] = attr[1]; + attr = attr[0]; + } + } else { + this._attrsByQName[qname] = void 0; + } + var ns = attr.namespaceURI; + var key = (ns === null ? "" : ns) + "|" + attr.localName; + this._attrsByLName[key] = void 0; + var i = this._attrKeys.indexOf(key); + if (this._attributes) { + Array.prototype.splice.call(this._attributes, i, 1); + this._attributes[qname] = void 0; + } + this._attrKeys.splice(i, 1); + var onchange = attr.onchange; + attr._setOwnerElement(null); + if (onchange) { + onchange.call(attr, this, attr.localName, attr.value, null); + } + if (this.rooted) this.ownerDocument.mutateRemoveAttr(attr); + } }, + removeAttributeNS: { value: function removeAttributeNS(ns, lname) { + ns = ns === void 0 || ns === null ? "" : String(ns); + lname = String(lname); + var key = ns + "|" + lname; + var attr = this._attrsByLName[key]; + if (!attr) return; + this._attrsByLName[key] = void 0; + var i = this._attrKeys.indexOf(key); + if (this._attributes) { + Array.prototype.splice.call(this._attributes, i, 1); + } + this._attrKeys.splice(i, 1); + this._removeQName(attr); + var onchange = attr.onchange; + attr._setOwnerElement(null); + if (onchange) { + onchange.call(attr, this, attr.localName, attr.value, null); + } + if (this.rooted) this.ownerDocument.mutateRemoveAttr(attr); + } }, + removeAttributeNode: { value: function removeAttributeNode(attr) { + var ns = attr.namespaceURI; + var key = (ns === null ? "" : ns) + "|" + attr.localName; + if (this._attrsByLName[key] !== attr) { + utils.NotFoundError(); + } + this.removeAttributeNS(ns, attr.localName); + return attr; + } }, + getAttributeNames: { value: function getAttributeNames() { + var elt = this; + return this._attrKeys.map(function(key) { + return elt._attrsByLName[key].name; + }); + } }, + // This 'raw' version of getAttribute is used by the getter functions + // of reflected attributes. It skips some error checking and + // namespace steps + _getattr: { value: function _getattr(qname) { + var attr = this._attrsByQName[qname]; + return attr ? attr.value : null; + } }, + // The raw version of setAttribute for reflected idl attributes. + _setattr: { value: function _setattr(qname, value2) { + var attr = this._attrsByQName[qname]; + var isnew; + if (!attr) { + attr = this._newattr(qname); + isnew = true; + } + attr.value = String(value2); + if (this._attributes) this._attributes[qname] = attr; + if (isnew && this._newattrhook) this._newattrhook(qname, value2); + } }, + // Create a new Attr object, insert it, and return it. + // Used by setAttribute() and by set() + _newattr: { value: function _newattr(qname) { + var attr = new Attr(this, qname, null, null); + var key = "|" + qname; + this._attrsByQName[qname] = attr; + this._attrsByLName[key] = attr; + if (this._attributes) { + this._attributes[this._attrKeys.length] = attr; + } + this._attrKeys.push(key); + return attr; + } }, + // Add a qname->Attr mapping to the _attrsByQName object, taking into + // account that there may be more than one attr object with the + // same qname + _addQName: { value: function(attr) { + var qname = attr.name; + var existing = this._attrsByQName[qname]; + if (!existing) { + this._attrsByQName[qname] = attr; + } else if (Array.isArray(existing)) { + existing.push(attr); + } else { + this._attrsByQName[qname] = [existing, attr]; + } + if (this._attributes) this._attributes[qname] = attr; + } }, + // Remove a qname->Attr mapping to the _attrsByQName object, taking into + // account that there may be more than one attr object with the + // same qname + _removeQName: { value: function(attr) { + var qname = attr.name; + var target = this._attrsByQName[qname]; + if (Array.isArray(target)) { + var idx = target.indexOf(attr); + utils.assert(idx !== -1); + if (target.length === 2) { + this._attrsByQName[qname] = target[1 - idx]; + if (this._attributes) { + this._attributes[qname] = this._attrsByQName[qname]; + } + } else { + target.splice(idx, 1); + if (this._attributes && this._attributes[qname] === attr) { + this._attributes[qname] = target[0]; + } + } + } else { + utils.assert(target === attr); + this._attrsByQName[qname] = void 0; + if (this._attributes) { + this._attributes[qname] = void 0; + } + } + } }, + // Return the number of attributes + _numattrs: { get: function() { + return this._attrKeys.length; + } }, + // Return the nth Attr object + _attr: { value: function(n) { + return this._attrsByLName[this._attrKeys[n]]; + } }, + // Define getters and setters for an 'id' property that reflects + // the content attribute 'id'. + id: attributes.property({ name: "id" }), + // Define getters and setters for a 'className' property that reflects + // the content attribute 'class'. + className: attributes.property({ name: "class" }), + classList: { get: function() { + var self2 = this; + if (this._classList) { + return this._classList; + } + var dtlist = new DOMTokenList( + function() { + return self2.className || ""; + }, + function(v) { + self2.className = v; + } + ); + this._classList = dtlist; + return dtlist; + }, set: function(v) { + this.className = v; + } }, + matches: { value: function(selector) { + return select.matches(this, selector); + } }, + closest: { value: function(selector) { + var el = this; + do { + if (el.matches && el.matches(selector)) { + return el; + } + el = el.parentElement || el.parentNode; + } while (el !== null && el.nodeType === Node.ELEMENT_NODE); + return null; + } }, + querySelector: { value: function(selector) { + return select(selector, this)[0]; + } }, + querySelectorAll: { value: function(selector) { + var nodes = select(selector, this); + return nodes.item ? nodes : new NodeList(nodes); + } } + }); + Object.defineProperties(Element.prototype, ChildNode); + Object.defineProperties(Element.prototype, NonDocumentTypeChildNode); + attributes.registerChangeHandler( + Element, + "id", + function(element, lname, oldval, newval) { + if (element.rooted) { + if (oldval) { + element.ownerDocument.delId(oldval, element); + } + if (newval) { + element.ownerDocument.addId(newval, element); + } + } + } + ); + attributes.registerChangeHandler( + Element, + "class", + function(element, lname, oldval, newval) { + if (element._classList) { + element._classList._update(); + } + } + ); + function Attr(elt, lname, prefix, namespace, value2) { + this.localName = lname; + this.prefix = prefix === null || prefix === "" ? null : "" + prefix; + this.namespaceURI = namespace === null || namespace === "" ? null : "" + namespace; + this.data = value2; + this._setOwnerElement(elt); + } + Attr.prototype = Object.create(Object.prototype, { + ownerElement: { + get: function() { + return this._ownerElement; + } + }, + _setOwnerElement: { value: function _setOwnerElement(elt) { + this._ownerElement = elt; + if (this.prefix === null && this.namespaceURI === null && elt) { + this.onchange = elt._attributeChangeHandlers[this.localName]; + } else { + this.onchange = null; + } + } }, + name: { get: function() { + return this.prefix ? this.prefix + ":" + this.localName : this.localName; + } }, + specified: { get: function() { + return true; + } }, + value: { + get: function() { + return this.data; + }, + set: function(value2) { + var oldval = this.data; + value2 = value2 === void 0 ? "" : value2 + ""; + if (value2 === oldval) return; + this.data = value2; + if (this.ownerElement) { + if (this.onchange) + this.onchange(this.ownerElement, this.localName, oldval, value2); + if (this.ownerElement.rooted) + this.ownerElement.ownerDocument.mutateAttr(this, oldval); + } + } + }, + cloneNode: { value: function cloneNode(deep) { + return new Attr( + null, + this.localName, + this.prefix, + this.namespaceURI, + this.data + ); + } }, + // Legacy aliases (see gh#70 and https://dom.spec.whatwg.org/#interface-attr) + nodeType: { get: function() { + return Node.ATTRIBUTE_NODE; + } }, + nodeName: { get: function() { + return this.name; + } }, + nodeValue: { + get: function() { + return this.value; + }, + set: function(v) { + this.value = v; + } + }, + textContent: { + get: function() { + return this.value; + }, + set: function(v) { + if (v === null || v === void 0) { + v = ""; + } + this.value = v; + } + }, + innerText: { + get: function() { + return this.value; + }, + set: function(v) { + if (v === null || v === void 0) { + v = ""; + } + this.value = v; + } + } + }); + Element._Attr = Attr; + function AttributesArray(elt) { + NamedNodeMap.call(this, elt); + for (var name in elt._attrsByQName) { + this[name] = elt._attrsByQName[name]; + } + for (var i = 0; i < elt._attrKeys.length; i++) { + this[i] = elt._attrsByLName[elt._attrKeys[i]]; + } + } + AttributesArray.prototype = Object.create(NamedNodeMap.prototype, { + length: { get: function() { + return this.element._attrKeys.length; + }, set: function() { + } }, + item: { value: function(n) { + n = n >>> 0; + if (n >= this.length) { + return null; + } + return this.element._attrsByLName[this.element._attrKeys[n]]; + } } + }); + if (globalThis.Symbol?.iterator) { + AttributesArray.prototype[globalThis.Symbol.iterator] = function() { + var i = 0, n = this.length, self2 = this; + return { + next: function() { + if (i < n) return { value: self2.item(i++) }; + return { done: true }; + } + }; + }; + } + function ChildrenCollection(e) { + this.element = e; + this.updateCache(); + } + ChildrenCollection.prototype = Object.create(Object.prototype, { + length: { get: function() { + this.updateCache(); + return this.childrenByNumber.length; + } }, + item: { value: function item(n) { + this.updateCache(); + return this.childrenByNumber[n] || null; + } }, + namedItem: { value: function namedItem(name) { + this.updateCache(); + return this.childrenByName[name] || null; + } }, + // This attribute returns the entire name->element map. + // It is not part of the HTMLCollection API, but we need it in + // src/HTMLCollectionProxy + namedItems: { get: function() { + this.updateCache(); + return this.childrenByName; + } }, + updateCache: { value: function updateCache() { + var namedElts = /^(a|applet|area|embed|form|frame|frameset|iframe|img|object)$/; + if (this.lastModTime !== this.element.lastModTime) { + this.lastModTime = this.element.lastModTime; + var n = this.childrenByNumber && this.childrenByNumber.length || 0; + for (var i = 0; i < n; i++) { + this[i] = void 0; + } + this.childrenByNumber = []; + this.childrenByName = /* @__PURE__ */ Object.create(null); + for (var c = this.element.firstChild; c !== null; c = c.nextSibling) { + if (c.nodeType === Node.ELEMENT_NODE) { + this[this.childrenByNumber.length] = c; + this.childrenByNumber.push(c); + var id = c.getAttribute("id"); + if (id && !this.childrenByName[id]) + this.childrenByName[id] = c; + var name = c.getAttribute("name"); + if (name && this.element.namespaceURI === NAMESPACE.HTML && namedElts.test(this.element.localName) && !this.childrenByName[name]) + this.childrenByName[id] = c; + } + } + } + } } + }); + function localNameElementFilter(lname) { + return function(e) { + return e.localName === lname; + }; + } + function htmlLocalNameElementFilter(lname) { + var lclname = utils.toASCIILowerCase(lname); + if (lclname === lname) + return localNameElementFilter(lname); + return function(e) { + return e.isHTML ? e.localName === lclname : e.localName === lname; + }; + } + function namespaceElementFilter(ns) { + return function(e) { + return e.namespaceURI === ns; + }; + } + function namespaceLocalNameElementFilter(ns, lname) { + return function(e) { + return e.namespaceURI === ns && e.localName === lname; + }; + } + function classNamesElementFilter(names) { + return function(e) { + return names.every(function(n) { + return e.classList.contains(n); + }); + }; + } + function elementNameFilter(name) { + return function(e) { + if (e.namespaceURI !== NAMESPACE.HTML) { + return false; + } + return e.getAttribute("name") === name; + }; + } + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Leaf.js +var require_Leaf = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Leaf.js"(exports, module) { + "use strict"; + module.exports = Leaf; + var Node = require_Node(); + var NodeList = require_NodeList(); + var utils = require_utils8(); + var HierarchyRequestError = utils.HierarchyRequestError; + var NotFoundError = utils.NotFoundError; + function Leaf() { + Node.call(this); + } + Leaf.prototype = Object.create(Node.prototype, { + hasChildNodes: { value: function() { + return false; + } }, + firstChild: { value: null }, + lastChild: { value: null }, + insertBefore: { value: function(node2, child) { + if (!node2.nodeType) throw new TypeError("not a node"); + HierarchyRequestError(); + } }, + replaceChild: { value: function(node2, child) { + if (!node2.nodeType) throw new TypeError("not a node"); + HierarchyRequestError(); + } }, + removeChild: { value: function(node2) { + if (!node2.nodeType) throw new TypeError("not a node"); + NotFoundError(); + } }, + removeChildren: { value: function() { + } }, + childNodes: { get: function() { + if (!this._childNodes) this._childNodes = new NodeList(); + return this._childNodes; + } } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/CharacterData.js +var require_CharacterData = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/CharacterData.js"(exports, module) { + "use strict"; + module.exports = CharacterData; + var Leaf = require_Leaf(); + var utils = require_utils8(); + var ChildNode = require_ChildNode(); + var NonDocumentTypeChildNode = require_NonDocumentTypeChildNode(); + function CharacterData() { + Leaf.call(this); + } + CharacterData.prototype = Object.create(Leaf.prototype, { + // DOMString substringData(unsigned long offset, + // unsigned long count); + // The substringData(offset, count) method must run these steps: + // + // If offset is greater than the context object's + // length, throw an INDEX_SIZE_ERR exception and + // terminate these steps. + // + // If offset+count is greater than the context + // object's length, return a DOMString whose value is + // the UTF-16 code units from the offsetth UTF-16 code + // unit to the end of data. + // + // Return a DOMString whose value is the UTF-16 code + // units from the offsetth UTF-16 code unit to the + // offset+countth UTF-16 code unit in data. + substringData: { value: function substringData(offset, count) { + if (arguments.length < 2) { + throw new TypeError("Not enough arguments"); + } + offset = offset >>> 0; + count = count >>> 0; + if (offset > this.data.length || offset < 0 || count < 0) { + utils.IndexSizeError(); + } + return this.data.substring(offset, offset + count); + } }, + // void appendData(DOMString data); + // The appendData(data) method must append data to the context + // object's data. + appendData: { value: function appendData(data) { + if (arguments.length < 1) { + throw new TypeError("Not enough arguments"); + } + this.data += String(data); + } }, + // void insertData(unsigned long offset, DOMString data); + // The insertData(offset, data) method must run these steps: + // + // If offset is greater than the context object's + // length, throw an INDEX_SIZE_ERR exception and + // terminate these steps. + // + // Insert data into the context object's data after + // offset UTF-16 code units. + // + insertData: { value: function insertData(offset, data) { + return this.replaceData(offset, 0, data); + } }, + // void deleteData(unsigned long offset, unsigned long count); + // The deleteData(offset, count) method must run these steps: + // + // If offset is greater than the context object's + // length, throw an INDEX_SIZE_ERR exception and + // terminate these steps. + // + // If offset+count is greater than the context + // object's length var count be length-offset. + // + // Starting from offset UTF-16 code units remove count + // UTF-16 code units from the context object's data. + deleteData: { value: function deleteData(offset, count) { + return this.replaceData(offset, count, ""); + } }, + // void replaceData(unsigned long offset, unsigned long count, + // DOMString data); + // + // The replaceData(offset, count, data) method must act as + // if the deleteData() method is invoked with offset and + // count as arguments followed by the insertData() method + // with offset and data as arguments and re-throw any + // exceptions these methods might have thrown. + replaceData: { value: function replaceData(offset, count, data) { + var curtext = this.data, len = curtext.length; + offset = offset >>> 0; + count = count >>> 0; + data = String(data); + if (offset > len || offset < 0) utils.IndexSizeError(); + if (offset + count > len) + count = len - offset; + var prefix = curtext.substring(0, offset), suffix2 = curtext.substring(offset + count); + this.data = prefix + data + suffix2; + } }, + // Utility method that Node.isEqualNode() calls to test Text and + // Comment nodes for equality. It is okay to put it here, since + // Node will have already verified that nodeType is equal + isEqual: { value: function isEqual(n) { + return this._data === n._data; + } }, + length: { get: function() { + return this.data.length; + } } + }); + Object.defineProperties(CharacterData.prototype, ChildNode); + Object.defineProperties(CharacterData.prototype, NonDocumentTypeChildNode); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Text.js +var require_Text = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Text.js"(exports, module) { + "use strict"; + module.exports = Text; + var utils = require_utils8(); + var Node = require_Node(); + var CharacterData = require_CharacterData(); + function Text(doc, data) { + CharacterData.call(this); + this.nodeType = Node.TEXT_NODE; + this.ownerDocument = doc; + this._data = data; + this._index = void 0; + } + var nodeValue = { + get: function() { + return this._data; + }, + set: function(v) { + if (v === null || v === void 0) { + v = ""; + } else { + v = String(v); + } + if (v === this._data) return; + this._data = v; + if (this.rooted) + this.ownerDocument.mutateValue(this); + if (this.parentNode && this.parentNode._textchangehook) + this.parentNode._textchangehook(this); + } + }; + Text.prototype = Object.create(CharacterData.prototype, { + nodeName: { value: "#text" }, + // These three attributes are all the same. + // The data attribute has a [TreatNullAs=EmptyString] but we'll + // implement that at the interface level + nodeValue, + textContent: nodeValue, + innerText: nodeValue, + data: { + get: nodeValue.get, + set: function(v) { + nodeValue.set.call(this, v === null ? "" : String(v)); + } + }, + splitText: { value: function splitText(offset) { + if (offset > this._data.length || offset < 0) utils.IndexSizeError(); + var newdata = this._data.substring(offset), newnode = this.ownerDocument.createTextNode(newdata); + this.data = this.data.substring(0, offset); + var parent = this.parentNode; + if (parent !== null) + parent.insertBefore(newnode, this.nextSibling); + return newnode; + } }, + wholeText: { get: function wholeText() { + var result = this.textContent; + for (var next2 = this.nextSibling; next2; next2 = next2.nextSibling) { + if (next2.nodeType !== Node.TEXT_NODE) { + break; + } + result += next2.textContent; + } + return result; + } }, + // Obsolete, removed from spec. + replaceWholeText: { value: utils.nyi }, + // Utility methods + clone: { value: function clone4() { + return new Text(this.ownerDocument, this._data); + } } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Comment.js +var require_Comment = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Comment.js"(exports, module) { + "use strict"; + module.exports = Comment2; + var Node = require_Node(); + var CharacterData = require_CharacterData(); + function Comment2(doc, data) { + CharacterData.call(this); + this.nodeType = Node.COMMENT_NODE; + this.ownerDocument = doc; + this._data = data; + } + var nodeValue = { + get: function() { + return this._data; + }, + set: function(v) { + if (v === null || v === void 0) { + v = ""; + } else { + v = String(v); + } + this._data = v; + if (this.rooted) + this.ownerDocument.mutateValue(this); + } + }; + Comment2.prototype = Object.create(CharacterData.prototype, { + nodeName: { value: "#comment" }, + nodeValue, + textContent: nodeValue, + innerText: nodeValue, + data: { + get: nodeValue.get, + set: function(v) { + nodeValue.set.call(this, v === null ? "" : String(v)); + } + }, + // Utility methods + clone: { value: function clone4() { + return new Comment2(this.ownerDocument, this._data); + } } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/DocumentFragment.js +var require_DocumentFragment = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/DocumentFragment.js"(exports, module) { + "use strict"; + module.exports = DocumentFragment; + var Node = require_Node(); + var NodeList = require_NodeList(); + var ContainerNode = require_ContainerNode(); + var Element = require_Element(); + var select = require_select(); + var utils = require_utils8(); + function DocumentFragment(doc) { + ContainerNode.call(this); + this.nodeType = Node.DOCUMENT_FRAGMENT_NODE; + this.ownerDocument = doc; + } + DocumentFragment.prototype = Object.create(ContainerNode.prototype, { + nodeName: { value: "#document-fragment" }, + nodeValue: { + get: function() { + return null; + }, + set: function() { + } + }, + // Copy the text content getter/setter from Element + textContent: Object.getOwnPropertyDescriptor(Element.prototype, "textContent"), + // Copy the text content getter/setter from Element + innerText: Object.getOwnPropertyDescriptor(Element.prototype, "innerText"), + querySelector: { value: function(selector) { + var nodes = this.querySelectorAll(selector); + return nodes.length ? nodes[0] : null; + } }, + querySelectorAll: { value: function(selector) { + var context = Object.create(this); + context.isHTML = true; + context.getElementsByTagName = Element.prototype.getElementsByTagName; + context.nextElement = Object.getOwnPropertyDescriptor(Element.prototype, "firstElementChild").get; + var nodes = select(selector, context); + return nodes.item ? nodes : new NodeList(nodes); + } }, + // Utility methods + clone: { value: function clone4() { + return new DocumentFragment(this.ownerDocument); + } }, + isEqual: { value: function isEqual(n) { + return true; + } }, + // Non-standard, but useful (github issue #73) + innerHTML: { + get: function() { + return this.serialize(); + }, + set: utils.nyi + }, + outerHTML: { + get: function() { + return this.serialize(); + }, + set: utils.nyi + } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/ProcessingInstruction.js +var require_ProcessingInstruction = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/ProcessingInstruction.js"(exports, module) { + "use strict"; + module.exports = ProcessingInstruction; + var Node = require_Node(); + var CharacterData = require_CharacterData(); + function ProcessingInstruction(doc, target, data) { + CharacterData.call(this); + this.nodeType = Node.PROCESSING_INSTRUCTION_NODE; + this.ownerDocument = doc; + this.target = target; + this._data = data; + } + var nodeValue = { + get: function() { + return this._data; + }, + set: function(v) { + if (v === null || v === void 0) { + v = ""; + } else { + v = String(v); + } + this._data = v; + if (this.rooted) this.ownerDocument.mutateValue(this); + } + }; + ProcessingInstruction.prototype = Object.create(CharacterData.prototype, { + nodeName: { get: function() { + return this.target; + } }, + nodeValue, + textContent: nodeValue, + innerText: nodeValue, + data: { + get: nodeValue.get, + set: function(v) { + nodeValue.set.call(this, v === null ? "" : String(v)); + } + }, + // Utility methods + clone: { value: function clone4() { + return new ProcessingInstruction(this.ownerDocument, this.target, this._data); + } }, + isEqual: { value: function isEqual(n) { + return this.target === n.target && this._data === n._data; + } } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NodeFilter.js +var require_NodeFilter = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NodeFilter.js"(exports, module) { + "use strict"; + var NodeFilter = { + // Constants for acceptNode() + FILTER_ACCEPT: 1, + FILTER_REJECT: 2, + FILTER_SKIP: 3, + // Constants for whatToShow + SHOW_ALL: 4294967295, + SHOW_ELEMENT: 1, + SHOW_ATTRIBUTE: 2, + // historical + SHOW_TEXT: 4, + SHOW_CDATA_SECTION: 8, + // historical + SHOW_ENTITY_REFERENCE: 16, + // historical + SHOW_ENTITY: 32, + // historical + SHOW_PROCESSING_INSTRUCTION: 64, + SHOW_COMMENT: 128, + SHOW_DOCUMENT: 256, + SHOW_DOCUMENT_TYPE: 512, + SHOW_DOCUMENT_FRAGMENT: 1024, + SHOW_NOTATION: 2048 + // historical + }; + module.exports = NodeFilter.constructor = NodeFilter.prototype = NodeFilter; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NodeTraversal.js +var require_NodeTraversal = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NodeTraversal.js"(exports, module) { + "use strict"; + var NodeTraversal = module.exports = { + nextSkippingChildren, + nextAncestorSibling, + next: next2, + previous, + deepLastChild + }; + function nextSkippingChildren(node2, stayWithin) { + if (node2 === stayWithin) { + return null; + } + if (node2.nextSibling !== null) { + return node2.nextSibling; + } + return nextAncestorSibling(node2, stayWithin); + } + function nextAncestorSibling(node2, stayWithin) { + for (node2 = node2.parentNode; node2 !== null; node2 = node2.parentNode) { + if (node2 === stayWithin) { + return null; + } + if (node2.nextSibling !== null) { + return node2.nextSibling; + } + } + return null; + } + function next2(node2, stayWithin) { + var n; + n = node2.firstChild; + if (n !== null) { + return n; + } + if (node2 === stayWithin) { + return null; + } + n = node2.nextSibling; + if (n !== null) { + return n; + } + return nextAncestorSibling(node2, stayWithin); + } + function deepLastChild(node2) { + while (node2.lastChild) { + node2 = node2.lastChild; + } + return node2; + } + function previous(node2, stayWithin) { + var p; + p = node2.previousSibling; + if (p !== null) { + return deepLastChild(p); + } + p = node2.parentNode; + if (p === stayWithin) { + return null; + } + return p; + } + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/TreeWalker.js +var require_TreeWalker = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/TreeWalker.js"(exports, module) { + "use strict"; + module.exports = TreeWalker; + var Node = require_Node(); + var NodeFilter = require_NodeFilter(); + var NodeTraversal = require_NodeTraversal(); + var utils = require_utils8(); + var mapChild = { + first: "firstChild", + last: "lastChild", + next: "firstChild", + previous: "lastChild" + }; + var mapSibling = { + first: "nextSibling", + last: "previousSibling", + next: "nextSibling", + previous: "previousSibling" + }; + function traverseChildren(tw, type2) { + var child, node2, parent, result, sibling; + node2 = tw._currentNode[mapChild[type2]]; + while (node2 !== null) { + result = tw._internalFilter(node2); + if (result === NodeFilter.FILTER_ACCEPT) { + tw._currentNode = node2; + return node2; + } + if (result === NodeFilter.FILTER_SKIP) { + child = node2[mapChild[type2]]; + if (child !== null) { + node2 = child; + continue; + } + } + while (node2 !== null) { + sibling = node2[mapSibling[type2]]; + if (sibling !== null) { + node2 = sibling; + break; + } + parent = node2.parentNode; + if (parent === null || parent === tw.root || parent === tw._currentNode) { + return null; + } else { + node2 = parent; + } + } + } + return null; + } + function traverseSiblings(tw, type2) { + var node2, result, sibling; + node2 = tw._currentNode; + if (node2 === tw.root) { + return null; + } + while (true) { + sibling = node2[mapSibling[type2]]; + while (sibling !== null) { + node2 = sibling; + result = tw._internalFilter(node2); + if (result === NodeFilter.FILTER_ACCEPT) { + tw._currentNode = node2; + return node2; + } + sibling = node2[mapChild[type2]]; + if (result === NodeFilter.FILTER_REJECT || sibling === null) { + sibling = node2[mapSibling[type2]]; + } + } + node2 = node2.parentNode; + if (node2 === null || node2 === tw.root) { + return null; + } + if (tw._internalFilter(node2) === NodeFilter.FILTER_ACCEPT) { + return null; + } + } + } + function TreeWalker(root2, whatToShow, filter) { + if (!root2 || !root2.nodeType) { + utils.NotSupportedError(); + } + this._root = root2; + this._whatToShow = Number(whatToShow) || 0; + this._filter = filter || null; + this._active = false; + this._currentNode = root2; + } + Object.defineProperties(TreeWalker.prototype, { + root: { get: function() { + return this._root; + } }, + whatToShow: { get: function() { + return this._whatToShow; + } }, + filter: { get: function() { + return this._filter; + } }, + currentNode: { + get: function currentNode() { + return this._currentNode; + }, + set: function setCurrentNode(v) { + if (!(v instanceof Node)) { + throw new TypeError("Not a Node"); + } + this._currentNode = v; + } + }, + /** + * @method + * @param {Node} node + * @return {Number} Constant NodeFilter.FILTER_ACCEPT, + * NodeFilter.FILTER_REJECT or NodeFilter.FILTER_SKIP. + */ + _internalFilter: { value: function _internalFilter(node2) { + var result, filter; + if (this._active) { + utils.InvalidStateError(); + } + if (!(1 << node2.nodeType - 1 & this._whatToShow)) { + return NodeFilter.FILTER_SKIP; + } + filter = this._filter; + if (filter === null) { + result = NodeFilter.FILTER_ACCEPT; + } else { + this._active = true; + try { + if (typeof filter === "function") { + result = filter(node2); + } else { + result = filter.acceptNode(node2); + } + } finally { + this._active = false; + } + } + return +result; + } }, + /** + * @spec https://dom.spec.whatwg.org/#dom-treewalker-parentnode + * @based on WebKit's TreeWalker::parentNode + * https://trac.webkit.org/browser/webkit/trunk/Source/WebCore/dom/TreeWalker.cpp?rev=220453#L50 + * @method + * @return {Node|null} + */ + parentNode: { value: function parentNode() { + var node2 = this._currentNode; + while (node2 !== this.root) { + node2 = node2.parentNode; + if (node2 === null) { + return null; + } + if (this._internalFilter(node2) === NodeFilter.FILTER_ACCEPT) { + this._currentNode = node2; + return node2; + } + } + return null; + } }, + /** + * @spec https://dom.spec.whatwg.org/#dom-treewalker-firstchild + * @method + * @return {Node|null} + */ + firstChild: { value: function firstChild() { + return traverseChildren(this, "first"); + } }, + /** + * @spec https://dom.spec.whatwg.org/#dom-treewalker-lastchild + * @method + * @return {Node|null} + */ + lastChild: { value: function lastChild() { + return traverseChildren(this, "last"); + } }, + /** + * @spec http://www.w3.org/TR/dom/#dom-treewalker-previoussibling + * @method + * @return {Node|null} + */ + previousSibling: { value: function previousSibling() { + return traverseSiblings(this, "previous"); + } }, + /** + * @spec http://www.w3.org/TR/dom/#dom-treewalker-nextsibling + * @method + * @return {Node|null} + */ + nextSibling: { value: function nextSibling() { + return traverseSiblings(this, "next"); + } }, + /** + * @spec https://dom.spec.whatwg.org/#dom-treewalker-previousnode + * @based on WebKit's TreeWalker::previousNode + * https://trac.webkit.org/browser/webkit/trunk/Source/WebCore/dom/TreeWalker.cpp?rev=220453#L181 + * @method + * @return {Node|null} + */ + previousNode: { value: function previousNode() { + var node2, result, previousSibling, lastChild; + node2 = this._currentNode; + while (node2 !== this._root) { + for (previousSibling = node2.previousSibling; previousSibling; previousSibling = node2.previousSibling) { + node2 = previousSibling; + result = this._internalFilter(node2); + if (result === NodeFilter.FILTER_REJECT) { + continue; + } + for (lastChild = node2.lastChild; lastChild; lastChild = node2.lastChild) { + node2 = lastChild; + result = this._internalFilter(node2); + if (result === NodeFilter.FILTER_REJECT) { + break; + } + } + if (result === NodeFilter.FILTER_ACCEPT) { + this._currentNode = node2; + return node2; + } + } + if (node2 === this.root || node2.parentNode === null) { + return null; + } + node2 = node2.parentNode; + if (this._internalFilter(node2) === NodeFilter.FILTER_ACCEPT) { + this._currentNode = node2; + return node2; + } + } + return null; + } }, + /** + * @spec https://dom.spec.whatwg.org/#dom-treewalker-nextnode + * @based on WebKit's TreeWalker::nextNode + * https://trac.webkit.org/browser/webkit/trunk/Source/WebCore/dom/TreeWalker.cpp?rev=220453#L228 + * @method + * @return {Node|null} + */ + nextNode: { value: function nextNode() { + var node2, result, firstChild, nextSibling; + node2 = this._currentNode; + result = NodeFilter.FILTER_ACCEPT; + CHILDREN: + while (true) { + for (firstChild = node2.firstChild; firstChild; firstChild = node2.firstChild) { + node2 = firstChild; + result = this._internalFilter(node2); + if (result === NodeFilter.FILTER_ACCEPT) { + this._currentNode = node2; + return node2; + } else if (result === NodeFilter.FILTER_REJECT) { + break; + } + } + for (nextSibling = NodeTraversal.nextSkippingChildren(node2, this.root); nextSibling; nextSibling = NodeTraversal.nextSkippingChildren(node2, this.root)) { + node2 = nextSibling; + result = this._internalFilter(node2); + if (result === NodeFilter.FILTER_ACCEPT) { + this._currentNode = node2; + return node2; + } else if (result === NodeFilter.FILTER_SKIP) { + continue CHILDREN; + } + } + return null; + } + } }, + /** For compatibility with web-platform-tests. */ + toString: { value: function toString2() { + return "[object TreeWalker]"; + } } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NodeIterator.js +var require_NodeIterator = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NodeIterator.js"(exports, module) { + "use strict"; + module.exports = NodeIterator; + var NodeFilter = require_NodeFilter(); + var NodeTraversal = require_NodeTraversal(); + var utils = require_utils8(); + function move(node2, stayWithin, directionIsNext) { + if (directionIsNext) { + return NodeTraversal.next(node2, stayWithin); + } else { + if (node2 === stayWithin) { + return null; + } + return NodeTraversal.previous(node2, null); + } + } + function isInclusiveAncestor(node2, possibleChild) { + for (; possibleChild; possibleChild = possibleChild.parentNode) { + if (node2 === possibleChild) { + return true; + } + } + return false; + } + function traverse(ni, directionIsNext) { + var node2, beforeNode; + node2 = ni._referenceNode; + beforeNode = ni._pointerBeforeReferenceNode; + while (true) { + if (beforeNode === directionIsNext) { + beforeNode = !beforeNode; + } else { + node2 = move(node2, ni._root, directionIsNext); + if (node2 === null) { + return null; + } + } + var result = ni._internalFilter(node2); + if (result === NodeFilter.FILTER_ACCEPT) { + break; + } + } + ni._referenceNode = node2; + ni._pointerBeforeReferenceNode = beforeNode; + return node2; + } + function NodeIterator(root2, whatToShow, filter) { + if (!root2 || !root2.nodeType) { + utils.NotSupportedError(); + } + this._root = root2; + this._referenceNode = root2; + this._pointerBeforeReferenceNode = true; + this._whatToShow = Number(whatToShow) || 0; + this._filter = filter || null; + this._active = false; + root2.doc._attachNodeIterator(this); + } + Object.defineProperties(NodeIterator.prototype, { + root: { get: function root2() { + return this._root; + } }, + referenceNode: { get: function referenceNode() { + return this._referenceNode; + } }, + pointerBeforeReferenceNode: { get: function pointerBeforeReferenceNode() { + return this._pointerBeforeReferenceNode; + } }, + whatToShow: { get: function whatToShow() { + return this._whatToShow; + } }, + filter: { get: function filter() { + return this._filter; + } }, + /** + * @method + * @param {Node} node + * @return {Number} Constant NodeFilter.FILTER_ACCEPT, + * NodeFilter.FILTER_REJECT or NodeFilter.FILTER_SKIP. + */ + _internalFilter: { value: function _internalFilter(node2) { + var result, filter; + if (this._active) { + utils.InvalidStateError(); + } + if (!(1 << node2.nodeType - 1 & this._whatToShow)) { + return NodeFilter.FILTER_SKIP; + } + filter = this._filter; + if (filter === null) { + result = NodeFilter.FILTER_ACCEPT; + } else { + this._active = true; + try { + if (typeof filter === "function") { + result = filter(node2); + } else { + result = filter.acceptNode(node2); + } + } finally { + this._active = false; + } + } + return +result; + } }, + /** + * @spec https://dom.spec.whatwg.org/#nodeiterator-pre-removing-steps + * @method + * @return void + */ + _preremove: { value: function _preremove(toBeRemovedNode) { + if (isInclusiveAncestor(toBeRemovedNode, this._root)) { + return; + } + if (!isInclusiveAncestor(toBeRemovedNode, this._referenceNode)) { + return; + } + if (this._pointerBeforeReferenceNode) { + var next2 = toBeRemovedNode; + while (next2.lastChild) { + next2 = next2.lastChild; + } + next2 = NodeTraversal.next(next2, this.root); + if (next2) { + this._referenceNode = next2; + return; + } + this._pointerBeforeReferenceNode = false; + } + if (toBeRemovedNode.previousSibling === null) { + this._referenceNode = toBeRemovedNode.parentNode; + } else { + this._referenceNode = toBeRemovedNode.previousSibling; + var lastChild; + for (lastChild = this._referenceNode.lastChild; lastChild; lastChild = this._referenceNode.lastChild) { + this._referenceNode = lastChild; + } + } + } }, + /** + * @spec http://www.w3.org/TR/dom/#dom-nodeiterator-nextnode + * @method + * @return {Node|null} + */ + nextNode: { value: function nextNode() { + return traverse(this, true); + } }, + /** + * @spec http://www.w3.org/TR/dom/#dom-nodeiterator-previousnode + * @method + * @return {Node|null} + */ + previousNode: { value: function previousNode() { + return traverse(this, false); + } }, + /** + * @spec http://www.w3.org/TR/dom/#dom-nodeiterator-detach + * @method + * @return void + */ + detach: { value: function detach() { + } }, + /** For compatibility with web-platform-tests. */ + toString: { value: function toString2() { + return "[object NodeIterator]"; + } } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/URL.js +var require_URL = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/URL.js"(exports, module) { + "use strict"; + module.exports = URL2; + function URL2(url4) { + if (!url4) return Object.create(URL2.prototype); + this.url = url4.replace(/^[ \t\n\r\f]+|[ \t\n\r\f]+$/g, ""); + var match2 = URL2.pattern.exec(this.url); + if (match2) { + if (match2[2]) this.scheme = match2[2]; + if (match2[4]) { + var userinfo = match2[4].match(URL2.userinfoPattern); + if (userinfo) { + this.username = userinfo[1]; + this.password = userinfo[3]; + match2[4] = match2[4].substring(userinfo[0].length); + } + if (match2[4].match(URL2.portPattern)) { + var pos = match2[4].lastIndexOf(":"); + this.host = match2[4].substring(0, pos); + this.port = match2[4].substring(pos + 1); + } else { + this.host = match2[4]; + } + } + if (match2[5]) this.path = match2[5]; + if (match2[6]) this.query = match2[7]; + if (match2[8]) this.fragment = match2[9]; + } + } + URL2.pattern = /^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/; + URL2.userinfoPattern = /^([^@:]*)(:([^@]*))?@/; + URL2.portPattern = /:\d+$/; + URL2.authorityPattern = /^[^:\/?#]+:\/\//; + URL2.hierarchyPattern = /^[^:\/?#]+:\//; + URL2.percentEncode = function percentEncode(s) { + var c = s.charCodeAt(0); + if (c < 256) return "%" + c.toString(16); + else throw Error("can't percent-encode codepoints > 255 yet"); + }; + URL2.prototype = { + constructor: URL2, + // XXX: not sure if this is the precise definition of absolute + isAbsolute: function() { + return !!this.scheme; + }, + isAuthorityBased: function() { + return URL2.authorityPattern.test(this.url); + }, + isHierarchical: function() { + return URL2.hierarchyPattern.test(this.url); + }, + toString: function() { + var s = ""; + if (this.scheme !== void 0) s += this.scheme + ":"; + if (this.isAbsolute()) { + s += "//"; + if (this.username || this.password) { + s += this.username || ""; + if (this.password) { + s += ":" + this.password; + } + s += "@"; + } + if (this.host) { + s += this.host; + } + } + if (this.port !== void 0) s += ":" + this.port; + if (this.path !== void 0) s += this.path; + if (this.query !== void 0) s += "?" + this.query; + if (this.fragment !== void 0) s += "#" + this.fragment; + return s; + }, + // See: http://tools.ietf.org/html/rfc3986#section-5.2 + // and https://url.spec.whatwg.org/#constructors + resolve: function(relative) { + var base = this; + var r = new URL2(relative); + var t = new URL2(); + if (r.scheme !== void 0) { + t.scheme = r.scheme; + t.username = r.username; + t.password = r.password; + t.host = r.host; + t.port = r.port; + t.path = remove_dot_segments(r.path); + t.query = r.query; + } else { + t.scheme = base.scheme; + if (r.host !== void 0) { + t.username = r.username; + t.password = r.password; + t.host = r.host; + t.port = r.port; + t.path = remove_dot_segments(r.path); + t.query = r.query; + } else { + t.username = base.username; + t.password = base.password; + t.host = base.host; + t.port = base.port; + if (!r.path) { + t.path = base.path; + if (r.query !== void 0) + t.query = r.query; + else + t.query = base.query; + } else { + if (r.path.charAt(0) === "/") { + t.path = remove_dot_segments(r.path); + } else { + t.path = merge5(base.path, r.path); + t.path = remove_dot_segments(t.path); + } + t.query = r.query; + } + } + } + t.fragment = r.fragment; + return t.toString(); + function merge5(basepath, refpath) { + if (base.host !== void 0 && !base.path) + return "/" + refpath; + var lastslash = basepath.lastIndexOf("/"); + if (lastslash === -1) + return refpath; + else + return basepath.substring(0, lastslash + 1) + refpath; + } + function remove_dot_segments(path3) { + if (!path3) return path3; + var output = ""; + while (path3.length > 0) { + if (path3 === "." || path3 === "..") { + path3 = ""; + break; + } + var twochars = path3.substring(0, 2); + var threechars = path3.substring(0, 3); + var fourchars = path3.substring(0, 4); + if (threechars === "../") { + path3 = path3.substring(3); + } else if (twochars === "./") { + path3 = path3.substring(2); + } else if (threechars === "/./") { + path3 = "/" + path3.substring(3); + } else if (twochars === "/." && path3.length === 2) { + path3 = "/"; + } else if (fourchars === "/../" || threechars === "/.." && path3.length === 3) { + path3 = "/" + path3.substring(4); + output = output.replace(/\/?[^\/]*$/, ""); + } else { + var segment = path3.match(/(\/?([^\/]*))/)[0]; + output += segment; + path3 = path3.substring(segment.length); + } + } + return output; + } + } + }; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/CustomEvent.js +var require_CustomEvent = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/CustomEvent.js"(exports, module) { + "use strict"; + module.exports = CustomEvent; + var Event2 = require_Event(); + function CustomEvent(type2, dictionary) { + Event2.call(this, type2, dictionary); + } + CustomEvent.prototype = Object.create(Event2.prototype, { + constructor: { value: CustomEvent } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/events.js +var require_events3 = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/events.js"(exports, module) { + "use strict"; + module.exports = { + Event: require_Event(), + UIEvent: require_UIEvent(), + MouseEvent: require_MouseEvent(), + CustomEvent: require_CustomEvent() + }; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/style_parser.js +var require_style_parser = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/style_parser.js"(exports) { + "use strict"; + Object.defineProperty(exports, "__esModule", { value: true }); + exports.hyphenate = exports.parse = void 0; + function parse5(value2) { + const styles = []; + let i = 0; + let parenDepth = 0; + let quote = 0; + let valueStart = 0; + let propStart = 0; + let currentProp = null; + while (i < value2.length) { + const token = value2.charCodeAt(i++); + switch (token) { + case 40: + parenDepth++; + break; + case 41: + parenDepth--; + break; + case 39: + if (quote === 0) { + quote = 39; + } else if (quote === 39 && value2.charCodeAt(i - 1) !== 92) { + quote = 0; + } + break; + case 34: + if (quote === 0) { + quote = 34; + } else if (quote === 34 && value2.charCodeAt(i - 1) !== 92) { + quote = 0; + } + break; + case 58: + if (!currentProp && parenDepth === 0 && quote === 0) { + currentProp = hyphenate(value2.substring(propStart, i - 1).trim()); + valueStart = i; + } + break; + case 59: + if (currentProp && valueStart > 0 && parenDepth === 0 && quote === 0) { + const styleVal = value2.substring(valueStart, i - 1).trim(); + styles.push(currentProp, styleVal); + propStart = i; + valueStart = 0; + currentProp = null; + } + break; + } + } + if (currentProp && valueStart) { + const styleVal = value2.slice(valueStart).trim(); + styles.push(currentProp, styleVal); + } + return styles; + } + exports.parse = parse5; + function hyphenate(value2) { + return value2.replace(/[a-z][A-Z]/g, (v) => { + return v.charAt(0) + "-" + v.charAt(1); + }).toLowerCase(); + } + exports.hyphenate = hyphenate; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/CSSStyleDeclaration.js +var require_CSSStyleDeclaration = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/CSSStyleDeclaration.js"(exports, module) { + "use strict"; + var { parse: parse5 } = require_style_parser(); + module.exports = function(elt) { + const style = new CSSStyleDeclaration(elt); + const handler2 = { + get: function(target, property) { + return property in target ? target[property] : target.getPropertyValue(dasherizeProperty(property)); + }, + has: function(target, key) { + return true; + }, + set: function(target, property, value2) { + if (property in target) { + target[property] = value2; + } else { + target.setProperty(dasherizeProperty(property), value2 ?? void 0); + } + return true; + } + }; + return new Proxy(style, handler2); + }; + function dasherizeProperty(property) { + return property.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase(); + } + function CSSStyleDeclaration(elt) { + this._element = elt; + } + var IMPORTANT_BANG = "!important"; + function parseStyles(value2) { + const result = { + property: {}, + priority: {} + }; + if (!value2) { + return result; + } + const styleValues = parse5(value2); + if (styleValues.length < 2) { + return result; + } + for (let i = 0; i < styleValues.length; i += 2) { + const name = styleValues[i]; + let value3 = styleValues[i + 1]; + if (value3.endsWith(IMPORTANT_BANG)) { + result.priority[name] = "important"; + value3 = value3.slice(0, -IMPORTANT_BANG.length).trim(); + } + result.property[name] = value3; + } + return result; + } + var NO_CHANGE = {}; + CSSStyleDeclaration.prototype = Object.create(Object.prototype, { + // Return the parsed form of the element's style attribute. + // If the element's style attribute has never been parsed + // or if it has changed since the last parse, then reparse it + // Note that the styles don't get parsed until they're actually needed + _parsed: { get: function() { + if (!this._parsedStyles || this.cssText !== this._lastParsedText) { + var text = this.cssText; + this._parsedStyles = parseStyles(text); + this._lastParsedText = text; + delete this._names; + } + return this._parsedStyles; + } }, + // Call this method any time the parsed representation of the + // style changes. It converts the style properties to a string and + // sets cssText and the element's style attribute + _serialize: { value: function() { + var styles = this._parsed; + var s = ""; + for (var name in styles.property) { + if (s) s += " "; + s += name + ": " + styles.property[name]; + if (styles.priority[name]) { + s += " !" + styles.priority[name]; + } + s += ";"; + } + this.cssText = s; + this._lastParsedText = s; + delete this._names; + } }, + cssText: { + get: function() { + return this._element.getAttribute("style"); + }, + set: function(value2) { + this._element.setAttribute("style", value2); + } + }, + length: { get: function() { + if (!this._names) + this._names = Object.getOwnPropertyNames(this._parsed.property); + return this._names.length; + } }, + item: { value: function(n) { + if (!this._names) + this._names = Object.getOwnPropertyNames(this._parsed.property); + return this._names[n]; + } }, + getPropertyValue: { value: function(property) { + property = property.toLowerCase(); + return this._parsed.property[property] || ""; + } }, + getPropertyPriority: { value: function(property) { + property = property.toLowerCase(); + return this._parsed.priority[property] || ""; + } }, + setProperty: { value: function(property, value2, priority) { + property = property.toLowerCase(); + if (value2 === null || value2 === void 0) { + value2 = ""; + } + if (priority === null || priority === void 0) { + priority = ""; + } + if (value2 !== NO_CHANGE) { + value2 = "" + value2; + } + value2 = value2.trim(); + if (value2 === "") { + this.removeProperty(property); + return; + } + if (priority !== "" && priority !== NO_CHANGE && !/^important$/i.test(priority)) { + return; + } + var styles = this._parsed; + if (value2 === NO_CHANGE) { + if (!styles.property[property]) { + return; + } + if (priority !== "") { + styles.priority[property] = "important"; + } else { + delete styles.priority[property]; + } + } else { + if (value2.indexOf(";") !== -1) return; + var newprops = parseStyles(property + ":" + value2); + if (Object.getOwnPropertyNames(newprops.property).length === 0) { + return; + } + if (Object.getOwnPropertyNames(newprops.priority).length !== 0) { + return; + } + for (var p in newprops.property) { + styles.property[p] = newprops.property[p]; + if (priority === NO_CHANGE) { + continue; + } else if (priority !== "") { + styles.priority[p] = "important"; + } else if (styles.priority[p]) { + delete styles.priority[p]; + } + } + } + this._serialize(); + } }, + setPropertyValue: { value: function(property, value2) { + return this.setProperty(property, value2, NO_CHANGE); + } }, + setPropertyPriority: { value: function(property, priority) { + return this.setProperty(property, NO_CHANGE, priority); + } }, + removeProperty: { value: function(property) { + property = property.toLowerCase(); + var styles = this._parsed; + if (property in styles.property) { + delete styles.property[property]; + delete styles.priority[property]; + this._serialize(); + } + } } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/URLUtils.js +var require_URLUtils = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/URLUtils.js"(exports, module) { + "use strict"; + var URL2 = require_URL(); + module.exports = URLUtils; + function URLUtils() { + } + URLUtils.prototype = Object.create(Object.prototype, { + _url: { get: function() { + return new URL2(this.href); + } }, + protocol: { + get: function() { + var url4 = this._url; + if (url4 && url4.scheme) return url4.scheme + ":"; + else return ":"; + }, + set: function(v) { + var output = this.href; + var url4 = new URL2(output); + if (url4.isAbsolute()) { + v = v.replace(/:+$/, ""); + v = v.replace(/[^-+\.a-zA-Z0-9]/g, URL2.percentEncode); + if (v.length > 0) { + url4.scheme = v; + output = url4.toString(); + } + } + this.href = output; + } + }, + host: { + get: function() { + var url4 = this._url; + if (url4.isAbsolute() && url4.isAuthorityBased()) + return url4.host + (url4.port ? ":" + url4.port : ""); + else + return ""; + }, + set: function(v) { + var output = this.href; + var url4 = new URL2(output); + if (url4.isAbsolute() && url4.isAuthorityBased()) { + v = v.replace(/[^-+\._~!$&'()*,;:=a-zA-Z0-9]/g, URL2.percentEncode); + if (v.length > 0) { + url4.host = v; + delete url4.port; + output = url4.toString(); + } + } + this.href = output; + } + }, + hostname: { + get: function() { + var url4 = this._url; + if (url4.isAbsolute() && url4.isAuthorityBased()) + return url4.host; + else + return ""; + }, + set: function(v) { + var output = this.href; + var url4 = new URL2(output); + if (url4.isAbsolute() && url4.isAuthorityBased()) { + v = v.replace(/^\/+/, ""); + v = v.replace(/[^-+\._~!$&'()*,;:=a-zA-Z0-9]/g, URL2.percentEncode); + if (v.length > 0) { + url4.host = v; + output = url4.toString(); + } + } + this.href = output; + } + }, + port: { + get: function() { + var url4 = this._url; + if (url4.isAbsolute() && url4.isAuthorityBased() && url4.port !== void 0) + return url4.port; + else + return ""; + }, + set: function(v) { + var output = this.href; + var url4 = new URL2(output); + if (url4.isAbsolute() && url4.isAuthorityBased()) { + v = "" + v; + v = v.replace(/[^0-9].*$/, ""); + v = v.replace(/^0+/, ""); + if (v.length === 0) v = "0"; + if (parseInt(v, 10) <= 65535) { + url4.port = v; + output = url4.toString(); + } + } + this.href = output; + } + }, + pathname: { + get: function() { + var url4 = this._url; + if (url4.isAbsolute() && url4.isHierarchical()) + return url4.path; + else + return ""; + }, + set: function(v) { + var output = this.href; + var url4 = new URL2(output); + if (url4.isAbsolute() && url4.isHierarchical()) { + if (v.charAt(0) !== "/") + v = "/" + v; + v = v.replace(/[^-+\._~!$&'()*,;:=@\/a-zA-Z0-9]/g, URL2.percentEncode); + url4.path = v; + output = url4.toString(); + } + this.href = output; + } + }, + search: { + get: function() { + var url4 = this._url; + if (url4.isAbsolute() && url4.isHierarchical() && url4.query !== void 0) + return "?" + url4.query; + else + return ""; + }, + set: function(v) { + var output = this.href; + var url4 = new URL2(output); + if (url4.isAbsolute() && url4.isHierarchical()) { + if (v.charAt(0) === "?") v = v.substring(1); + v = v.replace(/[^-+\._~!$&'()*,;:=@\/?a-zA-Z0-9]/g, URL2.percentEncode); + url4.query = v; + output = url4.toString(); + } + this.href = output; + } + }, + hash: { + get: function() { + var url4 = this._url; + if (url4 == null || url4.fragment == null || url4.fragment === "") { + return ""; + } else { + return "#" + url4.fragment; + } + }, + set: function(v) { + var output = this.href; + var url4 = new URL2(output); + if (v.charAt(0) === "#") v = v.substring(1); + v = v.replace(/[^-+\._~!$&'()*,;:=@\/?a-zA-Z0-9]/g, URL2.percentEncode); + url4.fragment = v; + output = url4.toString(); + this.href = output; + } + }, + username: { + get: function() { + var url4 = this._url; + return url4.username || ""; + }, + set: function(v) { + var output = this.href; + var url4 = new URL2(output); + if (url4.isAbsolute()) { + v = v.replace(/[\x00-\x1F\x7F-\uFFFF "#<>?`\/@\\:]/g, URL2.percentEncode); + url4.username = v; + output = url4.toString(); + } + this.href = output; + } + }, + password: { + get: function() { + var url4 = this._url; + return url4.password || ""; + }, + set: function(v) { + var output = this.href; + var url4 = new URL2(output); + if (url4.isAbsolute()) { + if (v === "") { + url4.password = null; + } else { + v = v.replace(/[\x00-\x1F\x7F-\uFFFF "#<>?`\/@\\]/g, URL2.percentEncode); + url4.password = v; + } + output = url4.toString(); + } + this.href = output; + } + }, + origin: { get: function() { + var url4 = this._url; + if (url4 == null) { + return ""; + } + var originForPort = function(defaultPort) { + var origin = [url4.scheme, url4.host, +url4.port || defaultPort]; + return origin[0] + "://" + origin[1] + (origin[2] === defaultPort ? "" : ":" + origin[2]); + }; + switch (url4.scheme) { + case "ftp": + return originForPort(21); + case "gopher": + return originForPort(70); + case "http": + case "ws": + return originForPort(80); + case "https": + case "wss": + return originForPort(443); + default: + return url4.scheme + "://"; + } + } } + /* + searchParams: { + get: function() { + var url = this._url; + // XXX + }, + set: function(v) { + var output = this.href; + var url = new URL(output); + // XXX + this.href = output; + }, + }, + */ + }); + URLUtils._inherit = function(proto) { + Object.getOwnPropertyNames(URLUtils.prototype).forEach(function(p) { + if (p === "constructor" || p === "href") { + return; + } + var desc = Object.getOwnPropertyDescriptor(URLUtils.prototype, p); + Object.defineProperty(proto, p, desc); + }); + }; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/defineElement.js +var require_defineElement = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/defineElement.js"(exports, module) { + "use strict"; + var attributes = require_attributes(); + var isApiWritable = require_config().isApiWritable; + module.exports = function(spec, defaultConstructor, tagList, tagNameToImpl) { + var c = spec.ctor; + if (c) { + var props = spec.props || {}; + if (spec.attributes) { + for (var n in spec.attributes) { + var attr = spec.attributes[n]; + if (typeof attr !== "object" || Array.isArray(attr)) attr = { type: attr }; + if (!attr.name) attr.name = n.toLowerCase(); + props[n] = attributes.property(attr); + } + } + props.constructor = { value: c, writable: isApiWritable }; + c.prototype = Object.create((spec.superclass || defaultConstructor).prototype, props); + if (spec.events) { + addEventHandlers(c, spec.events); + } + tagList[spec.name] = c; + } else { + c = defaultConstructor; + } + (spec.tags || spec.tag && [spec.tag] || []).forEach(function(tag) { + tagNameToImpl[tag] = c; + }); + return c; + }; + function EventHandlerBuilder(body, document, form, element) { + this.body = body; + this.document = document; + this.form = form; + this.element = element; + } + EventHandlerBuilder.prototype.build = function() { + return () => { + }; + }; + function EventHandlerChangeHandler(elt, name, oldval, newval) { + var doc = elt.ownerDocument || /* @__PURE__ */ Object.create(null); + var form = elt.form || /* @__PURE__ */ Object.create(null); + elt[name] = new EventHandlerBuilder(newval, doc, form, elt).build(); + } + function addEventHandlers(c, eventHandlerTypes) { + var p = c.prototype; + eventHandlerTypes.forEach(function(type2) { + Object.defineProperty(p, "on" + type2, { + get: function() { + return this._getEventHandler(type2); + }, + set: function(v) { + this._setEventHandler(type2, v); + } + }); + attributes.registerChangeHandler(c, "on" + type2, EventHandlerChangeHandler); + }); + } + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/htmlelts.js +var require_htmlelts = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/htmlelts.js"(exports) { + "use strict"; + var Node = require_Node(); + var Element = require_Element(); + var CSSStyleDeclaration = require_CSSStyleDeclaration(); + var utils = require_utils8(); + var URLUtils = require_URLUtils(); + var defineElement = require_defineElement(); + var htmlElements = exports.elements = {}; + var htmlNameToImpl = /* @__PURE__ */ Object.create(null); + exports.createElement = function(doc, localName, prefix) { + var impl = htmlNameToImpl[localName] || HTMLUnknownElement; + return new impl(doc, localName, prefix); + }; + function define3(spec) { + return defineElement(spec, HTMLElement, htmlElements, htmlNameToImpl); + } + function URL2(attr) { + return { + get: function() { + var v = this._getattr(attr); + if (v === null) { + return ""; + } + var url4 = this.doc._resolve(v); + return url4 === null ? v : url4; + }, + set: function(value2) { + this._setattr(attr, value2); + } + }; + } + function CORS(attr) { + return { + get: function() { + var v = this._getattr(attr); + if (v === null) { + return null; + } + if (v.toLowerCase() === "use-credentials") { + return "use-credentials"; + } + return "anonymous"; + }, + set: function(value2) { + if (value2 === null || value2 === void 0) { + this.removeAttribute(attr); + } else { + this._setattr(attr, value2); + } + } + }; + } + var REFERRER = { + type: ["", "no-referrer", "no-referrer-when-downgrade", "same-origin", "origin", "strict-origin", "origin-when-cross-origin", "strict-origin-when-cross-origin", "unsafe-url"], + missing: "" + }; + var focusableElements = { + "A": true, + "LINK": true, + "BUTTON": true, + "INPUT": true, + "SELECT": true, + "TEXTAREA": true, + "COMMAND": true + }; + var HTMLFormElement = function(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + this._form = null; + }; + var HTMLElement = exports.HTMLElement = define3({ + superclass: Element, + name: "HTMLElement", + ctor: function HTMLElement2(doc, localName, prefix) { + Element.call(this, doc, localName, utils.NAMESPACE.HTML, prefix); + }, + props: { + dangerouslySetInnerHTML: { + set: function(v) { + this._innerHTML = v; + } + }, + innerHTML: { + get: function() { + return this.serialize(); + }, + set: function(v) { + var parser = this.ownerDocument.implementation.mozHTMLParser( + this.ownerDocument._address, + this + ); + parser.parse(v === null ? "" : String(v), true); + var target = this instanceof htmlNameToImpl.template ? this.content : this; + while (target.hasChildNodes()) + target.removeChild(target.firstChild); + target.appendChild(parser._asDocumentFragment()); + } + }, + style: { get: function() { + if (!this._style) + this._style = new CSSStyleDeclaration(this); + return this._style; + }, set: function(v) { + if (v === null || v === void 0) { + v = ""; + } + this._setattr("style", String(v)); + } }, + // These can't really be implemented server-side in a reasonable way. + blur: { value: function() { + } }, + focus: { value: function() { + } }, + forceSpellCheck: { value: function() { + } }, + click: { value: function() { + if (this._click_in_progress) return; + this._click_in_progress = true; + try { + if (this._pre_click_activation_steps) + this._pre_click_activation_steps(); + var event = this.ownerDocument.createEvent("MouseEvent"); + event.initMouseEvent( + "click", + true, + true, + this.ownerDocument.defaultView, + 1, + 0, + 0, + 0, + 0, + // These 4 should be initialized with + // the actually current keyboard state + // somehow... + false, + false, + false, + false, + 0, + null + ); + var success2 = this.dispatchEvent(event); + if (success2) { + if (this._post_click_activation_steps) + this._post_click_activation_steps(event); + } else { + if (this._cancelled_activation_steps) + this._cancelled_activation_steps(); + } + } finally { + this._click_in_progress = false; + } + } }, + submit: { value: utils.nyi } + }, + attributes: { + title: String, + lang: String, + dir: { type: ["ltr", "rtl", "auto"], missing: "" }, + draggable: { type: ["true", "false"], treatNullAsEmptyString: true }, + spellcheck: { type: ["true", "false"], missing: "" }, + enterKeyHint: { type: ["enter", "done", "go", "next", "previous", "search", "send"], missing: "" }, + autoCapitalize: { type: ["off", "on", "none", "sentences", "words", "characters"], missing: "" }, + autoFocus: Boolean, + accessKey: String, + nonce: String, + hidden: Boolean, + translate: { type: ["no", "yes"], missing: "" }, + tabIndex: { type: "long", default: function() { + if (this.tagName in focusableElements || this.contentEditable) + return 0; + else + return -1; + } } + }, + events: [ + "abort", + "canplay", + "canplaythrough", + "change", + "click", + "contextmenu", + "cuechange", + "dblclick", + "drag", + "dragend", + "dragenter", + "dragleave", + "dragover", + "dragstart", + "drop", + "durationchange", + "emptied", + "ended", + "input", + "invalid", + "keydown", + "keypress", + "keyup", + "loadeddata", + "loadedmetadata", + "loadstart", + "mousedown", + "mousemove", + "mouseout", + "mouseover", + "mouseup", + "mousewheel", + "pause", + "play", + "playing", + "progress", + "ratechange", + "readystatechange", + "reset", + "seeked", + "seeking", + "select", + "show", + "stalled", + "submit", + "suspend", + "timeupdate", + "volumechange", + "waiting", + // These last 5 event types will be overriden by HTMLBodyElement + "blur", + "error", + "focus", + "load", + "scroll" + ] + }); + var HTMLUnknownElement = define3({ + name: "HTMLUnknownElement", + ctor: function HTMLUnknownElement2(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + } + }); + var formAssociatedProps = { + // See http://www.w3.org/TR/html5/association-of-controls-and-forms.html#form-owner + form: { get: function() { + return this._form; + } } + }; + define3({ + tag: "a", + name: "HTMLAnchorElement", + ctor: function HTMLAnchorElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + props: { + _post_click_activation_steps: { value: function(e) { + if (this.href) { + this.ownerDocument.defaultView.location = this.href; + } + } } + }, + attributes: { + href: URL2, + ping: String, + download: String, + target: String, + rel: String, + media: String, + hreflang: String, + type: String, + referrerPolicy: REFERRER, + // Obsolete + coords: String, + charset: String, + name: String, + rev: String, + shape: String + } + }); + URLUtils._inherit(htmlNameToImpl.a.prototype); + define3({ + tag: "area", + name: "HTMLAreaElement", + ctor: function HTMLAreaElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + alt: String, + target: String, + download: String, + rel: String, + media: String, + href: URL2, + hreflang: String, + type: String, + shape: String, + coords: String, + ping: String, + // XXX: also reflect relList + referrerPolicy: REFERRER, + // Obsolete + noHref: Boolean + } + }); + URLUtils._inherit(htmlNameToImpl.area.prototype); + define3({ + tag: "br", + name: "HTMLBRElement", + ctor: function HTMLBRElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + // Obsolete + clear: String + } + }); + define3({ + tag: "base", + name: "HTMLBaseElement", + ctor: function HTMLBaseElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + "target": String + } + }); + define3({ + tag: "body", + name: "HTMLBodyElement", + ctor: function HTMLBodyElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + // Certain event handler attributes on a tag actually set + // handlers for the window rather than just that element. Define + // getters and setters for those here. Note that some of these override + // properties on HTMLElement.prototype. + // XXX: If I add support for , these have to go there, too + // XXX + // When the Window object is implemented, these attribute will have + // to work with the same-named attributes on the Window. + events: [ + "afterprint", + "beforeprint", + "beforeunload", + "blur", + "error", + "focus", + "hashchange", + "load", + "message", + "offline", + "online", + "pagehide", + "pageshow", + "popstate", + "resize", + "scroll", + "storage", + "unload" + ], + attributes: { + // Obsolete + text: { type: String, treatNullAsEmptyString: true }, + link: { type: String, treatNullAsEmptyString: true }, + vLink: { type: String, treatNullAsEmptyString: true }, + aLink: { type: String, treatNullAsEmptyString: true }, + bgColor: { type: String, treatNullAsEmptyString: true }, + background: String + } + }); + define3({ + tag: "button", + name: "HTMLButtonElement", + ctor: function HTMLButtonElement(doc, localName, prefix) { + HTMLFormElement.call(this, doc, localName, prefix); + }, + props: formAssociatedProps, + attributes: { + name: String, + value: String, + disabled: Boolean, + autofocus: Boolean, + type: { type: ["submit", "reset", "button", "menu"], missing: "submit" }, + formTarget: String, + formAction: URL2, + formNoValidate: Boolean, + formMethod: { type: ["get", "post", "dialog"], invalid: "get", missing: "" }, + formEnctype: { type: ["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"], invalid: "application/x-www-form-urlencoded", missing: "" } + } + }); + define3({ + tag: "dl", + name: "HTMLDListElement", + ctor: function HTMLDListElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + // Obsolete + compact: Boolean + } + }); + define3({ + tag: "data", + name: "HTMLDataElement", + ctor: function HTMLDataElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + value: String + } + }); + define3({ + tag: "datalist", + name: "HTMLDataListElement", + ctor: function HTMLDataListElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + } + }); + define3({ + tag: "details", + name: "HTMLDetailsElement", + ctor: function HTMLDetailsElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + "open": Boolean + } + }); + define3({ + tag: "div", + name: "HTMLDivElement", + ctor: function HTMLDivElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + // Obsolete + align: String + } + }); + define3({ + tag: "embed", + name: "HTMLEmbedElement", + ctor: function HTMLEmbedElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + src: URL2, + type: String, + width: String, + height: String, + // Obsolete + align: String, + name: String + } + }); + define3({ + tag: "fieldset", + name: "HTMLFieldSetElement", + ctor: function HTMLFieldSetElement(doc, localName, prefix) { + HTMLFormElement.call(this, doc, localName, prefix); + }, + props: formAssociatedProps, + attributes: { + disabled: Boolean, + name: String + } + }); + define3({ + tag: "form", + name: "HTMLFormElement", + ctor: function HTMLFormElement2(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + action: String, + autocomplete: { type: ["on", "off"], missing: "on" }, + name: String, + acceptCharset: { name: "accept-charset" }, + target: String, + noValidate: Boolean, + method: { type: ["get", "post", "dialog"], invalid: "get", missing: "get" }, + // Both enctype and encoding reflect the enctype content attribute + enctype: { type: ["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"], invalid: "application/x-www-form-urlencoded", missing: "application/x-www-form-urlencoded" }, + encoding: { name: "enctype", type: ["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"], invalid: "application/x-www-form-urlencoded", missing: "application/x-www-form-urlencoded" } + } + }); + define3({ + tag: "hr", + name: "HTMLHRElement", + ctor: function HTMLHRElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + // Obsolete + align: String, + color: String, + noShade: Boolean, + size: String, + width: String + } + }); + define3({ + tag: "head", + name: "HTMLHeadElement", + ctor: function HTMLHeadElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + } + }); + define3({ + tags: ["h1", "h2", "h3", "h4", "h5", "h6"], + name: "HTMLHeadingElement", + ctor: function HTMLHeadingElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + // Obsolete + align: String + } + }); + define3({ + tag: "html", + name: "HTMLHtmlElement", + ctor: function HTMLHtmlElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + xmlns: URL2, + // Obsolete + version: String + } + }); + define3({ + tag: "iframe", + name: "HTMLIFrameElement", + ctor: function HTMLIFrameElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + src: URL2, + srcdoc: String, + name: String, + width: String, + height: String, + // XXX: sandbox is a reflected settable token list + seamless: Boolean, + allow: Boolean, + allowFullscreen: Boolean, + allowUserMedia: Boolean, + allowPaymentRequest: Boolean, + referrerPolicy: REFERRER, + loading: { type: ["eager", "lazy"], treatNullAsEmptyString: true }, + // Obsolete + align: String, + scrolling: String, + frameBorder: String, + longDesc: URL2, + marginHeight: { type: String, treatNullAsEmptyString: true }, + marginWidth: { type: String, treatNullAsEmptyString: true } + } + }); + define3({ + tag: "img", + name: "HTMLImageElement", + ctor: function HTMLImageElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + alt: String, + src: URL2, + srcset: String, + crossOrigin: CORS, + useMap: String, + isMap: Boolean, + sizes: String, + height: { type: "unsigned long", default: 0 }, + width: { type: "unsigned long", default: 0 }, + referrerPolicy: REFERRER, + loading: { type: ["eager", "lazy"], missing: "" }, + // Obsolete: + name: String, + lowsrc: URL2, + align: String, + hspace: { type: "unsigned long", default: 0 }, + vspace: { type: "unsigned long", default: 0 }, + longDesc: URL2, + border: { type: String, treatNullAsEmptyString: true } + } + }); + define3({ + tag: "input", + name: "HTMLInputElement", + ctor: function HTMLInputElement(doc, localName, prefix) { + HTMLFormElement.call(this, doc, localName, prefix); + }, + props: { + form: formAssociatedProps.form, + _post_click_activation_steps: { value: function(e) { + if (this.type === "checkbox") { + this.checked = !this.checked; + } else if (this.type === "radio") { + var group2 = this.form.getElementsByName(this.name); + for (var i = group2.length - 1; i >= 0; i--) { + var el = group2[i]; + el.checked = el === this; + } + } + } } + }, + attributes: { + name: String, + disabled: Boolean, + autofocus: Boolean, + accept: String, + alt: String, + max: String, + min: String, + pattern: String, + placeholder: String, + step: String, + dirName: String, + defaultValue: { name: "value" }, + multiple: Boolean, + required: Boolean, + readOnly: Boolean, + checked: Boolean, + value: String, + src: URL2, + defaultChecked: { name: "checked", type: Boolean }, + size: { type: "unsigned long", default: 20, min: 1, setmin: 1 }, + width: { type: "unsigned long", min: 0, setmin: 0, default: 0 }, + height: { type: "unsigned long", min: 0, setmin: 0, default: 0 }, + minLength: { type: "unsigned long", min: 0, setmin: 0, default: -1 }, + maxLength: { type: "unsigned long", min: 0, setmin: 0, default: -1 }, + autocomplete: String, + // It's complicated + type: { + type: [ + "text", + "hidden", + "search", + "tel", + "url", + "email", + "password", + "datetime", + "date", + "month", + "week", + "time", + "datetime-local", + "number", + "range", + "color", + "checkbox", + "radio", + "file", + "submit", + "image", + "reset", + "button" + ], + missing: "text" + }, + formTarget: String, + formNoValidate: Boolean, + formMethod: { type: ["get", "post"], invalid: "get", missing: "" }, + formEnctype: { type: ["application/x-www-form-urlencoded", "multipart/form-data", "text/plain"], invalid: "application/x-www-form-urlencoded", missing: "" }, + inputMode: { type: ["verbatim", "latin", "latin-name", "latin-prose", "full-width-latin", "kana", "kana-name", "katakana", "numeric", "tel", "email", "url"], missing: "" }, + // Obsolete + align: String, + useMap: String + } + }); + define3({ + tag: "keygen", + name: "HTMLKeygenElement", + ctor: function HTMLKeygenElement(doc, localName, prefix) { + HTMLFormElement.call(this, doc, localName, prefix); + }, + props: formAssociatedProps, + attributes: { + name: String, + disabled: Boolean, + autofocus: Boolean, + challenge: String, + keytype: { type: ["rsa"], missing: "" } + } + }); + define3({ + tag: "li", + name: "HTMLLIElement", + ctor: function HTMLLIElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + value: { type: "long", default: 0 }, + // Obsolete + type: String + } + }); + define3({ + tag: "label", + name: "HTMLLabelElement", + ctor: function HTMLLabelElement(doc, localName, prefix) { + HTMLFormElement.call(this, doc, localName, prefix); + }, + props: formAssociatedProps, + attributes: { + htmlFor: { name: "for", type: String } + } + }); + define3({ + tag: "legend", + name: "HTMLLegendElement", + ctor: function HTMLLegendElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + // Obsolete + align: String + } + }); + define3({ + tag: "link", + name: "HTMLLinkElement", + ctor: function HTMLLinkElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + // XXX Reflect DOMSettableTokenList sizes also DOMTokenList relList + href: URL2, + rel: String, + media: String, + hreflang: String, + type: String, + crossOrigin: CORS, + nonce: String, + integrity: String, + referrerPolicy: REFERRER, + imageSizes: String, + imageSrcset: String, + // Obsolete + charset: String, + rev: String, + target: String + } + }); + define3({ + tag: "map", + name: "HTMLMapElement", + ctor: function HTMLMapElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + name: String + } + }); + define3({ + tag: "menu", + name: "HTMLMenuElement", + ctor: function HTMLMenuElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + // XXX: not quite right, default should be popup if parent element is + // popup. + type: { type: ["context", "popup", "toolbar"], missing: "toolbar" }, + label: String, + // Obsolete + compact: Boolean + } + }); + define3({ + tag: "meta", + name: "HTMLMetaElement", + ctor: function HTMLMetaElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + name: String, + content: String, + httpEquiv: { name: "http-equiv", type: String }, + // Obsolete + scheme: String + } + }); + define3({ + tag: "meter", + name: "HTMLMeterElement", + ctor: function HTMLMeterElement(doc, localName, prefix) { + HTMLFormElement.call(this, doc, localName, prefix); + }, + props: formAssociatedProps + }); + define3({ + tags: ["ins", "del"], + name: "HTMLModElement", + ctor: function HTMLModElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + cite: URL2, + dateTime: String + } + }); + define3({ + tag: "ol", + name: "HTMLOListElement", + ctor: function HTMLOListElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + props: { + // Utility function (see the start attribute default value). Returns + // the number of
  • children of this element + _numitems: { get: function() { + var items = 0; + this.childNodes.forEach(function(n) { + if (n.nodeType === Node.ELEMENT_NODE && n.tagName === "LI") + items++; + }); + return items; + } } + }, + attributes: { + type: String, + reversed: Boolean, + start: { + type: "long", + default: function() { + if (this.reversed) + return this._numitems; + else + return 1; + } + }, + // Obsolete + compact: Boolean + } + }); + define3({ + tag: "object", + name: "HTMLObjectElement", + ctor: function HTMLObjectElement(doc, localName, prefix) { + HTMLFormElement.call(this, doc, localName, prefix); + }, + props: formAssociatedProps, + attributes: { + data: URL2, + type: String, + name: String, + useMap: String, + typeMustMatch: Boolean, + width: String, + height: String, + // Obsolete + align: String, + archive: String, + code: String, + declare: Boolean, + hspace: { type: "unsigned long", default: 0 }, + standby: String, + vspace: { type: "unsigned long", default: 0 }, + codeBase: URL2, + codeType: String, + border: { type: String, treatNullAsEmptyString: true } + } + }); + define3({ + tag: "optgroup", + name: "HTMLOptGroupElement", + ctor: function HTMLOptGroupElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + disabled: Boolean, + label: String + } + }); + define3({ + tag: "option", + name: "HTMLOptionElement", + ctor: function HTMLOptionElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + props: { + form: { get: function() { + var p = this.parentNode; + while (p && p.nodeType === Node.ELEMENT_NODE) { + if (p.localName === "select") return p.form; + p = p.parentNode; + } + } }, + value: { + get: function() { + return this._getattr("value") || this.text; + }, + set: function(v) { + this._setattr("value", v); + } + }, + text: { + get: function() { + return this.textContent.replace(/[ \t\n\f\r]+/g, " ").trim(); + }, + set: function(v) { + this.textContent = v; + } + } + // missing: index + }, + attributes: { + disabled: Boolean, + defaultSelected: { name: "selected", type: Boolean }, + label: String + } + }); + define3({ + tag: "output", + name: "HTMLOutputElement", + ctor: function HTMLOutputElement(doc, localName, prefix) { + HTMLFormElement.call(this, doc, localName, prefix); + }, + props: formAssociatedProps, + attributes: { + // XXX Reflect for/htmlFor as a settable token list + name: String + } + }); + define3({ + tag: "p", + name: "HTMLParagraphElement", + ctor: function HTMLParagraphElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + // Obsolete + align: String + } + }); + define3({ + tag: "param", + name: "HTMLParamElement", + ctor: function HTMLParamElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + name: String, + value: String, + // Obsolete + type: String, + valueType: String + } + }); + define3({ + tags: [ + "pre", + /*legacy elements:*/ + "listing", + "xmp" + ], + name: "HTMLPreElement", + ctor: function HTMLPreElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + // Obsolete + width: { type: "long", default: 0 } + } + }); + define3({ + tag: "progress", + name: "HTMLProgressElement", + ctor: function HTMLProgressElement(doc, localName, prefix) { + HTMLFormElement.call(this, doc, localName, prefix); + }, + props: formAssociatedProps, + attributes: { + max: { type: Number, float: true, default: 1, min: 0 } + } + }); + define3({ + tags: ["q", "blockquote"], + name: "HTMLQuoteElement", + ctor: function HTMLQuoteElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + cite: URL2 + } + }); + define3({ + tag: "script", + name: "HTMLScriptElement", + ctor: function HTMLScriptElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + props: { + text: { + get: function() { + var s = ""; + for (var i = 0, n = this.childNodes.length; i < n; i++) { + var child = this.childNodes[i]; + if (child.nodeType === Node.TEXT_NODE) + s += child._data; + } + return s; + }, + set: function(value2) { + this.removeChildren(); + if (value2 !== null && value2 !== "") { + this.appendChild(this.ownerDocument.createTextNode(value2)); + } + } + } + }, + attributes: { + src: URL2, + type: String, + charset: String, + referrerPolicy: REFERRER, + defer: Boolean, + async: Boolean, + nomodule: Boolean, + crossOrigin: CORS, + nonce: String, + integrity: String + } + }); + define3({ + tag: "select", + name: "HTMLSelectElement", + ctor: function HTMLSelectElement(doc, localName, prefix) { + HTMLFormElement.call(this, doc, localName, prefix); + }, + props: { + form: formAssociatedProps.form, + options: { get: function() { + return this.getElementsByTagName("option"); + } } + }, + attributes: { + autocomplete: String, + // It's complicated + name: String, + disabled: Boolean, + autofocus: Boolean, + multiple: Boolean, + required: Boolean, + size: { type: "unsigned long", default: 0 } + } + }); + define3({ + tag: "span", + name: "HTMLSpanElement", + ctor: function HTMLSpanElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + } + }); + define3({ + tag: "style", + name: "HTMLStyleElement", + ctor: function HTMLStyleElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + media: String, + type: String, + scoped: Boolean + } + }); + define3({ + tag: "caption", + name: "HTMLTableCaptionElement", + ctor: function HTMLTableCaptionElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + // Obsolete + align: String + } + }); + define3({ + name: "HTMLTableCellElement", + ctor: function HTMLTableCellElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + colSpan: { type: "unsigned long", default: 1 }, + rowSpan: { type: "unsigned long", default: 1 }, + //XXX Also reflect settable token list headers + scope: { type: ["row", "col", "rowgroup", "colgroup"], missing: "" }, + abbr: String, + // Obsolete + align: String, + axis: String, + height: String, + width: String, + ch: { name: "char", type: String }, + chOff: { name: "charoff", type: String }, + noWrap: Boolean, + vAlign: String, + bgColor: { type: String, treatNullAsEmptyString: true } + } + }); + define3({ + tags: ["col", "colgroup"], + name: "HTMLTableColElement", + ctor: function HTMLTableColElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + span: { type: "limited unsigned long with fallback", default: 1, min: 1 }, + // Obsolete + align: String, + ch: { name: "char", type: String }, + chOff: { name: "charoff", type: String }, + vAlign: String, + width: String + } + }); + define3({ + tag: "table", + name: "HTMLTableElement", + ctor: function HTMLTableElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + props: { + rows: { get: function() { + return this.getElementsByTagName("tr"); + } } + }, + attributes: { + // Obsolete + align: String, + border: String, + frame: String, + rules: String, + summary: String, + width: String, + bgColor: { type: String, treatNullAsEmptyString: true }, + cellPadding: { type: String, treatNullAsEmptyString: true }, + cellSpacing: { type: String, treatNullAsEmptyString: true } + } + }); + define3({ + tag: "template", + name: "HTMLTemplateElement", + ctor: function HTMLTemplateElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + this._contentFragment = doc._templateDoc.createDocumentFragment(); + }, + props: { + content: { get: function() { + return this._contentFragment; + } }, + serialize: { value: function() { + return this.content.serialize(); + } } + } + }); + define3({ + tag: "tr", + name: "HTMLTableRowElement", + ctor: function HTMLTableRowElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + props: { + cells: { get: function() { + return this.querySelectorAll("td,th"); + } } + }, + attributes: { + // Obsolete + align: String, + ch: { name: "char", type: String }, + chOff: { name: "charoff", type: String }, + vAlign: String, + bgColor: { type: String, treatNullAsEmptyString: true } + } + }); + define3({ + tags: ["thead", "tfoot", "tbody"], + name: "HTMLTableSectionElement", + ctor: function HTMLTableSectionElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + props: { + rows: { get: function() { + return this.getElementsByTagName("tr"); + } } + }, + attributes: { + // Obsolete + align: String, + ch: { name: "char", type: String }, + chOff: { name: "charoff", type: String }, + vAlign: String + } + }); + define3({ + tag: "textarea", + name: "HTMLTextAreaElement", + ctor: function HTMLTextAreaElement(doc, localName, prefix) { + HTMLFormElement.call(this, doc, localName, prefix); + }, + props: { + form: formAssociatedProps.form, + type: { get: function() { + return "textarea"; + } }, + defaultValue: { + get: function() { + return this.textContent; + }, + set: function(v) { + this.textContent = v; + } + }, + value: { + get: function() { + return this.defaultValue; + }, + set: function(v) { + this.defaultValue = v; + } + }, + textLength: { get: function() { + return this.value.length; + } } + }, + attributes: { + autocomplete: String, + // It's complicated + name: String, + disabled: Boolean, + autofocus: Boolean, + placeholder: String, + wrap: String, + dirName: String, + required: Boolean, + readOnly: Boolean, + rows: { type: "limited unsigned long with fallback", default: 2 }, + cols: { type: "limited unsigned long with fallback", default: 20 }, + maxLength: { type: "unsigned long", min: 0, setmin: 0, default: -1 }, + minLength: { type: "unsigned long", min: 0, setmin: 0, default: -1 }, + inputMode: { type: ["verbatim", "latin", "latin-name", "latin-prose", "full-width-latin", "kana", "kana-name", "katakana", "numeric", "tel", "email", "url"], missing: "" } + } + }); + define3({ + tag: "time", + name: "HTMLTimeElement", + ctor: function HTMLTimeElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + dateTime: String, + pubDate: Boolean + } + }); + define3({ + tag: "title", + name: "HTMLTitleElement", + ctor: function HTMLTitleElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + props: { + text: { get: function() { + return this.textContent; + } } + } + }); + define3({ + tag: "ul", + name: "HTMLUListElement", + ctor: function HTMLUListElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + type: String, + // Obsolete + compact: Boolean + } + }); + define3({ + name: "HTMLMediaElement", + ctor: function HTMLMediaElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + src: URL2, + crossOrigin: CORS, + preload: { type: ["metadata", "none", "auto", { value: "", alias: "auto" }], missing: "auto" }, + loop: Boolean, + autoplay: Boolean, + mediaGroup: String, + controls: Boolean, + defaultMuted: { name: "muted", type: Boolean } + } + }); + define3({ + name: "HTMLAudioElement", + tag: "audio", + superclass: htmlElements.HTMLMediaElement, + ctor: function HTMLAudioElement(doc, localName, prefix) { + htmlElements.HTMLMediaElement.call(this, doc, localName, prefix); + } + }); + define3({ + name: "HTMLVideoElement", + tag: "video", + superclass: htmlElements.HTMLMediaElement, + ctor: function HTMLVideoElement(doc, localName, prefix) { + htmlElements.HTMLMediaElement.call(this, doc, localName, prefix); + }, + attributes: { + poster: URL2, + width: { type: "unsigned long", min: 0, default: 0 }, + height: { type: "unsigned long", min: 0, default: 0 } + } + }); + define3({ + tag: "td", + name: "HTMLTableDataCellElement", + superclass: htmlElements.HTMLTableCellElement, + ctor: function HTMLTableDataCellElement(doc, localName, prefix) { + htmlElements.HTMLTableCellElement.call(this, doc, localName, prefix); + } + }); + define3({ + tag: "th", + name: "HTMLTableHeaderCellElement", + superclass: htmlElements.HTMLTableCellElement, + ctor: function HTMLTableHeaderCellElement(doc, localName, prefix) { + htmlElements.HTMLTableCellElement.call(this, doc, localName, prefix); + } + }); + define3({ + tag: "frameset", + name: "HTMLFrameSetElement", + ctor: function HTMLFrameSetElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + } + }); + define3({ + tag: "frame", + name: "HTMLFrameElement", + ctor: function HTMLFrameElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + } + }); + define3({ + tag: "canvas", + name: "HTMLCanvasElement", + ctor: function HTMLCanvasElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + props: { + getContext: { value: utils.nyi }, + probablySupportsContext: { value: utils.nyi }, + setContext: { value: utils.nyi }, + transferControlToProxy: { value: utils.nyi }, + toDataURL: { value: utils.nyi }, + toBlob: { value: utils.nyi } + }, + attributes: { + width: { type: "unsigned long", default: 300 }, + height: { type: "unsigned long", default: 150 } + } + }); + define3({ + tag: "dialog", + name: "HTMLDialogElement", + ctor: function HTMLDialogElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + props: { + show: { value: utils.nyi }, + showModal: { value: utils.nyi }, + close: { value: utils.nyi } + }, + attributes: { + open: Boolean, + returnValue: String + } + }); + define3({ + tag: "menuitem", + name: "HTMLMenuItemElement", + ctor: function HTMLMenuItemElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + props: { + // The menuitem's label + _label: { + get: function() { + var val = this._getattr("label"); + if (val !== null && val !== "") { + return val; + } + val = this.textContent; + return val.replace(/[ \t\n\f\r]+/g, " ").trim(); + } + }, + // The menuitem label IDL attribute + label: { + get: function() { + var val = this._getattr("label"); + if (val !== null) { + return val; + } + return this._label; + }, + set: function(v) { + this._setattr("label", v); + } + } + }, + attributes: { + type: { type: ["command", "checkbox", "radio"], missing: "command" }, + icon: URL2, + disabled: Boolean, + checked: Boolean, + radiogroup: String, + default: Boolean + } + }); + define3({ + tag: "source", + name: "HTMLSourceElement", + ctor: function HTMLSourceElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + srcset: String, + sizes: String, + media: String, + src: URL2, + type: String, + width: String, + height: String + } + }); + define3({ + tag: "track", + name: "HTMLTrackElement", + ctor: function HTMLTrackElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + src: URL2, + srclang: String, + label: String, + default: Boolean, + kind: { type: ["subtitles", "captions", "descriptions", "chapters", "metadata"], missing: "subtitles", invalid: "metadata" } + }, + props: { + NONE: { get: function() { + return 0; + } }, + LOADING: { get: function() { + return 1; + } }, + LOADED: { get: function() { + return 2; + } }, + ERROR: { get: function() { + return 3; + } }, + readyState: { get: utils.nyi }, + track: { get: utils.nyi } + } + }); + define3({ + // obsolete + tag: "font", + name: "HTMLFontElement", + ctor: function HTMLFontElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + color: { type: String, treatNullAsEmptyString: true }, + face: { type: String }, + size: { type: String } + } + }); + define3({ + // obsolete + tag: "dir", + name: "HTMLDirectoryElement", + ctor: function HTMLDirectoryElement(doc, localName, prefix) { + HTMLElement.call(this, doc, localName, prefix); + }, + attributes: { + compact: Boolean + } + }); + define3({ + tags: [ + "abbr", + "address", + "article", + "aside", + "b", + "bdi", + "bdo", + "cite", + "content", + "code", + "dd", + "dfn", + "dt", + "em", + "figcaption", + "figure", + "footer", + "header", + "hgroup", + "i", + "kbd", + "main", + "mark", + "nav", + "noscript", + "rb", + "rp", + "rt", + "rtc", + "ruby", + "s", + "samp", + "section", + "small", + "strong", + "sub", + "summary", + "sup", + "u", + "var", + "wbr", + // Legacy elements + "acronym", + "basefont", + "big", + "center", + "nobr", + "noembed", + "noframes", + "plaintext", + "strike", + "tt" + ] + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/svg.js +var require_svg = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/svg.js"(exports) { + "use strict"; + var Element = require_Element(); + var defineElement = require_defineElement(); + var utils = require_utils8(); + var CSSStyleDeclaration = require_CSSStyleDeclaration(); + var svgElements = exports.elements = {}; + var svgNameToImpl = /* @__PURE__ */ Object.create(null); + exports.createElement = function(doc, localName, prefix) { + var impl = svgNameToImpl[localName] || SVGElement; + return new impl(doc, localName, prefix); + }; + function define3(spec) { + return defineElement(spec, SVGElement, svgElements, svgNameToImpl); + } + var SVGElement = define3({ + superclass: Element, + name: "SVGElement", + ctor: function SVGElement2(doc, localName, prefix) { + Element.call(this, doc, localName, utils.NAMESPACE.SVG, prefix); + }, + props: { + style: { get: function() { + if (!this._style) + this._style = new CSSStyleDeclaration(this); + return this._style; + } } + } + }); + define3({ + name: "SVGSVGElement", + ctor: function SVGSVGElement(doc, localName, prefix) { + SVGElement.call(this, doc, localName, prefix); + }, + tag: "svg", + props: { + createSVGRect: { value: function() { + return exports.createElement(this.ownerDocument, "rect", null); + } } + } + }); + define3({ + tags: [ + "a", + "altGlyph", + "altGlyphDef", + "altGlyphItem", + "animate", + "animateColor", + "animateMotion", + "animateTransform", + "circle", + "clipPath", + "color-profile", + "cursor", + "defs", + "desc", + "ellipse", + "feBlend", + "feColorMatrix", + "feComponentTransfer", + "feComposite", + "feConvolveMatrix", + "feDiffuseLighting", + "feDisplacementMap", + "feDistantLight", + "feFlood", + "feFuncA", + "feFuncB", + "feFuncG", + "feFuncR", + "feGaussianBlur", + "feImage", + "feMerge", + "feMergeNode", + "feMorphology", + "feOffset", + "fePointLight", + "feSpecularLighting", + "feSpotLight", + "feTile", + "feTurbulence", + "filter", + "font", + "font-face", + "font-face-format", + "font-face-name", + "font-face-src", + "font-face-uri", + "foreignObject", + "g", + "glyph", + "glyphRef", + "hkern", + "image", + "line", + "linearGradient", + "marker", + "mask", + "metadata", + "missing-glyph", + "mpath", + "path", + "pattern", + "polygon", + "polyline", + "radialGradient", + "rect", + "script", + "set", + "stop", + "style", + "switch", + "symbol", + "text", + "textPath", + "title", + "tref", + "tspan", + "use", + "view", + "vkern" + ] + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/MutationConstants.js +var require_MutationConstants = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/MutationConstants.js"(exports, module) { + "use strict"; + module.exports = { + VALUE: 1, + // The value of a Text, Comment or PI node changed + ATTR: 2, + // A new attribute was added or an attribute value and/or prefix changed + REMOVE_ATTR: 3, + // An attribute was removed + REMOVE: 4, + // A node was removed + MOVE: 5, + // A node was moved + INSERT: 6 + // A node (or a subtree of nodes) was inserted + }; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Document.js +var require_Document = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Document.js"(exports, module) { + "use strict"; + module.exports = Document; + var Node = require_Node(); + var NodeList = require_NodeList(); + var ContainerNode = require_ContainerNode(); + var Element = require_Element(); + var Text = require_Text(); + var Comment2 = require_Comment(); + var Event2 = require_Event(); + var DocumentFragment = require_DocumentFragment(); + var ProcessingInstruction = require_ProcessingInstruction(); + var DOMImplementation = require_DOMImplementation(); + var TreeWalker = require_TreeWalker(); + var NodeIterator = require_NodeIterator(); + var NodeFilter = require_NodeFilter(); + var URL2 = require_URL(); + var select = require_select(); + var events = require_events3(); + var xml = require_xmlnames(); + var html = require_htmlelts(); + var svg = require_svg(); + var utils = require_utils8(); + var MUTATE = require_MutationConstants(); + var NAMESPACE = utils.NAMESPACE; + var isApiWritable = require_config().isApiWritable; + function Document(isHTML, address) { + ContainerNode.call(this); + this.nodeType = Node.DOCUMENT_NODE; + this.isHTML = isHTML; + this._address = address || "about:blank"; + this.readyState = "loading"; + this.implementation = new DOMImplementation(this); + this.ownerDocument = null; + this._contentType = isHTML ? "text/html" : "application/xml"; + this.doctype = null; + this.documentElement = null; + this._templateDocCache = null; + this._nodeIterators = null; + this._nid = 1; + this._nextnid = 2; + this._nodes = [null, this]; + this.byId = /* @__PURE__ */ Object.create(null); + this.modclock = 0; + } + var supportedEvents = { + event: "Event", + customevent: "CustomEvent", + uievent: "UIEvent", + mouseevent: "MouseEvent" + }; + var replacementEvent = { + events: "event", + htmlevents: "event", + mouseevents: "mouseevent", + mutationevents: "mutationevent", + uievents: "uievent" + }; + var mirrorAttr = function(f, name, defaultValue) { + return { + get: function() { + var o = f.call(this); + if (o) { + return o[name]; + } + return defaultValue; + }, + set: function(value2) { + var o = f.call(this); + if (o) { + o[name] = value2; + } + } + }; + }; + function validateAndExtract(namespace, qualifiedName) { + var prefix, localName, pos; + if (namespace === "") { + namespace = null; + } + if (!xml.isValidQName(qualifiedName)) { + utils.InvalidCharacterError(); + } + prefix = null; + localName = qualifiedName; + pos = qualifiedName.indexOf(":"); + if (pos >= 0) { + prefix = qualifiedName.substring(0, pos); + localName = qualifiedName.substring(pos + 1); + } + if (prefix !== null && namespace === null) { + utils.NamespaceError(); + } + if (prefix === "xml" && namespace !== NAMESPACE.XML) { + utils.NamespaceError(); + } + if ((prefix === "xmlns" || qualifiedName === "xmlns") && namespace !== NAMESPACE.XMLNS) { + utils.NamespaceError(); + } + if (namespace === NAMESPACE.XMLNS && !(prefix === "xmlns" || qualifiedName === "xmlns")) { + utils.NamespaceError(); + } + return { namespace, prefix, localName }; + } + Document.prototype = Object.create(ContainerNode.prototype, { + // This method allows dom.js to communicate with a renderer + // that displays the document in some way + // XXX: I should probably move this to the window object + _setMutationHandler: { value: function(handler2) { + this.mutationHandler = handler2; + } }, + // This method allows dom.js to receive event notifications + // from the renderer. + // XXX: I should probably move this to the window object + _dispatchRendererEvent: { value: function(targetNid, type2, details) { + var target = this._nodes[targetNid]; + if (!target) return; + target._dispatchEvent(new Event2(type2, details), true); + } }, + nodeName: { value: "#document" }, + nodeValue: { + get: function() { + return null; + }, + set: function() { + } + }, + // XXX: DOMCore may remove documentURI, so it is NYI for now + documentURI: { get: function() { + return this._address; + }, set: utils.nyi }, + compatMode: { get: function() { + return this._quirks ? "BackCompat" : "CSS1Compat"; + } }, + createTextNode: { value: function(data) { + return new Text(this, String(data)); + } }, + createComment: { value: function(data) { + return new Comment2(this, data); + } }, + createDocumentFragment: { value: function() { + return new DocumentFragment(this); + } }, + createProcessingInstruction: { value: function(target, data) { + if (!xml.isValidName(target) || data.indexOf("?>") !== -1) + utils.InvalidCharacterError(); + return new ProcessingInstruction(this, target, data); + } }, + createAttribute: { value: function(localName) { + localName = String(localName); + if (!xml.isValidName(localName)) utils.InvalidCharacterError(); + if (this.isHTML) { + localName = utils.toASCIILowerCase(localName); + } + return new Element._Attr(null, localName, null, null, ""); + } }, + createAttributeNS: { value: function(namespace, qualifiedName) { + namespace = namespace === null || namespace === void 0 || namespace === "" ? null : String(namespace); + qualifiedName = String(qualifiedName); + var ve = validateAndExtract(namespace, qualifiedName); + return new Element._Attr(null, ve.localName, ve.prefix, ve.namespace, ""); + } }, + createElement: { value: function(localName) { + localName = String(localName); + if (!xml.isValidName(localName)) utils.InvalidCharacterError(); + if (this.isHTML) { + if (/[A-Z]/.test(localName)) + localName = utils.toASCIILowerCase(localName); + return html.createElement(this, localName, null); + } else if (this.contentType === "application/xhtml+xml") { + return html.createElement(this, localName, null); + } else { + return new Element(this, localName, null, null); + } + }, writable: isApiWritable }, + createElementNS: { value: function(namespace, qualifiedName) { + namespace = namespace === null || namespace === void 0 || namespace === "" ? null : String(namespace); + qualifiedName = String(qualifiedName); + var ve = validateAndExtract(namespace, qualifiedName); + return this._createElementNS(ve.localName, ve.namespace, ve.prefix); + }, writable: isApiWritable }, + // This is used directly by HTML parser, which allows it to create + // elements with localNames containing ':' and non-default namespaces + _createElementNS: { value: function(localName, namespace, prefix) { + if (namespace === NAMESPACE.HTML) { + return html.createElement(this, localName, prefix); + } else if (namespace === NAMESPACE.SVG) { + return svg.createElement(this, localName, prefix); + } + return new Element(this, localName, namespace, prefix); + } }, + createEvent: { value: function createEvent(interfaceName) { + interfaceName = interfaceName.toLowerCase(); + var name = replacementEvent[interfaceName] || interfaceName; + var constructor = events[supportedEvents[name]]; + if (constructor) { + var e = new constructor(); + e._initialized = false; + return e; + } else { + utils.NotSupportedError(); + } + } }, + // See: http://www.w3.org/TR/dom/#dom-document-createtreewalker + createTreeWalker: { value: function(root3, whatToShow, filter) { + if (!root3) { + throw new TypeError("root argument is required"); + } + if (!(root3 instanceof Node)) { + throw new TypeError("root not a node"); + } + whatToShow = whatToShow === void 0 ? NodeFilter.SHOW_ALL : +whatToShow; + filter = filter === void 0 ? null : filter; + return new TreeWalker(root3, whatToShow, filter); + } }, + // See: http://www.w3.org/TR/dom/#dom-document-createnodeiterator + createNodeIterator: { value: function(root3, whatToShow, filter) { + if (!root3) { + throw new TypeError("root argument is required"); + } + if (!(root3 instanceof Node)) { + throw new TypeError("root not a node"); + } + whatToShow = whatToShow === void 0 ? NodeFilter.SHOW_ALL : +whatToShow; + filter = filter === void 0 ? null : filter; + return new NodeIterator(root3, whatToShow, filter); + } }, + _attachNodeIterator: { value: function(ni) { + if (!this._nodeIterators) { + this._nodeIterators = []; + } + this._nodeIterators.push(ni); + } }, + _detachNodeIterator: { value: function(ni) { + var idx = this._nodeIterators.indexOf(ni); + this._nodeIterators.splice(idx, 1); + } }, + _preremoveNodeIterators: { value: function(toBeRemoved) { + if (this._nodeIterators) { + this._nodeIterators.forEach(function(ni) { + ni._preremove(toBeRemoved); + }); + } + } }, + // Maintain the documentElement and + // doctype properties of the document. Each of the following + // methods chains to the Node implementation of the method + // to do the actual inserting, removal or replacement. + _updateDocTypeElement: { value: function _updateDocTypeElement() { + this.doctype = this.documentElement = null; + for (var kid = this.firstChild; kid !== null; kid = kid.nextSibling) { + if (kid.nodeType === Node.DOCUMENT_TYPE_NODE) + this.doctype = kid; + else if (kid.nodeType === Node.ELEMENT_NODE) + this.documentElement = kid; + } + } }, + insertBefore: { value: function insertBefore(child, refChild) { + Node.prototype.insertBefore.call(this, child, refChild); + this._updateDocTypeElement(); + return child; + } }, + replaceChild: { value: function replaceChild(node2, child) { + Node.prototype.replaceChild.call(this, node2, child); + this._updateDocTypeElement(); + return child; + } }, + removeChild: { value: function removeChild(child) { + Node.prototype.removeChild.call(this, child); + this._updateDocTypeElement(); + return child; + } }, + getElementById: { value: function(id) { + var n = this.byId[id]; + if (!n) return null; + if (n instanceof MultiId) { + return n.getFirst(); + } + return n; + } }, + _hasMultipleElementsWithId: { value: function(id) { + return this.byId[id] instanceof MultiId; + } }, + // Just copy this method from the Element prototype + getElementsByName: { value: Element.prototype.getElementsByName }, + getElementsByTagName: { value: Element.prototype.getElementsByTagName }, + getElementsByTagNameNS: { value: Element.prototype.getElementsByTagNameNS }, + getElementsByClassName: { value: Element.prototype.getElementsByClassName }, + adoptNode: { value: function adoptNode(node2) { + if (node2.nodeType === Node.DOCUMENT_NODE) utils.NotSupportedError(); + if (node2.nodeType === Node.ATTRIBUTE_NODE) { + return node2; + } + if (node2.parentNode) node2.parentNode.removeChild(node2); + if (node2.ownerDocument !== this) + recursivelySetOwner(node2, this); + return node2; + } }, + importNode: { value: function importNode(node2, deep) { + return this.adoptNode(node2.cloneNode(deep)); + }, writable: isApiWritable }, + // The following attributes and methods are from the HTML spec + origin: { get: function origin() { + return null; + } }, + characterSet: { get: function characterSet() { + return "UTF-8"; + } }, + contentType: { get: function contentType() { + return this._contentType; + } }, + URL: { get: function URL3() { + return this._address; + } }, + domain: { get: utils.nyi, set: utils.nyi }, + referrer: { get: utils.nyi }, + cookie: { get: utils.nyi, set: utils.nyi }, + lastModified: { get: utils.nyi }, + location: { + get: function() { + return this.defaultView ? this.defaultView.location : null; + }, + set: utils.nyi + }, + _titleElement: { + get: function() { + return this.getElementsByTagName("title").item(0) || null; + } + }, + title: { + get: function() { + var elt = this._titleElement; + var value2 = elt ? elt.textContent : ""; + return value2.replace(/[ \t\n\r\f]+/g, " ").replace(/(^ )|( $)/g, ""); + }, + set: function(value2) { + var elt = this._titleElement; + var head = this.head; + if (!elt && !head) { + return; + } + if (!elt) { + elt = this.createElement("title"); + head.appendChild(elt); + } + elt.textContent = value2; + } + }, + dir: mirrorAttr(function() { + var htmlElement = this.documentElement; + if (htmlElement && htmlElement.tagName === "HTML") { + return htmlElement; + } + }, "dir", ""), + fgColor: mirrorAttr(function() { + return this.body; + }, "text", ""), + linkColor: mirrorAttr(function() { + return this.body; + }, "link", ""), + vlinkColor: mirrorAttr(function() { + return this.body; + }, "vLink", ""), + alinkColor: mirrorAttr(function() { + return this.body; + }, "aLink", ""), + bgColor: mirrorAttr(function() { + return this.body; + }, "bgColor", ""), + // Historical aliases of Document#characterSet + charset: { get: function() { + return this.characterSet; + } }, + inputEncoding: { get: function() { + return this.characterSet; + } }, + scrollingElement: { + get: function() { + return this._quirks ? this.body : this.documentElement; + } + }, + // Return the first child of the document element. + // XXX For now, setting this attribute is not implemented. + body: { + get: function() { + return namedHTMLChild(this.documentElement, "body"); + }, + set: utils.nyi + }, + // Return the first child of the document element. + head: { get: function() { + return namedHTMLChild(this.documentElement, "head"); + } }, + images: { get: utils.nyi }, + embeds: { get: utils.nyi }, + plugins: { get: utils.nyi }, + links: { get: utils.nyi }, + forms: { get: utils.nyi }, + scripts: { get: utils.nyi }, + applets: { get: function() { + return []; + } }, + activeElement: { get: function() { + return null; + } }, + innerHTML: { + get: function() { + return this.serialize(); + }, + set: utils.nyi + }, + outerHTML: { + get: function() { + return this.serialize(); + }, + set: utils.nyi + }, + write: { value: function(args3) { + if (!this.isHTML) utils.InvalidStateError(); + if (!this._parser) + return; + if (!this._parser) { + } + var s = arguments.join(""); + this._parser.parse(s); + } }, + writeln: { value: function writeln(args3) { + this.write(Array.prototype.join.call(arguments, "") + "\n"); + } }, + open: { value: function() { + this.documentElement = null; + } }, + close: { value: function() { + this.readyState = "interactive"; + this._dispatchEvent(new Event2("readystatechange"), true); + this._dispatchEvent(new Event2("DOMContentLoaded"), true); + this.readyState = "complete"; + this._dispatchEvent(new Event2("readystatechange"), true); + if (this.defaultView) { + this.defaultView._dispatchEvent(new Event2("load"), true); + } + } }, + // Utility methods + clone: { value: function clone4() { + var d = new Document(this.isHTML, this._address); + d._quirks = this._quirks; + d._contentType = this._contentType; + return d; + } }, + // We need to adopt the nodes if we do a deep clone + cloneNode: { value: function cloneNode(deep) { + var clone4 = Node.prototype.cloneNode.call(this, false); + if (deep) { + for (var kid = this.firstChild; kid !== null; kid = kid.nextSibling) { + clone4._appendChild(clone4.importNode(kid, true)); + } + } + clone4._updateDocTypeElement(); + return clone4; + } }, + isEqual: { value: function isEqual(n) { + return true; + } }, + // Implementation-specific function. Called when a text, comment, + // or pi value changes. + mutateValue: { value: function(node2) { + if (this.mutationHandler) { + this.mutationHandler({ + type: MUTATE.VALUE, + target: node2, + data: node2.data + }); + } + } }, + // Invoked when an attribute's value changes. Attr holds the new + // value. oldval is the old value. Attribute mutations can also + // involve changes to the prefix (and therefore the qualified name) + mutateAttr: { value: function(attr, oldval) { + if (this.mutationHandler) { + this.mutationHandler({ + type: MUTATE.ATTR, + target: attr.ownerElement, + attr + }); + } + } }, + // Used by removeAttribute and removeAttributeNS for attributes. + mutateRemoveAttr: { value: function(attr) { + if (this.mutationHandler) { + this.mutationHandler({ + type: MUTATE.REMOVE_ATTR, + target: attr.ownerElement, + attr + }); + } + } }, + // Called by Node.removeChild, etc. to remove a rooted element from + // the tree. Only needs to generate a single mutation event when a + // node is removed, but must recursively mark all descendants as not + // rooted. + mutateRemove: { value: function(node2) { + if (this.mutationHandler) { + this.mutationHandler({ + type: MUTATE.REMOVE, + target: node2.parentNode, + node: node2 + }); + } + recursivelyUproot(node2); + } }, + // Called when a new element becomes rooted. It must recursively + // generate mutation events for each of the children, and mark them all + // as rooted. + mutateInsert: { value: function(node2) { + recursivelyRoot(node2); + if (this.mutationHandler) { + this.mutationHandler({ + type: MUTATE.INSERT, + target: node2.parentNode, + node: node2 + }); + } + } }, + // Called when a rooted element is moved within the document + mutateMove: { value: function(node2) { + if (this.mutationHandler) { + this.mutationHandler({ + type: MUTATE.MOVE, + target: node2 + }); + } + } }, + // Add a mapping from id to n for n.ownerDocument + addId: { value: function addId(id, n) { + var val = this.byId[id]; + if (!val) { + this.byId[id] = n; + } else { + if (!(val instanceof MultiId)) { + val = new MultiId(val); + this.byId[id] = val; + } + val.add(n); + } + } }, + // Delete the mapping from id to n for n.ownerDocument + delId: { value: function delId(id, n) { + var val = this.byId[id]; + utils.assert(val); + if (val instanceof MultiId) { + val.del(n); + if (val.length === 1) { + this.byId[id] = val.downgrade(); + } + } else { + this.byId[id] = void 0; + } + } }, + _resolve: { value: function(href) { + return new URL2(this._documentBaseURL).resolve(href); + } }, + _documentBaseURL: { get: function() { + var url4 = this._address; + if (url4 === "about:blank") url4 = "/"; + var base = this.querySelector("base[href]"); + if (base) { + return new URL2(url4).resolve(base.getAttribute("href")); + } + return url4; + } }, + _templateDoc: { get: function() { + if (!this._templateDocCache) { + var newDoc = new Document(this.isHTML, this._address); + this._templateDocCache = newDoc._templateDocCache = newDoc; + } + return this._templateDocCache; + } }, + querySelector: { value: function(selector) { + return select(selector, this)[0]; + } }, + querySelectorAll: { value: function(selector) { + var nodes = select(selector, this); + return nodes.item ? nodes : new NodeList(nodes); + } } + }); + var eventHandlerTypes = [ + "abort", + "canplay", + "canplaythrough", + "change", + "click", + "contextmenu", + "cuechange", + "dblclick", + "drag", + "dragend", + "dragenter", + "dragleave", + "dragover", + "dragstart", + "drop", + "durationchange", + "emptied", + "ended", + "input", + "invalid", + "keydown", + "keypress", + "keyup", + "loadeddata", + "loadedmetadata", + "loadstart", + "mousedown", + "mousemove", + "mouseout", + "mouseover", + "mouseup", + "mousewheel", + "pause", + "play", + "playing", + "progress", + "ratechange", + "readystatechange", + "reset", + "seeked", + "seeking", + "select", + "show", + "stalled", + "submit", + "suspend", + "timeupdate", + "volumechange", + "waiting", + "blur", + "error", + "focus", + "load", + "scroll" + ]; + eventHandlerTypes.forEach(function(type2) { + Object.defineProperty(Document.prototype, "on" + type2, { + get: function() { + return this._getEventHandler(type2); + }, + set: function(v) { + this._setEventHandler(type2, v); + } + }); + }); + function namedHTMLChild(parent, name) { + if (parent && parent.isHTML) { + for (var kid = parent.firstChild; kid !== null; kid = kid.nextSibling) { + if (kid.nodeType === Node.ELEMENT_NODE && kid.localName === name && kid.namespaceURI === NAMESPACE.HTML) { + return kid; + } + } + } + return null; + } + function root2(n) { + n._nid = n.ownerDocument._nextnid++; + n.ownerDocument._nodes[n._nid] = n; + if (n.nodeType === Node.ELEMENT_NODE) { + var id = n.getAttribute("id"); + if (id) n.ownerDocument.addId(id, n); + if (n._roothook) n._roothook(); + } + } + function uproot(n) { + if (n.nodeType === Node.ELEMENT_NODE) { + var id = n.getAttribute("id"); + if (id) n.ownerDocument.delId(id, n); + } + n.ownerDocument._nodes[n._nid] = void 0; + n._nid = void 0; + } + function recursivelyRoot(node2) { + root2(node2); + if (node2.nodeType === Node.ELEMENT_NODE) { + for (var kid = node2.firstChild; kid !== null; kid = kid.nextSibling) + recursivelyRoot(kid); + } + } + function recursivelyUproot(node2) { + uproot(node2); + for (var kid = node2.firstChild; kid !== null; kid = kid.nextSibling) + recursivelyUproot(kid); + } + function recursivelySetOwner(node2, owner) { + node2.ownerDocument = owner; + node2._lastModTime = void 0; + if (Object.prototype.hasOwnProperty.call(node2, "_tagName")) { + node2._tagName = void 0; + } + for (var kid = node2.firstChild; kid !== null; kid = kid.nextSibling) + recursivelySetOwner(kid, owner); + } + function MultiId(node2) { + this.nodes = /* @__PURE__ */ Object.create(null); + this.nodes[node2._nid] = node2; + this.length = 1; + this.firstNode = void 0; + } + MultiId.prototype.add = function(node2) { + if (!this.nodes[node2._nid]) { + this.nodes[node2._nid] = node2; + this.length++; + this.firstNode = void 0; + } + }; + MultiId.prototype.del = function(node2) { + if (this.nodes[node2._nid]) { + delete this.nodes[node2._nid]; + this.length--; + this.firstNode = void 0; + } + }; + MultiId.prototype.getFirst = function() { + if (!this.firstNode) { + var nid; + for (nid in this.nodes) { + if (this.firstNode === void 0 || this.firstNode.compareDocumentPosition(this.nodes[nid]) & Node.DOCUMENT_POSITION_PRECEDING) { + this.firstNode = this.nodes[nid]; + } + } + } + return this.firstNode; + }; + MultiId.prototype.downgrade = function() { + if (this.length === 1) { + var nid; + for (nid in this.nodes) { + return this.nodes[nid]; + } + } + return this; + }; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/DocumentType.js +var require_DocumentType = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/DocumentType.js"(exports, module) { + "use strict"; + module.exports = DocumentType; + var Node = require_Node(); + var Leaf = require_Leaf(); + var ChildNode = require_ChildNode(); + function DocumentType(ownerDocument, name, publicId, systemId) { + Leaf.call(this); + this.nodeType = Node.DOCUMENT_TYPE_NODE; + this.ownerDocument = ownerDocument || null; + this.name = name; + this.publicId = publicId || ""; + this.systemId = systemId || ""; + } + DocumentType.prototype = Object.create(Leaf.prototype, { + nodeName: { get: function() { + return this.name; + } }, + nodeValue: { + get: function() { + return null; + }, + set: function() { + } + }, + // Utility methods + clone: { value: function clone4() { + return new DocumentType(this.ownerDocument, this.name, this.publicId, this.systemId); + } }, + isEqual: { value: function isEqual(n) { + return this.name === n.name && this.publicId === n.publicId && this.systemId === n.systemId; + } } + }); + Object.defineProperties(DocumentType.prototype, ChildNode); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/HTMLParser.js +var require_HTMLParser = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/HTMLParser.js"(exports, module) { + "use strict"; + module.exports = HTMLParser; + var Document = require_Document(); + var DocumentType = require_DocumentType(); + var Node = require_Node(); + var NAMESPACE = require_utils8().NAMESPACE; + var html = require_htmlelts(); + var impl = html.elements; + var pushAll = Function.prototype.apply.bind(Array.prototype.push); + var EOF = -1; + var TEXT = 1; + var TAG = 2; + var ENDTAG = 3; + var COMMENT = 4; + var DOCTYPE = 5; + var NOATTRS = []; + var quirkyPublicIds = /^HTML$|^-\/\/W3O\/\/DTD W3 HTML Strict 3\.0\/\/EN\/\/$|^-\/W3C\/DTD HTML 4\.0 Transitional\/EN$|^\+\/\/Silmaril\/\/dtd html Pro v0r11 19970101\/\/|^-\/\/AdvaSoft Ltd\/\/DTD HTML 3\.0 asWedit \+ extensions\/\/|^-\/\/AS\/\/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\/\/|^-\/\/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\/\/|^-\/\/SQ\/\/DTD HTML 2\.0 HoTMetaL \+ extensions\/\/|^-\/\/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\/\//i; + var quirkySystemId = "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd"; + var conditionallyQuirkyPublicIds = /^-\/\/W3C\/\/DTD HTML 4\.01 Frameset\/\/|^-\/\/W3C\/\/DTD HTML 4\.01 Transitional\/\//i; + var limitedQuirkyPublicIds = /^-\/\/W3C\/\/DTD XHTML 1\.0 Frameset\/\/|^-\/\/W3C\/\/DTD XHTML 1\.0 Transitional\/\//i; + var specialSet = /* @__PURE__ */ Object.create(null); + specialSet[NAMESPACE.HTML] = { + __proto__: null, + "address": true, + "applet": true, + "area": true, + "article": true, + "aside": true, + "base": true, + "basefont": true, + "bgsound": true, + "blockquote": true, + "body": true, + "br": true, + "button": true, + "caption": true, + "center": true, + "col": true, + "colgroup": true, + "dd": true, + "details": true, + "dir": true, + "div": true, + "dl": true, + "dt": true, + "embed": true, + "fieldset": true, + "figcaption": true, + "figure": true, + "footer": true, + "form": true, + "frame": true, + "frameset": true, + "h1": true, + "h2": true, + "h3": true, + "h4": true, + "h5": true, + "h6": true, + "head": true, + "header": true, + "hgroup": true, + "hr": true, + "html": true, + "iframe": true, + "img": true, + "input": true, + "li": true, + "link": true, + "listing": true, + "main": true, + "marquee": true, + "menu": true, + "meta": true, + "nav": true, + "noembed": true, + "noframes": true, + "noscript": true, + "object": true, + "ol": true, + "p": true, + "param": true, + "plaintext": true, + "pre": true, + "script": true, + "section": true, + "select": true, + "source": true, + "style": true, + "summary": true, + "table": true, + "tbody": true, + "td": true, + "template": true, + "textarea": true, + "tfoot": true, + "th": true, + "thead": true, + "title": true, + "tr": true, + "track": true, + // Note that "xmp" was removed from the "special" set in the latest + // spec, apparently by accident; see + // https://github.com/whatwg/html/pull/1919 + "ul": true, + "wbr": true, + "xmp": true + }; + specialSet[NAMESPACE.SVG] = { + __proto__: null, + "foreignObject": true, + "desc": true, + "title": true + }; + specialSet[NAMESPACE.MATHML] = { + __proto__: null, + "mi": true, + "mo": true, + "mn": true, + "ms": true, + "mtext": true, + "annotation-xml": true + }; + var addressdivpSet = /* @__PURE__ */ Object.create(null); + addressdivpSet[NAMESPACE.HTML] = { + __proto__: null, + "address": true, + "div": true, + "p": true + }; + var dddtSet = /* @__PURE__ */ Object.create(null); + dddtSet[NAMESPACE.HTML] = { + __proto__: null, + "dd": true, + "dt": true + }; + var tablesectionrowSet = /* @__PURE__ */ Object.create(null); + tablesectionrowSet[NAMESPACE.HTML] = { + __proto__: null, + "table": true, + "thead": true, + "tbody": true, + "tfoot": true, + "tr": true + }; + var impliedEndTagsSet = /* @__PURE__ */ Object.create(null); + impliedEndTagsSet[NAMESPACE.HTML] = { + __proto__: null, + "dd": true, + "dt": true, + "li": true, + "menuitem": true, + "optgroup": true, + "option": true, + "p": true, + "rb": true, + "rp": true, + "rt": true, + "rtc": true + }; + var thoroughImpliedEndTagsSet = /* @__PURE__ */ Object.create(null); + thoroughImpliedEndTagsSet[NAMESPACE.HTML] = { + __proto__: null, + "caption": true, + "colgroup": true, + "dd": true, + "dt": true, + "li": true, + "optgroup": true, + "option": true, + "p": true, + "rb": true, + "rp": true, + "rt": true, + "rtc": true, + "tbody": true, + "td": true, + "tfoot": true, + "th": true, + "thead": true, + "tr": true + }; + var tableContextSet = /* @__PURE__ */ Object.create(null); + tableContextSet[NAMESPACE.HTML] = { + __proto__: null, + "table": true, + "template": true, + "html": true + }; + var tableBodyContextSet = /* @__PURE__ */ Object.create(null); + tableBodyContextSet[NAMESPACE.HTML] = { + __proto__: null, + "tbody": true, + "tfoot": true, + "thead": true, + "template": true, + "html": true + }; + var tableRowContextSet = /* @__PURE__ */ Object.create(null); + tableRowContextSet[NAMESPACE.HTML] = { + __proto__: null, + "tr": true, + "template": true, + "html": true + }; + var formassociatedSet = /* @__PURE__ */ Object.create(null); + formassociatedSet[NAMESPACE.HTML] = { + __proto__: null, + "button": true, + "fieldset": true, + "input": true, + "keygen": true, + "object": true, + "output": true, + "select": true, + "textarea": true, + "img": true + }; + var inScopeSet = /* @__PURE__ */ Object.create(null); + inScopeSet[NAMESPACE.HTML] = { + __proto__: null, + "applet": true, + "caption": true, + "html": true, + "table": true, + "td": true, + "th": true, + "marquee": true, + "object": true, + "template": true + }; + inScopeSet[NAMESPACE.MATHML] = { + __proto__: null, + "mi": true, + "mo": true, + "mn": true, + "ms": true, + "mtext": true, + "annotation-xml": true + }; + inScopeSet[NAMESPACE.SVG] = { + __proto__: null, + "foreignObject": true, + "desc": true, + "title": true + }; + var inListItemScopeSet = Object.create(inScopeSet); + inListItemScopeSet[NAMESPACE.HTML] = Object.create(inScopeSet[NAMESPACE.HTML]); + inListItemScopeSet[NAMESPACE.HTML].ol = true; + inListItemScopeSet[NAMESPACE.HTML].ul = true; + var inButtonScopeSet = Object.create(inScopeSet); + inButtonScopeSet[NAMESPACE.HTML] = Object.create(inScopeSet[NAMESPACE.HTML]); + inButtonScopeSet[NAMESPACE.HTML].button = true; + var inTableScopeSet = /* @__PURE__ */ Object.create(null); + inTableScopeSet[NAMESPACE.HTML] = { + __proto__: null, + "html": true, + "table": true, + "template": true + }; + var invertedSelectScopeSet = /* @__PURE__ */ Object.create(null); + invertedSelectScopeSet[NAMESPACE.HTML] = { + __proto__: null, + "optgroup": true, + "option": true + }; + var mathmlTextIntegrationPointSet = /* @__PURE__ */ Object.create(null); + mathmlTextIntegrationPointSet[NAMESPACE.MATHML] = { + __proto__: null, + mi: true, + mo: true, + mn: true, + ms: true, + mtext: true + }; + var htmlIntegrationPointSet = /* @__PURE__ */ Object.create(null); + htmlIntegrationPointSet[NAMESPACE.SVG] = { + __proto__: null, + foreignObject: true, + desc: true, + title: true + }; + var foreignAttributes = { + __proto__: null, + "xlink:actuate": NAMESPACE.XLINK, + "xlink:arcrole": NAMESPACE.XLINK, + "xlink:href": NAMESPACE.XLINK, + "xlink:role": NAMESPACE.XLINK, + "xlink:show": NAMESPACE.XLINK, + "xlink:title": NAMESPACE.XLINK, + "xlink:type": NAMESPACE.XLINK, + "xml:base": NAMESPACE.XML, + "xml:lang": NAMESPACE.XML, + "xml:space": NAMESPACE.XML, + "xmlns": NAMESPACE.XMLNS, + "xmlns:xlink": NAMESPACE.XMLNS + }; + var svgAttrAdjustments = { + __proto__: null, + attributename: "attributeName", + attributetype: "attributeType", + basefrequency: "baseFrequency", + baseprofile: "baseProfile", + calcmode: "calcMode", + clippathunits: "clipPathUnits", + diffuseconstant: "diffuseConstant", + edgemode: "edgeMode", + filterunits: "filterUnits", + glyphref: "glyphRef", + gradienttransform: "gradientTransform", + gradientunits: "gradientUnits", + kernelmatrix: "kernelMatrix", + kernelunitlength: "kernelUnitLength", + keypoints: "keyPoints", + keysplines: "keySplines", + keytimes: "keyTimes", + lengthadjust: "lengthAdjust", + limitingconeangle: "limitingConeAngle", + markerheight: "markerHeight", + markerunits: "markerUnits", + markerwidth: "markerWidth", + maskcontentunits: "maskContentUnits", + maskunits: "maskUnits", + numoctaves: "numOctaves", + pathlength: "pathLength", + patterncontentunits: "patternContentUnits", + patterntransform: "patternTransform", + patternunits: "patternUnits", + pointsatx: "pointsAtX", + pointsaty: "pointsAtY", + pointsatz: "pointsAtZ", + preservealpha: "preserveAlpha", + preserveaspectratio: "preserveAspectRatio", + primitiveunits: "primitiveUnits", + refx: "refX", + refy: "refY", + repeatcount: "repeatCount", + repeatdur: "repeatDur", + requiredextensions: "requiredExtensions", + requiredfeatures: "requiredFeatures", + specularconstant: "specularConstant", + specularexponent: "specularExponent", + spreadmethod: "spreadMethod", + startoffset: "startOffset", + stddeviation: "stdDeviation", + stitchtiles: "stitchTiles", + surfacescale: "surfaceScale", + systemlanguage: "systemLanguage", + tablevalues: "tableValues", + targetx: "targetX", + targety: "targetY", + textlength: "textLength", + viewbox: "viewBox", + viewtarget: "viewTarget", + xchannelselector: "xChannelSelector", + ychannelselector: "yChannelSelector", + zoomandpan: "zoomAndPan" + }; + var svgTagNameAdjustments = { + __proto__: null, + altglyph: "altGlyph", + altglyphdef: "altGlyphDef", + altglyphitem: "altGlyphItem", + animatecolor: "animateColor", + animatemotion: "animateMotion", + animatetransform: "animateTransform", + clippath: "clipPath", + feblend: "feBlend", + fecolormatrix: "feColorMatrix", + fecomponenttransfer: "feComponentTransfer", + fecomposite: "feComposite", + feconvolvematrix: "feConvolveMatrix", + fediffuselighting: "feDiffuseLighting", + fedisplacementmap: "feDisplacementMap", + fedistantlight: "feDistantLight", + feflood: "feFlood", + fefunca: "feFuncA", + fefuncb: "feFuncB", + fefuncg: "feFuncG", + fefuncr: "feFuncR", + fegaussianblur: "feGaussianBlur", + feimage: "feImage", + femerge: "feMerge", + femergenode: "feMergeNode", + femorphology: "feMorphology", + feoffset: "feOffset", + fepointlight: "fePointLight", + fespecularlighting: "feSpecularLighting", + fespotlight: "feSpotLight", + fetile: "feTile", + feturbulence: "feTurbulence", + foreignobject: "foreignObject", + glyphref: "glyphRef", + lineargradient: "linearGradient", + radialgradient: "radialGradient", + textpath: "textPath" + }; + var numericCharRefReplacements = { + __proto__: null, + 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 namedCharRefs = { + __proto__: null, + "AElig": 198, + "AElig;": 198, + "AMP": 38, + "AMP;": 38, + "Aacute": 193, + "Aacute;": 193, + "Abreve;": 258, + "Acirc": 194, + "Acirc;": 194, + "Acy;": 1040, + "Afr;": [55349, 56580], + "Agrave": 192, + "Agrave;": 192, + "Alpha;": 913, + "Amacr;": 256, + "And;": 10835, + "Aogon;": 260, + "Aopf;": [55349, 56632], + "ApplyFunction;": 8289, + "Aring": 197, + "Aring;": 197, + "Ascr;": [55349, 56476], + "Assign;": 8788, + "Atilde": 195, + "Atilde;": 195, + "Auml": 196, + "Auml;": 196, + "Backslash;": 8726, + "Barv;": 10983, + "Barwed;": 8966, + "Bcy;": 1041, + "Because;": 8757, + "Bernoullis;": 8492, + "Beta;": 914, + "Bfr;": [55349, 56581], + "Bopf;": [55349, 56633], + "Breve;": 728, + "Bscr;": 8492, + "Bumpeq;": 8782, + "CHcy;": 1063, + "COPY": 169, + "COPY;": 169, + "Cacute;": 262, + "Cap;": 8914, + "CapitalDifferentialD;": 8517, + "Cayleys;": 8493, + "Ccaron;": 268, + "Ccedil": 199, + "Ccedil;": 199, + "Ccirc;": 264, + "Cconint;": 8752, + "Cdot;": 266, + "Cedilla;": 184, + "CenterDot;": 183, + "Cfr;": 8493, + "Chi;": 935, + "CircleDot;": 8857, + "CircleMinus;": 8854, + "CirclePlus;": 8853, + "CircleTimes;": 8855, + "ClockwiseContourIntegral;": 8754, + "CloseCurlyDoubleQuote;": 8221, + "CloseCurlyQuote;": 8217, + "Colon;": 8759, + "Colone;": 10868, + "Congruent;": 8801, + "Conint;": 8751, + "ContourIntegral;": 8750, + "Copf;": 8450, + "Coproduct;": 8720, + "CounterClockwiseContourIntegral;": 8755, + "Cross;": 10799, + "Cscr;": [55349, 56478], + "Cup;": 8915, + "CupCap;": 8781, + "DD;": 8517, + "DDotrahd;": 10513, + "DJcy;": 1026, + "DScy;": 1029, + "DZcy;": 1039, + "Dagger;": 8225, + "Darr;": 8609, + "Dashv;": 10980, + "Dcaron;": 270, + "Dcy;": 1044, + "Del;": 8711, + "Delta;": 916, + "Dfr;": [55349, 56583], + "DiacriticalAcute;": 180, + "DiacriticalDot;": 729, + "DiacriticalDoubleAcute;": 733, + "DiacriticalGrave;": 96, + "DiacriticalTilde;": 732, + "Diamond;": 8900, + "DifferentialD;": 8518, + "Dopf;": [55349, 56635], + "Dot;": 168, + "DotDot;": 8412, + "DotEqual;": 8784, + "DoubleContourIntegral;": 8751, + "DoubleDot;": 168, + "DoubleDownArrow;": 8659, + "DoubleLeftArrow;": 8656, + "DoubleLeftRightArrow;": 8660, + "DoubleLeftTee;": 10980, + "DoubleLongLeftArrow;": 10232, + "DoubleLongLeftRightArrow;": 10234, + "DoubleLongRightArrow;": 10233, + "DoubleRightArrow;": 8658, + "DoubleRightTee;": 8872, + "DoubleUpArrow;": 8657, + "DoubleUpDownArrow;": 8661, + "DoubleVerticalBar;": 8741, + "DownArrow;": 8595, + "DownArrowBar;": 10515, + "DownArrowUpArrow;": 8693, + "DownBreve;": 785, + "DownLeftRightVector;": 10576, + "DownLeftTeeVector;": 10590, + "DownLeftVector;": 8637, + "DownLeftVectorBar;": 10582, + "DownRightTeeVector;": 10591, + "DownRightVector;": 8641, + "DownRightVectorBar;": 10583, + "DownTee;": 8868, + "DownTeeArrow;": 8615, + "Downarrow;": 8659, + "Dscr;": [55349, 56479], + "Dstrok;": 272, + "ENG;": 330, + "ETH": 208, + "ETH;": 208, + "Eacute": 201, + "Eacute;": 201, + "Ecaron;": 282, + "Ecirc": 202, + "Ecirc;": 202, + "Ecy;": 1069, + "Edot;": 278, + "Efr;": [55349, 56584], + "Egrave": 200, + "Egrave;": 200, + "Element;": 8712, + "Emacr;": 274, + "EmptySmallSquare;": 9723, + "EmptyVerySmallSquare;": 9643, + "Eogon;": 280, + "Eopf;": [55349, 56636], + "Epsilon;": 917, + "Equal;": 10869, + "EqualTilde;": 8770, + "Equilibrium;": 8652, + "Escr;": 8496, + "Esim;": 10867, + "Eta;": 919, + "Euml": 203, + "Euml;": 203, + "Exists;": 8707, + "ExponentialE;": 8519, + "Fcy;": 1060, + "Ffr;": [55349, 56585], + "FilledSmallSquare;": 9724, + "FilledVerySmallSquare;": 9642, + "Fopf;": [55349, 56637], + "ForAll;": 8704, + "Fouriertrf;": 8497, + "Fscr;": 8497, + "GJcy;": 1027, + "GT": 62, + "GT;": 62, + "Gamma;": 915, + "Gammad;": 988, + "Gbreve;": 286, + "Gcedil;": 290, + "Gcirc;": 284, + "Gcy;": 1043, + "Gdot;": 288, + "Gfr;": [55349, 56586], + "Gg;": 8921, + "Gopf;": [55349, 56638], + "GreaterEqual;": 8805, + "GreaterEqualLess;": 8923, + "GreaterFullEqual;": 8807, + "GreaterGreater;": 10914, + "GreaterLess;": 8823, + "GreaterSlantEqual;": 10878, + "GreaterTilde;": 8819, + "Gscr;": [55349, 56482], + "Gt;": 8811, + "HARDcy;": 1066, + "Hacek;": 711, + "Hat;": 94, + "Hcirc;": 292, + "Hfr;": 8460, + "HilbertSpace;": 8459, + "Hopf;": 8461, + "HorizontalLine;": 9472, + "Hscr;": 8459, + "Hstrok;": 294, + "HumpDownHump;": 8782, + "HumpEqual;": 8783, + "IEcy;": 1045, + "IJlig;": 306, + "IOcy;": 1025, + "Iacute": 205, + "Iacute;": 205, + "Icirc": 206, + "Icirc;": 206, + "Icy;": 1048, + "Idot;": 304, + "Ifr;": 8465, + "Igrave": 204, + "Igrave;": 204, + "Im;": 8465, + "Imacr;": 298, + "ImaginaryI;": 8520, + "Implies;": 8658, + "Int;": 8748, + "Integral;": 8747, + "Intersection;": 8898, + "InvisibleComma;": 8291, + "InvisibleTimes;": 8290, + "Iogon;": 302, + "Iopf;": [55349, 56640], + "Iota;": 921, + "Iscr;": 8464, + "Itilde;": 296, + "Iukcy;": 1030, + "Iuml": 207, + "Iuml;": 207, + "Jcirc;": 308, + "Jcy;": 1049, + "Jfr;": [55349, 56589], + "Jopf;": [55349, 56641], + "Jscr;": [55349, 56485], + "Jsercy;": 1032, + "Jukcy;": 1028, + "KHcy;": 1061, + "KJcy;": 1036, + "Kappa;": 922, + "Kcedil;": 310, + "Kcy;": 1050, + "Kfr;": [55349, 56590], + "Kopf;": [55349, 56642], + "Kscr;": [55349, 56486], + "LJcy;": 1033, + "LT": 60, + "LT;": 60, + "Lacute;": 313, + "Lambda;": 923, + "Lang;": 10218, + "Laplacetrf;": 8466, + "Larr;": 8606, + "Lcaron;": 317, + "Lcedil;": 315, + "Lcy;": 1051, + "LeftAngleBracket;": 10216, + "LeftArrow;": 8592, + "LeftArrowBar;": 8676, + "LeftArrowRightArrow;": 8646, + "LeftCeiling;": 8968, + "LeftDoubleBracket;": 10214, + "LeftDownTeeVector;": 10593, + "LeftDownVector;": 8643, + "LeftDownVectorBar;": 10585, + "LeftFloor;": 8970, + "LeftRightArrow;": 8596, + "LeftRightVector;": 10574, + "LeftTee;": 8867, + "LeftTeeArrow;": 8612, + "LeftTeeVector;": 10586, + "LeftTriangle;": 8882, + "LeftTriangleBar;": 10703, + "LeftTriangleEqual;": 8884, + "LeftUpDownVector;": 10577, + "LeftUpTeeVector;": 10592, + "LeftUpVector;": 8639, + "LeftUpVectorBar;": 10584, + "LeftVector;": 8636, + "LeftVectorBar;": 10578, + "Leftarrow;": 8656, + "Leftrightarrow;": 8660, + "LessEqualGreater;": 8922, + "LessFullEqual;": 8806, + "LessGreater;": 8822, + "LessLess;": 10913, + "LessSlantEqual;": 10877, + "LessTilde;": 8818, + "Lfr;": [55349, 56591], + "Ll;": 8920, + "Lleftarrow;": 8666, + "Lmidot;": 319, + "LongLeftArrow;": 10229, + "LongLeftRightArrow;": 10231, + "LongRightArrow;": 10230, + "Longleftarrow;": 10232, + "Longleftrightarrow;": 10234, + "Longrightarrow;": 10233, + "Lopf;": [55349, 56643], + "LowerLeftArrow;": 8601, + "LowerRightArrow;": 8600, + "Lscr;": 8466, + "Lsh;": 8624, + "Lstrok;": 321, + "Lt;": 8810, + "Map;": 10501, + "Mcy;": 1052, + "MediumSpace;": 8287, + "Mellintrf;": 8499, + "Mfr;": [55349, 56592], + "MinusPlus;": 8723, + "Mopf;": [55349, 56644], + "Mscr;": 8499, + "Mu;": 924, + "NJcy;": 1034, + "Nacute;": 323, + "Ncaron;": 327, + "Ncedil;": 325, + "Ncy;": 1053, + "NegativeMediumSpace;": 8203, + "NegativeThickSpace;": 8203, + "NegativeThinSpace;": 8203, + "NegativeVeryThinSpace;": 8203, + "NestedGreaterGreater;": 8811, + "NestedLessLess;": 8810, + "NewLine;": 10, + "Nfr;": [55349, 56593], + "NoBreak;": 8288, + "NonBreakingSpace;": 160, + "Nopf;": 8469, + "Not;": 10988, + "NotCongruent;": 8802, + "NotCupCap;": 8813, + "NotDoubleVerticalBar;": 8742, + "NotElement;": 8713, + "NotEqual;": 8800, + "NotEqualTilde;": [8770, 824], + "NotExists;": 8708, + "NotGreater;": 8815, + "NotGreaterEqual;": 8817, + "NotGreaterFullEqual;": [8807, 824], + "NotGreaterGreater;": [8811, 824], + "NotGreaterLess;": 8825, + "NotGreaterSlantEqual;": [10878, 824], + "NotGreaterTilde;": 8821, + "NotHumpDownHump;": [8782, 824], + "NotHumpEqual;": [8783, 824], + "NotLeftTriangle;": 8938, + "NotLeftTriangleBar;": [10703, 824], + "NotLeftTriangleEqual;": 8940, + "NotLess;": 8814, + "NotLessEqual;": 8816, + "NotLessGreater;": 8824, + "NotLessLess;": [8810, 824], + "NotLessSlantEqual;": [10877, 824], + "NotLessTilde;": 8820, + "NotNestedGreaterGreater;": [10914, 824], + "NotNestedLessLess;": [10913, 824], + "NotPrecedes;": 8832, + "NotPrecedesEqual;": [10927, 824], + "NotPrecedesSlantEqual;": 8928, + "NotReverseElement;": 8716, + "NotRightTriangle;": 8939, + "NotRightTriangleBar;": [10704, 824], + "NotRightTriangleEqual;": 8941, + "NotSquareSubset;": [8847, 824], + "NotSquareSubsetEqual;": 8930, + "NotSquareSuperset;": [8848, 824], + "NotSquareSupersetEqual;": 8931, + "NotSubset;": [8834, 8402], + "NotSubsetEqual;": 8840, + "NotSucceeds;": 8833, + "NotSucceedsEqual;": [10928, 824], + "NotSucceedsSlantEqual;": 8929, + "NotSucceedsTilde;": [8831, 824], + "NotSuperset;": [8835, 8402], + "NotSupersetEqual;": 8841, + "NotTilde;": 8769, + "NotTildeEqual;": 8772, + "NotTildeFullEqual;": 8775, + "NotTildeTilde;": 8777, + "NotVerticalBar;": 8740, + "Nscr;": [55349, 56489], + "Ntilde": 209, + "Ntilde;": 209, + "Nu;": 925, + "OElig;": 338, + "Oacute": 211, + "Oacute;": 211, + "Ocirc": 212, + "Ocirc;": 212, + "Ocy;": 1054, + "Odblac;": 336, + "Ofr;": [55349, 56594], + "Ograve": 210, + "Ograve;": 210, + "Omacr;": 332, + "Omega;": 937, + "Omicron;": 927, + "Oopf;": [55349, 56646], + "OpenCurlyDoubleQuote;": 8220, + "OpenCurlyQuote;": 8216, + "Or;": 10836, + "Oscr;": [55349, 56490], + "Oslash": 216, + "Oslash;": 216, + "Otilde": 213, + "Otilde;": 213, + "Otimes;": 10807, + "Ouml": 214, + "Ouml;": 214, + "OverBar;": 8254, + "OverBrace;": 9182, + "OverBracket;": 9140, + "OverParenthesis;": 9180, + "PartialD;": 8706, + "Pcy;": 1055, + "Pfr;": [55349, 56595], + "Phi;": 934, + "Pi;": 928, + "PlusMinus;": 177, + "Poincareplane;": 8460, + "Popf;": 8473, + "Pr;": 10939, + "Precedes;": 8826, + "PrecedesEqual;": 10927, + "PrecedesSlantEqual;": 8828, + "PrecedesTilde;": 8830, + "Prime;": 8243, + "Product;": 8719, + "Proportion;": 8759, + "Proportional;": 8733, + "Pscr;": [55349, 56491], + "Psi;": 936, + "QUOT": 34, + "QUOT;": 34, + "Qfr;": [55349, 56596], + "Qopf;": 8474, + "Qscr;": [55349, 56492], + "RBarr;": 10512, + "REG": 174, + "REG;": 174, + "Racute;": 340, + "Rang;": 10219, + "Rarr;": 8608, + "Rarrtl;": 10518, + "Rcaron;": 344, + "Rcedil;": 342, + "Rcy;": 1056, + "Re;": 8476, + "ReverseElement;": 8715, + "ReverseEquilibrium;": 8651, + "ReverseUpEquilibrium;": 10607, + "Rfr;": 8476, + "Rho;": 929, + "RightAngleBracket;": 10217, + "RightArrow;": 8594, + "RightArrowBar;": 8677, + "RightArrowLeftArrow;": 8644, + "RightCeiling;": 8969, + "RightDoubleBracket;": 10215, + "RightDownTeeVector;": 10589, + "RightDownVector;": 8642, + "RightDownVectorBar;": 10581, + "RightFloor;": 8971, + "RightTee;": 8866, + "RightTeeArrow;": 8614, + "RightTeeVector;": 10587, + "RightTriangle;": 8883, + "RightTriangleBar;": 10704, + "RightTriangleEqual;": 8885, + "RightUpDownVector;": 10575, + "RightUpTeeVector;": 10588, + "RightUpVector;": 8638, + "RightUpVectorBar;": 10580, + "RightVector;": 8640, + "RightVectorBar;": 10579, + "Rightarrow;": 8658, + "Ropf;": 8477, + "RoundImplies;": 10608, + "Rrightarrow;": 8667, + "Rscr;": 8475, + "Rsh;": 8625, + "RuleDelayed;": 10740, + "SHCHcy;": 1065, + "SHcy;": 1064, + "SOFTcy;": 1068, + "Sacute;": 346, + "Sc;": 10940, + "Scaron;": 352, + "Scedil;": 350, + "Scirc;": 348, + "Scy;": 1057, + "Sfr;": [55349, 56598], + "ShortDownArrow;": 8595, + "ShortLeftArrow;": 8592, + "ShortRightArrow;": 8594, + "ShortUpArrow;": 8593, + "Sigma;": 931, + "SmallCircle;": 8728, + "Sopf;": [55349, 56650], + "Sqrt;": 8730, + "Square;": 9633, + "SquareIntersection;": 8851, + "SquareSubset;": 8847, + "SquareSubsetEqual;": 8849, + "SquareSuperset;": 8848, + "SquareSupersetEqual;": 8850, + "SquareUnion;": 8852, + "Sscr;": [55349, 56494], + "Star;": 8902, + "Sub;": 8912, + "Subset;": 8912, + "SubsetEqual;": 8838, + "Succeeds;": 8827, + "SucceedsEqual;": 10928, + "SucceedsSlantEqual;": 8829, + "SucceedsTilde;": 8831, + "SuchThat;": 8715, + "Sum;": 8721, + "Sup;": 8913, + "Superset;": 8835, + "SupersetEqual;": 8839, + "Supset;": 8913, + "THORN": 222, + "THORN;": 222, + "TRADE;": 8482, + "TSHcy;": 1035, + "TScy;": 1062, + "Tab;": 9, + "Tau;": 932, + "Tcaron;": 356, + "Tcedil;": 354, + "Tcy;": 1058, + "Tfr;": [55349, 56599], + "Therefore;": 8756, + "Theta;": 920, + "ThickSpace;": [8287, 8202], + "ThinSpace;": 8201, + "Tilde;": 8764, + "TildeEqual;": 8771, + "TildeFullEqual;": 8773, + "TildeTilde;": 8776, + "Topf;": [55349, 56651], + "TripleDot;": 8411, + "Tscr;": [55349, 56495], + "Tstrok;": 358, + "Uacute": 218, + "Uacute;": 218, + "Uarr;": 8607, + "Uarrocir;": 10569, + "Ubrcy;": 1038, + "Ubreve;": 364, + "Ucirc": 219, + "Ucirc;": 219, + "Ucy;": 1059, + "Udblac;": 368, + "Ufr;": [55349, 56600], + "Ugrave": 217, + "Ugrave;": 217, + "Umacr;": 362, + "UnderBar;": 95, + "UnderBrace;": 9183, + "UnderBracket;": 9141, + "UnderParenthesis;": 9181, + "Union;": 8899, + "UnionPlus;": 8846, + "Uogon;": 370, + "Uopf;": [55349, 56652], + "UpArrow;": 8593, + "UpArrowBar;": 10514, + "UpArrowDownArrow;": 8645, + "UpDownArrow;": 8597, + "UpEquilibrium;": 10606, + "UpTee;": 8869, + "UpTeeArrow;": 8613, + "Uparrow;": 8657, + "Updownarrow;": 8661, + "UpperLeftArrow;": 8598, + "UpperRightArrow;": 8599, + "Upsi;": 978, + "Upsilon;": 933, + "Uring;": 366, + "Uscr;": [55349, 56496], + "Utilde;": 360, + "Uuml": 220, + "Uuml;": 220, + "VDash;": 8875, + "Vbar;": 10987, + "Vcy;": 1042, + "Vdash;": 8873, + "Vdashl;": 10982, + "Vee;": 8897, + "Verbar;": 8214, + "Vert;": 8214, + "VerticalBar;": 8739, + "VerticalLine;": 124, + "VerticalSeparator;": 10072, + "VerticalTilde;": 8768, + "VeryThinSpace;": 8202, + "Vfr;": [55349, 56601], + "Vopf;": [55349, 56653], + "Vscr;": [55349, 56497], + "Vvdash;": 8874, + "Wcirc;": 372, + "Wedge;": 8896, + "Wfr;": [55349, 56602], + "Wopf;": [55349, 56654], + "Wscr;": [55349, 56498], + "Xfr;": [55349, 56603], + "Xi;": 926, + "Xopf;": [55349, 56655], + "Xscr;": [55349, 56499], + "YAcy;": 1071, + "YIcy;": 1031, + "YUcy;": 1070, + "Yacute": 221, + "Yacute;": 221, + "Ycirc;": 374, + "Ycy;": 1067, + "Yfr;": [55349, 56604], + "Yopf;": [55349, 56656], + "Yscr;": [55349, 56500], + "Yuml;": 376, + "ZHcy;": 1046, + "Zacute;": 377, + "Zcaron;": 381, + "Zcy;": 1047, + "Zdot;": 379, + "ZeroWidthSpace;": 8203, + "Zeta;": 918, + "Zfr;": 8488, + "Zopf;": 8484, + "Zscr;": [55349, 56501], + "aacute": 225, + "aacute;": 225, + "abreve;": 259, + "ac;": 8766, + "acE;": [8766, 819], + "acd;": 8767, + "acirc": 226, + "acirc;": 226, + "acute": 180, + "acute;": 180, + "acy;": 1072, + "aelig": 230, + "aelig;": 230, + "af;": 8289, + "afr;": [55349, 56606], + "agrave": 224, + "agrave;": 224, + "alefsym;": 8501, + "aleph;": 8501, + "alpha;": 945, + "amacr;": 257, + "amalg;": 10815, + "amp": 38, + "amp;": 38, + "and;": 8743, + "andand;": 10837, + "andd;": 10844, + "andslope;": 10840, + "andv;": 10842, + "ang;": 8736, + "ange;": 10660, + "angle;": 8736, + "angmsd;": 8737, + "angmsdaa;": 10664, + "angmsdab;": 10665, + "angmsdac;": 10666, + "angmsdad;": 10667, + "angmsdae;": 10668, + "angmsdaf;": 10669, + "angmsdag;": 10670, + "angmsdah;": 10671, + "angrt;": 8735, + "angrtvb;": 8894, + "angrtvbd;": 10653, + "angsph;": 8738, + "angst;": 197, + "angzarr;": 9084, + "aogon;": 261, + "aopf;": [55349, 56658], + "ap;": 8776, + "apE;": 10864, + "apacir;": 10863, + "ape;": 8778, + "apid;": 8779, + "apos;": 39, + "approx;": 8776, + "approxeq;": 8778, + "aring": 229, + "aring;": 229, + "ascr;": [55349, 56502], + "ast;": 42, + "asymp;": 8776, + "asympeq;": 8781, + "atilde": 227, + "atilde;": 227, + "auml": 228, + "auml;": 228, + "awconint;": 8755, + "awint;": 10769, + "bNot;": 10989, + "backcong;": 8780, + "backepsilon;": 1014, + "backprime;": 8245, + "backsim;": 8765, + "backsimeq;": 8909, + "barvee;": 8893, + "barwed;": 8965, + "barwedge;": 8965, + "bbrk;": 9141, + "bbrktbrk;": 9142, + "bcong;": 8780, + "bcy;": 1073, + "bdquo;": 8222, + "becaus;": 8757, + "because;": 8757, + "bemptyv;": 10672, + "bepsi;": 1014, + "bernou;": 8492, + "beta;": 946, + "beth;": 8502, + "between;": 8812, + "bfr;": [55349, 56607], + "bigcap;": 8898, + "bigcirc;": 9711, + "bigcup;": 8899, + "bigodot;": 10752, + "bigoplus;": 10753, + "bigotimes;": 10754, + "bigsqcup;": 10758, + "bigstar;": 9733, + "bigtriangledown;": 9661, + "bigtriangleup;": 9651, + "biguplus;": 10756, + "bigvee;": 8897, + "bigwedge;": 8896, + "bkarow;": 10509, + "blacklozenge;": 10731, + "blacksquare;": 9642, + "blacktriangle;": 9652, + "blacktriangledown;": 9662, + "blacktriangleleft;": 9666, + "blacktriangleright;": 9656, + "blank;": 9251, + "blk12;": 9618, + "blk14;": 9617, + "blk34;": 9619, + "block;": 9608, + "bne;": [61, 8421], + "bnequiv;": [8801, 8421], + "bnot;": 8976, + "bopf;": [55349, 56659], + "bot;": 8869, + "bottom;": 8869, + "bowtie;": 8904, + "boxDL;": 9559, + "boxDR;": 9556, + "boxDl;": 9558, + "boxDr;": 9555, + "boxH;": 9552, + "boxHD;": 9574, + "boxHU;": 9577, + "boxHd;": 9572, + "boxHu;": 9575, + "boxUL;": 9565, + "boxUR;": 9562, + "boxUl;": 9564, + "boxUr;": 9561, + "boxV;": 9553, + "boxVH;": 9580, + "boxVL;": 9571, + "boxVR;": 9568, + "boxVh;": 9579, + "boxVl;": 9570, + "boxVr;": 9567, + "boxbox;": 10697, + "boxdL;": 9557, + "boxdR;": 9554, + "boxdl;": 9488, + "boxdr;": 9484, + "boxh;": 9472, + "boxhD;": 9573, + "boxhU;": 9576, + "boxhd;": 9516, + "boxhu;": 9524, + "boxminus;": 8863, + "boxplus;": 8862, + "boxtimes;": 8864, + "boxuL;": 9563, + "boxuR;": 9560, + "boxul;": 9496, + "boxur;": 9492, + "boxv;": 9474, + "boxvH;": 9578, + "boxvL;": 9569, + "boxvR;": 9566, + "boxvh;": 9532, + "boxvl;": 9508, + "boxvr;": 9500, + "bprime;": 8245, + "breve;": 728, + "brvbar": 166, + "brvbar;": 166, + "bscr;": [55349, 56503], + "bsemi;": 8271, + "bsim;": 8765, + "bsime;": 8909, + "bsol;": 92, + "bsolb;": 10693, + "bsolhsub;": 10184, + "bull;": 8226, + "bullet;": 8226, + "bump;": 8782, + "bumpE;": 10926, + "bumpe;": 8783, + "bumpeq;": 8783, + "cacute;": 263, + "cap;": 8745, + "capand;": 10820, + "capbrcup;": 10825, + "capcap;": 10827, + "capcup;": 10823, + "capdot;": 10816, + "caps;": [8745, 65024], + "caret;": 8257, + "caron;": 711, + "ccaps;": 10829, + "ccaron;": 269, + "ccedil": 231, + "ccedil;": 231, + "ccirc;": 265, + "ccups;": 10828, + "ccupssm;": 10832, + "cdot;": 267, + "cedil": 184, + "cedil;": 184, + "cemptyv;": 10674, + "cent": 162, + "cent;": 162, + "centerdot;": 183, + "cfr;": [55349, 56608], + "chcy;": 1095, + "check;": 10003, + "checkmark;": 10003, + "chi;": 967, + "cir;": 9675, + "cirE;": 10691, + "circ;": 710, + "circeq;": 8791, + "circlearrowleft;": 8634, + "circlearrowright;": 8635, + "circledR;": 174, + "circledS;": 9416, + "circledast;": 8859, + "circledcirc;": 8858, + "circleddash;": 8861, + "cire;": 8791, + "cirfnint;": 10768, + "cirmid;": 10991, + "cirscir;": 10690, + "clubs;": 9827, + "clubsuit;": 9827, + "colon;": 58, + "colone;": 8788, + "coloneq;": 8788, + "comma;": 44, + "commat;": 64, + "comp;": 8705, + "compfn;": 8728, + "complement;": 8705, + "complexes;": 8450, + "cong;": 8773, + "congdot;": 10861, + "conint;": 8750, + "copf;": [55349, 56660], + "coprod;": 8720, + "copy": 169, + "copy;": 169, + "copysr;": 8471, + "crarr;": 8629, + "cross;": 10007, + "cscr;": [55349, 56504], + "csub;": 10959, + "csube;": 10961, + "csup;": 10960, + "csupe;": 10962, + "ctdot;": 8943, + "cudarrl;": 10552, + "cudarrr;": 10549, + "cuepr;": 8926, + "cuesc;": 8927, + "cularr;": 8630, + "cularrp;": 10557, + "cup;": 8746, + "cupbrcap;": 10824, + "cupcap;": 10822, + "cupcup;": 10826, + "cupdot;": 8845, + "cupor;": 10821, + "cups;": [8746, 65024], + "curarr;": 8631, + "curarrm;": 10556, + "curlyeqprec;": 8926, + "curlyeqsucc;": 8927, + "curlyvee;": 8910, + "curlywedge;": 8911, + "curren": 164, + "curren;": 164, + "curvearrowleft;": 8630, + "curvearrowright;": 8631, + "cuvee;": 8910, + "cuwed;": 8911, + "cwconint;": 8754, + "cwint;": 8753, + "cylcty;": 9005, + "dArr;": 8659, + "dHar;": 10597, + "dagger;": 8224, + "daleth;": 8504, + "darr;": 8595, + "dash;": 8208, + "dashv;": 8867, + "dbkarow;": 10511, + "dblac;": 733, + "dcaron;": 271, + "dcy;": 1076, + "dd;": 8518, + "ddagger;": 8225, + "ddarr;": 8650, + "ddotseq;": 10871, + "deg": 176, + "deg;": 176, + "delta;": 948, + "demptyv;": 10673, + "dfisht;": 10623, + "dfr;": [55349, 56609], + "dharl;": 8643, + "dharr;": 8642, + "diam;": 8900, + "diamond;": 8900, + "diamondsuit;": 9830, + "diams;": 9830, + "die;": 168, + "digamma;": 989, + "disin;": 8946, + "div;": 247, + "divide": 247, + "divide;": 247, + "divideontimes;": 8903, + "divonx;": 8903, + "djcy;": 1106, + "dlcorn;": 8990, + "dlcrop;": 8973, + "dollar;": 36, + "dopf;": [55349, 56661], + "dot;": 729, + "doteq;": 8784, + "doteqdot;": 8785, + "dotminus;": 8760, + "dotplus;": 8724, + "dotsquare;": 8865, + "doublebarwedge;": 8966, + "downarrow;": 8595, + "downdownarrows;": 8650, + "downharpoonleft;": 8643, + "downharpoonright;": 8642, + "drbkarow;": 10512, + "drcorn;": 8991, + "drcrop;": 8972, + "dscr;": [55349, 56505], + "dscy;": 1109, + "dsol;": 10742, + "dstrok;": 273, + "dtdot;": 8945, + "dtri;": 9663, + "dtrif;": 9662, + "duarr;": 8693, + "duhar;": 10607, + "dwangle;": 10662, + "dzcy;": 1119, + "dzigrarr;": 10239, + "eDDot;": 10871, + "eDot;": 8785, + "eacute": 233, + "eacute;": 233, + "easter;": 10862, + "ecaron;": 283, + "ecir;": 8790, + "ecirc": 234, + "ecirc;": 234, + "ecolon;": 8789, + "ecy;": 1101, + "edot;": 279, + "ee;": 8519, + "efDot;": 8786, + "efr;": [55349, 56610], + "eg;": 10906, + "egrave": 232, + "egrave;": 232, + "egs;": 10902, + "egsdot;": 10904, + "el;": 10905, + "elinters;": 9191, + "ell;": 8467, + "els;": 10901, + "elsdot;": 10903, + "emacr;": 275, + "empty;": 8709, + "emptyset;": 8709, + "emptyv;": 8709, + "emsp13;": 8196, + "emsp14;": 8197, + "emsp;": 8195, + "eng;": 331, + "ensp;": 8194, + "eogon;": 281, + "eopf;": [55349, 56662], + "epar;": 8917, + "eparsl;": 10723, + "eplus;": 10865, + "epsi;": 949, + "epsilon;": 949, + "epsiv;": 1013, + "eqcirc;": 8790, + "eqcolon;": 8789, + "eqsim;": 8770, + "eqslantgtr;": 10902, + "eqslantless;": 10901, + "equals;": 61, + "equest;": 8799, + "equiv;": 8801, + "equivDD;": 10872, + "eqvparsl;": 10725, + "erDot;": 8787, + "erarr;": 10609, + "escr;": 8495, + "esdot;": 8784, + "esim;": 8770, + "eta;": 951, + "eth": 240, + "eth;": 240, + "euml": 235, + "euml;": 235, + "euro;": 8364, + "excl;": 33, + "exist;": 8707, + "expectation;": 8496, + "exponentiale;": 8519, + "fallingdotseq;": 8786, + "fcy;": 1092, + "female;": 9792, + "ffilig;": 64259, + "fflig;": 64256, + "ffllig;": 64260, + "ffr;": [55349, 56611], + "filig;": 64257, + "fjlig;": [102, 106], + "flat;": 9837, + "fllig;": 64258, + "fltns;": 9649, + "fnof;": 402, + "fopf;": [55349, 56663], + "forall;": 8704, + "fork;": 8916, + "forkv;": 10969, + "fpartint;": 10765, + "frac12": 189, + "frac12;": 189, + "frac13;": 8531, + "frac14": 188, + "frac14;": 188, + "frac15;": 8533, + "frac16;": 8537, + "frac18;": 8539, + "frac23;": 8532, + "frac25;": 8534, + "frac34": 190, + "frac34;": 190, + "frac35;": 8535, + "frac38;": 8540, + "frac45;": 8536, + "frac56;": 8538, + "frac58;": 8541, + "frac78;": 8542, + "frasl;": 8260, + "frown;": 8994, + "fscr;": [55349, 56507], + "gE;": 8807, + "gEl;": 10892, + "gacute;": 501, + "gamma;": 947, + "gammad;": 989, + "gap;": 10886, + "gbreve;": 287, + "gcirc;": 285, + "gcy;": 1075, + "gdot;": 289, + "ge;": 8805, + "gel;": 8923, + "geq;": 8805, + "geqq;": 8807, + "geqslant;": 10878, + "ges;": 10878, + "gescc;": 10921, + "gesdot;": 10880, + "gesdoto;": 10882, + "gesdotol;": 10884, + "gesl;": [8923, 65024], + "gesles;": 10900, + "gfr;": [55349, 56612], + "gg;": 8811, + "ggg;": 8921, + "gimel;": 8503, + "gjcy;": 1107, + "gl;": 8823, + "glE;": 10898, + "gla;": 10917, + "glj;": 10916, + "gnE;": 8809, + "gnap;": 10890, + "gnapprox;": 10890, + "gne;": 10888, + "gneq;": 10888, + "gneqq;": 8809, + "gnsim;": 8935, + "gopf;": [55349, 56664], + "grave;": 96, + "gscr;": 8458, + "gsim;": 8819, + "gsime;": 10894, + "gsiml;": 10896, + "gt": 62, + "gt;": 62, + "gtcc;": 10919, + "gtcir;": 10874, + "gtdot;": 8919, + "gtlPar;": 10645, + "gtquest;": 10876, + "gtrapprox;": 10886, + "gtrarr;": 10616, + "gtrdot;": 8919, + "gtreqless;": 8923, + "gtreqqless;": 10892, + "gtrless;": 8823, + "gtrsim;": 8819, + "gvertneqq;": [8809, 65024], + "gvnE;": [8809, 65024], + "hArr;": 8660, + "hairsp;": 8202, + "half;": 189, + "hamilt;": 8459, + "hardcy;": 1098, + "harr;": 8596, + "harrcir;": 10568, + "harrw;": 8621, + "hbar;": 8463, + "hcirc;": 293, + "hearts;": 9829, + "heartsuit;": 9829, + "hellip;": 8230, + "hercon;": 8889, + "hfr;": [55349, 56613], + "hksearow;": 10533, + "hkswarow;": 10534, + "hoarr;": 8703, + "homtht;": 8763, + "hookleftarrow;": 8617, + "hookrightarrow;": 8618, + "hopf;": [55349, 56665], + "horbar;": 8213, + "hscr;": [55349, 56509], + "hslash;": 8463, + "hstrok;": 295, + "hybull;": 8259, + "hyphen;": 8208, + "iacute": 237, + "iacute;": 237, + "ic;": 8291, + "icirc": 238, + "icirc;": 238, + "icy;": 1080, + "iecy;": 1077, + "iexcl": 161, + "iexcl;": 161, + "iff;": 8660, + "ifr;": [55349, 56614], + "igrave": 236, + "igrave;": 236, + "ii;": 8520, + "iiiint;": 10764, + "iiint;": 8749, + "iinfin;": 10716, + "iiota;": 8489, + "ijlig;": 307, + "imacr;": 299, + "image;": 8465, + "imagline;": 8464, + "imagpart;": 8465, + "imath;": 305, + "imof;": 8887, + "imped;": 437, + "in;": 8712, + "incare;": 8453, + "infin;": 8734, + "infintie;": 10717, + "inodot;": 305, + "int;": 8747, + "intcal;": 8890, + "integers;": 8484, + "intercal;": 8890, + "intlarhk;": 10775, + "intprod;": 10812, + "iocy;": 1105, + "iogon;": 303, + "iopf;": [55349, 56666], + "iota;": 953, + "iprod;": 10812, + "iquest": 191, + "iquest;": 191, + "iscr;": [55349, 56510], + "isin;": 8712, + "isinE;": 8953, + "isindot;": 8949, + "isins;": 8948, + "isinsv;": 8947, + "isinv;": 8712, + "it;": 8290, + "itilde;": 297, + "iukcy;": 1110, + "iuml": 239, + "iuml;": 239, + "jcirc;": 309, + "jcy;": 1081, + "jfr;": [55349, 56615], + "jmath;": 567, + "jopf;": [55349, 56667], + "jscr;": [55349, 56511], + "jsercy;": 1112, + "jukcy;": 1108, + "kappa;": 954, + "kappav;": 1008, + "kcedil;": 311, + "kcy;": 1082, + "kfr;": [55349, 56616], + "kgreen;": 312, + "khcy;": 1093, + "kjcy;": 1116, + "kopf;": [55349, 56668], + "kscr;": [55349, 56512], + "lAarr;": 8666, + "lArr;": 8656, + "lAtail;": 10523, + "lBarr;": 10510, + "lE;": 8806, + "lEg;": 10891, + "lHar;": 10594, + "lacute;": 314, + "laemptyv;": 10676, + "lagran;": 8466, + "lambda;": 955, + "lang;": 10216, + "langd;": 10641, + "langle;": 10216, + "lap;": 10885, + "laquo": 171, + "laquo;": 171, + "larr;": 8592, + "larrb;": 8676, + "larrbfs;": 10527, + "larrfs;": 10525, + "larrhk;": 8617, + "larrlp;": 8619, + "larrpl;": 10553, + "larrsim;": 10611, + "larrtl;": 8610, + "lat;": 10923, + "latail;": 10521, + "late;": 10925, + "lates;": [10925, 65024], + "lbarr;": 10508, + "lbbrk;": 10098, + "lbrace;": 123, + "lbrack;": 91, + "lbrke;": 10635, + "lbrksld;": 10639, + "lbrkslu;": 10637, + "lcaron;": 318, + "lcedil;": 316, + "lceil;": 8968, + "lcub;": 123, + "lcy;": 1083, + "ldca;": 10550, + "ldquo;": 8220, + "ldquor;": 8222, + "ldrdhar;": 10599, + "ldrushar;": 10571, + "ldsh;": 8626, + "le;": 8804, + "leftarrow;": 8592, + "leftarrowtail;": 8610, + "leftharpoondown;": 8637, + "leftharpoonup;": 8636, + "leftleftarrows;": 8647, + "leftrightarrow;": 8596, + "leftrightarrows;": 8646, + "leftrightharpoons;": 8651, + "leftrightsquigarrow;": 8621, + "leftthreetimes;": 8907, + "leg;": 8922, + "leq;": 8804, + "leqq;": 8806, + "leqslant;": 10877, + "les;": 10877, + "lescc;": 10920, + "lesdot;": 10879, + "lesdoto;": 10881, + "lesdotor;": 10883, + "lesg;": [8922, 65024], + "lesges;": 10899, + "lessapprox;": 10885, + "lessdot;": 8918, + "lesseqgtr;": 8922, + "lesseqqgtr;": 10891, + "lessgtr;": 8822, + "lesssim;": 8818, + "lfisht;": 10620, + "lfloor;": 8970, + "lfr;": [55349, 56617], + "lg;": 8822, + "lgE;": 10897, + "lhard;": 8637, + "lharu;": 8636, + "lharul;": 10602, + "lhblk;": 9604, + "ljcy;": 1113, + "ll;": 8810, + "llarr;": 8647, + "llcorner;": 8990, + "llhard;": 10603, + "lltri;": 9722, + "lmidot;": 320, + "lmoust;": 9136, + "lmoustache;": 9136, + "lnE;": 8808, + "lnap;": 10889, + "lnapprox;": 10889, + "lne;": 10887, + "lneq;": 10887, + "lneqq;": 8808, + "lnsim;": 8934, + "loang;": 10220, + "loarr;": 8701, + "lobrk;": 10214, + "longleftarrow;": 10229, + "longleftrightarrow;": 10231, + "longmapsto;": 10236, + "longrightarrow;": 10230, + "looparrowleft;": 8619, + "looparrowright;": 8620, + "lopar;": 10629, + "lopf;": [55349, 56669], + "loplus;": 10797, + "lotimes;": 10804, + "lowast;": 8727, + "lowbar;": 95, + "loz;": 9674, + "lozenge;": 9674, + "lozf;": 10731, + "lpar;": 40, + "lparlt;": 10643, + "lrarr;": 8646, + "lrcorner;": 8991, + "lrhar;": 8651, + "lrhard;": 10605, + "lrm;": 8206, + "lrtri;": 8895, + "lsaquo;": 8249, + "lscr;": [55349, 56513], + "lsh;": 8624, + "lsim;": 8818, + "lsime;": 10893, + "lsimg;": 10895, + "lsqb;": 91, + "lsquo;": 8216, + "lsquor;": 8218, + "lstrok;": 322, + "lt": 60, + "lt;": 60, + "ltcc;": 10918, + "ltcir;": 10873, + "ltdot;": 8918, + "lthree;": 8907, + "ltimes;": 8905, + "ltlarr;": 10614, + "ltquest;": 10875, + "ltrPar;": 10646, + "ltri;": 9667, + "ltrie;": 8884, + "ltrif;": 9666, + "lurdshar;": 10570, + "luruhar;": 10598, + "lvertneqq;": [8808, 65024], + "lvnE;": [8808, 65024], + "mDDot;": 8762, + "macr": 175, + "macr;": 175, + "male;": 9794, + "malt;": 10016, + "maltese;": 10016, + "map;": 8614, + "mapsto;": 8614, + "mapstodown;": 8615, + "mapstoleft;": 8612, + "mapstoup;": 8613, + "marker;": 9646, + "mcomma;": 10793, + "mcy;": 1084, + "mdash;": 8212, + "measuredangle;": 8737, + "mfr;": [55349, 56618], + "mho;": 8487, + "micro": 181, + "micro;": 181, + "mid;": 8739, + "midast;": 42, + "midcir;": 10992, + "middot": 183, + "middot;": 183, + "minus;": 8722, + "minusb;": 8863, + "minusd;": 8760, + "minusdu;": 10794, + "mlcp;": 10971, + "mldr;": 8230, + "mnplus;": 8723, + "models;": 8871, + "mopf;": [55349, 56670], + "mp;": 8723, + "mscr;": [55349, 56514], + "mstpos;": 8766, + "mu;": 956, + "multimap;": 8888, + "mumap;": 8888, + "nGg;": [8921, 824], + "nGt;": [8811, 8402], + "nGtv;": [8811, 824], + "nLeftarrow;": 8653, + "nLeftrightarrow;": 8654, + "nLl;": [8920, 824], + "nLt;": [8810, 8402], + "nLtv;": [8810, 824], + "nRightarrow;": 8655, + "nVDash;": 8879, + "nVdash;": 8878, + "nabla;": 8711, + "nacute;": 324, + "nang;": [8736, 8402], + "nap;": 8777, + "napE;": [10864, 824], + "napid;": [8779, 824], + "napos;": 329, + "napprox;": 8777, + "natur;": 9838, + "natural;": 9838, + "naturals;": 8469, + "nbsp": 160, + "nbsp;": 160, + "nbump;": [8782, 824], + "nbumpe;": [8783, 824], + "ncap;": 10819, + "ncaron;": 328, + "ncedil;": 326, + "ncong;": 8775, + "ncongdot;": [10861, 824], + "ncup;": 10818, + "ncy;": 1085, + "ndash;": 8211, + "ne;": 8800, + "neArr;": 8663, + "nearhk;": 10532, + "nearr;": 8599, + "nearrow;": 8599, + "nedot;": [8784, 824], + "nequiv;": 8802, + "nesear;": 10536, + "nesim;": [8770, 824], + "nexist;": 8708, + "nexists;": 8708, + "nfr;": [55349, 56619], + "ngE;": [8807, 824], + "nge;": 8817, + "ngeq;": 8817, + "ngeqq;": [8807, 824], + "ngeqslant;": [10878, 824], + "nges;": [10878, 824], + "ngsim;": 8821, + "ngt;": 8815, + "ngtr;": 8815, + "nhArr;": 8654, + "nharr;": 8622, + "nhpar;": 10994, + "ni;": 8715, + "nis;": 8956, + "nisd;": 8954, + "niv;": 8715, + "njcy;": 1114, + "nlArr;": 8653, + "nlE;": [8806, 824], + "nlarr;": 8602, + "nldr;": 8229, + "nle;": 8816, + "nleftarrow;": 8602, + "nleftrightarrow;": 8622, + "nleq;": 8816, + "nleqq;": [8806, 824], + "nleqslant;": [10877, 824], + "nles;": [10877, 824], + "nless;": 8814, + "nlsim;": 8820, + "nlt;": 8814, + "nltri;": 8938, + "nltrie;": 8940, + "nmid;": 8740, + "nopf;": [55349, 56671], + "not": 172, + "not;": 172, + "notin;": 8713, + "notinE;": [8953, 824], + "notindot;": [8949, 824], + "notinva;": 8713, + "notinvb;": 8951, + "notinvc;": 8950, + "notni;": 8716, + "notniva;": 8716, + "notnivb;": 8958, + "notnivc;": 8957, + "npar;": 8742, + "nparallel;": 8742, + "nparsl;": [11005, 8421], + "npart;": [8706, 824], + "npolint;": 10772, + "npr;": 8832, + "nprcue;": 8928, + "npre;": [10927, 824], + "nprec;": 8832, + "npreceq;": [10927, 824], + "nrArr;": 8655, + "nrarr;": 8603, + "nrarrc;": [10547, 824], + "nrarrw;": [8605, 824], + "nrightarrow;": 8603, + "nrtri;": 8939, + "nrtrie;": 8941, + "nsc;": 8833, + "nsccue;": 8929, + "nsce;": [10928, 824], + "nscr;": [55349, 56515], + "nshortmid;": 8740, + "nshortparallel;": 8742, + "nsim;": 8769, + "nsime;": 8772, + "nsimeq;": 8772, + "nsmid;": 8740, + "nspar;": 8742, + "nsqsube;": 8930, + "nsqsupe;": 8931, + "nsub;": 8836, + "nsubE;": [10949, 824], + "nsube;": 8840, + "nsubset;": [8834, 8402], + "nsubseteq;": 8840, + "nsubseteqq;": [10949, 824], + "nsucc;": 8833, + "nsucceq;": [10928, 824], + "nsup;": 8837, + "nsupE;": [10950, 824], + "nsupe;": 8841, + "nsupset;": [8835, 8402], + "nsupseteq;": 8841, + "nsupseteqq;": [10950, 824], + "ntgl;": 8825, + "ntilde": 241, + "ntilde;": 241, + "ntlg;": 8824, + "ntriangleleft;": 8938, + "ntrianglelefteq;": 8940, + "ntriangleright;": 8939, + "ntrianglerighteq;": 8941, + "nu;": 957, + "num;": 35, + "numero;": 8470, + "numsp;": 8199, + "nvDash;": 8877, + "nvHarr;": 10500, + "nvap;": [8781, 8402], + "nvdash;": 8876, + "nvge;": [8805, 8402], + "nvgt;": [62, 8402], + "nvinfin;": 10718, + "nvlArr;": 10498, + "nvle;": [8804, 8402], + "nvlt;": [60, 8402], + "nvltrie;": [8884, 8402], + "nvrArr;": 10499, + "nvrtrie;": [8885, 8402], + "nvsim;": [8764, 8402], + "nwArr;": 8662, + "nwarhk;": 10531, + "nwarr;": 8598, + "nwarrow;": 8598, + "nwnear;": 10535, + "oS;": 9416, + "oacute": 243, + "oacute;": 243, + "oast;": 8859, + "ocir;": 8858, + "ocirc": 244, + "ocirc;": 244, + "ocy;": 1086, + "odash;": 8861, + "odblac;": 337, + "odiv;": 10808, + "odot;": 8857, + "odsold;": 10684, + "oelig;": 339, + "ofcir;": 10687, + "ofr;": [55349, 56620], + "ogon;": 731, + "ograve": 242, + "ograve;": 242, + "ogt;": 10689, + "ohbar;": 10677, + "ohm;": 937, + "oint;": 8750, + "olarr;": 8634, + "olcir;": 10686, + "olcross;": 10683, + "oline;": 8254, + "olt;": 10688, + "omacr;": 333, + "omega;": 969, + "omicron;": 959, + "omid;": 10678, + "ominus;": 8854, + "oopf;": [55349, 56672], + "opar;": 10679, + "operp;": 10681, + "oplus;": 8853, + "or;": 8744, + "orarr;": 8635, + "ord;": 10845, + "order;": 8500, + "orderof;": 8500, + "ordf": 170, + "ordf;": 170, + "ordm": 186, + "ordm;": 186, + "origof;": 8886, + "oror;": 10838, + "orslope;": 10839, + "orv;": 10843, + "oscr;": 8500, + "oslash": 248, + "oslash;": 248, + "osol;": 8856, + "otilde": 245, + "otilde;": 245, + "otimes;": 8855, + "otimesas;": 10806, + "ouml": 246, + "ouml;": 246, + "ovbar;": 9021, + "par;": 8741, + "para": 182, + "para;": 182, + "parallel;": 8741, + "parsim;": 10995, + "parsl;": 11005, + "part;": 8706, + "pcy;": 1087, + "percnt;": 37, + "period;": 46, + "permil;": 8240, + "perp;": 8869, + "pertenk;": 8241, + "pfr;": [55349, 56621], + "phi;": 966, + "phiv;": 981, + "phmmat;": 8499, + "phone;": 9742, + "pi;": 960, + "pitchfork;": 8916, + "piv;": 982, + "planck;": 8463, + "planckh;": 8462, + "plankv;": 8463, + "plus;": 43, + "plusacir;": 10787, + "plusb;": 8862, + "pluscir;": 10786, + "plusdo;": 8724, + "plusdu;": 10789, + "pluse;": 10866, + "plusmn": 177, + "plusmn;": 177, + "plussim;": 10790, + "plustwo;": 10791, + "pm;": 177, + "pointint;": 10773, + "popf;": [55349, 56673], + "pound": 163, + "pound;": 163, + "pr;": 8826, + "prE;": 10931, + "prap;": 10935, + "prcue;": 8828, + "pre;": 10927, + "prec;": 8826, + "precapprox;": 10935, + "preccurlyeq;": 8828, + "preceq;": 10927, + "precnapprox;": 10937, + "precneqq;": 10933, + "precnsim;": 8936, + "precsim;": 8830, + "prime;": 8242, + "primes;": 8473, + "prnE;": 10933, + "prnap;": 10937, + "prnsim;": 8936, + "prod;": 8719, + "profalar;": 9006, + "profline;": 8978, + "profsurf;": 8979, + "prop;": 8733, + "propto;": 8733, + "prsim;": 8830, + "prurel;": 8880, + "pscr;": [55349, 56517], + "psi;": 968, + "puncsp;": 8200, + "qfr;": [55349, 56622], + "qint;": 10764, + "qopf;": [55349, 56674], + "qprime;": 8279, + "qscr;": [55349, 56518], + "quaternions;": 8461, + "quatint;": 10774, + "quest;": 63, + "questeq;": 8799, + "quot": 34, + "quot;": 34, + "rAarr;": 8667, + "rArr;": 8658, + "rAtail;": 10524, + "rBarr;": 10511, + "rHar;": 10596, + "race;": [8765, 817], + "racute;": 341, + "radic;": 8730, + "raemptyv;": 10675, + "rang;": 10217, + "rangd;": 10642, + "range;": 10661, + "rangle;": 10217, + "raquo": 187, + "raquo;": 187, + "rarr;": 8594, + "rarrap;": 10613, + "rarrb;": 8677, + "rarrbfs;": 10528, + "rarrc;": 10547, + "rarrfs;": 10526, + "rarrhk;": 8618, + "rarrlp;": 8620, + "rarrpl;": 10565, + "rarrsim;": 10612, + "rarrtl;": 8611, + "rarrw;": 8605, + "ratail;": 10522, + "ratio;": 8758, + "rationals;": 8474, + "rbarr;": 10509, + "rbbrk;": 10099, + "rbrace;": 125, + "rbrack;": 93, + "rbrke;": 10636, + "rbrksld;": 10638, + "rbrkslu;": 10640, + "rcaron;": 345, + "rcedil;": 343, + "rceil;": 8969, + "rcub;": 125, + "rcy;": 1088, + "rdca;": 10551, + "rdldhar;": 10601, + "rdquo;": 8221, + "rdquor;": 8221, + "rdsh;": 8627, + "real;": 8476, + "realine;": 8475, + "realpart;": 8476, + "reals;": 8477, + "rect;": 9645, + "reg": 174, + "reg;": 174, + "rfisht;": 10621, + "rfloor;": 8971, + "rfr;": [55349, 56623], + "rhard;": 8641, + "rharu;": 8640, + "rharul;": 10604, + "rho;": 961, + "rhov;": 1009, + "rightarrow;": 8594, + "rightarrowtail;": 8611, + "rightharpoondown;": 8641, + "rightharpoonup;": 8640, + "rightleftarrows;": 8644, + "rightleftharpoons;": 8652, + "rightrightarrows;": 8649, + "rightsquigarrow;": 8605, + "rightthreetimes;": 8908, + "ring;": 730, + "risingdotseq;": 8787, + "rlarr;": 8644, + "rlhar;": 8652, + "rlm;": 8207, + "rmoust;": 9137, + "rmoustache;": 9137, + "rnmid;": 10990, + "roang;": 10221, + "roarr;": 8702, + "robrk;": 10215, + "ropar;": 10630, + "ropf;": [55349, 56675], + "roplus;": 10798, + "rotimes;": 10805, + "rpar;": 41, + "rpargt;": 10644, + "rppolint;": 10770, + "rrarr;": 8649, + "rsaquo;": 8250, + "rscr;": [55349, 56519], + "rsh;": 8625, + "rsqb;": 93, + "rsquo;": 8217, + "rsquor;": 8217, + "rthree;": 8908, + "rtimes;": 8906, + "rtri;": 9657, + "rtrie;": 8885, + "rtrif;": 9656, + "rtriltri;": 10702, + "ruluhar;": 10600, + "rx;": 8478, + "sacute;": 347, + "sbquo;": 8218, + "sc;": 8827, + "scE;": 10932, + "scap;": 10936, + "scaron;": 353, + "sccue;": 8829, + "sce;": 10928, + "scedil;": 351, + "scirc;": 349, + "scnE;": 10934, + "scnap;": 10938, + "scnsim;": 8937, + "scpolint;": 10771, + "scsim;": 8831, + "scy;": 1089, + "sdot;": 8901, + "sdotb;": 8865, + "sdote;": 10854, + "seArr;": 8664, + "searhk;": 10533, + "searr;": 8600, + "searrow;": 8600, + "sect": 167, + "sect;": 167, + "semi;": 59, + "seswar;": 10537, + "setminus;": 8726, + "setmn;": 8726, + "sext;": 10038, + "sfr;": [55349, 56624], + "sfrown;": 8994, + "sharp;": 9839, + "shchcy;": 1097, + "shcy;": 1096, + "shortmid;": 8739, + "shortparallel;": 8741, + "shy": 173, + "shy;": 173, + "sigma;": 963, + "sigmaf;": 962, + "sigmav;": 962, + "sim;": 8764, + "simdot;": 10858, + "sime;": 8771, + "simeq;": 8771, + "simg;": 10910, + "simgE;": 10912, + "siml;": 10909, + "simlE;": 10911, + "simne;": 8774, + "simplus;": 10788, + "simrarr;": 10610, + "slarr;": 8592, + "smallsetminus;": 8726, + "smashp;": 10803, + "smeparsl;": 10724, + "smid;": 8739, + "smile;": 8995, + "smt;": 10922, + "smte;": 10924, + "smtes;": [10924, 65024], + "softcy;": 1100, + "sol;": 47, + "solb;": 10692, + "solbar;": 9023, + "sopf;": [55349, 56676], + "spades;": 9824, + "spadesuit;": 9824, + "spar;": 8741, + "sqcap;": 8851, + "sqcaps;": [8851, 65024], + "sqcup;": 8852, + "sqcups;": [8852, 65024], + "sqsub;": 8847, + "sqsube;": 8849, + "sqsubset;": 8847, + "sqsubseteq;": 8849, + "sqsup;": 8848, + "sqsupe;": 8850, + "sqsupset;": 8848, + "sqsupseteq;": 8850, + "squ;": 9633, + "square;": 9633, + "squarf;": 9642, + "squf;": 9642, + "srarr;": 8594, + "sscr;": [55349, 56520], + "ssetmn;": 8726, + "ssmile;": 8995, + "sstarf;": 8902, + "star;": 9734, + "starf;": 9733, + "straightepsilon;": 1013, + "straightphi;": 981, + "strns;": 175, + "sub;": 8834, + "subE;": 10949, + "subdot;": 10941, + "sube;": 8838, + "subedot;": 10947, + "submult;": 10945, + "subnE;": 10955, + "subne;": 8842, + "subplus;": 10943, + "subrarr;": 10617, + "subset;": 8834, + "subseteq;": 8838, + "subseteqq;": 10949, + "subsetneq;": 8842, + "subsetneqq;": 10955, + "subsim;": 10951, + "subsub;": 10965, + "subsup;": 10963, + "succ;": 8827, + "succapprox;": 10936, + "succcurlyeq;": 8829, + "succeq;": 10928, + "succnapprox;": 10938, + "succneqq;": 10934, + "succnsim;": 8937, + "succsim;": 8831, + "sum;": 8721, + "sung;": 9834, + "sup1": 185, + "sup1;": 185, + "sup2": 178, + "sup2;": 178, + "sup3": 179, + "sup3;": 179, + "sup;": 8835, + "supE;": 10950, + "supdot;": 10942, + "supdsub;": 10968, + "supe;": 8839, + "supedot;": 10948, + "suphsol;": 10185, + "suphsub;": 10967, + "suplarr;": 10619, + "supmult;": 10946, + "supnE;": 10956, + "supne;": 8843, + "supplus;": 10944, + "supset;": 8835, + "supseteq;": 8839, + "supseteqq;": 10950, + "supsetneq;": 8843, + "supsetneqq;": 10956, + "supsim;": 10952, + "supsub;": 10964, + "supsup;": 10966, + "swArr;": 8665, + "swarhk;": 10534, + "swarr;": 8601, + "swarrow;": 8601, + "swnwar;": 10538, + "szlig": 223, + "szlig;": 223, + "target;": 8982, + "tau;": 964, + "tbrk;": 9140, + "tcaron;": 357, + "tcedil;": 355, + "tcy;": 1090, + "tdot;": 8411, + "telrec;": 8981, + "tfr;": [55349, 56625], + "there4;": 8756, + "therefore;": 8756, + "theta;": 952, + "thetasym;": 977, + "thetav;": 977, + "thickapprox;": 8776, + "thicksim;": 8764, + "thinsp;": 8201, + "thkap;": 8776, + "thksim;": 8764, + "thorn": 254, + "thorn;": 254, + "tilde;": 732, + "times": 215, + "times;": 215, + "timesb;": 8864, + "timesbar;": 10801, + "timesd;": 10800, + "tint;": 8749, + "toea;": 10536, + "top;": 8868, + "topbot;": 9014, + "topcir;": 10993, + "topf;": [55349, 56677], + "topfork;": 10970, + "tosa;": 10537, + "tprime;": 8244, + "trade;": 8482, + "triangle;": 9653, + "triangledown;": 9663, + "triangleleft;": 9667, + "trianglelefteq;": 8884, + "triangleq;": 8796, + "triangleright;": 9657, + "trianglerighteq;": 8885, + "tridot;": 9708, + "trie;": 8796, + "triminus;": 10810, + "triplus;": 10809, + "trisb;": 10701, + "tritime;": 10811, + "trpezium;": 9186, + "tscr;": [55349, 56521], + "tscy;": 1094, + "tshcy;": 1115, + "tstrok;": 359, + "twixt;": 8812, + "twoheadleftarrow;": 8606, + "twoheadrightarrow;": 8608, + "uArr;": 8657, + "uHar;": 10595, + "uacute": 250, + "uacute;": 250, + "uarr;": 8593, + "ubrcy;": 1118, + "ubreve;": 365, + "ucirc": 251, + "ucirc;": 251, + "ucy;": 1091, + "udarr;": 8645, + "udblac;": 369, + "udhar;": 10606, + "ufisht;": 10622, + "ufr;": [55349, 56626], + "ugrave": 249, + "ugrave;": 249, + "uharl;": 8639, + "uharr;": 8638, + "uhblk;": 9600, + "ulcorn;": 8988, + "ulcorner;": 8988, + "ulcrop;": 8975, + "ultri;": 9720, + "umacr;": 363, + "uml": 168, + "uml;": 168, + "uogon;": 371, + "uopf;": [55349, 56678], + "uparrow;": 8593, + "updownarrow;": 8597, + "upharpoonleft;": 8639, + "upharpoonright;": 8638, + "uplus;": 8846, + "upsi;": 965, + "upsih;": 978, + "upsilon;": 965, + "upuparrows;": 8648, + "urcorn;": 8989, + "urcorner;": 8989, + "urcrop;": 8974, + "uring;": 367, + "urtri;": 9721, + "uscr;": [55349, 56522], + "utdot;": 8944, + "utilde;": 361, + "utri;": 9653, + "utrif;": 9652, + "uuarr;": 8648, + "uuml": 252, + "uuml;": 252, + "uwangle;": 10663, + "vArr;": 8661, + "vBar;": 10984, + "vBarv;": 10985, + "vDash;": 8872, + "vangrt;": 10652, + "varepsilon;": 1013, + "varkappa;": 1008, + "varnothing;": 8709, + "varphi;": 981, + "varpi;": 982, + "varpropto;": 8733, + "varr;": 8597, + "varrho;": 1009, + "varsigma;": 962, + "varsubsetneq;": [8842, 65024], + "varsubsetneqq;": [10955, 65024], + "varsupsetneq;": [8843, 65024], + "varsupsetneqq;": [10956, 65024], + "vartheta;": 977, + "vartriangleleft;": 8882, + "vartriangleright;": 8883, + "vcy;": 1074, + "vdash;": 8866, + "vee;": 8744, + "veebar;": 8891, + "veeeq;": 8794, + "vellip;": 8942, + "verbar;": 124, + "vert;": 124, + "vfr;": [55349, 56627], + "vltri;": 8882, + "vnsub;": [8834, 8402], + "vnsup;": [8835, 8402], + "vopf;": [55349, 56679], + "vprop;": 8733, + "vrtri;": 8883, + "vscr;": [55349, 56523], + "vsubnE;": [10955, 65024], + "vsubne;": [8842, 65024], + "vsupnE;": [10956, 65024], + "vsupne;": [8843, 65024], + "vzigzag;": 10650, + "wcirc;": 373, + "wedbar;": 10847, + "wedge;": 8743, + "wedgeq;": 8793, + "weierp;": 8472, + "wfr;": [55349, 56628], + "wopf;": [55349, 56680], + "wp;": 8472, + "wr;": 8768, + "wreath;": 8768, + "wscr;": [55349, 56524], + "xcap;": 8898, + "xcirc;": 9711, + "xcup;": 8899, + "xdtri;": 9661, + "xfr;": [55349, 56629], + "xhArr;": 10234, + "xharr;": 10231, + "xi;": 958, + "xlArr;": 10232, + "xlarr;": 10229, + "xmap;": 10236, + "xnis;": 8955, + "xodot;": 10752, + "xopf;": [55349, 56681], + "xoplus;": 10753, + "xotime;": 10754, + "xrArr;": 10233, + "xrarr;": 10230, + "xscr;": [55349, 56525], + "xsqcup;": 10758, + "xuplus;": 10756, + "xutri;": 9651, + "xvee;": 8897, + "xwedge;": 8896, + "yacute": 253, + "yacute;": 253, + "yacy;": 1103, + "ycirc;": 375, + "ycy;": 1099, + "yen": 165, + "yen;": 165, + "yfr;": [55349, 56630], + "yicy;": 1111, + "yopf;": [55349, 56682], + "yscr;": [55349, 56526], + "yucy;": 1102, + "yuml": 255, + "yuml;": 255, + "zacute;": 378, + "zcaron;": 382, + "zcy;": 1079, + "zdot;": 380, + "zeetrf;": 8488, + "zeta;": 950, + "zfr;": [55349, 56631], + "zhcy;": 1078, + "zigrarr;": 8669, + "zopf;": [55349, 56683], + "zscr;": [55349, 56527], + "zwj;": 8205, + "zwnj;": 8204 + }; + var NAMEDCHARREF = /(A(?:Elig;?|MP;?|acute;?|breve;|c(?:irc;?|y;)|fr;|grave;?|lpha;|macr;|nd;|o(?:gon;|pf;)|pplyFunction;|ring;?|s(?:cr;|sign;)|tilde;?|uml;?)|B(?:a(?:ckslash;|r(?:v;|wed;))|cy;|e(?:cause;|rnoullis;|ta;)|fr;|opf;|reve;|scr;|umpeq;)|C(?:Hcy;|OPY;?|a(?:cute;|p(?:;|italDifferentialD;)|yleys;)|c(?:aron;|edil;?|irc;|onint;)|dot;|e(?:dilla;|nterDot;)|fr;|hi;|ircle(?:Dot;|Minus;|Plus;|Times;)|lo(?:ckwiseContourIntegral;|seCurly(?:DoubleQuote;|Quote;))|o(?:lon(?:;|e;)|n(?:gruent;|int;|tourIntegral;)|p(?:f;|roduct;)|unterClockwiseContourIntegral;)|ross;|scr;|up(?:;|Cap;))|D(?:D(?:;|otrahd;)|Jcy;|Scy;|Zcy;|a(?:gger;|rr;|shv;)|c(?:aron;|y;)|el(?:;|ta;)|fr;|i(?:a(?:critical(?:Acute;|Do(?:t;|ubleAcute;)|Grave;|Tilde;)|mond;)|fferentialD;)|o(?:pf;|t(?:;|Dot;|Equal;)|uble(?:ContourIntegral;|Do(?:t;|wnArrow;)|L(?:eft(?:Arrow;|RightArrow;|Tee;)|ong(?:Left(?:Arrow;|RightArrow;)|RightArrow;))|Right(?:Arrow;|Tee;)|Up(?:Arrow;|DownArrow;)|VerticalBar;)|wn(?:Arrow(?:;|Bar;|UpArrow;)|Breve;|Left(?:RightVector;|TeeVector;|Vector(?:;|Bar;))|Right(?:TeeVector;|Vector(?:;|Bar;))|Tee(?:;|Arrow;)|arrow;))|s(?:cr;|trok;))|E(?:NG;|TH;?|acute;?|c(?:aron;|irc;?|y;)|dot;|fr;|grave;?|lement;|m(?:acr;|pty(?:SmallSquare;|VerySmallSquare;))|o(?:gon;|pf;)|psilon;|qu(?:al(?:;|Tilde;)|ilibrium;)|s(?:cr;|im;)|ta;|uml;?|x(?:ists;|ponentialE;))|F(?:cy;|fr;|illed(?:SmallSquare;|VerySmallSquare;)|o(?:pf;|rAll;|uriertrf;)|scr;)|G(?:Jcy;|T;?|amma(?:;|d;)|breve;|c(?:edil;|irc;|y;)|dot;|fr;|g;|opf;|reater(?:Equal(?:;|Less;)|FullEqual;|Greater;|Less;|SlantEqual;|Tilde;)|scr;|t;)|H(?:ARDcy;|a(?:cek;|t;)|circ;|fr;|ilbertSpace;|o(?:pf;|rizontalLine;)|s(?:cr;|trok;)|ump(?:DownHump;|Equal;))|I(?:Ecy;|Jlig;|Ocy;|acute;?|c(?:irc;?|y;)|dot;|fr;|grave;?|m(?:;|a(?:cr;|ginaryI;)|plies;)|n(?:t(?:;|e(?:gral;|rsection;))|visible(?:Comma;|Times;))|o(?:gon;|pf;|ta;)|scr;|tilde;|u(?:kcy;|ml;?))|J(?:c(?:irc;|y;)|fr;|opf;|s(?:cr;|ercy;)|ukcy;)|K(?:Hcy;|Jcy;|appa;|c(?:edil;|y;)|fr;|opf;|scr;)|L(?:Jcy;|T;?|a(?:cute;|mbda;|ng;|placetrf;|rr;)|c(?:aron;|edil;|y;)|e(?:ft(?:A(?:ngleBracket;|rrow(?:;|Bar;|RightArrow;))|Ceiling;|Do(?:ubleBracket;|wn(?:TeeVector;|Vector(?:;|Bar;)))|Floor;|Right(?:Arrow;|Vector;)|T(?:ee(?:;|Arrow;|Vector;)|riangle(?:;|Bar;|Equal;))|Up(?:DownVector;|TeeVector;|Vector(?:;|Bar;))|Vector(?:;|Bar;)|arrow;|rightarrow;)|ss(?:EqualGreater;|FullEqual;|Greater;|Less;|SlantEqual;|Tilde;))|fr;|l(?:;|eftarrow;)|midot;|o(?:ng(?:Left(?:Arrow;|RightArrow;)|RightArrow;|left(?:arrow;|rightarrow;)|rightarrow;)|pf;|wer(?:LeftArrow;|RightArrow;))|s(?:cr;|h;|trok;)|t;)|M(?:ap;|cy;|e(?:diumSpace;|llintrf;)|fr;|inusPlus;|opf;|scr;|u;)|N(?:Jcy;|acute;|c(?:aron;|edil;|y;)|e(?:gative(?:MediumSpace;|Thi(?:ckSpace;|nSpace;)|VeryThinSpace;)|sted(?:GreaterGreater;|LessLess;)|wLine;)|fr;|o(?:Break;|nBreakingSpace;|pf;|t(?:;|C(?:ongruent;|upCap;)|DoubleVerticalBar;|E(?:lement;|qual(?:;|Tilde;)|xists;)|Greater(?:;|Equal;|FullEqual;|Greater;|Less;|SlantEqual;|Tilde;)|Hump(?:DownHump;|Equal;)|Le(?:ftTriangle(?:;|Bar;|Equal;)|ss(?:;|Equal;|Greater;|Less;|SlantEqual;|Tilde;))|Nested(?:GreaterGreater;|LessLess;)|Precedes(?:;|Equal;|SlantEqual;)|R(?:everseElement;|ightTriangle(?:;|Bar;|Equal;))|S(?:quareSu(?:bset(?:;|Equal;)|perset(?:;|Equal;))|u(?:bset(?:;|Equal;)|cceeds(?:;|Equal;|SlantEqual;|Tilde;)|perset(?:;|Equal;)))|Tilde(?:;|Equal;|FullEqual;|Tilde;)|VerticalBar;))|scr;|tilde;?|u;)|O(?:Elig;|acute;?|c(?:irc;?|y;)|dblac;|fr;|grave;?|m(?:acr;|ega;|icron;)|opf;|penCurly(?:DoubleQuote;|Quote;)|r;|s(?:cr;|lash;?)|ti(?:lde;?|mes;)|uml;?|ver(?:B(?:ar;|rac(?:e;|ket;))|Parenthesis;))|P(?:artialD;|cy;|fr;|hi;|i;|lusMinus;|o(?:incareplane;|pf;)|r(?:;|ecedes(?:;|Equal;|SlantEqual;|Tilde;)|ime;|o(?:duct;|portion(?:;|al;)))|s(?:cr;|i;))|Q(?:UOT;?|fr;|opf;|scr;)|R(?:Barr;|EG;?|a(?:cute;|ng;|rr(?:;|tl;))|c(?:aron;|edil;|y;)|e(?:;|verse(?:E(?:lement;|quilibrium;)|UpEquilibrium;))|fr;|ho;|ight(?:A(?:ngleBracket;|rrow(?:;|Bar;|LeftArrow;))|Ceiling;|Do(?:ubleBracket;|wn(?:TeeVector;|Vector(?:;|Bar;)))|Floor;|T(?:ee(?:;|Arrow;|Vector;)|riangle(?:;|Bar;|Equal;))|Up(?:DownVector;|TeeVector;|Vector(?:;|Bar;))|Vector(?:;|Bar;)|arrow;)|o(?:pf;|undImplies;)|rightarrow;|s(?:cr;|h;)|uleDelayed;)|S(?:H(?:CHcy;|cy;)|OFTcy;|acute;|c(?:;|aron;|edil;|irc;|y;)|fr;|hort(?:DownArrow;|LeftArrow;|RightArrow;|UpArrow;)|igma;|mallCircle;|opf;|q(?:rt;|uare(?:;|Intersection;|Su(?:bset(?:;|Equal;)|perset(?:;|Equal;))|Union;))|scr;|tar;|u(?:b(?:;|set(?:;|Equal;))|c(?:ceeds(?:;|Equal;|SlantEqual;|Tilde;)|hThat;)|m;|p(?:;|erset(?:;|Equal;)|set;)))|T(?:HORN;?|RADE;|S(?:Hcy;|cy;)|a(?:b;|u;)|c(?:aron;|edil;|y;)|fr;|h(?:e(?:refore;|ta;)|i(?:ckSpace;|nSpace;))|ilde(?:;|Equal;|FullEqual;|Tilde;)|opf;|ripleDot;|s(?:cr;|trok;))|U(?:a(?:cute;?|rr(?:;|ocir;))|br(?:cy;|eve;)|c(?:irc;?|y;)|dblac;|fr;|grave;?|macr;|n(?:der(?:B(?:ar;|rac(?:e;|ket;))|Parenthesis;)|ion(?:;|Plus;))|o(?:gon;|pf;)|p(?:Arrow(?:;|Bar;|DownArrow;)|DownArrow;|Equilibrium;|Tee(?:;|Arrow;)|arrow;|downarrow;|per(?:LeftArrow;|RightArrow;)|si(?:;|lon;))|ring;|scr;|tilde;|uml;?)|V(?:Dash;|bar;|cy;|dash(?:;|l;)|e(?:e;|r(?:bar;|t(?:;|ical(?:Bar;|Line;|Separator;|Tilde;))|yThinSpace;))|fr;|opf;|scr;|vdash;)|W(?:circ;|edge;|fr;|opf;|scr;)|X(?:fr;|i;|opf;|scr;)|Y(?:Acy;|Icy;|Ucy;|acute;?|c(?:irc;|y;)|fr;|opf;|scr;|uml;)|Z(?:Hcy;|acute;|c(?:aron;|y;)|dot;|e(?:roWidthSpace;|ta;)|fr;|opf;|scr;)|a(?:acute;?|breve;|c(?:;|E;|d;|irc;?|ute;?|y;)|elig;?|f(?:;|r;)|grave;?|l(?:e(?:fsym;|ph;)|pha;)|m(?:a(?:cr;|lg;)|p;?)|n(?:d(?:;|and;|d;|slope;|v;)|g(?:;|e;|le;|msd(?:;|a(?:a;|b;|c;|d;|e;|f;|g;|h;))|rt(?:;|vb(?:;|d;))|s(?:ph;|t;)|zarr;))|o(?:gon;|pf;)|p(?:;|E;|acir;|e;|id;|os;|prox(?:;|eq;))|ring;?|s(?:cr;|t;|ymp(?:;|eq;))|tilde;?|uml;?|w(?:conint;|int;))|b(?:Not;|a(?:ck(?:cong;|epsilon;|prime;|sim(?:;|eq;))|r(?:vee;|wed(?:;|ge;)))|brk(?:;|tbrk;)|c(?:ong;|y;)|dquo;|e(?:caus(?:;|e;)|mptyv;|psi;|rnou;|t(?:a;|h;|ween;))|fr;|ig(?:c(?:ap;|irc;|up;)|o(?:dot;|plus;|times;)|s(?:qcup;|tar;)|triangle(?:down;|up;)|uplus;|vee;|wedge;)|karow;|l(?:a(?:ck(?:lozenge;|square;|triangle(?:;|down;|left;|right;))|nk;)|k(?:1(?:2;|4;)|34;)|ock;)|n(?:e(?:;|quiv;)|ot;)|o(?:pf;|t(?:;|tom;)|wtie;|x(?:D(?:L;|R;|l;|r;)|H(?:;|D;|U;|d;|u;)|U(?:L;|R;|l;|r;)|V(?:;|H;|L;|R;|h;|l;|r;)|box;|d(?:L;|R;|l;|r;)|h(?:;|D;|U;|d;|u;)|minus;|plus;|times;|u(?:L;|R;|l;|r;)|v(?:;|H;|L;|R;|h;|l;|r;)))|prime;|r(?:eve;|vbar;?)|s(?:cr;|emi;|im(?:;|e;)|ol(?:;|b;|hsub;))|u(?:ll(?:;|et;)|mp(?:;|E;|e(?:;|q;))))|c(?:a(?:cute;|p(?:;|and;|brcup;|c(?:ap;|up;)|dot;|s;)|r(?:et;|on;))|c(?:a(?:ps;|ron;)|edil;?|irc;|ups(?:;|sm;))|dot;|e(?:dil;?|mptyv;|nt(?:;|erdot;|))|fr;|h(?:cy;|eck(?:;|mark;)|i;)|ir(?:;|E;|c(?:;|eq;|le(?:arrow(?:left;|right;)|d(?:R;|S;|ast;|circ;|dash;)))|e;|fnint;|mid;|scir;)|lubs(?:;|uit;)|o(?:lon(?:;|e(?:;|q;))|m(?:ma(?:;|t;)|p(?:;|fn;|le(?:ment;|xes;)))|n(?:g(?:;|dot;)|int;)|p(?:f;|rod;|y(?:;|sr;|)))|r(?:arr;|oss;)|s(?:cr;|u(?:b(?:;|e;)|p(?:;|e;)))|tdot;|u(?:darr(?:l;|r;)|e(?:pr;|sc;)|larr(?:;|p;)|p(?:;|brcap;|c(?:ap;|up;)|dot;|or;|s;)|r(?:arr(?:;|m;)|ly(?:eq(?:prec;|succ;)|vee;|wedge;)|ren;?|vearrow(?:left;|right;))|vee;|wed;)|w(?:conint;|int;)|ylcty;)|d(?:Arr;|Har;|a(?:gger;|leth;|rr;|sh(?:;|v;))|b(?:karow;|lac;)|c(?:aron;|y;)|d(?:;|a(?:gger;|rr;)|otseq;)|e(?:g;?|lta;|mptyv;)|f(?:isht;|r;)|har(?:l;|r;)|i(?:am(?:;|ond(?:;|suit;)|s;)|e;|gamma;|sin;|v(?:;|ide(?:;|ontimes;|)|onx;))|jcy;|lc(?:orn;|rop;)|o(?:llar;|pf;|t(?:;|eq(?:;|dot;)|minus;|plus;|square;)|ublebarwedge;|wn(?:arrow;|downarrows;|harpoon(?:left;|right;)))|r(?:bkarow;|c(?:orn;|rop;))|s(?:c(?:r;|y;)|ol;|trok;)|t(?:dot;|ri(?:;|f;))|u(?:arr;|har;)|wangle;|z(?:cy;|igrarr;))|e(?:D(?:Dot;|ot;)|a(?:cute;?|ster;)|c(?:aron;|ir(?:;|c;?)|olon;|y;)|dot;|e;|f(?:Dot;|r;)|g(?:;|rave;?|s(?:;|dot;))|l(?:;|inters;|l;|s(?:;|dot;))|m(?:acr;|pty(?:;|set;|v;)|sp(?:1(?:3;|4;)|;))|n(?:g;|sp;)|o(?:gon;|pf;)|p(?:ar(?:;|sl;)|lus;|si(?:;|lon;|v;))|q(?:c(?:irc;|olon;)|s(?:im;|lant(?:gtr;|less;))|u(?:als;|est;|iv(?:;|DD;))|vparsl;)|r(?:Dot;|arr;)|s(?:cr;|dot;|im;)|t(?:a;|h;?)|u(?:ml;?|ro;)|x(?:cl;|ist;|p(?:ectation;|onentiale;)))|f(?:allingdotseq;|cy;|emale;|f(?:ilig;|l(?:ig;|lig;)|r;)|ilig;|jlig;|l(?:at;|lig;|tns;)|nof;|o(?:pf;|r(?:all;|k(?:;|v;)))|partint;|r(?:a(?:c(?:1(?:2;?|3;|4;?|5;|6;|8;)|2(?:3;|5;)|3(?:4;?|5;|8;)|45;|5(?:6;|8;)|78;)|sl;)|own;)|scr;)|g(?:E(?:;|l;)|a(?:cute;|mma(?:;|d;)|p;)|breve;|c(?:irc;|y;)|dot;|e(?:;|l;|q(?:;|q;|slant;)|s(?:;|cc;|dot(?:;|o(?:;|l;))|l(?:;|es;)))|fr;|g(?:;|g;)|imel;|jcy;|l(?:;|E;|a;|j;)|n(?:E;|ap(?:;|prox;)|e(?:;|q(?:;|q;))|sim;)|opf;|rave;|s(?:cr;|im(?:;|e;|l;))|t(?:;|c(?:c;|ir;)|dot;|lPar;|quest;|r(?:a(?:pprox;|rr;)|dot;|eq(?:less;|qless;)|less;|sim;)|)|v(?:ertneqq;|nE;))|h(?:Arr;|a(?:irsp;|lf;|milt;|r(?:dcy;|r(?:;|cir;|w;)))|bar;|circ;|e(?:arts(?:;|uit;)|llip;|rcon;)|fr;|ks(?:earow;|warow;)|o(?:arr;|mtht;|ok(?:leftarrow;|rightarrow;)|pf;|rbar;)|s(?:cr;|lash;|trok;)|y(?:bull;|phen;))|i(?:acute;?|c(?:;|irc;?|y;)|e(?:cy;|xcl;?)|f(?:f;|r;)|grave;?|i(?:;|i(?:int;|nt;)|nfin;|ota;)|jlig;|m(?:a(?:cr;|g(?:e;|line;|part;)|th;)|of;|ped;)|n(?:;|care;|fin(?:;|tie;)|odot;|t(?:;|cal;|e(?:gers;|rcal;)|larhk;|prod;))|o(?:cy;|gon;|pf;|ta;)|prod;|quest;?|s(?:cr;|in(?:;|E;|dot;|s(?:;|v;)|v;))|t(?:;|ilde;)|u(?:kcy;|ml;?))|j(?:c(?:irc;|y;)|fr;|math;|opf;|s(?:cr;|ercy;)|ukcy;)|k(?:appa(?:;|v;)|c(?:edil;|y;)|fr;|green;|hcy;|jcy;|opf;|scr;)|l(?:A(?:arr;|rr;|tail;)|Barr;|E(?:;|g;)|Har;|a(?:cute;|emptyv;|gran;|mbda;|ng(?:;|d;|le;)|p;|quo;?|rr(?:;|b(?:;|fs;)|fs;|hk;|lp;|pl;|sim;|tl;)|t(?:;|ail;|e(?:;|s;)))|b(?:arr;|brk;|r(?:ac(?:e;|k;)|k(?:e;|sl(?:d;|u;))))|c(?:aron;|e(?:dil;|il;)|ub;|y;)|d(?:ca;|quo(?:;|r;)|r(?:dhar;|ushar;)|sh;)|e(?:;|ft(?:arrow(?:;|tail;)|harpoon(?:down;|up;)|leftarrows;|right(?:arrow(?:;|s;)|harpoons;|squigarrow;)|threetimes;)|g;|q(?:;|q;|slant;)|s(?:;|cc;|dot(?:;|o(?:;|r;))|g(?:;|es;)|s(?:approx;|dot;|eq(?:gtr;|qgtr;)|gtr;|sim;)))|f(?:isht;|loor;|r;)|g(?:;|E;)|h(?:ar(?:d;|u(?:;|l;))|blk;)|jcy;|l(?:;|arr;|corner;|hard;|tri;)|m(?:idot;|oust(?:;|ache;))|n(?:E;|ap(?:;|prox;)|e(?:;|q(?:;|q;))|sim;)|o(?:a(?:ng;|rr;)|brk;|ng(?:left(?:arrow;|rightarrow;)|mapsto;|rightarrow;)|oparrow(?:left;|right;)|p(?:ar;|f;|lus;)|times;|w(?:ast;|bar;)|z(?:;|enge;|f;))|par(?:;|lt;)|r(?:arr;|corner;|har(?:;|d;)|m;|tri;)|s(?:aquo;|cr;|h;|im(?:;|e;|g;)|q(?:b;|uo(?:;|r;))|trok;)|t(?:;|c(?:c;|ir;)|dot;|hree;|imes;|larr;|quest;|r(?:Par;|i(?:;|e;|f;))|)|ur(?:dshar;|uhar;)|v(?:ertneqq;|nE;))|m(?:DDot;|a(?:cr;?|l(?:e;|t(?:;|ese;))|p(?:;|sto(?:;|down;|left;|up;))|rker;)|c(?:omma;|y;)|dash;|easuredangle;|fr;|ho;|i(?:cro;?|d(?:;|ast;|cir;|dot;?)|nus(?:;|b;|d(?:;|u;)))|l(?:cp;|dr;)|nplus;|o(?:dels;|pf;)|p;|s(?:cr;|tpos;)|u(?:;|ltimap;|map;))|n(?:G(?:g;|t(?:;|v;))|L(?:eft(?:arrow;|rightarrow;)|l;|t(?:;|v;))|Rightarrow;|V(?:Dash;|dash;)|a(?:bla;|cute;|ng;|p(?:;|E;|id;|os;|prox;)|tur(?:;|al(?:;|s;)))|b(?:sp;?|ump(?:;|e;))|c(?:a(?:p;|ron;)|edil;|ong(?:;|dot;)|up;|y;)|dash;|e(?:;|Arr;|ar(?:hk;|r(?:;|ow;))|dot;|quiv;|s(?:ear;|im;)|xist(?:;|s;))|fr;|g(?:E;|e(?:;|q(?:;|q;|slant;)|s;)|sim;|t(?:;|r;))|h(?:Arr;|arr;|par;)|i(?:;|s(?:;|d;)|v;)|jcy;|l(?:Arr;|E;|arr;|dr;|e(?:;|ft(?:arrow;|rightarrow;)|q(?:;|q;|slant;)|s(?:;|s;))|sim;|t(?:;|ri(?:;|e;)))|mid;|o(?:pf;|t(?:;|in(?:;|E;|dot;|v(?:a;|b;|c;))|ni(?:;|v(?:a;|b;|c;))|))|p(?:ar(?:;|allel;|sl;|t;)|olint;|r(?:;|cue;|e(?:;|c(?:;|eq;))))|r(?:Arr;|arr(?:;|c;|w;)|ightarrow;|tri(?:;|e;))|s(?:c(?:;|cue;|e;|r;)|hort(?:mid;|parallel;)|im(?:;|e(?:;|q;))|mid;|par;|qsu(?:be;|pe;)|u(?:b(?:;|E;|e;|set(?:;|eq(?:;|q;)))|cc(?:;|eq;)|p(?:;|E;|e;|set(?:;|eq(?:;|q;)))))|t(?:gl;|ilde;?|lg;|riangle(?:left(?:;|eq;)|right(?:;|eq;)))|u(?:;|m(?:;|ero;|sp;))|v(?:Dash;|Harr;|ap;|dash;|g(?:e;|t;)|infin;|l(?:Arr;|e;|t(?:;|rie;))|r(?:Arr;|trie;)|sim;)|w(?:Arr;|ar(?:hk;|r(?:;|ow;))|near;))|o(?:S;|a(?:cute;?|st;)|c(?:ir(?:;|c;?)|y;)|d(?:ash;|blac;|iv;|ot;|sold;)|elig;|f(?:cir;|r;)|g(?:on;|rave;?|t;)|h(?:bar;|m;)|int;|l(?:arr;|c(?:ir;|ross;)|ine;|t;)|m(?:acr;|ega;|i(?:cron;|d;|nus;))|opf;|p(?:ar;|erp;|lus;)|r(?:;|arr;|d(?:;|er(?:;|of;)|f;?|m;?)|igof;|or;|slope;|v;)|s(?:cr;|lash;?|ol;)|ti(?:lde;?|mes(?:;|as;))|uml;?|vbar;)|p(?:ar(?:;|a(?:;|llel;|)|s(?:im;|l;)|t;)|cy;|er(?:cnt;|iod;|mil;|p;|tenk;)|fr;|h(?:i(?:;|v;)|mmat;|one;)|i(?:;|tchfork;|v;)|l(?:an(?:ck(?:;|h;)|kv;)|us(?:;|acir;|b;|cir;|d(?:o;|u;)|e;|mn;?|sim;|two;))|m;|o(?:intint;|pf;|und;?)|r(?:;|E;|ap;|cue;|e(?:;|c(?:;|approx;|curlyeq;|eq;|n(?:approx;|eqq;|sim;)|sim;))|ime(?:;|s;)|n(?:E;|ap;|sim;)|o(?:d;|f(?:alar;|line;|surf;)|p(?:;|to;))|sim;|urel;)|s(?:cr;|i;)|uncsp;)|q(?:fr;|int;|opf;|prime;|scr;|u(?:at(?:ernions;|int;)|est(?:;|eq;)|ot;?))|r(?:A(?:arr;|rr;|tail;)|Barr;|Har;|a(?:c(?:e;|ute;)|dic;|emptyv;|ng(?:;|d;|e;|le;)|quo;?|rr(?:;|ap;|b(?:;|fs;)|c;|fs;|hk;|lp;|pl;|sim;|tl;|w;)|t(?:ail;|io(?:;|nals;)))|b(?:arr;|brk;|r(?:ac(?:e;|k;)|k(?:e;|sl(?:d;|u;))))|c(?:aron;|e(?:dil;|il;)|ub;|y;)|d(?:ca;|ldhar;|quo(?:;|r;)|sh;)|e(?:al(?:;|ine;|part;|s;)|ct;|g;?)|f(?:isht;|loor;|r;)|h(?:ar(?:d;|u(?:;|l;))|o(?:;|v;))|i(?:ght(?:arrow(?:;|tail;)|harpoon(?:down;|up;)|left(?:arrows;|harpoons;)|rightarrows;|squigarrow;|threetimes;)|ng;|singdotseq;)|l(?:arr;|har;|m;)|moust(?:;|ache;)|nmid;|o(?:a(?:ng;|rr;)|brk;|p(?:ar;|f;|lus;)|times;)|p(?:ar(?:;|gt;)|polint;)|rarr;|s(?:aquo;|cr;|h;|q(?:b;|uo(?:;|r;)))|t(?:hree;|imes;|ri(?:;|e;|f;|ltri;))|uluhar;|x;)|s(?:acute;|bquo;|c(?:;|E;|a(?:p;|ron;)|cue;|e(?:;|dil;)|irc;|n(?:E;|ap;|sim;)|polint;|sim;|y;)|dot(?:;|b;|e;)|e(?:Arr;|ar(?:hk;|r(?:;|ow;))|ct;?|mi;|swar;|tm(?:inus;|n;)|xt;)|fr(?:;|own;)|h(?:arp;|c(?:hcy;|y;)|ort(?:mid;|parallel;)|y;?)|i(?:gma(?:;|f;|v;)|m(?:;|dot;|e(?:;|q;)|g(?:;|E;)|l(?:;|E;)|ne;|plus;|rarr;))|larr;|m(?:a(?:llsetminus;|shp;)|eparsl;|i(?:d;|le;)|t(?:;|e(?:;|s;)))|o(?:ftcy;|l(?:;|b(?:;|ar;))|pf;)|pa(?:des(?:;|uit;)|r;)|q(?:c(?:ap(?:;|s;)|up(?:;|s;))|su(?:b(?:;|e;|set(?:;|eq;))|p(?:;|e;|set(?:;|eq;)))|u(?:;|ar(?:e;|f;)|f;))|rarr;|s(?:cr;|etmn;|mile;|tarf;)|t(?:ar(?:;|f;)|r(?:aight(?:epsilon;|phi;)|ns;))|u(?:b(?:;|E;|dot;|e(?:;|dot;)|mult;|n(?:E;|e;)|plus;|rarr;|s(?:et(?:;|eq(?:;|q;)|neq(?:;|q;))|im;|u(?:b;|p;)))|cc(?:;|approx;|curlyeq;|eq;|n(?:approx;|eqq;|sim;)|sim;)|m;|ng;|p(?:1;?|2;?|3;?|;|E;|d(?:ot;|sub;)|e(?:;|dot;)|hs(?:ol;|ub;)|larr;|mult;|n(?:E;|e;)|plus;|s(?:et(?:;|eq(?:;|q;)|neq(?:;|q;))|im;|u(?:b;|p;))))|w(?:Arr;|ar(?:hk;|r(?:;|ow;))|nwar;)|zlig;?)|t(?:a(?:rget;|u;)|brk;|c(?:aron;|edil;|y;)|dot;|elrec;|fr;|h(?:e(?:re(?:4;|fore;)|ta(?:;|sym;|v;))|i(?:ck(?:approx;|sim;)|nsp;)|k(?:ap;|sim;)|orn;?)|i(?:lde;|mes(?:;|b(?:;|ar;)|d;|)|nt;)|o(?:ea;|p(?:;|bot;|cir;|f(?:;|ork;))|sa;)|prime;|r(?:ade;|i(?:angle(?:;|down;|left(?:;|eq;)|q;|right(?:;|eq;))|dot;|e;|minus;|plus;|sb;|time;)|pezium;)|s(?:c(?:r;|y;)|hcy;|trok;)|w(?:ixt;|ohead(?:leftarrow;|rightarrow;)))|u(?:Arr;|Har;|a(?:cute;?|rr;)|br(?:cy;|eve;)|c(?:irc;?|y;)|d(?:arr;|blac;|har;)|f(?:isht;|r;)|grave;?|h(?:ar(?:l;|r;)|blk;)|l(?:c(?:orn(?:;|er;)|rop;)|tri;)|m(?:acr;|l;?)|o(?:gon;|pf;)|p(?:arrow;|downarrow;|harpoon(?:left;|right;)|lus;|si(?:;|h;|lon;)|uparrows;)|r(?:c(?:orn(?:;|er;)|rop;)|ing;|tri;)|scr;|t(?:dot;|ilde;|ri(?:;|f;))|u(?:arr;|ml;?)|wangle;)|v(?:Arr;|Bar(?:;|v;)|Dash;|a(?:ngrt;|r(?:epsilon;|kappa;|nothing;|p(?:hi;|i;|ropto;)|r(?:;|ho;)|s(?:igma;|u(?:bsetneq(?:;|q;)|psetneq(?:;|q;)))|t(?:heta;|riangle(?:left;|right;))))|cy;|dash;|e(?:e(?:;|bar;|eq;)|llip;|r(?:bar;|t;))|fr;|ltri;|nsu(?:b;|p;)|opf;|prop;|rtri;|s(?:cr;|u(?:bn(?:E;|e;)|pn(?:E;|e;)))|zigzag;)|w(?:circ;|e(?:d(?:bar;|ge(?:;|q;))|ierp;)|fr;|opf;|p;|r(?:;|eath;)|scr;)|x(?:c(?:ap;|irc;|up;)|dtri;|fr;|h(?:Arr;|arr;)|i;|l(?:Arr;|arr;)|map;|nis;|o(?:dot;|p(?:f;|lus;)|time;)|r(?:Arr;|arr;)|s(?:cr;|qcup;)|u(?:plus;|tri;)|vee;|wedge;)|y(?:ac(?:ute;?|y;)|c(?:irc;|y;)|en;?|fr;|icy;|opf;|scr;|u(?:cy;|ml;?))|z(?:acute;|c(?:aron;|y;)|dot;|e(?:etrf;|ta;)|fr;|hcy;|igrarr;|opf;|scr;|w(?:j;|nj;)))|[\s\S]/g; + var NAMEDCHARREF_MAXLEN = 32; + var DBLQUOTEATTRVAL = /[^\r"&\u0000]+/g; + var SINGLEQUOTEATTRVAL = /[^\r'&\u0000]+/g; + var UNQUOTEDATTRVAL = /[^\r\t\n\f &>\u0000]+/g; + var TAGNAME = /[^\r\t\n\f \/>A-Z\u0000]+/g; + var ATTRNAME = /[^\r\t\n\f \/=>A-Z\u0000]+/g; + var CDATATEXT = /[^\]\r\u0000\uffff]*/g; + var DATATEXT = /[^&<\r\u0000\uffff]*/g; + var RAWTEXT = /[^<\r\u0000\uffff]*/g; + var PLAINTEXT = /[^\r\u0000\uffff]*/g; + var SIMPLETAG = /(?:(\/)?([a-z]+)>)|[\s\S]/g; + var SIMPLEATTR = /(?:([-a-z]+)[ \t\n\f]*=[ \t\n\f]*('[^'&\r\u0000]*'|"[^"&\r\u0000]*"|[^\t\n\r\f "&'\u0000>][^&> \t\n\r\f\u0000]*[ \t\n\f]))|[\s\S]/g; + var NONWS = /[^\x09\x0A\x0C\x0D\x20]/; + var ALLNONWS = /[^\x09\x0A\x0C\x0D\x20]/g; + var NONWSNONNUL = /[^\x00\x09\x0A\x0C\x0D\x20]/; + var LEADINGWS = /^[\x09\x0A\x0C\x0D\x20]+/; + var NULCHARS = /\x00/g; + function buf2str(buf) { + var CHUNKSIZE = 16384; + if (buf.length < CHUNKSIZE) { + return String.fromCharCode.apply(String, buf); + } + var result = ""; + for (var i = 0; i < buf.length; i += CHUNKSIZE) { + result += String.fromCharCode.apply(String, buf.slice(i, i + CHUNKSIZE)); + } + return result; + } + function str2buf(s) { + var result = []; + for (var i = 0; i < s.length; i++) { + result[i] = s.charCodeAt(i); + } + return result; + } + function isA(elt, set2) { + if (typeof set2 === "string") { + return elt.namespaceURI === NAMESPACE.HTML && elt.localName === set2; + } + var tagnames = set2[elt.namespaceURI]; + return tagnames && tagnames[elt.localName]; + } + function isMathmlTextIntegrationPoint(n) { + return isA(n, mathmlTextIntegrationPointSet); + } + function isHTMLIntegrationPoint(n) { + if (isA(n, htmlIntegrationPointSet)) return true; + if (n.namespaceURI === NAMESPACE.MATHML && n.localName === "annotation-xml") { + var encoding = n.getAttribute("encoding"); + if (encoding) encoding = encoding.toLowerCase(); + if (encoding === "text/html" || encoding === "application/xhtml+xml") + return true; + } + return false; + } + function adjustSVGTagName(name) { + if (name in svgTagNameAdjustments) + return svgTagNameAdjustments[name]; + else + return name; + } + function adjustSVGAttributes(attrs) { + for (var i = 0, n = attrs.length; i < n; i++) { + if (attrs[i][0] in svgAttrAdjustments) { + attrs[i][0] = svgAttrAdjustments[attrs[i][0]]; + } + } + } + function adjustMathMLAttributes(attrs) { + for (var i = 0, n = attrs.length; i < n; i++) { + if (attrs[i][0] === "definitionurl") { + attrs[i][0] = "definitionURL"; + break; + } + } + } + function adjustForeignAttributes(attrs) { + for (var i = 0, n = attrs.length; i < n; i++) { + if (attrs[i][0] in foreignAttributes) { + attrs[i].push(foreignAttributes[attrs[i][0]]); + } + } + } + function transferAttributes(attrs, elt) { + for (var i = 0, n = attrs.length; i < n; i++) { + var name = attrs[i][0], value2 = attrs[i][1]; + if (elt.hasAttribute(name)) continue; + elt._setAttribute(name, value2); + } + } + HTMLParser.ElementStack = function ElementStack() { + this.elements = []; + this.top = null; + }; + HTMLParser.ElementStack.prototype.push = function(e) { + this.elements.push(e); + this.top = e; + }; + HTMLParser.ElementStack.prototype.pop = function(e) { + this.elements.pop(); + this.top = this.elements[this.elements.length - 1]; + }; + HTMLParser.ElementStack.prototype.popTag = function(tag) { + for (var i = this.elements.length - 1; i > 0; i--) { + var e = this.elements[i]; + if (isA(e, tag)) break; + } + this.elements.length = i; + this.top = this.elements[i - 1]; + }; + HTMLParser.ElementStack.prototype.popElementType = function(type2) { + for (var i = this.elements.length - 1; i > 0; i--) { + if (this.elements[i] instanceof type2) break; + } + this.elements.length = i; + this.top = this.elements[i - 1]; + }; + HTMLParser.ElementStack.prototype.popElement = function(e) { + for (var i = this.elements.length - 1; i > 0; i--) { + if (this.elements[i] === e) break; + } + this.elements.length = i; + this.top = this.elements[i - 1]; + }; + HTMLParser.ElementStack.prototype.removeElement = function(e) { + if (this.top === e) this.pop(); + else { + var idx = this.elements.lastIndexOf(e); + if (idx !== -1) + this.elements.splice(idx, 1); + } + }; + HTMLParser.ElementStack.prototype.clearToContext = function(set2) { + for (var i = this.elements.length - 1; i > 0; i--) { + if (isA(this.elements[i], set2)) break; + } + this.elements.length = i + 1; + this.top = this.elements[i]; + }; + HTMLParser.ElementStack.prototype.contains = function(tag) { + return this.inSpecificScope(tag, /* @__PURE__ */ Object.create(null)); + }; + HTMLParser.ElementStack.prototype.inSpecificScope = function(tag, set2) { + for (var i = this.elements.length - 1; i >= 0; i--) { + var elt = this.elements[i]; + if (isA(elt, tag)) return true; + if (isA(elt, set2)) return false; + } + return false; + }; + HTMLParser.ElementStack.prototype.elementInSpecificScope = function(target, set2) { + for (var i = this.elements.length - 1; i >= 0; i--) { + var elt = this.elements[i]; + if (elt === target) return true; + if (isA(elt, set2)) return false; + } + return false; + }; + HTMLParser.ElementStack.prototype.elementTypeInSpecificScope = function(target, set2) { + for (var i = this.elements.length - 1; i >= 0; i--) { + var elt = this.elements[i]; + if (elt instanceof target) return true; + if (isA(elt, set2)) return false; + } + return false; + }; + HTMLParser.ElementStack.prototype.inScope = function(tag) { + return this.inSpecificScope(tag, inScopeSet); + }; + HTMLParser.ElementStack.prototype.elementInScope = function(e) { + return this.elementInSpecificScope(e, inScopeSet); + }; + HTMLParser.ElementStack.prototype.elementTypeInScope = function(type2) { + return this.elementTypeInSpecificScope(type2, inScopeSet); + }; + HTMLParser.ElementStack.prototype.inButtonScope = function(tag) { + return this.inSpecificScope(tag, inButtonScopeSet); + }; + HTMLParser.ElementStack.prototype.inListItemScope = function(tag) { + return this.inSpecificScope(tag, inListItemScopeSet); + }; + HTMLParser.ElementStack.prototype.inTableScope = function(tag) { + return this.inSpecificScope(tag, inTableScopeSet); + }; + HTMLParser.ElementStack.prototype.inSelectScope = function(tag) { + for (var i = this.elements.length - 1; i >= 0; i--) { + var elt = this.elements[i]; + if (elt.namespaceURI !== NAMESPACE.HTML) return false; + var localname = elt.localName; + if (localname === tag) return true; + if (localname !== "optgroup" && localname !== "option") + return false; + } + return false; + }; + HTMLParser.ElementStack.prototype.generateImpliedEndTags = function(butnot, thorough) { + var endTagSet = thorough ? thoroughImpliedEndTagsSet : impliedEndTagsSet; + for (var i = this.elements.length - 1; i >= 0; i--) { + var e = this.elements[i]; + if (butnot && isA(e, butnot)) break; + if (!isA(this.elements[i], endTagSet)) break; + } + this.elements.length = i + 1; + this.top = this.elements[i]; + }; + HTMLParser.ActiveFormattingElements = function AFE() { + this.list = []; + this.attrs = []; + }; + HTMLParser.ActiveFormattingElements.prototype.MARKER = { localName: "|" }; + HTMLParser.ActiveFormattingElements.prototype.insertMarker = function() { + this.list.push(this.MARKER); + this.attrs.push(this.MARKER); + }; + HTMLParser.ActiveFormattingElements.prototype.push = function(elt, attrs) { + var count = 0; + for (var i = this.list.length - 1; i >= 0; i--) { + if (this.list[i] === this.MARKER) break; + if (equal(elt, this.list[i], this.attrs[i])) { + count++; + if (count === 3) { + this.list.splice(i, 1); + this.attrs.splice(i, 1); + break; + } + } + } + this.list.push(elt); + var attrcopy = []; + for (var ii = 0; ii < attrs.length; ii++) { + attrcopy[ii] = attrs[ii]; + } + this.attrs.push(attrcopy); + function equal(newelt, oldelt, oldattrs) { + if (newelt.localName !== oldelt.localName) return false; + if (newelt._numattrs !== oldattrs.length) return false; + for (var i2 = 0, n = oldattrs.length; i2 < n; i2++) { + var oldname = oldattrs[i2][0]; + var oldval = oldattrs[i2][1]; + if (!newelt.hasAttribute(oldname)) return false; + if (newelt.getAttribute(oldname) !== oldval) return false; + } + return true; + } + }; + HTMLParser.ActiveFormattingElements.prototype.clearToMarker = function() { + for (var i = this.list.length - 1; i >= 0; i--) { + if (this.list[i] === this.MARKER) break; + } + if (i < 0) i = 0; + this.list.length = i; + this.attrs.length = i; + }; + HTMLParser.ActiveFormattingElements.prototype.findElementByTag = function(tag) { + for (var i = this.list.length - 1; i >= 0; i--) { + var elt = this.list[i]; + if (elt === this.MARKER) break; + if (elt.localName === tag) return elt; + } + return null; + }; + HTMLParser.ActiveFormattingElements.prototype.indexOf = function(e) { + return this.list.lastIndexOf(e); + }; + HTMLParser.ActiveFormattingElements.prototype.remove = function(e) { + var idx = this.list.lastIndexOf(e); + if (idx !== -1) { + this.list.splice(idx, 1); + this.attrs.splice(idx, 1); + } + }; + HTMLParser.ActiveFormattingElements.prototype.replace = function(a, b, attrs) { + var idx = this.list.lastIndexOf(a); + if (idx !== -1) { + this.list[idx] = b; + this.attrs[idx] = attrs; + } + }; + HTMLParser.ActiveFormattingElements.prototype.insertAfter = function(a, b) { + var idx = this.list.lastIndexOf(a); + if (idx !== -1) { + this.list.splice(idx, 0, b); + this.attrs.splice(idx, 0, b); + } + }; + function HTMLParser(address, fragmentContext, options) { + var chars = null; + var numchars = 0; + var nextchar = 0; + var input_complete = false; + var scanner_skip_newline = false; + var reentrant_invocations = 0; + var saved_scanner_state = []; + var leftovers = ""; + var first_batch = true; + var paused = 0; + var tokenizer = data_state; + var return_state; + var character_reference_code; + var tagnamebuf = ""; + var lasttagname = ""; + var tempbuf = []; + var attrnamebuf = ""; + var attrvaluebuf = ""; + var commentbuf = []; + var doctypenamebuf = []; + var doctypepublicbuf = []; + var doctypesystembuf = []; + var attributes = []; + var is_end_tag = false; + var parser = initial_mode; + var originalInsertionMode = null; + var templateInsertionModes = []; + var stack = new HTMLParser.ElementStack(); + var afe = new HTMLParser.ActiveFormattingElements(); + var fragment = fragmentContext !== void 0; + var head_element_pointer = null; + var form_element_pointer = null; + var scripting_enabled = true; + if (fragmentContext) { + scripting_enabled = fragmentContext.ownerDocument._scripting_enabled; + } + if (options && options.scripting_enabled === false) + scripting_enabled = false; + var frameset_ok = true; + var force_quirks = false; + var pending_table_text; + var text_integration_mode; + var textrun = []; + var textIncludesNUL = false; + var ignore_linefeed = false; + var htmlparser = { + document: function() { + return doc; + }, + // Convenience function for internal use. Can only be called once, + // as it removes the nodes from `doc` to add them to fragment. + _asDocumentFragment: function() { + var frag = doc.createDocumentFragment(); + var root3 = doc.firstChild; + while (root3.hasChildNodes()) { + frag.appendChild(root3.firstChild); + } + return frag; + }, + // Internal function used from HTMLScriptElement to pause the + // parser while a script is being loaded from the network + pause: function() { + paused++; + }, + // Called when a script finishes loading + resume: function() { + paused--; + this.parse(""); + }, + // Parse the HTML text s. + // The second argument should be true if there is no more + // text to be parsed, and should be false or omitted otherwise. + // The second argument must not be set for recursive invocations + // from document.write() + parse: function(s, end, shouldPauseFunc) { + var moreToDo; + if (paused > 0) { + leftovers += s; + return true; + } + if (reentrant_invocations === 0) { + if (leftovers) { + s = leftovers + s; + leftovers = ""; + } + if (end) { + s += "\uFFFF"; + input_complete = true; + } + chars = s; + numchars = s.length; + nextchar = 0; + if (first_batch) { + first_batch = false; + if (chars.charCodeAt(0) === 65279) nextchar = 1; + } + reentrant_invocations++; + moreToDo = scanChars(shouldPauseFunc); + leftovers = chars.substring(nextchar, numchars); + reentrant_invocations--; + } else { + reentrant_invocations++; + saved_scanner_state.push(chars, numchars, nextchar); + chars = s; + numchars = s.length; + nextchar = 0; + scanChars(); + moreToDo = false; + leftovers = chars.substring(nextchar, numchars); + nextchar = saved_scanner_state.pop(); + numchars = saved_scanner_state.pop(); + chars = saved_scanner_state.pop(); + if (leftovers) { + chars = leftovers + chars.substring(nextchar); + numchars = chars.length; + nextchar = 0; + leftovers = ""; + } + reentrant_invocations--; + } + return moreToDo; + } + }; + var doc = new Document(true, address); + doc._parser = htmlparser; + doc._scripting_enabled = scripting_enabled; + if (fragmentContext) { + if (fragmentContext.ownerDocument._quirks) + doc._quirks = true; + if (fragmentContext.ownerDocument._limitedQuirks) + doc._limitedQuirks = true; + if (fragmentContext.namespaceURI === NAMESPACE.HTML) { + switch (fragmentContext.localName) { + case "title": + case "textarea": + tokenizer = rcdata_state; + break; + case "style": + case "xmp": + case "iframe": + case "noembed": + case "noframes": + case "script": + case "plaintext": + tokenizer = plaintext_state; + break; + } + } + var root2 = doc.createElement("html"); + doc._appendChild(root2); + stack.push(root2); + if (fragmentContext instanceof impl.HTMLTemplateElement) { + templateInsertionModes.push(in_template_mode); + } + resetInsertionMode(); + for (var e = fragmentContext; e !== null; e = e.parentElement) { + if (e instanceof impl.HTMLFormElement) { + form_element_pointer = e; + break; + } + } + } + function scanChars(shouldPauseFunc) { + var codepoint, s, pattern, eof; + while (nextchar < numchars) { + if (paused > 0 || shouldPauseFunc && shouldPauseFunc()) { + return true; + } + switch (typeof tokenizer.lookahead) { + case "undefined": + codepoint = chars.charCodeAt(nextchar++); + if (scanner_skip_newline) { + scanner_skip_newline = false; + if (codepoint === 10) { + nextchar++; + continue; + } + } + switch (codepoint) { + case 13: + if (nextchar < numchars) { + if (chars.charCodeAt(nextchar) === 10) + nextchar++; + } else { + scanner_skip_newline = true; + } + tokenizer(10); + break; + case 65535: + if (input_complete && nextchar === numchars) { + tokenizer(EOF); + break; + } + /* falls through */ + default: + tokenizer(codepoint); + break; + } + break; + case "number": + codepoint = chars.charCodeAt(nextchar); + var n = tokenizer.lookahead; + var needsString = true; + if (n < 0) { + needsString = false; + n = -n; + } + if (n < numchars - nextchar) { + s = needsString ? chars.substring(nextchar, nextchar + n) : null; + eof = false; + } else { + if (input_complete) { + s = needsString ? chars.substring(nextchar, numchars) : null; + eof = true; + if (codepoint === 65535 && nextchar === numchars - 1) + codepoint = EOF; + } else { + return true; + } + } + tokenizer(codepoint, s, eof); + break; + case "string": + codepoint = chars.charCodeAt(nextchar); + pattern = tokenizer.lookahead; + var pos = chars.indexOf(pattern, nextchar); + if (pos !== -1) { + s = chars.substring(nextchar, pos + pattern.length); + eof = false; + } else { + if (!input_complete) return true; + s = chars.substring(nextchar, numchars); + if (codepoint === 65535 && nextchar === numchars - 1) + codepoint = EOF; + eof = true; + } + tokenizer(codepoint, s, eof); + break; + } + } + return false; + } + function addAttribute(name, value2) { + for (var i = 0; i < attributes.length; i++) { + if (attributes[i][0] === name) return; + } + if (value2 !== void 0) { + attributes.push([name, value2]); + } else { + attributes.push([name]); + } + } + function handleSimpleAttribute() { + SIMPLEATTR.lastIndex = nextchar - 1; + var matched = SIMPLEATTR.exec(chars); + if (!matched) throw new Error("should never happen"); + var name = matched[1]; + if (!name) return false; + var value2 = matched[2]; + var len = value2.length; + switch (value2[0]) { + case '"': + case "'": + value2 = value2.substring(1, len - 1); + nextchar += matched[0].length - 1; + tokenizer = after_attribute_value_quoted_state; + break; + default: + tokenizer = before_attribute_name_state; + nextchar += matched[0].length - 1; + value2 = value2.substring(0, len - 1); + break; + } + for (var i = 0; i < attributes.length; i++) { + if (attributes[i][0] === name) return true; + } + attributes.push([name, value2]); + return true; + } + function beginTagName() { + is_end_tag = false; + tagnamebuf = ""; + attributes.length = 0; + } + function beginEndTagName() { + is_end_tag = true; + tagnamebuf = ""; + attributes.length = 0; + } + function beginTempBuf() { + tempbuf.length = 0; + } + function beginAttrName() { + attrnamebuf = ""; + } + function beginAttrValue() { + attrvaluebuf = ""; + } + function beginComment() { + commentbuf.length = 0; + } + function beginDoctype() { + doctypenamebuf.length = 0; + doctypepublicbuf = null; + doctypesystembuf = null; + } + function beginDoctypePublicId() { + doctypepublicbuf = []; + } + function beginDoctypeSystemId() { + doctypesystembuf = []; + } + function forcequirks() { + force_quirks = true; + } + function cdataAllowed() { + return stack.top && stack.top.namespaceURI !== "http://www.w3.org/1999/xhtml"; + } + function appropriateEndTag(buf) { + return lasttagname === buf; + } + function flushText() { + if (textrun.length > 0) { + var s = buf2str(textrun); + textrun.length = 0; + if (ignore_linefeed) { + ignore_linefeed = false; + if (s[0] === "\n") s = s.substring(1); + if (s.length === 0) return; + } + insertToken(TEXT, s); + textIncludesNUL = false; + } + ignore_linefeed = false; + } + function getMatchingChars(pattern) { + pattern.lastIndex = nextchar - 1; + var match2 = pattern.exec(chars); + if (match2 && match2.index === nextchar - 1) { + match2 = match2[0]; + nextchar += match2.length - 1; + if (input_complete && nextchar === numchars) { + match2 = match2.slice(0, -1); + nextchar--; + } + return match2; + } else { + throw new Error("should never happen"); + } + } + function emitCharsWhile(pattern) { + pattern.lastIndex = nextchar - 1; + var match2 = pattern.exec(chars)[0]; + if (!match2) return false; + emitCharString(match2); + nextchar += match2.length - 1; + return true; + } + function emitCharString(s) { + if (textrun.length > 0) flushText(); + if (ignore_linefeed) { + ignore_linefeed = false; + if (s[0] === "\n") s = s.substring(1); + if (s.length === 0) return; + } + insertToken(TEXT, s); + } + function emitTag() { + if (is_end_tag) insertToken(ENDTAG, tagnamebuf); + else { + var tagname = tagnamebuf; + tagnamebuf = ""; + lasttagname = tagname; + insertToken(TAG, tagname, attributes); + } + } + function emitSimpleTag() { + if (nextchar === numchars) { + return false; + } + SIMPLETAG.lastIndex = nextchar; + var matched = SIMPLETAG.exec(chars); + if (!matched) throw new Error("should never happen"); + var tagname = matched[2]; + if (!tagname) return false; + var endtag = matched[1]; + if (endtag) { + nextchar += tagname.length + 2; + insertToken(ENDTAG, tagname); + } else { + nextchar += tagname.length + 1; + lasttagname = tagname; + insertToken(TAG, tagname, NOATTRS); + } + return true; + } + function emitSelfClosingTag() { + if (is_end_tag) insertToken(ENDTAG, tagnamebuf, null, true); + else { + insertToken(TAG, tagnamebuf, attributes, true); + } + } + function emitDoctype() { + insertToken( + DOCTYPE, + buf2str(doctypenamebuf), + doctypepublicbuf ? buf2str(doctypepublicbuf) : void 0, + doctypesystembuf ? buf2str(doctypesystembuf) : void 0 + ); + } + function emitEOF() { + flushText(); + parser(EOF); + doc.modclock = 1; + } + var insertToken = htmlparser.insertToken = function insertToken2(t, value2, arg3, arg4) { + flushText(); + var current = stack.top; + if (!current || current.namespaceURI === NAMESPACE.HTML) { + parser(t, value2, arg3, arg4); + } else { + if (t !== TAG && t !== TEXT) { + insertForeignToken(t, value2, arg3, arg4); + } else { + if (isMathmlTextIntegrationPoint(current) && (t === TEXT || t === TAG && value2 !== "mglyph" && value2 !== "malignmark") || t === TAG && value2 === "svg" && current.namespaceURI === NAMESPACE.MATHML && current.localName === "annotation-xml" || isHTMLIntegrationPoint(current)) { + text_integration_mode = true; + parser(t, value2, arg3, arg4); + text_integration_mode = false; + } else { + insertForeignToken(t, value2, arg3, arg4); + } + } + } + }; + function insertComment(data) { + var parent = stack.top; + if (foster_parent_mode && isA(parent, tablesectionrowSet)) { + fosterParent(function(doc2) { + return doc2.createComment(data); + }); + } else { + if (parent instanceof impl.HTMLTemplateElement) { + parent = parent.content; + } + parent._appendChild(parent.ownerDocument.createComment(data)); + } + } + function insertText(s) { + var parent = stack.top; + if (foster_parent_mode && isA(parent, tablesectionrowSet)) { + fosterParent(function(doc2) { + return doc2.createTextNode(s); + }); + } else { + if (parent instanceof impl.HTMLTemplateElement) { + parent = parent.content; + } + var lastChild = parent.lastChild; + if (lastChild && lastChild.nodeType === Node.TEXT_NODE) { + lastChild.appendData(s); + } else { + parent._appendChild(parent.ownerDocument.createTextNode(s)); + } + } + } + function createHTMLElt(doc2, name, attrs) { + var elt = html.createElement(doc2, name, null); + if (attrs) { + for (var i = 0, n = attrs.length; i < n; i++) { + elt._setAttribute(attrs[i][0], attrs[i][1]); + } + } + return elt; + } + var foster_parent_mode = false; + function insertHTMLElement(name, attrs) { + var elt = insertElement(function(doc2) { + return createHTMLElt(doc2, name, attrs); + }); + if (isA(elt, formassociatedSet)) { + elt._form = form_element_pointer; + } + return elt; + } + function insertElement(eltFunc) { + var elt; + if (foster_parent_mode && isA(stack.top, tablesectionrowSet)) { + elt = fosterParent(eltFunc); + } else if (stack.top instanceof impl.HTMLTemplateElement) { + elt = eltFunc(stack.top.content.ownerDocument); + stack.top.content._appendChild(elt); + } else { + elt = eltFunc(stack.top.ownerDocument); + stack.top._appendChild(elt); + } + stack.push(elt); + return elt; + } + function insertForeignElement(name, attrs, ns) { + return insertElement(function(doc2) { + var elt = doc2._createElementNS(name, ns, null); + if (attrs) { + for (var i = 0, n = attrs.length; i < n; i++) { + var attr = attrs[i]; + if (attr.length === 2) + elt._setAttribute(attr[0], attr[1]); + else { + elt._setAttributeNS(attr[2], attr[0], attr[1]); + } + } + } + return elt; + }); + } + function lastElementOfType(type2) { + for (var i = stack.elements.length - 1; i >= 0; i--) { + if (stack.elements[i] instanceof type2) { + return i; + } + } + return -1; + } + function fosterParent(eltFunc) { + var parent, before, lastTable = -1, lastTemplate = -1, elt; + lastTable = lastElementOfType(impl.HTMLTableElement); + lastTemplate = lastElementOfType(impl.HTMLTemplateElement); + if (lastTemplate >= 0 && (lastTable < 0 || lastTemplate > lastTable)) { + parent = stack.elements[lastTemplate]; + } else if (lastTable >= 0) { + parent = stack.elements[lastTable].parentNode; + if (parent) { + before = stack.elements[lastTable]; + } else { + parent = stack.elements[lastTable - 1]; + } + } + if (!parent) parent = stack.elements[0]; + if (parent instanceof impl.HTMLTemplateElement) { + parent = parent.content; + } + elt = eltFunc(parent.ownerDocument); + if (elt.nodeType === Node.TEXT_NODE) { + var prev; + if (before) prev = before.previousSibling; + else prev = parent.lastChild; + if (prev && prev.nodeType === Node.TEXT_NODE) { + prev.appendData(elt.data); + return elt; + } + } + if (before) + parent.insertBefore(elt, before); + else + parent._appendChild(elt); + return elt; + } + function resetInsertionMode() { + var last = false; + for (var i = stack.elements.length - 1; i >= 0; i--) { + var node2 = stack.elements[i]; + if (i === 0) { + last = true; + if (fragment) { + node2 = fragmentContext; + } + } + if (node2.namespaceURI === NAMESPACE.HTML) { + var tag = node2.localName; + switch (tag) { + case "select": + for (var j = i; j > 0; ) { + var ancestor = stack.elements[--j]; + if (ancestor instanceof impl.HTMLTemplateElement) { + break; + } else if (ancestor instanceof impl.HTMLTableElement) { + parser = in_select_in_table_mode; + return; + } + } + parser = in_select_mode; + return; + case "tr": + parser = in_row_mode; + return; + case "tbody": + case "tfoot": + case "thead": + parser = in_table_body_mode; + return; + case "caption": + parser = in_caption_mode; + return; + case "colgroup": + parser = in_column_group_mode; + return; + case "table": + parser = in_table_mode; + return; + case "template": + parser = templateInsertionModes[templateInsertionModes.length - 1]; + return; + case "body": + parser = in_body_mode; + return; + case "frameset": + parser = in_frameset_mode; + return; + case "html": + if (head_element_pointer === null) { + parser = before_head_mode; + } else { + parser = after_head_mode; + } + return; + default: + if (!last) { + if (tag === "head") { + parser = in_head_mode; + return; + } + if (tag === "td" || tag === "th") { + parser = in_cell_mode; + return; + } + } + } + } + if (last) { + parser = in_body_mode; + return; + } + } + } + function parseRawText(name, attrs) { + insertHTMLElement(name, attrs); + tokenizer = rawtext_state; + originalInsertionMode = parser; + parser = text_mode; + } + function parseRCDATA(name, attrs) { + insertHTMLElement(name, attrs); + tokenizer = rcdata_state; + originalInsertionMode = parser; + parser = text_mode; + } + function afeclone(doc2, i) { + return { + elt: createHTMLElt(doc2, afe.list[i].localName, afe.attrs[i]), + attrs: afe.attrs[i] + }; + } + function afereconstruct() { + if (afe.list.length === 0) return; + var entry = afe.list[afe.list.length - 1]; + if (entry === afe.MARKER) return; + if (stack.elements.lastIndexOf(entry) !== -1) return; + for (var i = afe.list.length - 2; i >= 0; i--) { + entry = afe.list[i]; + if (entry === afe.MARKER) break; + if (stack.elements.lastIndexOf(entry) !== -1) break; + } + for (i = i + 1; i < afe.list.length; i++) { + var newelt = insertElement(function(doc2) { + return afeclone(doc2, i).elt; + }); + afe.list[i] = newelt; + } + } + var BOOKMARK = { localName: "BM" }; + function adoptionAgency(tag) { + if (isA(stack.top, tag) && afe.indexOf(stack.top) === -1) { + stack.pop(); + return true; + } + var outer = 0; + while (outer < 8) { + outer++; + var fmtelt = afe.findElementByTag(tag); + if (!fmtelt) { + return false; + } + var index = stack.elements.lastIndexOf(fmtelt); + if (index === -1) { + afe.remove(fmtelt); + return true; + } + if (!stack.elementInScope(fmtelt)) { + return true; + } + var furthestblock = null, furthestblockindex; + for (var i = index + 1; i < stack.elements.length; i++) { + if (isA(stack.elements[i], specialSet)) { + furthestblock = stack.elements[i]; + furthestblockindex = i; + break; + } + } + if (!furthestblock) { + stack.popElement(fmtelt); + afe.remove(fmtelt); + return true; + } else { + var ancestor = stack.elements[index - 1]; + afe.insertAfter(fmtelt, BOOKMARK); + var node2 = furthestblock; + var lastnode = furthestblock; + var nodeindex = furthestblockindex; + var nodeafeindex; + var inner = 0; + while (true) { + inner++; + node2 = stack.elements[--nodeindex]; + if (node2 === fmtelt) break; + nodeafeindex = afe.indexOf(node2); + if (inner > 3 && nodeafeindex !== -1) { + afe.remove(node2); + nodeafeindex = -1; + } + if (nodeafeindex === -1) { + stack.removeElement(node2); + continue; + } + var newelt = afeclone(ancestor.ownerDocument, nodeafeindex); + afe.replace(node2, newelt.elt, newelt.attrs); + stack.elements[nodeindex] = newelt.elt; + node2 = newelt.elt; + if (lastnode === furthestblock) { + afe.remove(BOOKMARK); + afe.insertAfter(newelt.elt, BOOKMARK); + } + node2._appendChild(lastnode); + lastnode = node2; + } + if (foster_parent_mode && isA(ancestor, tablesectionrowSet)) { + fosterParent(function() { + return lastnode; + }); + } else if (ancestor instanceof impl.HTMLTemplateElement) { + ancestor.content._appendChild(lastnode); + } else { + ancestor._appendChild(lastnode); + } + var newelt2 = afeclone(furthestblock.ownerDocument, afe.indexOf(fmtelt)); + while (furthestblock.hasChildNodes()) { + newelt2.elt._appendChild(furthestblock.firstChild); + } + furthestblock._appendChild(newelt2.elt); + afe.remove(fmtelt); + afe.replace(BOOKMARK, newelt2.elt, newelt2.attrs); + stack.removeElement(fmtelt); + var pos = stack.elements.lastIndexOf(furthestblock); + stack.elements.splice(pos + 1, 0, newelt2.elt); + } + } + return true; + } + function handleScriptEnd() { + stack.pop(); + parser = originalInsertionMode; + return; + } + function stopParsing() { + delete doc._parser; + stack.elements.length = 0; + if (doc.defaultView) { + doc.defaultView.dispatchEvent(new impl.Event("load", {})); + } + } + function reconsume(c, new_state) { + tokenizer = new_state; + nextchar--; + } + function data_state(c) { + switch (c) { + case 38: + return_state = data_state; + tokenizer = character_reference_state; + break; + case 60: + if (emitSimpleTag()) + break; + tokenizer = tag_open_state; + break; + case 0: + textrun.push(c); + textIncludesNUL = true; + break; + case -1: + emitEOF(); + break; + default: + emitCharsWhile(DATATEXT) || textrun.push(c); + break; + } + } + function rcdata_state(c) { + switch (c) { + case 38: + return_state = rcdata_state; + tokenizer = character_reference_state; + break; + case 60: + tokenizer = rcdata_less_than_sign_state; + break; + case 0: + textrun.push(65533); + textIncludesNUL = true; + break; + case -1: + emitEOF(); + break; + default: + textrun.push(c); + break; + } + } + function rawtext_state(c) { + switch (c) { + case 60: + tokenizer = rawtext_less_than_sign_state; + break; + case 0: + textrun.push(65533); + break; + case -1: + emitEOF(); + break; + default: + emitCharsWhile(RAWTEXT) || textrun.push(c); + break; + } + } + function script_data_state(c) { + switch (c) { + case 60: + tokenizer = script_data_less_than_sign_state; + break; + case 0: + textrun.push(65533); + break; + case -1: + emitEOF(); + break; + default: + emitCharsWhile(RAWTEXT) || textrun.push(c); + break; + } + } + function plaintext_state(c) { + switch (c) { + case 0: + textrun.push(65533); + break; + case -1: + emitEOF(); + break; + default: + emitCharsWhile(PLAINTEXT) || textrun.push(c); + break; + } + } + function tag_open_state(c) { + switch (c) { + case 33: + tokenizer = markup_declaration_open_state; + break; + case 47: + tokenizer = end_tag_open_state; + break; + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + case 97: + // [a-z] + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + beginTagName(); + reconsume(c, tag_name_state); + break; + case 63: + reconsume(c, bogus_comment_state); + break; + default: + textrun.push(60); + reconsume(c, data_state); + break; + } + } + function end_tag_open_state(c) { + switch (c) { + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + case 97: + // [a-z] + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + beginEndTagName(); + reconsume(c, tag_name_state); + break; + case 62: + tokenizer = data_state; + break; + case -1: + textrun.push(60); + textrun.push(47); + emitEOF(); + break; + default: + reconsume(c, bogus_comment_state); + break; + } + } + function tag_name_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + tokenizer = before_attribute_name_state; + break; + case 47: + tokenizer = self_closing_start_tag_state; + break; + case 62: + tokenizer = data_state; + emitTag(); + break; + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + tagnamebuf += String.fromCharCode(c + 32); + break; + case 0: + tagnamebuf += String.fromCharCode( + 65533 + /* REPLACEMENT CHARACTER */ + ); + break; + case -1: + emitEOF(); + break; + default: + tagnamebuf += getMatchingChars(TAGNAME); + break; + } + } + function rcdata_less_than_sign_state(c) { + if (c === 47) { + beginTempBuf(); + tokenizer = rcdata_end_tag_open_state; + } else { + textrun.push(60); + reconsume(c, rcdata_state); + } + } + function rcdata_end_tag_open_state(c) { + switch (c) { + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + case 97: + // [a-z] + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + beginEndTagName(); + reconsume(c, rcdata_end_tag_name_state); + break; + default: + textrun.push(60); + textrun.push(47); + reconsume(c, rcdata_state); + break; + } + } + function rcdata_end_tag_name_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + if (appropriateEndTag(tagnamebuf)) { + tokenizer = before_attribute_name_state; + return; + } + break; + case 47: + if (appropriateEndTag(tagnamebuf)) { + tokenizer = self_closing_start_tag_state; + return; + } + break; + case 62: + if (appropriateEndTag(tagnamebuf)) { + tokenizer = data_state; + emitTag(); + return; + } + break; + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + tagnamebuf += String.fromCharCode(c + 32); + tempbuf.push(c); + return; + case 97: + // [a-z] + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + tagnamebuf += String.fromCharCode(c); + tempbuf.push(c); + return; + default: + break; + } + textrun.push(60); + textrun.push(47); + pushAll(textrun, tempbuf); + reconsume(c, rcdata_state); + } + function rawtext_less_than_sign_state(c) { + if (c === 47) { + beginTempBuf(); + tokenizer = rawtext_end_tag_open_state; + } else { + textrun.push(60); + reconsume(c, rawtext_state); + } + } + function rawtext_end_tag_open_state(c) { + switch (c) { + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + case 97: + // [a-z] + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + beginEndTagName(); + reconsume(c, rawtext_end_tag_name_state); + break; + default: + textrun.push(60); + textrun.push(47); + reconsume(c, rawtext_state); + break; + } + } + function rawtext_end_tag_name_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + if (appropriateEndTag(tagnamebuf)) { + tokenizer = before_attribute_name_state; + return; + } + break; + case 47: + if (appropriateEndTag(tagnamebuf)) { + tokenizer = self_closing_start_tag_state; + return; + } + break; + case 62: + if (appropriateEndTag(tagnamebuf)) { + tokenizer = data_state; + emitTag(); + return; + } + break; + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + tagnamebuf += String.fromCharCode(c + 32); + tempbuf.push(c); + return; + case 97: + // [a-z] + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + tagnamebuf += String.fromCharCode(c); + tempbuf.push(c); + return; + default: + break; + } + textrun.push(60); + textrun.push(47); + pushAll(textrun, tempbuf); + reconsume(c, rawtext_state); + } + function script_data_less_than_sign_state(c) { + switch (c) { + case 47: + beginTempBuf(); + tokenizer = script_data_end_tag_open_state; + break; + case 33: + tokenizer = script_data_escape_start_state; + textrun.push(60); + textrun.push(33); + break; + default: + textrun.push(60); + reconsume(c, script_data_state); + break; + } + } + function script_data_end_tag_open_state(c) { + switch (c) { + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + case 97: + // [a-z] + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + beginEndTagName(); + reconsume(c, script_data_end_tag_name_state); + break; + default: + textrun.push(60); + textrun.push(47); + reconsume(c, script_data_state); + break; + } + } + function script_data_end_tag_name_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + if (appropriateEndTag(tagnamebuf)) { + tokenizer = before_attribute_name_state; + return; + } + break; + case 47: + if (appropriateEndTag(tagnamebuf)) { + tokenizer = self_closing_start_tag_state; + return; + } + break; + case 62: + if (appropriateEndTag(tagnamebuf)) { + tokenizer = data_state; + emitTag(); + return; + } + break; + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + tagnamebuf += String.fromCharCode(c + 32); + tempbuf.push(c); + return; + case 97: + // [a-z] + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + tagnamebuf += String.fromCharCode(c); + tempbuf.push(c); + return; + default: + break; + } + textrun.push(60); + textrun.push(47); + pushAll(textrun, tempbuf); + reconsume(c, script_data_state); + } + function script_data_escape_start_state(c) { + if (c === 45) { + tokenizer = script_data_escape_start_dash_state; + textrun.push(45); + } else { + reconsume(c, script_data_state); + } + } + function script_data_escape_start_dash_state(c) { + if (c === 45) { + tokenizer = script_data_escaped_dash_dash_state; + textrun.push(45); + } else { + reconsume(c, script_data_state); + } + } + function script_data_escaped_state(c) { + switch (c) { + case 45: + tokenizer = script_data_escaped_dash_state; + textrun.push(45); + break; + case 60: + tokenizer = script_data_escaped_less_than_sign_state; + break; + case 0: + textrun.push(65533); + break; + case -1: + emitEOF(); + break; + default: + textrun.push(c); + break; + } + } + function script_data_escaped_dash_state(c) { + switch (c) { + case 45: + tokenizer = script_data_escaped_dash_dash_state; + textrun.push(45); + break; + case 60: + tokenizer = script_data_escaped_less_than_sign_state; + break; + case 0: + tokenizer = script_data_escaped_state; + textrun.push(65533); + break; + case -1: + emitEOF(); + break; + default: + tokenizer = script_data_escaped_state; + textrun.push(c); + break; + } + } + function script_data_escaped_dash_dash_state(c) { + switch (c) { + case 45: + textrun.push(45); + break; + case 60: + tokenizer = script_data_escaped_less_than_sign_state; + break; + case 62: + tokenizer = script_data_state; + textrun.push(62); + break; + case 0: + tokenizer = script_data_escaped_state; + textrun.push(65533); + break; + case -1: + emitEOF(); + break; + default: + tokenizer = script_data_escaped_state; + textrun.push(c); + break; + } + } + function script_data_escaped_less_than_sign_state(c) { + switch (c) { + case 47: + beginTempBuf(); + tokenizer = script_data_escaped_end_tag_open_state; + break; + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + case 97: + // [a-z] + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + beginTempBuf(); + textrun.push(60); + reconsume(c, script_data_double_escape_start_state); + break; + default: + textrun.push(60); + reconsume(c, script_data_escaped_state); + break; + } + } + function script_data_escaped_end_tag_open_state(c) { + switch (c) { + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + case 97: + // [a-z] + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + beginEndTagName(); + reconsume(c, script_data_escaped_end_tag_name_state); + break; + default: + textrun.push(60); + textrun.push(47); + reconsume(c, script_data_escaped_state); + break; + } + } + function script_data_escaped_end_tag_name_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + if (appropriateEndTag(tagnamebuf)) { + tokenizer = before_attribute_name_state; + return; + } + break; + case 47: + if (appropriateEndTag(tagnamebuf)) { + tokenizer = self_closing_start_tag_state; + return; + } + break; + case 62: + if (appropriateEndTag(tagnamebuf)) { + tokenizer = data_state; + emitTag(); + return; + } + break; + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + tagnamebuf += String.fromCharCode(c + 32); + tempbuf.push(c); + return; + case 97: + // [a-z] + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + tagnamebuf += String.fromCharCode(c); + tempbuf.push(c); + return; + default: + break; + } + textrun.push(60); + textrun.push(47); + pushAll(textrun, tempbuf); + reconsume(c, script_data_escaped_state); + } + function script_data_double_escape_start_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + // SPACE + case 47: + // SOLIDUS + case 62: + if (buf2str(tempbuf) === "script") { + tokenizer = script_data_double_escaped_state; + } else { + tokenizer = script_data_escaped_state; + } + textrun.push(c); + break; + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + tempbuf.push(c + 32); + textrun.push(c); + break; + case 97: + // [a-z] + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + tempbuf.push(c); + textrun.push(c); + break; + default: + reconsume(c, script_data_escaped_state); + break; + } + } + function script_data_double_escaped_state(c) { + switch (c) { + case 45: + tokenizer = script_data_double_escaped_dash_state; + textrun.push(45); + break; + case 60: + tokenizer = script_data_double_escaped_less_than_sign_state; + textrun.push(60); + break; + case 0: + textrun.push(65533); + break; + case -1: + emitEOF(); + break; + default: + textrun.push(c); + break; + } + } + function script_data_double_escaped_dash_state(c) { + switch (c) { + case 45: + tokenizer = script_data_double_escaped_dash_dash_state; + textrun.push(45); + break; + case 60: + tokenizer = script_data_double_escaped_less_than_sign_state; + textrun.push(60); + break; + case 0: + tokenizer = script_data_double_escaped_state; + textrun.push(65533); + break; + case -1: + emitEOF(); + break; + default: + tokenizer = script_data_double_escaped_state; + textrun.push(c); + break; + } + } + function script_data_double_escaped_dash_dash_state(c) { + switch (c) { + case 45: + textrun.push(45); + break; + case 60: + tokenizer = script_data_double_escaped_less_than_sign_state; + textrun.push(60); + break; + case 62: + tokenizer = script_data_state; + textrun.push(62); + break; + case 0: + tokenizer = script_data_double_escaped_state; + textrun.push(65533); + break; + case -1: + emitEOF(); + break; + default: + tokenizer = script_data_double_escaped_state; + textrun.push(c); + break; + } + } + function script_data_double_escaped_less_than_sign_state(c) { + if (c === 47) { + beginTempBuf(); + tokenizer = script_data_double_escape_end_state; + textrun.push(47); + } else { + reconsume(c, script_data_double_escaped_state); + } + } + function script_data_double_escape_end_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + // SPACE + case 47: + // SOLIDUS + case 62: + if (buf2str(tempbuf) === "script") { + tokenizer = script_data_escaped_state; + } else { + tokenizer = script_data_double_escaped_state; + } + textrun.push(c); + break; + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + tempbuf.push(c + 32); + textrun.push(c); + break; + case 97: + // [a-z] + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 113: + case 114: + case 115: + case 116: + case 117: + case 118: + case 119: + case 120: + case 121: + case 122: + tempbuf.push(c); + textrun.push(c); + break; + default: + reconsume(c, script_data_double_escaped_state); + break; + } + } + function before_attribute_name_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + break; + // For SOLIDUS, GREATER-THAN SIGN, and EOF, spec says "reconsume in + // the after attribute name state", but in our implementation that + // state always has an active attribute in attrnamebuf. Just clone + // the rules here, without the addAttribute business. + case 47: + tokenizer = self_closing_start_tag_state; + break; + case 62: + tokenizer = data_state; + emitTag(); + break; + case -1: + emitEOF(); + break; + case 61: + beginAttrName(); + attrnamebuf += String.fromCharCode(c); + tokenizer = attribute_name_state; + break; + default: + if (handleSimpleAttribute()) break; + beginAttrName(); + reconsume(c, attribute_name_state); + break; + } + } + function attribute_name_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + // SPACE + case 47: + // SOLIDUS + case 62: + // GREATER-THAN SIGN + case -1: + reconsume(c, after_attribute_name_state); + break; + case 61: + tokenizer = before_attribute_value_state; + break; + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + attrnamebuf += String.fromCharCode(c + 32); + break; + case 0: + attrnamebuf += String.fromCharCode( + 65533 + /* REPLACEMENT CHARACTER */ + ); + break; + case 34: + // QUOTATION MARK + case 39: + // APOSTROPHE + case 60: + // LESS-THAN SIGN + /* falls through */ + default: + attrnamebuf += getMatchingChars(ATTRNAME); + break; + } + } + function after_attribute_name_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + break; + case 47: + addAttribute(attrnamebuf); + tokenizer = self_closing_start_tag_state; + break; + case 61: + tokenizer = before_attribute_value_state; + break; + case 62: + tokenizer = data_state; + addAttribute(attrnamebuf); + emitTag(); + break; + case -1: + addAttribute(attrnamebuf); + emitEOF(); + break; + default: + addAttribute(attrnamebuf); + beginAttrName(); + reconsume(c, attribute_name_state); + break; + } + } + function before_attribute_value_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + break; + case 34: + beginAttrValue(); + tokenizer = attribute_value_double_quoted_state; + break; + case 39: + beginAttrValue(); + tokenizer = attribute_value_single_quoted_state; + break; + case 62: + // GREATER-THAN SIGN + /* falls through */ + default: + beginAttrValue(); + reconsume(c, attribute_value_unquoted_state); + break; + } + } + function attribute_value_double_quoted_state(c) { + switch (c) { + case 34: + addAttribute(attrnamebuf, attrvaluebuf); + tokenizer = after_attribute_value_quoted_state; + break; + case 38: + return_state = attribute_value_double_quoted_state; + tokenizer = character_reference_state; + break; + case 0: + attrvaluebuf += String.fromCharCode( + 65533 + /* REPLACEMENT CHARACTER */ + ); + break; + case -1: + emitEOF(); + break; + case 10: + attrvaluebuf += String.fromCharCode(c); + break; + default: + attrvaluebuf += getMatchingChars(DBLQUOTEATTRVAL); + break; + } + } + function attribute_value_single_quoted_state(c) { + switch (c) { + case 39: + addAttribute(attrnamebuf, attrvaluebuf); + tokenizer = after_attribute_value_quoted_state; + break; + case 38: + return_state = attribute_value_single_quoted_state; + tokenizer = character_reference_state; + break; + case 0: + attrvaluebuf += String.fromCharCode( + 65533 + /* REPLACEMENT CHARACTER */ + ); + break; + case -1: + emitEOF(); + break; + case 10: + attrvaluebuf += String.fromCharCode(c); + break; + default: + attrvaluebuf += getMatchingChars(SINGLEQUOTEATTRVAL); + break; + } + } + function attribute_value_unquoted_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + addAttribute(attrnamebuf, attrvaluebuf); + tokenizer = before_attribute_name_state; + break; + case 38: + return_state = attribute_value_unquoted_state; + tokenizer = character_reference_state; + break; + case 62: + addAttribute(attrnamebuf, attrvaluebuf); + tokenizer = data_state; + emitTag(); + break; + case 0: + attrvaluebuf += String.fromCharCode( + 65533 + /* REPLACEMENT CHARACTER */ + ); + break; + case -1: + nextchar--; + tokenizer = data_state; + break; + case 34: + // QUOTATION MARK + case 39: + // APOSTROPHE + case 60: + // LESS-THAN SIGN + case 61: + // EQUALS SIGN + case 96: + // GRAVE ACCENT + /* falls through */ + default: + attrvaluebuf += getMatchingChars(UNQUOTEDATTRVAL); + break; + } + } + function after_attribute_value_quoted_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + tokenizer = before_attribute_name_state; + break; + case 47: + tokenizer = self_closing_start_tag_state; + break; + case 62: + tokenizer = data_state; + emitTag(); + break; + case -1: + emitEOF(); + break; + default: + reconsume(c, before_attribute_name_state); + break; + } + } + function self_closing_start_tag_state(c) { + switch (c) { + case 62: + tokenizer = data_state; + emitSelfClosingTag(true); + break; + case -1: + emitEOF(); + break; + default: + reconsume(c, before_attribute_name_state); + break; + } + } + function bogus_comment_state(c, lookahead, eof) { + var len = lookahead.length; + if (eof) { + nextchar += len - 1; + } else { + nextchar += len; + } + var comment = lookahead.substring(0, len - 1); + comment = comment.replace(/\u0000/g, "\uFFFD"); + comment = comment.replace(/\u000D\u000A/g, "\n"); + comment = comment.replace(/\u000D/g, "\n"); + insertToken(COMMENT, comment); + tokenizer = data_state; + } + bogus_comment_state.lookahead = ">"; + function markup_declaration_open_state(c, lookahead, eof) { + if (lookahead[0] === "-" && lookahead[1] === "-") { + nextchar += 2; + beginComment(); + tokenizer = comment_start_state; + return; + } + if (lookahead.toUpperCase() === "DOCTYPE") { + nextchar += 7; + tokenizer = doctype_state; + } else if (lookahead === "[CDATA[" && cdataAllowed()) { + nextchar += 7; + tokenizer = cdata_section_state; + } else { + tokenizer = bogus_comment_state; + } + } + markup_declaration_open_state.lookahead = 7; + function comment_start_state(c) { + beginComment(); + switch (c) { + case 45: + tokenizer = comment_start_dash_state; + break; + case 62: + tokenizer = data_state; + insertToken(COMMENT, buf2str(commentbuf)); + break; + /* see comment in comment end state */ + default: + reconsume(c, comment_state); + break; + } + } + function comment_start_dash_state(c) { + switch (c) { + case 45: + tokenizer = comment_end_state; + break; + case 62: + tokenizer = data_state; + insertToken(COMMENT, buf2str(commentbuf)); + break; + case -1: + insertToken(COMMENT, buf2str(commentbuf)); + emitEOF(); + break; + /* see comment in comment end state */ + default: + commentbuf.push( + 45 + /* HYPHEN-MINUS */ + ); + reconsume(c, comment_state); + break; + } + } + function comment_state(c) { + switch (c) { + case 60: + commentbuf.push(c); + tokenizer = comment_less_than_sign_state; + break; + case 45: + tokenizer = comment_end_dash_state; + break; + case 0: + commentbuf.push( + 65533 + /* REPLACEMENT CHARACTER */ + ); + break; + case -1: + insertToken(COMMENT, buf2str(commentbuf)); + emitEOF(); + break; + /* see comment in comment end state */ + default: + commentbuf.push(c); + break; + } + } + function comment_less_than_sign_state(c) { + switch (c) { + case 33: + commentbuf.push(c); + tokenizer = comment_less_than_sign_bang_state; + break; + case 60: + commentbuf.push(c); + break; + default: + reconsume(c, comment_state); + break; + } + } + function comment_less_than_sign_bang_state(c) { + switch (c) { + case 45: + tokenizer = comment_less_than_sign_bang_dash_state; + break; + default: + reconsume(c, comment_state); + break; + } + } + function comment_less_than_sign_bang_dash_state(c) { + switch (c) { + case 45: + tokenizer = comment_less_than_sign_bang_dash_dash_state; + break; + default: + reconsume(c, comment_end_dash_state); + break; + } + } + function comment_less_than_sign_bang_dash_dash_state(c) { + switch (c) { + case 62: + // GREATER-THAN SIGN + case -1: + reconsume(c, comment_end_state); + break; + default: + reconsume(c, comment_end_state); + break; + } + } + function comment_end_dash_state(c) { + switch (c) { + case 45: + tokenizer = comment_end_state; + break; + case -1: + insertToken(COMMENT, buf2str(commentbuf)); + emitEOF(); + break; + /* see comment in comment end state */ + default: + commentbuf.push( + 45 + /* HYPHEN-MINUS */ + ); + reconsume(c, comment_state); + break; + } + } + function comment_end_state(c) { + switch (c) { + case 62: + tokenizer = data_state; + insertToken(COMMENT, buf2str(commentbuf)); + break; + case 33: + tokenizer = comment_end_bang_state; + break; + case 45: + commentbuf.push(45); + break; + case -1: + insertToken(COMMENT, buf2str(commentbuf)); + emitEOF(); + break; + /* For security reasons: otherwise, hostile user could put a script in a comment e.g. in a blog comment and then DOS the server so that the end tag isn't read, and then the commented script tag would be treated as live code */ + default: + commentbuf.push(45); + commentbuf.push(45); + reconsume(c, comment_state); + break; + } + } + function comment_end_bang_state(c) { + switch (c) { + case 45: + commentbuf.push(45); + commentbuf.push(45); + commentbuf.push(33); + tokenizer = comment_end_dash_state; + break; + case 62: + tokenizer = data_state; + insertToken(COMMENT, buf2str(commentbuf)); + break; + case -1: + insertToken(COMMENT, buf2str(commentbuf)); + emitEOF(); + break; + /* see comment in comment end state */ + default: + commentbuf.push(45); + commentbuf.push(45); + commentbuf.push(33); + reconsume(c, comment_state); + break; + } + } + function doctype_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + tokenizer = before_doctype_name_state; + break; + case -1: + beginDoctype(); + forcequirks(); + emitDoctype(); + emitEOF(); + break; + default: + reconsume(c, before_doctype_name_state); + break; + } + } + function before_doctype_name_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + break; + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + beginDoctype(); + doctypenamebuf.push(c + 32); + tokenizer = doctype_name_state; + break; + case 0: + beginDoctype(); + doctypenamebuf.push(65533); + tokenizer = doctype_name_state; + break; + case 62: + beginDoctype(); + forcequirks(); + tokenizer = data_state; + emitDoctype(); + break; + case -1: + beginDoctype(); + forcequirks(); + emitDoctype(); + emitEOF(); + break; + default: + beginDoctype(); + doctypenamebuf.push(c); + tokenizer = doctype_name_state; + break; + } + } + function doctype_name_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + tokenizer = after_doctype_name_state; + break; + case 62: + tokenizer = data_state; + emitDoctype(); + break; + case 65: + // [A-Z] + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + doctypenamebuf.push(c + 32); + break; + case 0: + doctypenamebuf.push( + 65533 + /* REPLACEMENT CHARACTER */ + ); + break; + case -1: + forcequirks(); + emitDoctype(); + emitEOF(); + break; + default: + doctypenamebuf.push(c); + break; + } + } + function after_doctype_name_state(c, lookahead, eof) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + nextchar += 1; + break; + case 62: + tokenizer = data_state; + nextchar += 1; + emitDoctype(); + break; + case -1: + forcequirks(); + emitDoctype(); + emitEOF(); + break; + default: + lookahead = lookahead.toUpperCase(); + if (lookahead === "PUBLIC") { + nextchar += 6; + tokenizer = after_doctype_public_keyword_state; + } else if (lookahead === "SYSTEM") { + nextchar += 6; + tokenizer = after_doctype_system_keyword_state; + } else { + forcequirks(); + tokenizer = bogus_doctype_state; + } + break; + } + } + after_doctype_name_state.lookahead = 6; + function after_doctype_public_keyword_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + tokenizer = before_doctype_public_identifier_state; + break; + case 34: + beginDoctypePublicId(); + tokenizer = doctype_public_identifier_double_quoted_state; + break; + case 39: + beginDoctypePublicId(); + tokenizer = doctype_public_identifier_single_quoted_state; + break; + case 62: + forcequirks(); + tokenizer = data_state; + emitDoctype(); + break; + case -1: + forcequirks(); + emitDoctype(); + emitEOF(); + break; + default: + forcequirks(); + tokenizer = bogus_doctype_state; + break; + } + } + function before_doctype_public_identifier_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + break; + case 34: + beginDoctypePublicId(); + tokenizer = doctype_public_identifier_double_quoted_state; + break; + case 39: + beginDoctypePublicId(); + tokenizer = doctype_public_identifier_single_quoted_state; + break; + case 62: + forcequirks(); + tokenizer = data_state; + emitDoctype(); + break; + case -1: + forcequirks(); + emitDoctype(); + emitEOF(); + break; + default: + forcequirks(); + tokenizer = bogus_doctype_state; + break; + } + } + function doctype_public_identifier_double_quoted_state(c) { + switch (c) { + case 34: + tokenizer = after_doctype_public_identifier_state; + break; + case 0: + doctypepublicbuf.push( + 65533 + /* REPLACEMENT CHARACTER */ + ); + break; + case 62: + forcequirks(); + tokenizer = data_state; + emitDoctype(); + break; + case -1: + forcequirks(); + emitDoctype(); + emitEOF(); + break; + default: + doctypepublicbuf.push(c); + break; + } + } + function doctype_public_identifier_single_quoted_state(c) { + switch (c) { + case 39: + tokenizer = after_doctype_public_identifier_state; + break; + case 0: + doctypepublicbuf.push( + 65533 + /* REPLACEMENT CHARACTER */ + ); + break; + case 62: + forcequirks(); + tokenizer = data_state; + emitDoctype(); + break; + case -1: + forcequirks(); + emitDoctype(); + emitEOF(); + break; + default: + doctypepublicbuf.push(c); + break; + } + } + function after_doctype_public_identifier_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + tokenizer = between_doctype_public_and_system_identifiers_state; + break; + case 62: + tokenizer = data_state; + emitDoctype(); + break; + case 34: + beginDoctypeSystemId(); + tokenizer = doctype_system_identifier_double_quoted_state; + break; + case 39: + beginDoctypeSystemId(); + tokenizer = doctype_system_identifier_single_quoted_state; + break; + case -1: + forcequirks(); + emitDoctype(); + emitEOF(); + break; + default: + forcequirks(); + tokenizer = bogus_doctype_state; + break; + } + } + function between_doctype_public_and_system_identifiers_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + break; + case 62: + tokenizer = data_state; + emitDoctype(); + break; + case 34: + beginDoctypeSystemId(); + tokenizer = doctype_system_identifier_double_quoted_state; + break; + case 39: + beginDoctypeSystemId(); + tokenizer = doctype_system_identifier_single_quoted_state; + break; + case -1: + forcequirks(); + emitDoctype(); + emitEOF(); + break; + default: + forcequirks(); + tokenizer = bogus_doctype_state; + break; + } + } + function after_doctype_system_keyword_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + tokenizer = before_doctype_system_identifier_state; + break; + case 34: + beginDoctypeSystemId(); + tokenizer = doctype_system_identifier_double_quoted_state; + break; + case 39: + beginDoctypeSystemId(); + tokenizer = doctype_system_identifier_single_quoted_state; + break; + case 62: + forcequirks(); + tokenizer = data_state; + emitDoctype(); + break; + case -1: + forcequirks(); + emitDoctype(); + emitEOF(); + break; + default: + forcequirks(); + tokenizer = bogus_doctype_state; + break; + } + } + function before_doctype_system_identifier_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + break; + case 34: + beginDoctypeSystemId(); + tokenizer = doctype_system_identifier_double_quoted_state; + break; + case 39: + beginDoctypeSystemId(); + tokenizer = doctype_system_identifier_single_quoted_state; + break; + case 62: + forcequirks(); + tokenizer = data_state; + emitDoctype(); + break; + case -1: + forcequirks(); + emitDoctype(); + emitEOF(); + break; + default: + forcequirks(); + tokenizer = bogus_doctype_state; + break; + } + } + function doctype_system_identifier_double_quoted_state(c) { + switch (c) { + case 34: + tokenizer = after_doctype_system_identifier_state; + break; + case 0: + doctypesystembuf.push( + 65533 + /* REPLACEMENT CHARACTER */ + ); + break; + case 62: + forcequirks(); + tokenizer = data_state; + emitDoctype(); + break; + case -1: + forcequirks(); + emitDoctype(); + emitEOF(); + break; + default: + doctypesystembuf.push(c); + break; + } + } + function doctype_system_identifier_single_quoted_state(c) { + switch (c) { + case 39: + tokenizer = after_doctype_system_identifier_state; + break; + case 0: + doctypesystembuf.push( + 65533 + /* REPLACEMENT CHARACTER */ + ); + break; + case 62: + forcequirks(); + tokenizer = data_state; + emitDoctype(); + break; + case -1: + forcequirks(); + emitDoctype(); + emitEOF(); + break; + default: + doctypesystembuf.push(c); + break; + } + } + function after_doctype_system_identifier_state(c) { + switch (c) { + case 9: + // CHARACTER TABULATION (tab) + case 10: + // LINE FEED (LF) + case 12: + // FORM FEED (FF) + case 32: + break; + case 62: + tokenizer = data_state; + emitDoctype(); + break; + case -1: + forcequirks(); + emitDoctype(); + emitEOF(); + break; + default: + tokenizer = bogus_doctype_state; + break; + } + } + function bogus_doctype_state(c) { + switch (c) { + case 62: + tokenizer = data_state; + emitDoctype(); + break; + case -1: + emitDoctype(); + emitEOF(); + break; + default: + break; + } + } + function cdata_section_state(c) { + switch (c) { + case 93: + tokenizer = cdata_section_bracket_state; + break; + case -1: + emitEOF(); + break; + case 0: + textIncludesNUL = true; + /* fall through */ + default: + emitCharsWhile(CDATATEXT) || textrun.push(c); + break; + } + } + function cdata_section_bracket_state(c) { + switch (c) { + case 93: + tokenizer = cdata_section_end_state; + break; + default: + textrun.push(93); + reconsume(c, cdata_section_state); + break; + } + } + function cdata_section_end_state(c) { + switch (c) { + case 93: + textrun.push(93); + break; + case 62: + flushText(); + tokenizer = data_state; + break; + default: + textrun.push(93); + textrun.push(93); + reconsume(c, cdata_section_state); + break; + } + } + function character_reference_state(c) { + beginTempBuf(); + tempbuf.push(38); + switch (c) { + case 9: + // TAB + case 10: + // LINE FEED + case 12: + // FORM FEED + case 32: + // SPACE + case 60: + // LESS-THAN SIGN + case 38: + // AMPERSAND + case -1: + reconsume(c, character_reference_end_state); + break; + case 35: + tempbuf.push(c); + tokenizer = numeric_character_reference_state; + break; + default: + reconsume(c, named_character_reference_state); + break; + } + } + function named_character_reference_state(c) { + NAMEDCHARREF.lastIndex = nextchar; + var matched = NAMEDCHARREF.exec(chars); + if (!matched) throw new Error("should never happen"); + var name = matched[1]; + if (!name) { + tokenizer = character_reference_end_state; + return; + } + nextchar += name.length; + pushAll(tempbuf, str2buf(name)); + switch (return_state) { + case attribute_value_double_quoted_state: + case attribute_value_single_quoted_state: + case attribute_value_unquoted_state: + if (name[name.length - 1] !== ";") { + if (/[=A-Za-z0-9]/.test(chars[nextchar])) { + tokenizer = character_reference_end_state; + return; + } + } + break; + default: + break; + } + beginTempBuf(); + var rv = namedCharRefs[name]; + if (typeof rv === "number") { + tempbuf.push(rv); + } else { + pushAll(tempbuf, rv); + } + tokenizer = character_reference_end_state; + } + named_character_reference_state.lookahead = -NAMEDCHARREF_MAXLEN; + function numeric_character_reference_state(c) { + character_reference_code = 0; + switch (c) { + case 120: + // x + case 88: + tempbuf.push(c); + tokenizer = hexadecimal_character_reference_start_state; + break; + default: + reconsume(c, decimal_character_reference_start_state); + break; + } + } + function hexadecimal_character_reference_start_state(c) { + switch (c) { + case 48: + case 49: + case 50: + case 51: + case 52: + case 53: + case 54: + case 55: + case 56: + case 57: + // [0-9] + case 65: + case 66: + case 67: + case 68: + case 69: + case 70: + // [A-F] + case 97: + case 98: + case 99: + case 100: + case 101: + case 102: + reconsume(c, hexadecimal_character_reference_state); + break; + default: + reconsume(c, character_reference_end_state); + break; + } + } + function decimal_character_reference_start_state(c) { + switch (c) { + case 48: + case 49: + case 50: + case 51: + case 52: + case 53: + case 54: + case 55: + case 56: + case 57: + reconsume(c, decimal_character_reference_state); + break; + default: + reconsume(c, character_reference_end_state); + break; + } + } + function hexadecimal_character_reference_state(c) { + switch (c) { + case 65: + case 66: + case 67: + case 68: + case 69: + case 70: + character_reference_code *= 16; + character_reference_code += c - 55; + break; + case 97: + case 98: + case 99: + case 100: + case 101: + case 102: + character_reference_code *= 16; + character_reference_code += c - 87; + break; + case 48: + case 49: + case 50: + case 51: + case 52: + case 53: + case 54: + case 55: + case 56: + case 57: + character_reference_code *= 16; + character_reference_code += c - 48; + break; + case 59: + tokenizer = numeric_character_reference_end_state; + break; + default: + reconsume(c, numeric_character_reference_end_state); + break; + } + } + function decimal_character_reference_state(c) { + switch (c) { + case 48: + case 49: + case 50: + case 51: + case 52: + case 53: + case 54: + case 55: + case 56: + case 57: + character_reference_code *= 10; + character_reference_code += c - 48; + break; + case 59: + tokenizer = numeric_character_reference_end_state; + break; + default: + reconsume(c, numeric_character_reference_end_state); + break; + } + } + function numeric_character_reference_end_state(c) { + if (character_reference_code in numericCharRefReplacements) { + character_reference_code = numericCharRefReplacements[character_reference_code]; + } else if (character_reference_code > 1114111 || character_reference_code >= 55296 && character_reference_code < 57344) { + character_reference_code = 65533; + } + beginTempBuf(); + if (character_reference_code <= 65535) { + tempbuf.push(character_reference_code); + } else { + character_reference_code = character_reference_code - 65536; + tempbuf.push(55296 + (character_reference_code >> 10)); + tempbuf.push(56320 + (character_reference_code & 1023)); + } + reconsume(c, character_reference_end_state); + } + function character_reference_end_state(c) { + switch (return_state) { + case attribute_value_double_quoted_state: + case attribute_value_single_quoted_state: + case attribute_value_unquoted_state: + attrvaluebuf += buf2str(tempbuf); + break; + default: + pushAll(textrun, tempbuf); + break; + } + reconsume(c, return_state); + } + function initial_mode(t, value2, arg3, arg4) { + switch (t) { + case 1: + value2 = value2.replace(LEADINGWS, ""); + if (value2.length === 0) return; + break; + // Handle anything non-space text below + case 4: + doc._appendChild(doc.createComment(value2)); + return; + case 5: + var name = value2; + var publicid = arg3; + var systemid = arg4; + doc.appendChild(new DocumentType(doc, name, publicid, systemid)); + if (force_quirks || name.toLowerCase() !== "html" || quirkyPublicIds.test(publicid) || systemid && systemid.toLowerCase() === quirkySystemId || systemid === void 0 && conditionallyQuirkyPublicIds.test(publicid)) + doc._quirks = true; + else if (limitedQuirkyPublicIds.test(publicid) || systemid !== void 0 && conditionallyQuirkyPublicIds.test(publicid)) + doc._limitedQuirks = true; + parser = before_html_mode; + return; + } + doc._quirks = true; + parser = before_html_mode; + parser(t, value2, arg3, arg4); + } + function before_html_mode(t, value2, arg3, arg4) { + var elt; + switch (t) { + case 1: + value2 = value2.replace(LEADINGWS, ""); + if (value2.length === 0) return; + break; + // Handle anything non-space text below + case 5: + return; + case 4: + doc._appendChild(doc.createComment(value2)); + return; + case 2: + if (value2 === "html") { + elt = createHTMLElt(doc, value2, arg3); + stack.push(elt); + doc.appendChild(elt); + parser = before_head_mode; + return; + } + break; + case 3: + switch (value2) { + case "html": + case "head": + case "body": + case "br": + break; + // fall through on these + default: + return; + } + } + elt = createHTMLElt(doc, "html", null); + stack.push(elt); + doc.appendChild(elt); + parser = before_head_mode; + parser(t, value2, arg3, arg4); + } + function before_head_mode(t, value2, arg3, arg4) { + switch (t) { + case 1: + value2 = value2.replace(LEADINGWS, ""); + if (value2.length === 0) return; + break; + // Handle anything non-space text below + case 5: + return; + case 4: + insertComment(value2); + return; + case 2: + switch (value2) { + case "html": + in_body_mode(t, value2, arg3, arg4); + return; + case "head": + var elt = insertHTMLElement(value2, arg3); + head_element_pointer = elt; + parser = in_head_mode; + return; + } + break; + case 3: + switch (value2) { + case "html": + case "head": + case "body": + case "br": + break; + default: + return; + } + } + before_head_mode(TAG, "head", null); + parser(t, value2, arg3, arg4); + } + function in_head_mode(t, value2, arg3, arg4) { + switch (t) { + case 1: + var ws = value2.match(LEADINGWS); + if (ws) { + insertText(ws[0]); + value2 = value2.substring(ws[0].length); + } + if (value2.length === 0) return; + break; + // Handle non-whitespace below + case 4: + insertComment(value2); + return; + case 5: + return; + case 2: + switch (value2) { + case "html": + in_body_mode(t, value2, arg3, arg4); + return; + case "meta": + // XXX: + // May need to change the encoding based on this tag + /* falls through */ + case "base": + case "basefont": + case "bgsound": + case "link": + insertHTMLElement(value2, arg3); + stack.pop(); + return; + case "title": + parseRCDATA(value2, arg3); + return; + case "noscript": + if (!scripting_enabled) { + insertHTMLElement(value2, arg3); + parser = in_head_noscript_mode; + return; + } + // Otherwise, if scripting is enabled... + /* falls through */ + case "noframes": + case "style": + parseRawText(value2, arg3); + return; + case "script": + insertElement(function(doc2) { + var elt = createHTMLElt(doc2, value2, arg3); + elt._parser_inserted = true; + elt._force_async = false; + if (fragment) elt._already_started = true; + flushText(); + return elt; + }); + tokenizer = script_data_state; + originalInsertionMode = parser; + parser = text_mode; + return; + case "template": + insertHTMLElement(value2, arg3); + afe.insertMarker(); + frameset_ok = false; + parser = in_template_mode; + templateInsertionModes.push(parser); + return; + case "head": + return; + } + break; + case 3: + switch (value2) { + case "head": + stack.pop(); + parser = after_head_mode; + return; + case "body": + case "html": + case "br": + break; + // handle these at the bottom of the function + case "template": + if (!stack.contains("template")) { + return; + } + stack.generateImpliedEndTags(null, "thorough"); + stack.popTag("template"); + afe.clearToMarker(); + templateInsertionModes.pop(); + resetInsertionMode(); + return; + default: + return; + } + break; + } + in_head_mode(ENDTAG, "head", null); + parser(t, value2, arg3, arg4); + } + function in_head_noscript_mode(t, value2, arg3, arg4) { + switch (t) { + case 5: + return; + case 4: + in_head_mode(t, value2); + return; + case 1: + var ws = value2.match(LEADINGWS); + if (ws) { + in_head_mode(t, ws[0]); + value2 = value2.substring(ws[0].length); + } + if (value2.length === 0) return; + break; + // Handle non-whitespace below + case 2: + switch (value2) { + case "html": + in_body_mode(t, value2, arg3, arg4); + return; + case "basefont": + case "bgsound": + case "link": + case "meta": + case "noframes": + case "style": + in_head_mode(t, value2, arg3); + return; + case "head": + case "noscript": + return; + } + break; + case 3: + switch (value2) { + case "noscript": + stack.pop(); + parser = in_head_mode; + return; + case "br": + break; + // goes to the outer default + default: + return; + } + break; + } + in_head_noscript_mode(ENDTAG, "noscript", null); + parser(t, value2, arg3, arg4); + } + function after_head_mode(t, value2, arg3, arg4) { + switch (t) { + case 1: + var ws = value2.match(LEADINGWS); + if (ws) { + insertText(ws[0]); + value2 = value2.substring(ws[0].length); + } + if (value2.length === 0) return; + break; + // Handle non-whitespace below + case 4: + insertComment(value2); + return; + case 5: + return; + case 2: + switch (value2) { + case "html": + in_body_mode(t, value2, arg3, arg4); + return; + case "body": + insertHTMLElement(value2, arg3); + frameset_ok = false; + parser = in_body_mode; + return; + case "frameset": + insertHTMLElement(value2, arg3); + parser = in_frameset_mode; + return; + case "base": + case "basefont": + case "bgsound": + case "link": + case "meta": + case "noframes": + case "script": + case "style": + case "template": + case "title": + stack.push(head_element_pointer); + in_head_mode(TAG, value2, arg3); + stack.removeElement(head_element_pointer); + return; + case "head": + return; + } + break; + case 3: + switch (value2) { + case "template": + return in_head_mode(t, value2, arg3, arg4); + case "body": + case "html": + case "br": + break; + default: + return; + } + break; + } + after_head_mode(TAG, "body", null); + frameset_ok = true; + parser(t, value2, arg3, arg4); + } + function in_body_mode(t, value2, arg3, arg4) { + var body, i, node2, elt; + switch (t) { + case 1: + if (textIncludesNUL) { + value2 = value2.replace(NULCHARS, ""); + if (value2.length === 0) return; + } + if (frameset_ok && NONWS.test(value2)) + frameset_ok = false; + afereconstruct(); + insertText(value2); + return; + case 5: + return; + case 4: + insertComment(value2); + return; + case -1: + if (templateInsertionModes.length) { + return in_template_mode(t); + } + stopParsing(); + return; + case 2: + switch (value2) { + case "html": + if (stack.contains("template")) { + return; + } + transferAttributes(arg3, stack.elements[0]); + return; + case "base": + case "basefont": + case "bgsound": + case "link": + case "meta": + case "noframes": + case "script": + case "style": + case "template": + case "title": + in_head_mode(TAG, value2, arg3); + return; + case "body": + body = stack.elements[1]; + if (!body || !(body instanceof impl.HTMLBodyElement) || stack.contains("template")) + return; + frameset_ok = false; + transferAttributes(arg3, body); + return; + case "frameset": + if (!frameset_ok) return; + body = stack.elements[1]; + if (!body || !(body instanceof impl.HTMLBodyElement)) + return; + if (body.parentNode) body.parentNode.removeChild(body); + while (!(stack.top instanceof impl.HTMLHtmlElement)) + stack.pop(); + insertHTMLElement(value2, arg3); + parser = in_frameset_mode; + return; + case "address": + case "article": + case "aside": + case "blockquote": + case "center": + case "details": + case "dialog": + case "dir": + case "div": + case "dl": + case "fieldset": + case "figcaption": + case "figure": + case "footer": + case "header": + case "hgroup": + case "main": + case "nav": + case "ol": + case "p": + case "section": + case "summary": + case "ul": + if (stack.inButtonScope("p")) in_body_mode(ENDTAG, "p"); + insertHTMLElement(value2, arg3); + return; + case "menu": + if (stack.inButtonScope("p")) in_body_mode(ENDTAG, "p"); + if (isA(stack.top, "menuitem")) { + stack.pop(); + } + insertHTMLElement(value2, arg3); + return; + case "h1": + case "h2": + case "h3": + case "h4": + case "h5": + case "h6": + if (stack.inButtonScope("p")) in_body_mode(ENDTAG, "p"); + if (stack.top instanceof impl.HTMLHeadingElement) + stack.pop(); + insertHTMLElement(value2, arg3); + return; + case "pre": + case "listing": + if (stack.inButtonScope("p")) in_body_mode(ENDTAG, "p"); + insertHTMLElement(value2, arg3); + ignore_linefeed = true; + frameset_ok = false; + return; + case "form": + if (form_element_pointer && !stack.contains("template")) return; + if (stack.inButtonScope("p")) in_body_mode(ENDTAG, "p"); + elt = insertHTMLElement(value2, arg3); + if (!stack.contains("template")) + form_element_pointer = elt; + return; + case "li": + frameset_ok = false; + for (i = stack.elements.length - 1; i >= 0; i--) { + node2 = stack.elements[i]; + if (node2 instanceof impl.HTMLLIElement) { + in_body_mode(ENDTAG, "li"); + break; + } + if (isA(node2, specialSet) && !isA(node2, addressdivpSet)) + break; + } + if (stack.inButtonScope("p")) in_body_mode(ENDTAG, "p"); + insertHTMLElement(value2, arg3); + return; + case "dd": + case "dt": + frameset_ok = false; + for (i = stack.elements.length - 1; i >= 0; i--) { + node2 = stack.elements[i]; + if (isA(node2, dddtSet)) { + in_body_mode(ENDTAG, node2.localName); + break; + } + if (isA(node2, specialSet) && !isA(node2, addressdivpSet)) + break; + } + if (stack.inButtonScope("p")) in_body_mode(ENDTAG, "p"); + insertHTMLElement(value2, arg3); + return; + case "plaintext": + if (stack.inButtonScope("p")) in_body_mode(ENDTAG, "p"); + insertHTMLElement(value2, arg3); + tokenizer = plaintext_state; + return; + case "button": + if (stack.inScope("button")) { + in_body_mode(ENDTAG, "button"); + parser(t, value2, arg3, arg4); + } else { + afereconstruct(); + insertHTMLElement(value2, arg3); + frameset_ok = false; + } + return; + case "a": + var activeElement = afe.findElementByTag("a"); + if (activeElement) { + in_body_mode(ENDTAG, value2); + afe.remove(activeElement); + stack.removeElement(activeElement); + } + /* falls through */ + case "b": + case "big": + case "code": + case "em": + case "font": + case "i": + case "s": + case "small": + case "strike": + case "strong": + case "tt": + case "u": + afereconstruct(); + afe.push(insertHTMLElement(value2, arg3), arg3); + return; + case "nobr": + afereconstruct(); + if (stack.inScope(value2)) { + in_body_mode(ENDTAG, value2); + afereconstruct(); + } + afe.push(insertHTMLElement(value2, arg3), arg3); + return; + case "applet": + case "marquee": + case "object": + afereconstruct(); + insertHTMLElement(value2, arg3); + afe.insertMarker(); + frameset_ok = false; + return; + case "table": + if (!doc._quirks && stack.inButtonScope("p")) { + in_body_mode(ENDTAG, "p"); + } + insertHTMLElement(value2, arg3); + frameset_ok = false; + parser = in_table_mode; + return; + case "area": + case "br": + case "embed": + case "img": + case "keygen": + case "wbr": + afereconstruct(); + insertHTMLElement(value2, arg3); + stack.pop(); + frameset_ok = false; + return; + case "input": + afereconstruct(); + elt = insertHTMLElement(value2, arg3); + stack.pop(); + var type2 = elt.getAttribute("type"); + if (!type2 || type2.toLowerCase() !== "hidden") + frameset_ok = false; + return; + case "param": + case "source": + case "track": + insertHTMLElement(value2, arg3); + stack.pop(); + return; + case "hr": + if (stack.inButtonScope("p")) in_body_mode(ENDTAG, "p"); + if (isA(stack.top, "menuitem")) { + stack.pop(); + } + insertHTMLElement(value2, arg3); + stack.pop(); + frameset_ok = false; + return; + case "image": + in_body_mode(TAG, "img", arg3, arg4); + return; + case "textarea": + insertHTMLElement(value2, arg3); + ignore_linefeed = true; + frameset_ok = false; + tokenizer = rcdata_state; + originalInsertionMode = parser; + parser = text_mode; + return; + case "xmp": + if (stack.inButtonScope("p")) in_body_mode(ENDTAG, "p"); + afereconstruct(); + frameset_ok = false; + parseRawText(value2, arg3); + return; + case "iframe": + frameset_ok = false; + parseRawText(value2, arg3); + return; + case "noembed": + parseRawText(value2, arg3); + return; + case "select": + afereconstruct(); + insertHTMLElement(value2, arg3); + frameset_ok = false; + if (parser === in_table_mode || parser === in_caption_mode || parser === in_table_body_mode || parser === in_row_mode || parser === in_cell_mode) + parser = in_select_in_table_mode; + else + parser = in_select_mode; + return; + case "optgroup": + case "option": + if (stack.top instanceof impl.HTMLOptionElement) { + in_body_mode(ENDTAG, "option"); + } + afereconstruct(); + insertHTMLElement(value2, arg3); + return; + case "menuitem": + if (isA(stack.top, "menuitem")) { + stack.pop(); + } + afereconstruct(); + insertHTMLElement(value2, arg3); + return; + case "rb": + case "rtc": + if (stack.inScope("ruby")) { + stack.generateImpliedEndTags(); + } + insertHTMLElement(value2, arg3); + return; + case "rp": + case "rt": + if (stack.inScope("ruby")) { + stack.generateImpliedEndTags("rtc"); + } + insertHTMLElement(value2, arg3); + return; + case "math": + afereconstruct(); + adjustMathMLAttributes(arg3); + adjustForeignAttributes(arg3); + insertForeignElement(value2, arg3, NAMESPACE.MATHML); + if (arg4) + stack.pop(); + return; + case "svg": + afereconstruct(); + adjustSVGAttributes(arg3); + adjustForeignAttributes(arg3); + insertForeignElement(value2, arg3, NAMESPACE.SVG); + if (arg4) + stack.pop(); + return; + case "caption": + case "col": + case "colgroup": + case "frame": + case "head": + case "tbody": + case "td": + case "tfoot": + case "th": + case "thead": + case "tr": + return; + } + afereconstruct(); + insertHTMLElement(value2, arg3); + return; + case 3: + switch (value2) { + case "template": + in_head_mode(ENDTAG, value2, arg3); + return; + case "body": + if (!stack.inScope("body")) return; + parser = after_body_mode; + return; + case "html": + if (!stack.inScope("body")) return; + parser = after_body_mode; + parser(t, value2, arg3); + return; + case "address": + case "article": + case "aside": + case "blockquote": + case "button": + case "center": + case "details": + case "dialog": + case "dir": + case "div": + case "dl": + case "fieldset": + case "figcaption": + case "figure": + case "footer": + case "header": + case "hgroup": + case "listing": + case "main": + case "menu": + case "nav": + case "ol": + case "pre": + case "section": + case "summary": + case "ul": + if (!stack.inScope(value2)) return; + stack.generateImpliedEndTags(); + stack.popTag(value2); + return; + case "form": + if (!stack.contains("template")) { + var openform = form_element_pointer; + form_element_pointer = null; + if (!openform || !stack.elementInScope(openform)) return; + stack.generateImpliedEndTags(); + stack.removeElement(openform); + } else { + if (!stack.inScope("form")) return; + stack.generateImpliedEndTags(); + stack.popTag("form"); + } + return; + case "p": + if (!stack.inButtonScope(value2)) { + in_body_mode(TAG, value2, null); + parser(t, value2, arg3, arg4); + } else { + stack.generateImpliedEndTags(value2); + stack.popTag(value2); + } + return; + case "li": + if (!stack.inListItemScope(value2)) return; + stack.generateImpliedEndTags(value2); + stack.popTag(value2); + return; + case "dd": + case "dt": + if (!stack.inScope(value2)) return; + stack.generateImpliedEndTags(value2); + stack.popTag(value2); + return; + case "h1": + case "h2": + case "h3": + case "h4": + case "h5": + case "h6": + if (!stack.elementTypeInScope(impl.HTMLHeadingElement)) return; + stack.generateImpliedEndTags(); + stack.popElementType(impl.HTMLHeadingElement); + return; + case "sarcasm": + break; + case "a": + case "b": + case "big": + case "code": + case "em": + case "font": + case "i": + case "nobr": + case "s": + case "small": + case "strike": + case "strong": + case "tt": + case "u": + var result = adoptionAgency(value2); + if (result) return; + break; + // Go to the "any other end tag" case + case "applet": + case "marquee": + case "object": + if (!stack.inScope(value2)) return; + stack.generateImpliedEndTags(); + stack.popTag(value2); + afe.clearToMarker(); + return; + case "br": + in_body_mode(TAG, value2, null); + return; + } + for (i = stack.elements.length - 1; i >= 0; i--) { + node2 = stack.elements[i]; + if (isA(node2, value2)) { + stack.generateImpliedEndTags(value2); + stack.popElement(node2); + break; + } else if (isA(node2, specialSet)) { + return; + } + } + return; + } + } + function text_mode(t, value2, arg3, arg4) { + switch (t) { + case 1: + insertText(value2); + return; + case -1: + if (stack.top instanceof impl.HTMLScriptElement) + stack.top._already_started = true; + stack.pop(); + parser = originalInsertionMode; + parser(t); + return; + case 3: + if (value2 === "script") { + handleScriptEnd(); + } else { + stack.pop(); + parser = originalInsertionMode; + } + return; + default: + return; + } + } + function in_table_mode(t, value2, arg3, arg4) { + function getTypeAttr(attrs) { + for (var i = 0, n = attrs.length; i < n; i++) { + if (attrs[i][0] === "type") + return attrs[i][1].toLowerCase(); + } + return null; + } + switch (t) { + case 1: + if (text_integration_mode) { + in_body_mode(t, value2, arg3, arg4); + return; + } else if (isA(stack.top, tablesectionrowSet)) { + pending_table_text = []; + originalInsertionMode = parser; + parser = in_table_text_mode; + parser(t, value2, arg3, arg4); + return; + } + break; + case 4: + insertComment(value2); + return; + case 5: + return; + case 2: + switch (value2) { + case "caption": + stack.clearToContext(tableContextSet); + afe.insertMarker(); + insertHTMLElement(value2, arg3); + parser = in_caption_mode; + return; + case "colgroup": + stack.clearToContext(tableContextSet); + insertHTMLElement(value2, arg3); + parser = in_column_group_mode; + return; + case "col": + in_table_mode(TAG, "colgroup", null); + parser(t, value2, arg3, arg4); + return; + case "tbody": + case "tfoot": + case "thead": + stack.clearToContext(tableContextSet); + insertHTMLElement(value2, arg3); + parser = in_table_body_mode; + return; + case "td": + case "th": + case "tr": + in_table_mode(TAG, "tbody", null); + parser(t, value2, arg3, arg4); + return; + case "table": + if (!stack.inTableScope(value2)) { + return; + } + in_table_mode(ENDTAG, value2); + parser(t, value2, arg3, arg4); + return; + case "style": + case "script": + case "template": + in_head_mode(t, value2, arg3, arg4); + return; + case "input": + var type2 = getTypeAttr(arg3); + if (type2 !== "hidden") break; + insertHTMLElement(value2, arg3); + stack.pop(); + return; + case "form": + if (form_element_pointer || stack.contains("template")) return; + form_element_pointer = insertHTMLElement(value2, arg3); + stack.popElement(form_element_pointer); + return; + } + break; + case 3: + switch (value2) { + case "table": + if (!stack.inTableScope(value2)) return; + stack.popTag(value2); + resetInsertionMode(); + return; + case "body": + case "caption": + case "col": + case "colgroup": + case "html": + case "tbody": + case "td": + case "tfoot": + case "th": + case "thead": + case "tr": + return; + case "template": + in_head_mode(t, value2, arg3, arg4); + return; + } + break; + case -1: + in_body_mode(t, value2, arg3, arg4); + return; + } + foster_parent_mode = true; + in_body_mode(t, value2, arg3, arg4); + foster_parent_mode = false; + } + function in_table_text_mode(t, value2, arg3, arg4) { + if (t === TEXT) { + if (textIncludesNUL) { + value2 = value2.replace(NULCHARS, ""); + if (value2.length === 0) return; + } + pending_table_text.push(value2); + } else { + var s = pending_table_text.join(""); + pending_table_text.length = 0; + if (NONWS.test(s)) { + foster_parent_mode = true; + in_body_mode(TEXT, s); + foster_parent_mode = false; + } else { + insertText(s); + } + parser = originalInsertionMode; + parser(t, value2, arg3, arg4); + } + } + function in_caption_mode(t, value2, arg3, arg4) { + function end_caption() { + if (!stack.inTableScope("caption")) return false; + stack.generateImpliedEndTags(); + stack.popTag("caption"); + afe.clearToMarker(); + parser = in_table_mode; + return true; + } + switch (t) { + case 2: + switch (value2) { + case "caption": + case "col": + case "colgroup": + case "tbody": + case "td": + case "tfoot": + case "th": + case "thead": + case "tr": + if (end_caption()) parser(t, value2, arg3, arg4); + return; + } + break; + case 3: + switch (value2) { + case "caption": + end_caption(); + return; + case "table": + if (end_caption()) parser(t, value2, arg3, arg4); + return; + case "body": + case "col": + case "colgroup": + case "html": + case "tbody": + case "td": + case "tfoot": + case "th": + case "thead": + case "tr": + return; + } + break; + } + in_body_mode(t, value2, arg3, arg4); + } + function in_column_group_mode(t, value2, arg3, arg4) { + switch (t) { + case 1: + var ws = value2.match(LEADINGWS); + if (ws) { + insertText(ws[0]); + value2 = value2.substring(ws[0].length); + } + if (value2.length === 0) return; + break; + // Handle non-whitespace below + case 4: + insertComment(value2); + return; + case 5: + return; + case 2: + switch (value2) { + case "html": + in_body_mode(t, value2, arg3, arg4); + return; + case "col": + insertHTMLElement(value2, arg3); + stack.pop(); + return; + case "template": + in_head_mode(t, value2, arg3, arg4); + return; + } + break; + case 3: + switch (value2) { + case "colgroup": + if (!isA(stack.top, "colgroup")) { + return; + } + stack.pop(); + parser = in_table_mode; + return; + case "col": + return; + case "template": + in_head_mode(t, value2, arg3, arg4); + return; + } + break; + case -1: + in_body_mode(t, value2, arg3, arg4); + return; + } + if (!isA(stack.top, "colgroup")) { + return; + } + in_column_group_mode(ENDTAG, "colgroup"); + parser(t, value2, arg3, arg4); + } + function in_table_body_mode(t, value2, arg3, arg4) { + function endsect() { + if (!stack.inTableScope("tbody") && !stack.inTableScope("thead") && !stack.inTableScope("tfoot")) + return; + stack.clearToContext(tableBodyContextSet); + in_table_body_mode(ENDTAG, stack.top.localName, null); + parser(t, value2, arg3, arg4); + } + switch (t) { + case 2: + switch (value2) { + case "tr": + stack.clearToContext(tableBodyContextSet); + insertHTMLElement(value2, arg3); + parser = in_row_mode; + return; + case "th": + case "td": + in_table_body_mode(TAG, "tr", null); + parser(t, value2, arg3, arg4); + return; + case "caption": + case "col": + case "colgroup": + case "tbody": + case "tfoot": + case "thead": + endsect(); + return; + } + break; + case 3: + switch (value2) { + case "table": + endsect(); + return; + case "tbody": + case "tfoot": + case "thead": + if (stack.inTableScope(value2)) { + stack.clearToContext(tableBodyContextSet); + stack.pop(); + parser = in_table_mode; + } + return; + case "body": + case "caption": + case "col": + case "colgroup": + case "html": + case "td": + case "th": + case "tr": + return; + } + break; + } + in_table_mode(t, value2, arg3, arg4); + } + function in_row_mode(t, value2, arg3, arg4) { + function endrow() { + if (!stack.inTableScope("tr")) return false; + stack.clearToContext(tableRowContextSet); + stack.pop(); + parser = in_table_body_mode; + return true; + } + switch (t) { + case 2: + switch (value2) { + case "th": + case "td": + stack.clearToContext(tableRowContextSet); + insertHTMLElement(value2, arg3); + parser = in_cell_mode; + afe.insertMarker(); + return; + case "caption": + case "col": + case "colgroup": + case "tbody": + case "tfoot": + case "thead": + case "tr": + if (endrow()) parser(t, value2, arg3, arg4); + return; + } + break; + case 3: + switch (value2) { + case "tr": + endrow(); + return; + case "table": + if (endrow()) parser(t, value2, arg3, arg4); + return; + case "tbody": + case "tfoot": + case "thead": + if (stack.inTableScope(value2)) { + if (endrow()) parser(t, value2, arg3, arg4); + } + return; + case "body": + case "caption": + case "col": + case "colgroup": + case "html": + case "td": + case "th": + return; + } + break; + } + in_table_mode(t, value2, arg3, arg4); + } + function in_cell_mode(t, value2, arg3, arg4) { + switch (t) { + case 2: + switch (value2) { + case "caption": + case "col": + case "colgroup": + case "tbody": + case "td": + case "tfoot": + case "th": + case "thead": + case "tr": + if (stack.inTableScope("td")) { + in_cell_mode(ENDTAG, "td"); + parser(t, value2, arg3, arg4); + } else if (stack.inTableScope("th")) { + in_cell_mode(ENDTAG, "th"); + parser(t, value2, arg3, arg4); + } + return; + } + break; + case 3: + switch (value2) { + case "td": + case "th": + if (!stack.inTableScope(value2)) return; + stack.generateImpliedEndTags(); + stack.popTag(value2); + afe.clearToMarker(); + parser = in_row_mode; + return; + case "body": + case "caption": + case "col": + case "colgroup": + case "html": + return; + case "table": + case "tbody": + case "tfoot": + case "thead": + case "tr": + if (!stack.inTableScope(value2)) return; + in_cell_mode(ENDTAG, stack.inTableScope("td") ? "td" : "th"); + parser(t, value2, arg3, arg4); + return; + } + break; + } + in_body_mode(t, value2, arg3, arg4); + } + function in_select_mode(t, value2, arg3, arg4) { + switch (t) { + case 1: + if (textIncludesNUL) { + value2 = value2.replace(NULCHARS, ""); + if (value2.length === 0) return; + } + insertText(value2); + return; + case 4: + insertComment(value2); + return; + case 5: + return; + case -1: + in_body_mode(t, value2, arg3, arg4); + return; + case 2: + switch (value2) { + case "html": + in_body_mode(t, value2, arg3, arg4); + return; + case "option": + if (stack.top instanceof impl.HTMLOptionElement) + in_select_mode(ENDTAG, value2); + insertHTMLElement(value2, arg3); + return; + case "optgroup": + if (stack.top instanceof impl.HTMLOptionElement) + in_select_mode(ENDTAG, "option"); + if (stack.top instanceof impl.HTMLOptGroupElement) + in_select_mode(ENDTAG, value2); + insertHTMLElement(value2, arg3); + return; + case "select": + in_select_mode(ENDTAG, value2); + return; + case "input": + case "keygen": + case "textarea": + if (!stack.inSelectScope("select")) return; + in_select_mode(ENDTAG, "select"); + parser(t, value2, arg3, arg4); + return; + case "script": + case "template": + in_head_mode(t, value2, arg3, arg4); + return; + } + break; + case 3: + switch (value2) { + case "optgroup": + if (stack.top instanceof impl.HTMLOptionElement && stack.elements[stack.elements.length - 2] instanceof impl.HTMLOptGroupElement) { + in_select_mode(ENDTAG, "option"); + } + if (stack.top instanceof impl.HTMLOptGroupElement) + stack.pop(); + return; + case "option": + if (stack.top instanceof impl.HTMLOptionElement) + stack.pop(); + return; + case "select": + if (!stack.inSelectScope(value2)) return; + stack.popTag(value2); + resetInsertionMode(); + return; + case "template": + in_head_mode(t, value2, arg3, arg4); + return; + } + break; + } + } + function in_select_in_table_mode(t, value2, arg3, arg4) { + switch (value2) { + case "caption": + case "table": + case "tbody": + case "tfoot": + case "thead": + case "tr": + case "td": + case "th": + switch (t) { + case 2: + in_select_in_table_mode(ENDTAG, "select"); + parser(t, value2, arg3, arg4); + return; + case 3: + if (stack.inTableScope(value2)) { + in_select_in_table_mode(ENDTAG, "select"); + parser(t, value2, arg3, arg4); + } + return; + } + } + in_select_mode(t, value2, arg3, arg4); + } + function in_template_mode(t, value2, arg3, arg4) { + function switchModeAndReprocess(mode) { + parser = mode; + templateInsertionModes[templateInsertionModes.length - 1] = parser; + parser(t, value2, arg3, arg4); + } + switch (t) { + case 1: + // TEXT + case 4: + // COMMENT + case 5: + in_body_mode(t, value2, arg3, arg4); + return; + case -1: + if (!stack.contains("template")) { + stopParsing(); + } else { + stack.popTag("template"); + afe.clearToMarker(); + templateInsertionModes.pop(); + resetInsertionMode(); + parser(t, value2, arg3, arg4); + } + return; + case 2: + switch (value2) { + case "base": + case "basefont": + case "bgsound": + case "link": + case "meta": + case "noframes": + case "script": + case "style": + case "template": + case "title": + in_head_mode(t, value2, arg3, arg4); + return; + case "caption": + case "colgroup": + case "tbody": + case "tfoot": + case "thead": + switchModeAndReprocess(in_table_mode); + return; + case "col": + switchModeAndReprocess(in_column_group_mode); + return; + case "tr": + switchModeAndReprocess(in_table_body_mode); + return; + case "td": + case "th": + switchModeAndReprocess(in_row_mode); + return; + } + switchModeAndReprocess(in_body_mode); + return; + case 3: + switch (value2) { + case "template": + in_head_mode(t, value2, arg3, arg4); + return; + default: + return; + } + } + } + function after_body_mode(t, value2, arg3, arg4) { + switch (t) { + case 1: + if (NONWS.test(value2)) break; + in_body_mode(t, value2); + return; + case 4: + stack.elements[0]._appendChild(doc.createComment(value2)); + return; + case 5: + return; + case -1: + stopParsing(); + return; + case 2: + if (value2 === "html") { + in_body_mode(t, value2, arg3, arg4); + return; + } + break; + // for any other tags + case 3: + if (value2 === "html") { + if (fragment) return; + parser = after_after_body_mode; + return; + } + break; + } + parser = in_body_mode; + parser(t, value2, arg3, arg4); + } + function in_frameset_mode(t, value2, arg3, arg4) { + switch (t) { + case 1: + value2 = value2.replace(ALLNONWS, ""); + if (value2.length > 0) insertText(value2); + return; + case 4: + insertComment(value2); + return; + case 5: + return; + case -1: + stopParsing(); + return; + case 2: + switch (value2) { + case "html": + in_body_mode(t, value2, arg3, arg4); + return; + case "frameset": + insertHTMLElement(value2, arg3); + return; + case "frame": + insertHTMLElement(value2, arg3); + stack.pop(); + return; + case "noframes": + in_head_mode(t, value2, arg3, arg4); + return; + } + break; + case 3: + if (value2 === "frameset") { + if (fragment && stack.top instanceof impl.HTMLHtmlElement) + return; + stack.pop(); + if (!fragment && !(stack.top instanceof impl.HTMLFrameSetElement)) + parser = after_frameset_mode; + return; + } + break; + } + } + function after_frameset_mode(t, value2, arg3, arg4) { + switch (t) { + case 1: + value2 = value2.replace(ALLNONWS, ""); + if (value2.length > 0) insertText(value2); + return; + case 4: + insertComment(value2); + return; + case 5: + return; + case -1: + stopParsing(); + return; + case 2: + switch (value2) { + case "html": + in_body_mode(t, value2, arg3, arg4); + return; + case "noframes": + in_head_mode(t, value2, arg3, arg4); + return; + } + break; + case 3: + if (value2 === "html") { + parser = after_after_frameset_mode; + return; + } + break; + } + } + function after_after_body_mode(t, value2, arg3, arg4) { + switch (t) { + case 1: + if (NONWS.test(value2)) break; + in_body_mode(t, value2, arg3, arg4); + return; + case 4: + doc._appendChild(doc.createComment(value2)); + return; + case 5: + in_body_mode(t, value2, arg3, arg4); + return; + case -1: + stopParsing(); + return; + case 2: + if (value2 === "html") { + in_body_mode(t, value2, arg3, arg4); + return; + } + break; + } + parser = in_body_mode; + parser(t, value2, arg3, arg4); + } + function after_after_frameset_mode(t, value2, arg3, arg4) { + switch (t) { + case 1: + value2 = value2.replace(ALLNONWS, ""); + if (value2.length > 0) + in_body_mode(t, value2, arg3, arg4); + return; + case 4: + doc._appendChild(doc.createComment(value2)); + return; + case 5: + in_body_mode(t, value2, arg3, arg4); + return; + case -1: + stopParsing(); + return; + case 2: + switch (value2) { + case "html": + in_body_mode(t, value2, arg3, arg4); + return; + case "noframes": + in_head_mode(t, value2, arg3, arg4); + return; + } + break; + } + } + function insertForeignToken(t, value2, arg3, arg4) { + function isHTMLFont(attrs) { + for (var i2 = 0, n = attrs.length; i2 < n; i2++) { + switch (attrs[i2][0]) { + case "color": + case "face": + case "size": + return true; + } + } + return false; + } + var current; + switch (t) { + case 1: + if (frameset_ok && NONWSNONNUL.test(value2)) + frameset_ok = false; + if (textIncludesNUL) { + value2 = value2.replace(NULCHARS, "\uFFFD"); + } + insertText(value2); + return; + case 4: + insertComment(value2); + return; + case 5: + return; + case 2: + switch (value2) { + case "font": + if (!isHTMLFont(arg3)) break; + /* falls through */ + case "b": + case "big": + case "blockquote": + case "body": + case "br": + case "center": + case "code": + case "dd": + case "div": + case "dl": + case "dt": + case "em": + case "embed": + case "h1": + case "h2": + case "h3": + case "h4": + case "h5": + case "h6": + case "head": + case "hr": + case "i": + case "img": + case "li": + case "listing": + case "menu": + case "meta": + case "nobr": + case "ol": + case "p": + case "pre": + case "ruby": + case "s": + case "small": + case "span": + case "strong": + case "strike": + case "sub": + case "sup": + case "table": + case "tt": + case "u": + case "ul": + case "var": + if (fragment) { + break; + } + do { + stack.pop(); + current = stack.top; + } while (current.namespaceURI !== NAMESPACE.HTML && !isMathmlTextIntegrationPoint(current) && !isHTMLIntegrationPoint(current)); + insertToken(t, value2, arg3, arg4); + return; + } + current = stack.elements.length === 1 && fragment ? fragmentContext : stack.top; + if (current.namespaceURI === NAMESPACE.MATHML) { + adjustMathMLAttributes(arg3); + } else if (current.namespaceURI === NAMESPACE.SVG) { + value2 = adjustSVGTagName(value2); + adjustSVGAttributes(arg3); + } + adjustForeignAttributes(arg3); + insertForeignElement(value2, arg3, current.namespaceURI); + if (arg4) { + if (value2 === "script" && current.namespaceURI === NAMESPACE.SVG) { + } + stack.pop(); + } + return; + case 3: + current = stack.top; + if (value2 === "script" && current.namespaceURI === NAMESPACE.SVG && current.localName === "script") { + stack.pop(); + } else { + var i = stack.elements.length - 1; + var node2 = stack.elements[i]; + for (; ; ) { + if (node2.localName.toLowerCase() === value2) { + stack.popElement(node2); + break; + } + node2 = stack.elements[--i]; + if (node2.namespaceURI !== NAMESPACE.HTML) + continue; + parser(t, value2, arg3, arg4); + break; + } + } + return; + } + } + htmlparser.testTokenizer = function(input, initialState, lastStartTag, charbychar) { + var tokens = []; + switch (initialState) { + case "PCDATA state": + tokenizer = data_state; + break; + case "RCDATA state": + tokenizer = rcdata_state; + break; + case "RAWTEXT state": + tokenizer = rawtext_state; + break; + case "PLAINTEXT state": + tokenizer = plaintext_state; + break; + } + if (lastStartTag) { + lasttagname = lastStartTag; + } + insertToken = function(t, value2, arg3, arg4) { + flushText(); + switch (t) { + case 1: + if (tokens.length > 0 && tokens[tokens.length - 1][0] === "Character") { + tokens[tokens.length - 1][1] += value2; + } else tokens.push(["Character", value2]); + break; + case 4: + tokens.push(["Comment", value2]); + break; + case 5: + tokens.push([ + "DOCTYPE", + value2, + arg3 === void 0 ? null : arg3, + arg4 === void 0 ? null : arg4, + !force_quirks + ]); + break; + case 2: + var attrs = /* @__PURE__ */ Object.create(null); + for (var i2 = 0; i2 < arg3.length; i2++) { + var a = arg3[i2]; + if (a.length === 1) { + attrs[a[0]] = ""; + } else { + attrs[a[0]] = a[1]; + } + } + var token = ["StartTag", value2, attrs]; + if (arg4) token.push(true); + tokens.push(token); + break; + case 3: + tokens.push(["EndTag", value2]); + break; + case -1: + break; + } + }; + if (!charbychar) { + this.parse(input, true); + } else { + for (var i = 0; i < input.length; i++) { + this.parse(input[i]); + } + this.parse("", true); + } + return tokens; + }; + return htmlparser; + } + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/DOMImplementation.js +var require_DOMImplementation = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/DOMImplementation.js"(exports, module) { + "use strict"; + module.exports = DOMImplementation; + var Document = require_Document(); + var DocumentType = require_DocumentType(); + var HTMLParser = require_HTMLParser(); + var utils = require_utils8(); + var xml = require_xmlnames(); + function DOMImplementation(contextObject) { + this.contextObject = contextObject; + } + var supportedFeatures = { + "xml": { "": true, "1.0": true, "2.0": true }, + // DOM Core + "core": { "": true, "2.0": true }, + // DOM Core + "html": { "": true, "1.0": true, "2.0": true }, + // HTML + "xhtml": { "": true, "1.0": true, "2.0": true } + // HTML + }; + DOMImplementation.prototype = { + hasFeature: function hasFeature(feature, version4) { + var f = supportedFeatures[(feature || "").toLowerCase()]; + return f && f[version4 || ""] || false; + }, + createDocumentType: function createDocumentType(qualifiedName, publicId, systemId) { + if (!xml.isValidQName(qualifiedName)) utils.InvalidCharacterError(); + return new DocumentType(this.contextObject, qualifiedName, publicId, systemId); + }, + createDocument: function createDocument(namespace, qualifiedName, doctype) { + var d = new Document(false, null); + var e; + if (qualifiedName) + e = d.createElementNS(namespace, qualifiedName); + else + e = null; + if (doctype) { + d.appendChild(doctype); + } + if (e) d.appendChild(e); + if (namespace === utils.NAMESPACE.HTML) { + d._contentType = "application/xhtml+xml"; + } else if (namespace === utils.NAMESPACE.SVG) { + d._contentType = "image/svg+xml"; + } else { + d._contentType = "application/xml"; + } + return d; + }, + createHTMLDocument: function createHTMLDocument(titleText) { + var d = new Document(true, null); + d.appendChild(new DocumentType(d, "html")); + var html = d.createElement("html"); + d.appendChild(html); + var head = d.createElement("head"); + html.appendChild(head); + if (titleText !== void 0) { + var title = d.createElement("title"); + head.appendChild(title); + title.appendChild(d.createTextNode(titleText)); + } + html.appendChild(d.createElement("body")); + d.modclock = 1; + return d; + }, + mozSetOutputMutationHandler: function(doc, handler2) { + doc.mutationHandler = handler2; + }, + mozGetInputMutationHandler: function(doc) { + utils.nyi(); + }, + mozHTMLParser: HTMLParser + }; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Location.js +var require_Location = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Location.js"(exports, module) { + "use strict"; + var URL2 = require_URL(); + var URLUtils = require_URLUtils(); + module.exports = Location; + function Location(window2, href) { + this._window = window2; + this._href = href; + } + Location.prototype = Object.create(URLUtils.prototype, { + constructor: { value: Location }, + // Special behavior when href is set + href: { + get: function() { + return this._href; + }, + set: function(v) { + this.assign(v); + } + }, + assign: { value: function(url4) { + var current = new URL2(this._href); + var newurl = current.resolve(url4); + this._href = newurl; + } }, + replace: { value: function(url4) { + this.assign(url4); + } }, + reload: { value: function() { + this.assign(this.href); + } }, + toString: { value: function() { + return this.href; + } } + }); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NavigatorID.js +var require_NavigatorID = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/NavigatorID.js"(exports, module) { + "use strict"; + var NavigatorID = Object.create(null, { + appCodeName: { value: "Mozilla" }, + appName: { value: "Netscape" }, + appVersion: { value: "4.0" }, + platform: { value: "" }, + product: { value: "Gecko" }, + productSub: { value: "20100101" }, + userAgent: { value: "" }, + vendor: { value: "" }, + vendorSub: { value: "" }, + taintEnabled: { value: function() { + return false; + } } + }); + module.exports = NavigatorID; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/WindowTimers.js +var require_WindowTimers = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/WindowTimers.js"(exports, module) { + "use strict"; + var WindowTimers = { + setTimeout, + clearTimeout, + setInterval, + clearInterval + }; + module.exports = WindowTimers; + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/impl.js +var require_impl = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/impl.js"(exports, module) { + "use strict"; + var utils = require_utils8(); + exports = module.exports = { + CSSStyleDeclaration: require_CSSStyleDeclaration(), + CharacterData: require_CharacterData(), + Comment: require_Comment(), + DOMException: require_DOMException(), + DOMImplementation: require_DOMImplementation(), + DOMTokenList: require_DOMTokenList(), + Document: require_Document(), + DocumentFragment: require_DocumentFragment(), + DocumentType: require_DocumentType(), + Element: require_Element(), + HTMLParser: require_HTMLParser(), + NamedNodeMap: require_NamedNodeMap(), + Node: require_Node(), + NodeList: require_NodeList(), + NodeFilter: require_NodeFilter(), + ProcessingInstruction: require_ProcessingInstruction(), + Text: require_Text(), + Window: require_Window() + }; + utils.merge(exports, require_events3()); + utils.merge(exports, require_htmlelts().elements); + utils.merge(exports, require_svg().elements); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Window.js +var require_Window = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/Window.js"(exports, module) { + "use strict"; + var DOMImplementation = require_DOMImplementation(); + var EventTarget2 = require_EventTarget(); + var Location = require_Location(); + var utils = require_utils8(); + module.exports = Window; + function Window(document) { + this.document = document || new DOMImplementation(null).createHTMLDocument(""); + this.document._scripting_enabled = true; + this.document.defaultView = this; + this.location = new Location(this, this.document._address || "about:blank"); + } + Window.prototype = Object.create(EventTarget2.prototype, { + console: { value: console }, + history: { value: { + back: utils.nyi, + forward: utils.nyi, + go: utils.nyi + } }, + navigator: { value: require_NavigatorID() }, + // Self-referential properties + window: { get: function() { + return this; + } }, + self: { get: function() { + return this; + } }, + frames: { get: function() { + return this; + } }, + // Self-referential properties for a top-level window + parent: { get: function() { + return this; + } }, + top: { get: function() { + return this; + } }, + // We don't support any other windows for now + length: { value: 0 }, + // no frames + frameElement: { value: null }, + // not part of a frame + opener: { value: null }, + // not opened by another window + // The onload event handler. + // XXX: need to support a bunch of other event types, too, + // and have them interoperate with document.body. + onload: { + get: function() { + return this._getEventHandler("load"); + }, + set: function(v) { + this._setEventHandler("load", v); + } + }, + // XXX This is a completely broken implementation + getComputedStyle: { value: function getComputedStyle(elt) { + return elt.style; + } } + }); + utils.expose(require_WindowTimers(), Window); + utils.expose(require_impl(), Window); + } +}); + +// node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/index.js +var require_lib3 = __commonJS({ + "node_modules/.pnpm/@mixmark-io+domino@2.2.0/node_modules/@mixmark-io/domino/lib/index.js"(exports) { + "use strict"; + var DOMImplementation = require_DOMImplementation(); + var HTMLParser = require_HTMLParser(); + var Window = require_Window(); + var impl = require_impl(); + exports.createDOMImplementation = function() { + return new DOMImplementation(null); + }; + exports.createDocument = function(html, force) { + if (html || force) { + var parser = new HTMLParser(); + parser.parse(html || "", true); + return parser.document(); + } + return new DOMImplementation(null).createHTMLDocument(""); + }; + exports.createIncrementalHTMLParser = function() { + var parser = new HTMLParser(); + return { + /** Provide an additional chunk of text to be parsed. */ + write: function(s) { + if (s.length > 0) { + parser.parse(s, false, function() { + return true; + }); + } + }, + /** + * Signal that we are done providing input text, optionally + * providing one last chunk as a parameter. + */ + end: function(s) { + parser.parse(s || "", true, function() { + return true; + }); + }, + /** + * Performs a chunk of parsing work, returning at the end of + * the next token as soon as shouldPauseFunc() returns true. + * Returns true iff there is more work to do. + * + * For example: + * ``` + * var incrParser = domino.createIncrementalHTMLParser(); + * incrParser.end('...long html document...'); + * while (true) { + * // Pause every 10ms + * var start = Date.now(); + * var pauseIn10 = function() { return (Date.now() - start) >= 10; }; + * if (!incrParser.process(pauseIn10)) { + * break; + * } + * ...yield to other tasks, do other housekeeping, etc... + * } + * ``` + */ + process: function(shouldPauseFunc) { + return parser.parse("", false, shouldPauseFunc); + }, + /** + * Returns the result of the incremental parse. Valid after + * `this.end()` has been called and `this.process()` has returned + * false. + */ + document: function() { + return parser.document(); + } + }; + }; + exports.createWindow = function(html, address) { + var document = exports.createDocument(html); + if (address !== void 0) { + document._address = address; + } + return new impl.Window(document); + }; + exports.impl = impl; + } +}); + +// node_modules/.pnpm/turndown@7.2.2/node_modules/turndown/lib/turndown.cjs.js +var require_turndown_cjs = __commonJS({ + "node_modules/.pnpm/turndown@7.2.2/node_modules/turndown/lib/turndown.cjs.js"(exports, module) { + "use strict"; + function extend4(destination) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) { + if (source.hasOwnProperty(key)) destination[key] = source[key]; + } + } + return destination; + } + function repeat(character, count) { + return Array(count + 1).join(character); + } + function trimLeadingNewlines(string7) { + return string7.replace(/^\n*/, ""); + } + function trimTrailingNewlines(string7) { + var indexEnd = string7.length; + while (indexEnd > 0 && string7[indexEnd - 1] === "\n") indexEnd--; + return string7.substring(0, indexEnd); + } + function trimNewlines(string7) { + return trimTrailingNewlines(trimLeadingNewlines(string7)); + } + var blockElements = [ + "ADDRESS", + "ARTICLE", + "ASIDE", + "AUDIO", + "BLOCKQUOTE", + "BODY", + "CANVAS", + "CENTER", + "DD", + "DIR", + "DIV", + "DL", + "DT", + "FIELDSET", + "FIGCAPTION", + "FIGURE", + "FOOTER", + "FORM", + "FRAMESET", + "H1", + "H2", + "H3", + "H4", + "H5", + "H6", + "HEADER", + "HGROUP", + "HR", + "HTML", + "ISINDEX", + "LI", + "MAIN", + "MENU", + "NAV", + "NOFRAMES", + "NOSCRIPT", + "OL", + "OUTPUT", + "P", + "PRE", + "SECTION", + "TABLE", + "TBODY", + "TD", + "TFOOT", + "TH", + "THEAD", + "TR", + "UL" + ]; + function isBlock(node2) { + return is(node2, blockElements); + } + var voidElements = [ + "AREA", + "BASE", + "BR", + "COL", + "COMMAND", + "EMBED", + "HR", + "IMG", + "INPUT", + "KEYGEN", + "LINK", + "META", + "PARAM", + "SOURCE", + "TRACK", + "WBR" + ]; + function isVoid(node2) { + return is(node2, voidElements); + } + function hasVoid(node2) { + return has(node2, voidElements); + } + var meaningfulWhenBlankElements = [ + "A", + "TABLE", + "THEAD", + "TBODY", + "TFOOT", + "TH", + "TD", + "IFRAME", + "SCRIPT", + "AUDIO", + "VIDEO" + ]; + function isMeaningfulWhenBlank(node2) { + return is(node2, meaningfulWhenBlankElements); + } + function hasMeaningfulWhenBlank(node2) { + return has(node2, meaningfulWhenBlankElements); + } + function is(node2, tagNames) { + return tagNames.indexOf(node2.nodeName) >= 0; + } + function has(node2, tagNames) { + return node2.getElementsByTagName && tagNames.some(function(tagName) { + return node2.getElementsByTagName(tagName).length; + }); + } + var rules = {}; + rules.paragraph = { + filter: "p", + replacement: function(content) { + return "\n\n" + content + "\n\n"; + } + }; + rules.lineBreak = { + filter: "br", + replacement: function(content, node2, options) { + return options.br + "\n"; + } + }; + rules.heading = { + filter: ["h1", "h2", "h3", "h4", "h5", "h6"], + replacement: function(content, node2, options) { + var hLevel = Number(node2.nodeName.charAt(1)); + if (options.headingStyle === "setext" && hLevel < 3) { + var underline = repeat(hLevel === 1 ? "=" : "-", content.length); + return "\n\n" + content + "\n" + underline + "\n\n"; + } else { + return "\n\n" + repeat("#", hLevel) + " " + content + "\n\n"; + } + } + }; + rules.blockquote = { + filter: "blockquote", + replacement: function(content) { + content = trimNewlines(content).replace(/^/gm, "> "); + return "\n\n" + content + "\n\n"; + } + }; + rules.list = { + filter: ["ul", "ol"], + replacement: function(content, node2) { + var parent = node2.parentNode; + if (parent.nodeName === "LI" && parent.lastElementChild === node2) { + return "\n" + content; + } else { + return "\n\n" + content + "\n\n"; + } + } + }; + rules.listItem = { + filter: "li", + replacement: function(content, node2, options) { + var prefix = options.bulletListMarker + " "; + var parent = node2.parentNode; + if (parent.nodeName === "OL") { + var start = parent.getAttribute("start"); + var index = Array.prototype.indexOf.call(parent.children, node2); + prefix = (start ? Number(start) + index : index + 1) + ". "; + } + var isParagraph = /\n$/.test(content); + content = trimNewlines(content) + (isParagraph ? "\n" : ""); + content = content.replace(/\n/gm, "\n" + " ".repeat(prefix.length)); + return prefix + content + (node2.nextSibling ? "\n" : ""); + } + }; + rules.indentedCodeBlock = { + filter: function(node2, options) { + return options.codeBlockStyle === "indented" && node2.nodeName === "PRE" && node2.firstChild && node2.firstChild.nodeName === "CODE"; + }, + replacement: function(content, node2, options) { + return "\n\n " + node2.firstChild.textContent.replace(/\n/g, "\n ") + "\n\n"; + } + }; + rules.fencedCodeBlock = { + filter: function(node2, options) { + return options.codeBlockStyle === "fenced" && node2.nodeName === "PRE" && node2.firstChild && node2.firstChild.nodeName === "CODE"; + }, + replacement: function(content, node2, options) { + var className = node2.firstChild.getAttribute("class") || ""; + var language = (className.match(/language-(\S+)/) || [null, ""])[1]; + var code = node2.firstChild.textContent; + var fenceChar = options.fence.charAt(0); + var fenceSize = 3; + var fenceInCodeRegex = new RegExp("^" + fenceChar + "{3,}", "gm"); + var match2; + while (match2 = fenceInCodeRegex.exec(code)) { + if (match2[0].length >= fenceSize) { + fenceSize = match2[0].length + 1; + } + } + var fence = repeat(fenceChar, fenceSize); + return "\n\n" + fence + language + "\n" + code.replace(/\n$/, "") + "\n" + fence + "\n\n"; + } + }; + rules.horizontalRule = { + filter: "hr", + replacement: function(content, node2, options) { + return "\n\n" + options.hr + "\n\n"; + } + }; + rules.inlineLink = { + filter: function(node2, options) { + return options.linkStyle === "inlined" && node2.nodeName === "A" && node2.getAttribute("href"); + }, + replacement: function(content, node2) { + var href = node2.getAttribute("href"); + if (href) href = href.replace(/([()])/g, "\\$1"); + var title = cleanAttribute(node2.getAttribute("title")); + if (title) title = ' "' + title.replace(/"/g, '\\"') + '"'; + return "[" + content + "](" + href + title + ")"; + } + }; + rules.referenceLink = { + filter: function(node2, options) { + return options.linkStyle === "referenced" && node2.nodeName === "A" && node2.getAttribute("href"); + }, + replacement: function(content, node2, options) { + var href = node2.getAttribute("href"); + var title = cleanAttribute(node2.getAttribute("title")); + if (title) title = ' "' + title + '"'; + var replacement; + var reference2; + switch (options.linkReferenceStyle) { + case "collapsed": + replacement = "[" + content + "][]"; + reference2 = "[" + content + "]: " + href + title; + break; + case "shortcut": + replacement = "[" + content + "]"; + reference2 = "[" + content + "]: " + href + title; + break; + default: + var id = this.references.length + 1; + replacement = "[" + content + "][" + id + "]"; + reference2 = "[" + id + "]: " + href + title; + } + this.references.push(reference2); + return replacement; + }, + references: [], + append: function(options) { + var references = ""; + if (this.references.length) { + references = "\n\n" + this.references.join("\n") + "\n\n"; + this.references = []; + } + return references; + } + }; + rules.emphasis = { + filter: ["em", "i"], + replacement: function(content, node2, options) { + if (!content.trim()) return ""; + return options.emDelimiter + content + options.emDelimiter; + } + }; + rules.strong = { + filter: ["strong", "b"], + replacement: function(content, node2, options) { + if (!content.trim()) return ""; + return options.strongDelimiter + content + options.strongDelimiter; + } + }; + rules.code = { + filter: function(node2) { + var hasSiblings = node2.previousSibling || node2.nextSibling; + var isCodeBlock = node2.parentNode.nodeName === "PRE" && !hasSiblings; + return node2.nodeName === "CODE" && !isCodeBlock; + }, + replacement: function(content) { + if (!content) return ""; + content = content.replace(/\r?\n|\r/g, " "); + var extraSpace = /^`|^ .*?[^ ].* $|`$/.test(content) ? " " : ""; + var delimiter = "`"; + var matches = content.match(/`+/gm) || []; + while (matches.indexOf(delimiter) !== -1) delimiter = delimiter + "`"; + return delimiter + extraSpace + content + extraSpace + delimiter; + } + }; + rules.image = { + filter: "img", + replacement: function(content, node2) { + var alt = cleanAttribute(node2.getAttribute("alt")); + var src = node2.getAttribute("src") || ""; + var title = cleanAttribute(node2.getAttribute("title")); + var titlePart = title ? ' "' + title + '"' : ""; + return src ? "![" + alt + "](" + src + titlePart + ")" : ""; + } + }; + function cleanAttribute(attribute) { + return attribute ? attribute.replace(/(\n+\s*)+/g, "\n") : ""; + } + function Rules(options) { + this.options = options; + this._keep = []; + this._remove = []; + this.blankRule = { + replacement: options.blankReplacement + }; + this.keepReplacement = options.keepReplacement; + this.defaultRule = { + replacement: options.defaultReplacement + }; + this.array = []; + for (var key in options.rules) this.array.push(options.rules[key]); + } + Rules.prototype = { + add: function(key, rule) { + this.array.unshift(rule); + }, + keep: function(filter) { + this._keep.unshift({ + filter, + replacement: this.keepReplacement + }); + }, + remove: function(filter) { + this._remove.unshift({ + filter, + replacement: function() { + return ""; + } + }); + }, + forNode: function(node2) { + if (node2.isBlank) return this.blankRule; + var rule; + if (rule = findRule(this.array, node2, this.options)) return rule; + if (rule = findRule(this._keep, node2, this.options)) return rule; + if (rule = findRule(this._remove, node2, this.options)) return rule; + return this.defaultRule; + }, + forEach: function(fn2) { + for (var i = 0; i < this.array.length; i++) fn2(this.array[i], i); + } + }; + function findRule(rules2, node2, options) { + for (var i = 0; i < rules2.length; i++) { + var rule = rules2[i]; + if (filterValue(rule, node2, options)) return rule; + } + return void 0; + } + function filterValue(rule, node2, options) { + var filter = rule.filter; + if (typeof filter === "string") { + if (filter === node2.nodeName.toLowerCase()) return true; + } else if (Array.isArray(filter)) { + if (filter.indexOf(node2.nodeName.toLowerCase()) > -1) return true; + } else if (typeof filter === "function") { + if (filter.call(rule, node2, options)) return true; + } else { + throw new TypeError("`filter` needs to be a string, array, or function"); + } + } + function collapseWhitespace(options) { + var element = options.element; + var isBlock2 = options.isBlock; + var isVoid2 = options.isVoid; + var isPre = options.isPre || function(node3) { + return node3.nodeName === "PRE"; + }; + if (!element.firstChild || isPre(element)) return; + var prevText = null; + var keepLeadingWs = false; + var prev = null; + var node2 = next2(prev, element, isPre); + while (node2 !== element) { + if (node2.nodeType === 3 || node2.nodeType === 4) { + var text = node2.data.replace(/[ \r\n\t]+/g, " "); + if ((!prevText || / $/.test(prevText.data)) && !keepLeadingWs && text[0] === " ") { + text = text.substr(1); + } + if (!text) { + node2 = remove(node2); + continue; + } + node2.data = text; + prevText = node2; + } else if (node2.nodeType === 1) { + if (isBlock2(node2) || node2.nodeName === "BR") { + if (prevText) { + prevText.data = prevText.data.replace(/ $/, ""); + } + prevText = null; + keepLeadingWs = false; + } else if (isVoid2(node2) || isPre(node2)) { + prevText = null; + keepLeadingWs = true; + } else if (prevText) { + keepLeadingWs = false; + } + } else { + node2 = remove(node2); + continue; + } + var nextNode = next2(prev, node2, isPre); + prev = node2; + node2 = nextNode; + } + if (prevText) { + prevText.data = prevText.data.replace(/ $/, ""); + if (!prevText.data) { + remove(prevText); + } + } + } + function remove(node2) { + var next3 = node2.nextSibling || node2.parentNode; + node2.parentNode.removeChild(node2); + return next3; + } + function next2(prev, current, isPre) { + if (prev && prev.parentNode === current || isPre(current)) { + return current.nextSibling || current.parentNode; + } + return current.firstChild || current.nextSibling || current.parentNode; + } + var root2 = typeof window !== "undefined" ? window : {}; + function canParseHTMLNatively() { + var Parser = root2.DOMParser; + var canParse = false; + try { + if (new Parser().parseFromString("", "text/html")) { + canParse = true; + } + } catch (e) { + } + return canParse; + } + function createHTMLParser() { + var Parser = function() { + }; + { + var domino = require_lib3(); + Parser.prototype.parseFromString = function(string7) { + return domino.createDocument(string7); + }; + } + return Parser; + } + var HTMLParser = canParseHTMLNatively() ? root2.DOMParser : createHTMLParser(); + function RootNode(input, options) { + var root3; + if (typeof input === "string") { + var doc = htmlParser().parseFromString( + // DOM parsers arrange elements in the and . + // Wrapping in a custom element ensures elements are reliably arranged in + // a single element. + '' + input + "", + "text/html" + ); + root3 = doc.getElementById("turndown-root"); + } else { + root3 = input.cloneNode(true); + } + collapseWhitespace({ + element: root3, + isBlock, + isVoid, + isPre: options.preformattedCode ? isPreOrCode : null + }); + return root3; + } + var _htmlParser; + function htmlParser() { + _htmlParser = _htmlParser || new HTMLParser(); + return _htmlParser; + } + function isPreOrCode(node2) { + return node2.nodeName === "PRE" || node2.nodeName === "CODE"; + } + function Node(node2, options) { + node2.isBlock = isBlock(node2); + node2.isCode = node2.nodeName === "CODE" || node2.parentNode.isCode; + node2.isBlank = isBlank2(node2); + node2.flankingWhitespace = flankingWhitespace(node2, options); + return node2; + } + function isBlank2(node2) { + return !isVoid(node2) && !isMeaningfulWhenBlank(node2) && /^\s*$/i.test(node2.textContent) && !hasVoid(node2) && !hasMeaningfulWhenBlank(node2); + } + function flankingWhitespace(node2, options) { + if (node2.isBlock || options.preformattedCode && node2.isCode) { + return { leading: "", trailing: "" }; + } + var edges = edgeWhitespace(node2.textContent); + if (edges.leadingAscii && isFlankedByWhitespace("left", node2, options)) { + edges.leading = edges.leadingNonAscii; + } + if (edges.trailingAscii && isFlankedByWhitespace("right", node2, options)) { + edges.trailing = edges.trailingNonAscii; + } + return { leading: edges.leading, trailing: edges.trailing }; + } + function edgeWhitespace(string7) { + var m = string7.match(/^(([ \t\r\n]*)(\s*))(?:(?=\S)[\s\S]*\S)?((\s*?)([ \t\r\n]*))$/); + return { + leading: m[1], + // whole string for whitespace-only strings + leadingAscii: m[2], + leadingNonAscii: m[3], + trailing: m[4], + // empty for whitespace-only strings + trailingNonAscii: m[5], + trailingAscii: m[6] + }; + } + function isFlankedByWhitespace(side, node2, options) { + var sibling; + var regExp; + var isFlanked; + if (side === "left") { + sibling = node2.previousSibling; + regExp = / $/; + } else { + sibling = node2.nextSibling; + regExp = /^ /; + } + if (sibling) { + if (sibling.nodeType === 3) { + isFlanked = regExp.test(sibling.nodeValue); + } else if (options.preformattedCode && sibling.nodeName === "CODE") { + isFlanked = false; + } else if (sibling.nodeType === 1 && !isBlock(sibling)) { + isFlanked = regExp.test(sibling.textContent); + } + } + return isFlanked; + } + var reduce = Array.prototype.reduce; + var escapes = [ + [/\\/g, "\\\\"], + [/\*/g, "\\*"], + [/^-/g, "\\-"], + [/^\+ /g, "\\+ "], + [/^(=+)/g, "\\$1"], + [/^(#{1,6}) /g, "\\$1 "], + [/`/g, "\\`"], + [/^~~~/g, "\\~~~"], + [/\[/g, "\\["], + [/\]/g, "\\]"], + [/^>/g, "\\>"], + [/_/g, "\\_"], + [/^(\d+)\. /g, "$1\\. "] + ]; + function TurndownService2(options) { + if (!(this instanceof TurndownService2)) return new TurndownService2(options); + var defaults = { + rules, + headingStyle: "setext", + hr: "* * *", + bulletListMarker: "*", + codeBlockStyle: "indented", + fence: "```", + emDelimiter: "_", + strongDelimiter: "**", + linkStyle: "inlined", + linkReferenceStyle: "full", + br: " ", + preformattedCode: false, + blankReplacement: function(content, node2) { + return node2.isBlock ? "\n\n" : ""; + }, + keepReplacement: function(content, node2) { + return node2.isBlock ? "\n\n" + node2.outerHTML + "\n\n" : node2.outerHTML; + }, + defaultReplacement: function(content, node2) { + return node2.isBlock ? "\n\n" + content + "\n\n" : content; + } + }; + this.options = extend4({}, defaults, options); + this.rules = new Rules(this.options); + } + TurndownService2.prototype = { + /** + * The entry point for converting a string or DOM node to Markdown + * @public + * @param {String|HTMLElement} input The string or DOM node to convert + * @returns A Markdown representation of the input + * @type String + */ + turndown: function(input) { + if (!canConvert(input)) { + throw new TypeError( + input + " is not a string, or an element/document/fragment node." + ); + } + if (input === "") return ""; + var output = process5.call(this, new RootNode(input, this.options)); + return postProcess.call(this, output); + }, + /** + * Add one or more plugins + * @public + * @param {Function|Array} plugin The plugin or array of plugins to add + * @returns The Turndown instance for chaining + * @type Object + */ + use: function(plugin) { + if (Array.isArray(plugin)) { + for (var i = 0; i < plugin.length; i++) this.use(plugin[i]); + } else if (typeof plugin === "function") { + plugin(this); + } else { + throw new TypeError("plugin must be a Function or an Array of Functions"); + } + return this; + }, + /** + * Adds a rule + * @public + * @param {String} key The unique key of the rule + * @param {Object} rule The rule + * @returns The Turndown instance for chaining + * @type Object + */ + addRule: function(key, rule) { + this.rules.add(key, rule); + return this; + }, + /** + * Keep a node (as HTML) that matches the filter + * @public + * @param {String|Array|Function} filter The unique key of the rule + * @returns The Turndown instance for chaining + * @type Object + */ + keep: function(filter) { + this.rules.keep(filter); + return this; + }, + /** + * Remove a node that matches the filter + * @public + * @param {String|Array|Function} filter The unique key of the rule + * @returns The Turndown instance for chaining + * @type Object + */ + remove: function(filter) { + this.rules.remove(filter); + return this; + }, + /** + * Escapes Markdown syntax + * @public + * @param {String} string The string to escape + * @returns A string with Markdown syntax escaped + * @type String + */ + escape: function(string7) { + return escapes.reduce(function(accumulator, escape2) { + return accumulator.replace(escape2[0], escape2[1]); + }, string7); + } + }; + function process5(parentNode) { + var self2 = this; + return reduce.call(parentNode.childNodes, function(output, node2) { + node2 = new Node(node2, self2.options); + var replacement = ""; + if (node2.nodeType === 3) { + replacement = node2.isCode ? node2.nodeValue : self2.escape(node2.nodeValue); + } else if (node2.nodeType === 1) { + replacement = replacementForNode.call(self2, node2); + } + return join14(output, replacement); + }, ""); + } + function postProcess(output) { + var self2 = this; + this.rules.forEach(function(rule) { + if (typeof rule.append === "function") { + output = join14(output, rule.append(self2.options)); + } + }); + return output.replace(/^[\t\r\n]+/, "").replace(/[\t\r\n\s]+$/, ""); + } + function replacementForNode(node2) { + var rule = this.rules.forNode(node2); + var content = process5.call(this, node2); + var whitespace = node2.flankingWhitespace; + if (whitespace.leading || whitespace.trailing) content = content.trim(); + return whitespace.leading + rule.replacement(content, node2, this.options) + whitespace.trailing; + } + function join14(output, replacement) { + var s1 = trimTrailingNewlines(output); + var s2 = trimLeadingNewlines(replacement); + var nls = Math.max(output.length - s1.length, replacement.length - s2.length); + var separator2 = "\n\n".substring(0, nls); + return s1 + separator2 + s2; + } + function canConvert(input) { + return input != null && (typeof input === "string" || input.nodeType && (input.nodeType === 1 || input.nodeType === 9 || input.nodeType === 11)); + } + module.exports = TurndownService2; + } +}); + // node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/constants.js var require_constants11 = __commonJS({ "node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/constants.js"(exports, module) { @@ -138387,11 +155771,14 @@ var package_default = { fastmcp: "^3.26.8", "package-manager-detector": "^1.6.0", semver: "^7.7.3", - table: "^6.9.0" + table: "^6.9.0", + turndown: "^7.2.0" }, devDependencies: { "@types/node": "^24.7.2", + "@types/turndown": "^5.0.5", "@types/semver": "^7.7.1", + "@types/turndown": "^5.0.5", arg: "^5.0.2", esbuild: "^0.25.9", husky: "^9.0.0", @@ -140184,6 +157571,98 @@ function validateApiKey(params) { } } +// utils/body.ts +var import_turndown = __toESM(require_turndown_cjs(), 1); +var turndown = new import_turndown.default(); +function hasImages(body) { + if (!body) return false; + return body.includes(" *) +@mixmark-io/domino/lib/style_parser.js: + (** + * @license + * Copyright Google LLC All Rights Reserved. + * + * Use of this source code is governed by an MIT-style license that can be + * found in the LICENSE file at https://angular.io/license + *) + mcp-proxy/dist/stdio-DBuYn6eo.mjs: (*! * bytes diff --git a/main.ts b/main.ts index f83f188..2bc300a 100644 --- a/main.ts +++ b/main.ts @@ -3,6 +3,7 @@ import { initToolState, startMcpHttpServer } from "./mcp/server.ts"; import { computeModes } from "./modes.ts"; import { resolveAgent } from "./utils/agent.ts"; import { validateApiKey } from "./utils/apiKeys.ts"; +import { resolveBody } from "./utils/body.ts"; import { log, writeSummary } from "./utils/cli.ts"; import { reportErrorToComment } from "./utils/errorReport.ts"; import { createOctokit } from "./utils/github.ts"; @@ -50,6 +51,18 @@ export async function main(): Promise { process.chdir(payload.cwd); } + // resolve body - fetches body_html and converts to markdown if images present + // this ensures agents receive markdown with working signed image URLs + const originalBody = payload.event.body; + const resolvedBody = await resolveBody({ event: payload.event, octokit, repo }); + if (resolvedBody !== originalBody) { + payload.event.body = resolvedBody; + // also update prompt if original body was included there + if (originalBody && payload.prompt.includes(originalBody)) { + payload.prompt = payload.prompt.replace(originalBody, resolvedBody ?? ""); + } + } + const tmpdir = createTempDirectory(); const agent = resolveAgent({ payload, repoSettings: repo.repoSettings }); diff --git a/package.json b/package.json index 2c89bfd..53ff2d0 100644 --- a/package.json +++ b/package.json @@ -43,11 +43,14 @@ "fastmcp": "^3.26.8", "package-manager-detector": "^1.6.0", "semver": "^7.7.3", - "table": "^6.9.0" + "table": "^6.9.0", + "turndown": "^7.2.0" }, "devDependencies": { "@types/node": "^24.7.2", + "@types/turndown": "^5.0.5", "@types/semver": "^7.7.1", + "@types/turndown": "^5.0.5", "arg": "^5.0.2", "esbuild": "^0.25.9", "husky": "^9.0.0", diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index e45ddb0..ca471b7 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -65,6 +65,9 @@ importers: table: specifier: ^6.9.0 version: 6.9.0 + turndown: + specifier: ^7.2.0 + version: 7.2.2 devDependencies: '@types/node': specifier: ^24.7.2 @@ -72,6 +75,9 @@ importers: '@types/semver': specifier: ^7.7.1 version: 7.7.1 + '@types/turndown': + specifier: ^5.0.5 + version: 5.0.6 arg: specifier: ^5.0.2 version: 5.0.2 @@ -534,6 +540,9 @@ packages: '@jridgewell/sourcemap-codec@1.5.5': resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==} + '@mixmark-io/domino@2.2.0': + resolution: {integrity: sha512-Y28PR25bHXUg88kCV7nivXrP2Nj2RueZ3/l/jdx6J9f8J4nsEGcgX0Qe6lt7Pa+J79+kPiJU3LguR6O/6zrLOw==} + '@modelcontextprotocol/sdk@1.25.2': resolution: {integrity: sha512-LZFeo4F9M5qOhC/Uc1aQSrBHxMrvxett+9KLHt7OhcExtoiRN9DKgbZffMP/nxjutWDQpfMDfP3nkHI4X9ijww==} engines: {node: '>=18'} @@ -826,6 +835,9 @@ packages: '@types/semver@7.7.1': resolution: {integrity: sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA==} + '@types/turndown@5.0.6': + resolution: {integrity: sha512-ru00MoyeeouE5BX4gRL+6m/BsDfbRayOskWqUvh7CLGW+UXxHQItqALa38kKnOiZPqJrtzJUgAC2+F0rL1S4Pg==} + '@vitest/expect@4.0.17': resolution: {integrity: sha512-mEoqP3RqhKlbmUmntNDDCJeTDavDR+fVYkSOw8qRwJFaW/0/5zA9zFeTrHqNtcmwh6j26yMmwx2PqUDPzt5ZAQ==} @@ -1500,6 +1512,9 @@ packages: resolution: {integrity: sha512-1h/Lnq9yajKY2PEbBadPXj3VxsDDu844OnaAo52UVmIzIvwwtBPIuNvkjuzBlTWpfJyUbG3ez0KSBibQkj4ojg==} engines: {node: '>=0.6.11 <=0.7.0 || >=0.7.3'} + turndown@7.2.2: + resolution: {integrity: sha512-1F7db8BiExOKxjSMU2b7if62D/XOyQyZbPKq/nUwopfgnHlqXHqQ0lvfUTeUIr1lZJzOPFn43dODyMSIfvWRKQ==} + type-is@2.0.1: resolution: {integrity: sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==} engines: {node: '>= 0.6'} @@ -1959,6 +1974,8 @@ snapshots: '@jridgewell/sourcemap-codec@1.5.5': {} + '@mixmark-io/domino@2.2.0': {} + '@modelcontextprotocol/sdk@1.25.2(hono@4.11.3)(zod@4.3.5)': dependencies: '@hono/node-server': 1.19.7(hono@4.11.3) @@ -2226,6 +2243,8 @@ snapshots: '@types/semver@7.7.1': {} + '@types/turndown@5.0.6': {} + '@vitest/expect@4.0.17': dependencies: '@standard-schema/spec': 1.0.0 @@ -2980,6 +2999,10 @@ snapshots: tunnel@0.0.6: {} + turndown@7.2.2: + dependencies: + '@mixmark-io/domino': 2.2.0 + type-is@2.0.1: dependencies: content-type: 1.0.5 diff --git a/utils/body.ts b/utils/body.ts new file mode 100644 index 0000000..1442bc0 --- /dev/null +++ b/utils/body.ts @@ -0,0 +1,140 @@ +import TurndownService from "turndown"; +import type { PayloadEvent } from "../external.ts"; +import type { OctokitWithPlugins } from "./github.ts"; +import type { RepoData } from "./repoData.ts"; + +const turndown = new TurndownService(); + +function hasImages(body: string | null | undefined): boolean { + if (!body) return false; + return body.includes(" { + const body = ctx.event.body; + + // pass through if no images - no API call needed + if (!hasImages(body)) return body ?? null; + + const bodyHtml = await fetchBodyHtml(ctx); + if (!bodyHtml) return body ?? null; + + return turndown.turndown(bodyHtml); +} + +async function fetchBodyHtml(ctx: ResolveBodyContext): Promise { + const event = ctx.event; + const headers = { accept: "application/vnd.github.full+json" }; + const owner = ctx.repo.owner; + const repo = ctx.repo.name; + + switch (event.trigger) { + case "issue_comment_created": + if (!event.comment_id) return; + return ( + await ctx.octokit.rest.issues.getComment({ + owner, + repo, + comment_id: event.comment_id, + headers, + }) + ).data.body_html; + + case "issues_opened": + case "issues_assigned": + case "issues_labeled": + if (!event.issue_number) return; + return ( + await ctx.octokit.rest.issues.get({ + owner, + repo, + issue_number: event.issue_number, + headers, + }) + ).data.body_html; + + case "pull_request_opened": + case "pull_request_ready_for_review": + case "pull_request_review_requested": + // PRs are also issues - use issues.get which returns body_html + if (!event.issue_number) return; + return ( + await ctx.octokit.rest.issues.get({ + owner, + repo, + issue_number: event.issue_number, + headers, + }) + ).data.body_html; + + case "pull_request_review_submitted": + if (!event.issue_number || !event.review_id) return; + return ( + await ctx.octokit.rest.pulls.getReview({ + owner, + repo, + pull_number: event.issue_number, + review_id: event.review_id, + headers, + }) + ).data.body_html; + + case "pull_request_review_comment_created": + if (!event.comment_id) return; + return ( + await ctx.octokit.rest.pulls.getReviewComment({ + owner, + repo, + comment_id: event.comment_id, + headers, + }) + ).data.body_html; + + case "check_suite_completed": + // body is the PR body + if (!event.issue_number) return; + return ( + await ctx.octokit.rest.issues.get({ + owner, + repo, + issue_number: event.issue_number, + headers, + }) + ).data.body_html; + + case "implement_plan": + // body is the plan content from an issue comment + if (!event.plan_comment_id) return; + return ( + await ctx.octokit.rest.issues.getComment({ + owner, + repo, + comment_id: event.plan_comment_id, + headers, + }) + ).data.body_html; + + // triggers without a body field that needs resolution + case "workflow_dispatch": + case "fix_review": + case "unknown": + return undefined; + + default: + // exhaustiveness check - TypeScript will error if a trigger is missing + event satisfies never; + return undefined; + } +}