From e0d0f2e9a0a8f07385cac5e403bda06bb87b303f Mon Sep 17 00:00:00 2001 From: Green! <81369743+GreenyDEV@users.noreply.github.com> Date: Tue, 17 May 2022 13:48:43 -0400 Subject: [PATCH] v6.7.7 --- static/form.js | 157 + static/images/fav.png | Bin 0 -> 14676 bytes static/index.html | 63 + static/script.js | 0 static/style/main.css | 122 + static/style/master.css | 20 + static/style/options.css | 63 + static/sw.js | 5 + static/uv/uv.bundle.js | 39304 +++++++++++++++++++++++++++++++++++++ static/uv/uv.config.js | 10 + static/uv/uv.handler.js | 1129 ++ static/uv/uv.sw.js | 789 + 12 files changed, 41662 insertions(+) create mode 100644 static/form.js create mode 100644 static/images/fav.png create mode 100644 static/index.html create mode 100644 static/script.js create mode 100644 static/style/main.css create mode 100644 static/style/master.css create mode 100644 static/style/options.css create mode 100644 static/sw.js create mode 100644 static/uv/uv.bundle.js create mode 100644 static/uv/uv.config.js create mode 100644 static/uv/uv.handler.js create mode 100644 static/uv/uv.sw.js diff --git a/static/form.js b/static/form.js new file mode 100644 index 0000000..544a149 --- /dev/null +++ b/static/form.js @@ -0,0 +1,157 @@ +var option = localStorage.getItem('nogg'); +var nogg = document.getElementById('nogg'); + +function toggleNoGG() { + console.log(option); + if (option === 'on') { + nogg.style.color = ''; + option = 'off'; + localStorage.setItem('nogg', 'off'); + } else { + nogg.style.color = 'green'; + option = 'on'; + localStorage.setItem('nogg', 'on'); + } +} + +window.addEventListener('load', () => { + if (localStorage.getItem('nogg') === 'on') + nogg.style.color = 'green'; + + function isUrl(val = '') { + if (/^http(s?):\/\//.test(val) || val.includes('.') && val.substr(0, 1) !== ' ') return true; + return false; + }; + + // NOGG + const useNoGG = false; + const form = document.querySelector('form'); + form.addEventListener('submit', event => { + event.preventDefault(); + + if (typeof navigator.serviceWorker === 'undefined') + alert('Your browser does not support service workers or you are in private browsing!'); + + navigator.serviceWorker.register('./sw.js', { + scope: __uv$config.prefix + }).then(() => { + const value = event.target.firstElementChild.value; + + let url = value.trim(); + if (!isUrl(url)) + url = 'https://search.brave.com/search?q=' + url; + else + if (!(url.startsWith('https://') || url.startsWith('http://'))) url = 'http://' + url; + const redirectTo = __uv$config.prefix + __uv$config.encodeUrl(url); + const option = localStorage.getItem('nogg'); + if (option === 'on') { + + const nogg = window.open("about:blank", '_blank', "popup"); + + setTimeout(() => { + nogg.document.write(` + + + + Google Classroom + + + + + + + + `); + }, 500); + } else location.href = redirectTo; + }); + }); +}); + +function hide() { + var x = document.getElementById("banner_bg_main"); + if (x.style.display === "none") { + x.style.display = "block"; + } else { + x.style.display = "none"; + } +} \ No newline at end of file diff --git a/static/images/fav.png b/static/images/fav.png new file mode 100644 index 0000000000000000000000000000000000000000..df4c0c8a76a747ffc9e3c7e33799bb3a3cd7f0be GIT binary patch literal 14676 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 WX!Zz=dkrE00000 + + + Nebula + + + + + + + + + + + + + + + + + + + + +
+

nebula.

+
+ +
+
+ + diff --git a/static/script.js b/static/script.js new file mode 100644 index 0000000..e69de29 diff --git a/static/style/main.css b/static/style/main.css new file mode 100644 index 0000000..90eb38f --- /dev/null +++ b/static/style/main.css @@ -0,0 +1,122 @@ +a { + color: white; + text-decoration: none !important; +} +a:hover { + color: grey; + transition: 0.5s; + cursor: pointer; +} + +#navbar ul { + font-family: 'Helvetica'; + + background-color: rgb(90, 24, 154); + color: white; + + list-style-type: none;; + + position: fixed; + left: 50%; + transform: translateX(-50%); +} + +#navbar ul li { + float: left; + padding-top: 1em; + padding-bottom: 1em; + padding-right: 1em; + padding-left: 1em; + + padding: 1rem; +} + +#navbar ul p { + font-weight: bold; +} + +#navbar ul li ul { + visibility: hidden; + opacity: 0; + transition: all 0.5s ease; + margin-top: 1rem; + left: 0; + display: none; +} + +#navbar ul li ul { + visibility: hidden; + opacity: 0; + transition: all 0.5s ease; + margin-top: 1rem; + left: 0; + display: none; +} + +#navbar ul li:hover > ul, +ul li ul:hover { + visibility: visible; + opacity: 1; + display: block; +} + +#navbar ul li ul li { + clear: both; + width: 100%; +} + +#content { + display: flex; + justify-content: center; + align-items: center; + + height: 100%; + + color: white; + + flex-direction: column; + + font-family: 'Roboto'; +} + +#content h1 { + padding-bottom: .5em; +} + +#content img { + padding-left: .5em; + filter: brightness(0) invert(1); +} + +#content input { + font-size: 20px; + text-align: center; + font-family: 'Roboto'; + + border-style: none; + border-width: 0; + border-radius: 10px; + + background-color: black; + color: white; + + outline: none !important; + + width: 300px; + height: 50px; +} + +canvas { + display: block; + vertical-align: bottom; + z-index: -1 !important; +} + +.options { + display: none; +} + + +.options a:hover {background-color: #ddd;} + +.options:hover .options {display: block;} diff --git a/static/style/master.css b/static/style/master.css new file mode 100644 index 0000000..a562dde --- /dev/null +++ b/static/style/master.css @@ -0,0 +1,20 @@ +@import url('https://fonts.googleapis.com/css2?family=Dongle&family=Roboto:wght@100&display=swap'); + +*, +*::before, +*::after { + padding: 0; + margin: 0; + box-sizing: border-box; +} + +html, body { + margin: 0; + padding: 0; + height: 100%; +} + +body { + background-color: rgb(60, 9, 108); + color: white; +} \ No newline at end of file diff --git a/static/style/options.css b/static/style/options.css new file mode 100644 index 0000000..e3229bd --- /dev/null +++ b/static/style/options.css @@ -0,0 +1,63 @@ +#back-button { + float: left; + + padding: .5em; + + font-weight: bold; + + font-size: 1.5em; +} + +a { + color: white; +} + +#content { + text-align: center; +} + +#content input { + display:inline-block; +} + +#content p { + display: inline-block; + + font-family: 'Roboto'; + font-size: 3em; +} + +input[type="checkbox"] { + -webkit-appearance: none; + -moz-appearance: none; + appearance: none; + -webkit-tap-highlight-color: transparent; + cursor: pointer; } + input[type="checkbox"]:focus { + outline: 0; } + +.toggle { + height: 32px; + width: 52px; + border-radius: 16px; + display: inline-block; + position: relative; + margin: 0; + border: 2px solid #474755; + background: linear-gradient(180deg, #2D2F39 0%, #1F2027 100%); + transition: all .2s ease; } + .toggle:after { + content: ''; + position: absolute; + top: 2px; + left: 2px; + width: 24px; + height: 24px; + border-radius: 50%; + background: white; + box-shadow: 0 1px 2px rgba(44, 44, 44, 0.2); + transition: all 0.2s cubic-bezier(0.5, 0.1, 0.75, 1.35); } + .toggle:checked { + border-color: #654FEC; } + .toggle:checked:after { + transform: translatex(20px); } diff --git a/static/sw.js b/static/sw.js new file mode 100644 index 0000000..89ac6a7 --- /dev/null +++ b/static/sw.js @@ -0,0 +1,5 @@ +importScripts('./uv/uv.sw.js'); + +const sw = new UVServiceWorker(); + +self.addEventListener('fetch', event => event.respondWith(sw.fetch(event))); \ No newline at end of file diff --git a/static/uv/uv.bundle.js b/static/uv/uv.bundle.js new file mode 100644 index 0000000..099a868 --- /dev/null +++ b/static/uv/uv.bundle.js @@ -0,0 +1,39304 @@ +/******/ (() => { // webpackBootstrap +/******/ var __webpack_modules__ = ([ +/* 0 */, +/* 1 */ +/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _events_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2); +/* harmony import */ var parse5__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3); + + + +class HTML extends _events_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(ctx) { + super(); + this.ctx = ctx; + this.rewriteUrl = ctx.rewriteUrl; + this.sourceUrl = ctx.sourceUrl; + }; + rewrite(str, options = {}) { + if (!str) return str; + return this.recast(str, node => { + if (node.tagName) this.emit('element', node, 'rewrite'); + if (node.attr) this.emit('attr', node, 'rewrite'); + if (node.nodeName === '#text') this.emit('text', node, 'rewrite'); + }, options) + }; + source(str, options = {}) { + if (!str) return str; + return this.recast(str, node => { + if (node.tagName) this.emit('element', node, 'source'); + if (node.attr) this.emit('attr', node, 'source'); + if (node.nodeName === '#text') this.emit('text', node, 'source'); + }, options) + }; + recast(str, fn, options = {}) { + try { + const ast = (options.document ? parse5__WEBPACK_IMPORTED_MODULE_1__.parse : parse5__WEBPACK_IMPORTED_MODULE_1__.parseFragment)(new String(str).toString()); + this.iterate(ast, fn, options); + return (0,parse5__WEBPACK_IMPORTED_MODULE_1__.serialize)(ast); + } catch(e) { + return str; + }; + }; + iterate(ast, fn, fnOptions) { + if (!ast) return ast; + + if (ast.tagName) { + const element = new P5Element(ast, false, fnOptions); + fn(element); + if (ast.attrs) { + for (const attr of ast.attrs) { + if (!attr.skip) fn(new AttributeEvent(element, attr, fnOptions)); + }; + }; + }; + + if (ast.childNodes) { + for (const child of ast.childNodes) { + if (!child.skip) this.iterate(child, fn, fnOptions); + }; + }; + + if (ast.nodeName === '#text') { + fn(new TextEvent(ast, new P5Element(ast.parentNode), false, fnOptions)); + }; + + return ast; + }; + wrapSrcset(str, meta = this.ctx.meta) { + return str.split(',').map(src => { + const parts = src.trimStart().split(' '); + if (parts[0]) parts[0] = this.ctx.rewriteUrl(parts[0], meta); + return parts.join(' '); + }).join(', '); + }; + unwrapSrcset(str, meta = this.ctx.meta) { + return str.split(',').map(src => { + const parts = src.trimStart().split(' '); + if (parts[0]) parts[0] = this.ctx.sourceUrl(parts[0], meta); + return parts.join(' '); + }).join(', '); + }; + static parse = parse5__WEBPACK_IMPORTED_MODULE_1__.parse; + static parseFragment = parse5__WEBPACK_IMPORTED_MODULE_1__.parseFragment; + static serialize = parse5__WEBPACK_IMPORTED_MODULE_1__.serialize; +}; + +class P5Element extends _events_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(node, stream = false, options = {}) { + super(); + this.stream = stream; + this.node = node; + this.options = options; + }; + setAttribute(name, value) { + for (const attr of this.attrs) { + if (attr.name === name) { + attr.value = value; + return true; + }; + }; + + this.attrs.push( + { + name, + value, + } + ); + }; + getAttribute(name) { + const attr = this.attrs.find(attr => attr.name === name) || {}; + return attr.value; + }; + hasAttribute(name) { + return !!this.attrs.find(attr => attr.name === name); + }; + removeAttribute(name) { + const i = this.attrs.findIndex(attr => attr.name === name); + if (typeof i !== 'undefined') this.attrs.splice(i, 1); + }; + get tagName() { + return this.node.tagName; + }; + set tagName(val) { + this.node.tagName = val; + }; + get childNodes() { + return !this.stream ? this.node.childNodes : null; + }; + get innerHTML() { + return !this.stream ? (0,parse5__WEBPACK_IMPORTED_MODULE_1__.serialize)( + { + nodeName: '#document-fragment', + childNodes: this.childNodes, + } + ) : null; + }; + set innerHTML(val) { + if (!this.stream) this.node.childNodes = (0,parse5__WEBPACK_IMPORTED_MODULE_1__.parseFragment)(val).childNodes; + }; + get outerHTML() { + return !this.stream ? (0,parse5__WEBPACK_IMPORTED_MODULE_1__.serialize)( + { + nodeName: '#document-fragment', + childNodes: [ this ], + } + ) : null; + }; + set outerHTML(val) { + if (!this.stream) this.parentNode.childNodes.splice(this.parentNode.childNodes.findIndex(node => node === this.node), 1, ...(0,parse5__WEBPACK_IMPORTED_MODULE_1__.parseFragment)(val).childNodes); + }; + get textContent() { + if (this.stream) return null; + + let str = ''; + iterate(this.node, node => { + if (node.nodeName === '#text') str += node.value; + }); + + return str; + }; + set textContent(val) { + if (!this.stream) this.node.childNodes = [ + { + nodeName: '#text', + value: val, + parentNode: this.node + } + ]; + }; + get nodeName() { + return this.node.nodeName; + } + get parentNode() { + return this.node.parentNode ? new P5Element(this.node.parentNode) : null; + }; + get attrs() { + return this.node.attrs; + } + get namespaceURI() { + return this.node.namespaceURI; + } +}; + +class AttributeEvent { + constructor(node, attr, options = {}) { + this.attr = attr; + this.attrs = node.attrs; + this.node = node; + this.options = options; + }; + delete() { + const i = this.attrs.findIndex(attr => attr === this.attr); + + this.attrs.splice(i, 1); + + Object.defineProperty(this, 'deleted', { + get: () => true, + }); + + return true; + }; + get name() { + return this.attr.name; + }; + + set name(val) { + this.attr.name = val; + }; + get value() { + return this.attr.value; + }; + + set value(val) { + this.attr.value = val; + }; + get deleted() { + return false; + }; +}; + +class TextEvent { + constructor(node, element, stream = false, options = {}) { + this.stream = stream; + this.node = node; + this.element = element; + this.options = options; + }; + get nodeName() { + return this.node.nodeName; + } + get parentNode() { + return this.element; + }; + get value() { + return this.stream ? this.node.text : this.node.value; + }; + set value(val) { + + if (this.stream) this.node.text = val; + else this.node.value = val; + }; +}; + +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (HTML); + +/***/ }), +/* 2 */ +/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + + + +var R = typeof Reflect === 'object' ? Reflect : null +var ReflectApply = R && typeof R.apply === 'function' + ? R.apply + : function ReflectApply(target, receiver, args) { + return Function.prototype.apply.call(target, receiver, args); + } + +var ReflectOwnKeys +if (R && typeof R.ownKeys === 'function') { + ReflectOwnKeys = R.ownKeys +} else if (Object.getOwnPropertySymbols) { + ReflectOwnKeys = function ReflectOwnKeys(target) { + return Object.getOwnPropertyNames(target) + .concat(Object.getOwnPropertySymbols(target)); + }; +} else { + ReflectOwnKeys = function ReflectOwnKeys(target) { + return Object.getOwnPropertyNames(target); + }; +} + +function ProcessEmitWarning(warning) { + if (console && console.warn) console.warn(warning); +} + +var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) { + return value !== value; +} + +function EventEmitter() { + EventEmitter.init.call(this); +} + +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (EventEmitter); + +// Backwards-compat with node 0.10.x +EventEmitter.EventEmitter = EventEmitter; + +EventEmitter.prototype._events = undefined; +EventEmitter.prototype._eventsCount = 0; +EventEmitter.prototype._maxListeners = undefined; + +// By default EventEmitters will print a warning if more than 10 listeners are +// added to it. This is a useful default which helps finding memory leaks. +var defaultMaxListeners = 10; + +function checkListener(listener) { + if (typeof listener !== 'function') { + throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener); + } +} + +Object.defineProperty(EventEmitter, 'defaultMaxListeners', { + enumerable: true, + get: function() { + return defaultMaxListeners; + }, + set: function(arg) { + if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) { + throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.'); + } + defaultMaxListeners = arg; + } +}); + +EventEmitter.init = function() { + + if (this._events === undefined || + this._events === Object.getPrototypeOf(this)._events) { + this._events = Object.create(null); + this._eventsCount = 0; + } + + this._maxListeners = this._maxListeners || undefined; +}; + +// Obviously not all Emitters should be limited to 10. This function allows +// that to be increased. Set to zero for unlimited. +EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { + if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) { + throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.'); + } + this._maxListeners = n; + return this; +}; + +function _getMaxListeners(that) { + if (that._maxListeners === undefined) + return EventEmitter.defaultMaxListeners; + return that._maxListeners; +} + +EventEmitter.prototype.getMaxListeners = function getMaxListeners() { + return _getMaxListeners(this); +}; + +EventEmitter.prototype.emit = function emit(type) { + var args = []; + for (var i = 1; i < arguments.length; i++) args.push(arguments[i]); + var doError = (type === 'error'); + + var events = this._events; + if (events !== undefined) + doError = (doError && events.error === undefined); + else if (!doError) + return false; + + // If there is no 'error' event listener then throw. + if (doError) { + var er; + if (args.length > 0) + er = args[0]; + if (er instanceof Error) { + // Note: The comments on the `throw` lines are intentional, they show + // up in Node's output if this results in an unhandled exception. + throw er; // Unhandled 'error' event + } + // At least give some kind of context to the user + var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : '')); + err.context = er; + throw err; // Unhandled 'error' event + } + + var handler = events[type]; + + if (handler === undefined) + return false; + + if (typeof handler === 'function') { + ReflectApply(handler, this, args); + } else { + var len = handler.length; + var listeners = arrayClone(handler, len); + for (var i = 0; i < len; ++i) + ReflectApply(listeners[i], this, args); + } + + return true; +}; + +function _addListener(target, type, listener, prepend) { + var m; + var events; + var existing; + + checkListener(listener); + + events = target._events; + if (events === undefined) { + events = target._events = Object.create(null); + target._eventsCount = 0; + } else { + // To avoid recursion in the case that type === "newListener"! Before + // adding it to the listeners, first emit "newListener". + if (events.newListener !== undefined) { + target.emit('newListener', type, + listener.listener ? listener.listener : listener); + + // Re-assign `events` because a newListener handler could have caused the + // this._events to be assigned to a new object + events = target._events; + } + existing = events[type]; + } + + if (existing === undefined) { + // Optimize the case of one listener. Don't need the extra array object. + existing = events[type] = listener; + ++target._eventsCount; + } else { + if (typeof existing === 'function') { + // Adding the second element, need to change to array. + existing = events[type] = + prepend ? [listener, existing] : [existing, listener]; + // If we've already got an array, just append. + } else if (prepend) { + existing.unshift(listener); + } else { + existing.push(listener); + } + + // Check for listener leak + m = _getMaxListeners(target); + if (m > 0 && existing.length > m && !existing.warned) { + existing.warned = true; + // No error code for this since it is a Warning + // eslint-disable-next-line no-restricted-syntax + var w = new Error('Possible EventEmitter memory leak detected. ' + + existing.length + ' ' + String(type) + ' listeners ' + + 'added. Use emitter.setMaxListeners() to ' + + 'increase limit'); + w.name = 'MaxListenersExceededWarning'; + w.emitter = target; + w.type = type; + w.count = existing.length; + ProcessEmitWarning(w); + } + } + + return target; +} + +EventEmitter.prototype.addListener = function addListener(type, listener) { + return _addListener(this, type, listener, false); +}; + +EventEmitter.prototype.on = EventEmitter.prototype.addListener; + +EventEmitter.prototype.prependListener = + function prependListener(type, listener) { + return _addListener(this, type, listener, true); + }; + +function onceWrapper() { + if (!this.fired) { + this.target.removeListener(this.type, this.wrapFn); + this.fired = true; + if (arguments.length === 0) + return this.listener.call(this.target); + return this.listener.apply(this.target, arguments); + } +} + +function _onceWrap(target, type, listener) { + var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener }; + var wrapped = onceWrapper.bind(state); + wrapped.listener = listener; + state.wrapFn = wrapped; + return wrapped; +} + +EventEmitter.prototype.once = function once(type, listener) { + checkListener(listener); + this.on(type, _onceWrap(this, type, listener)); + return this; +}; + +EventEmitter.prototype.prependOnceListener = + function prependOnceListener(type, listener) { + checkListener(listener); + this.prependListener(type, _onceWrap(this, type, listener)); + return this; + }; + +// Emits a 'removeListener' event if and only if the listener was removed. +EventEmitter.prototype.removeListener = + function removeListener(type, listener) { + var list, events, position, i, originalListener; + + checkListener(listener); + + events = this._events; + if (events === undefined) + return this; + + list = events[type]; + if (list === undefined) + return this; + + if (list === listener || list.listener === listener) { + if (--this._eventsCount === 0) + this._events = Object.create(null); + else { + delete events[type]; + if (events.removeListener) + this.emit('removeListener', type, list.listener || listener); + } + } else if (typeof list !== 'function') { + position = -1; + + for (i = list.length - 1; i >= 0; i--) { + if (list[i] === listener || list[i].listener === listener) { + originalListener = list[i].listener; + position = i; + break; + } + } + + if (position < 0) + return this; + + if (position === 0) + list.shift(); + else { + spliceOne(list, position); + } + + if (list.length === 1) + events[type] = list[0]; + + if (events.removeListener !== undefined) + this.emit('removeListener', type, originalListener || listener); + } + + return this; + }; + +EventEmitter.prototype.off = EventEmitter.prototype.removeListener; + +EventEmitter.prototype.removeAllListeners = + function removeAllListeners(type) { + var listeners, events, i; + + events = this._events; + if (events === undefined) + return this; + + // not listening for removeListener, no need to emit + if (events.removeListener === undefined) { + if (arguments.length === 0) { + this._events = Object.create(null); + this._eventsCount = 0; + } else if (events[type] !== undefined) { + if (--this._eventsCount === 0) + this._events = Object.create(null); + else + delete events[type]; + } + return this; + } + + // emit removeListener for all listeners on all events + if (arguments.length === 0) { + var keys = Object.keys(events); + var key; + for (i = 0; i < keys.length; ++i) { + key = keys[i]; + if (key === 'removeListener') continue; + this.removeAllListeners(key); + } + this.removeAllListeners('removeListener'); + this._events = Object.create(null); + this._eventsCount = 0; + return this; + } + + listeners = events[type]; + + if (typeof listeners === 'function') { + this.removeListener(type, listeners); + } else if (listeners !== undefined) { + // LIFO order + for (i = listeners.length - 1; i >= 0; i--) { + this.removeListener(type, listeners[i]); + } + } + + return this; + }; + +function _listeners(target, type, unwrap) { + var events = target._events; + + if (events === undefined) + return []; + + var evlistener = events[type]; + if (evlistener === undefined) + return []; + + if (typeof evlistener === 'function') + return unwrap ? [evlistener.listener || evlistener] : [evlistener]; + + return unwrap ? + unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length); +} + +EventEmitter.prototype.listeners = function listeners(type) { + return _listeners(this, type, true); +}; + +EventEmitter.prototype.rawListeners = function rawListeners(type) { + return _listeners(this, type, false); +}; + +EventEmitter.listenerCount = function(emitter, type) { + if (typeof emitter.listenerCount === 'function') { + return emitter.listenerCount(type); + } else { + return listenerCount.call(emitter, type); + } +}; + +EventEmitter.prototype.listenerCount = listenerCount; +function listenerCount(type) { + var events = this._events; + + if (events !== undefined) { + var evlistener = events[type]; + + if (typeof evlistener === 'function') { + return 1; + } else if (evlistener !== undefined) { + return evlistener.length; + } + } + + return 0; +} + +EventEmitter.prototype.eventNames = function eventNames() { + return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : []; +}; + +function arrayClone(arr, n) { + var copy = new Array(n); + for (var i = 0; i < n; ++i) + copy[i] = arr[i]; + return copy; +} + +function spliceOne(list, index) { + for (; index + 1 < list.length; index++) + list[index] = list[index + 1]; + list.pop(); +} + +function unwrapListeners(arr) { + var ret = new Array(arr.length); + for (var i = 0; i < ret.length; ++i) { + ret[i] = arr[i].listener || arr[i]; + } + return ret; +} + +function once(emitter, name) { + return new Promise(function (resolve, reject) { + function errorListener(err) { + emitter.removeListener(name, resolver); + reject(err); + } + + function resolver() { + if (typeof emitter.removeListener === 'function') { + emitter.removeListener('error', errorListener); + } + resolve([].slice.call(arguments)); + }; + + eventTargetAgnosticAddListener(emitter, name, resolver, { once: true }); + if (name !== 'error') { + addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true }); + } + }); +} + +function addErrorHandlerIfEventEmitter(emitter, handler, flags) { + if (typeof emitter.on === 'function') { + eventTargetAgnosticAddListener(emitter, 'error', handler, flags); + } +} + +function eventTargetAgnosticAddListener(emitter, name, listener, flags) { + if (typeof emitter.on === 'function') { + if (flags.once) { + emitter.once(name, listener); + } else { + emitter.on(name, listener); + } + } else if (typeof emitter.addEventListener === 'function') { + // EventTarget does not have `error` event semantics like Node + // EventEmitters, we do not listen for `error` events here. + emitter.addEventListener(name, function wrapListener(arg) { + // IE does not have builtin `{ once: true }` support so we + // have to do it manually. + if (flags.once) { + emitter.removeEventListener(name, wrapListener); + } + listener(arg); + }); + } else { + throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter); + } +} + +/***/ }), +/* 3 */ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + + +const Parser = __webpack_require__(4); +const Serializer = __webpack_require__(26); + +// Shorthands +exports.parse = function parse(html, options) { + const parser = new Parser(options); + + return parser.parse(html); +}; + +exports.parseFragment = function parseFragment(fragmentContext, html, options) { + if (typeof fragmentContext === 'string') { + options = html; + html = fragmentContext; + fragmentContext = null; + } + + const parser = new Parser(options); + + return parser.parseFragment(html, fragmentContext); +}; + +exports.serialize = function(node, options) { + const serializer = new Serializer(node, options); + + return serializer.serialize(); +}; + + +/***/ }), +/* 4 */ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + + +const Tokenizer = __webpack_require__(5); +const OpenElementStack = __webpack_require__(10); +const FormattingElementList = __webpack_require__(12); +const LocationInfoParserMixin = __webpack_require__(13); +const ErrorReportingParserMixin = __webpack_require__(18); +const Mixin = __webpack_require__(14); +const defaultTreeAdapter = __webpack_require__(22); +const mergeOptions = __webpack_require__(23); +const doctype = __webpack_require__(24); +const foreignContent = __webpack_require__(25); +const ERR = __webpack_require__(8); +const unicode = __webpack_require__(7); +const HTML = __webpack_require__(11); + +//Aliases +const $ = HTML.TAG_NAMES; +const NS = HTML.NAMESPACES; +const ATTRS = HTML.ATTRS; + +const DEFAULT_OPTIONS = { + scriptingEnabled: true, + sourceCodeLocationInfo: false, + onParseError: null, + treeAdapter: defaultTreeAdapter +}; + +//Misc constants +const HIDDEN_INPUT_TYPE = 'hidden'; + +//Adoption agency loops iteration count +const AA_OUTER_LOOP_ITER = 8; +const AA_INNER_LOOP_ITER = 3; + +//Insertion modes +const INITIAL_MODE = 'INITIAL_MODE'; +const BEFORE_HTML_MODE = 'BEFORE_HTML_MODE'; +const BEFORE_HEAD_MODE = 'BEFORE_HEAD_MODE'; +const IN_HEAD_MODE = 'IN_HEAD_MODE'; +const IN_HEAD_NO_SCRIPT_MODE = 'IN_HEAD_NO_SCRIPT_MODE'; +const AFTER_HEAD_MODE = 'AFTER_HEAD_MODE'; +const IN_BODY_MODE = 'IN_BODY_MODE'; +const TEXT_MODE = 'TEXT_MODE'; +const IN_TABLE_MODE = 'IN_TABLE_MODE'; +const IN_TABLE_TEXT_MODE = 'IN_TABLE_TEXT_MODE'; +const IN_CAPTION_MODE = 'IN_CAPTION_MODE'; +const IN_COLUMN_GROUP_MODE = 'IN_COLUMN_GROUP_MODE'; +const IN_TABLE_BODY_MODE = 'IN_TABLE_BODY_MODE'; +const IN_ROW_MODE = 'IN_ROW_MODE'; +const IN_CELL_MODE = 'IN_CELL_MODE'; +const IN_SELECT_MODE = 'IN_SELECT_MODE'; +const IN_SELECT_IN_TABLE_MODE = 'IN_SELECT_IN_TABLE_MODE'; +const IN_TEMPLATE_MODE = 'IN_TEMPLATE_MODE'; +const AFTER_BODY_MODE = 'AFTER_BODY_MODE'; +const IN_FRAMESET_MODE = 'IN_FRAMESET_MODE'; +const AFTER_FRAMESET_MODE = 'AFTER_FRAMESET_MODE'; +const AFTER_AFTER_BODY_MODE = 'AFTER_AFTER_BODY_MODE'; +const AFTER_AFTER_FRAMESET_MODE = 'AFTER_AFTER_FRAMESET_MODE'; + +//Insertion mode reset map +const INSERTION_MODE_RESET_MAP = { + [$.TR]: IN_ROW_MODE, + [$.TBODY]: IN_TABLE_BODY_MODE, + [$.THEAD]: IN_TABLE_BODY_MODE, + [$.TFOOT]: IN_TABLE_BODY_MODE, + [$.CAPTION]: IN_CAPTION_MODE, + [$.COLGROUP]: IN_COLUMN_GROUP_MODE, + [$.TABLE]: IN_TABLE_MODE, + [$.BODY]: IN_BODY_MODE, + [$.FRAMESET]: IN_FRAMESET_MODE +}; + +//Template insertion mode switch map +const TEMPLATE_INSERTION_MODE_SWITCH_MAP = { + [$.CAPTION]: IN_TABLE_MODE, + [$.COLGROUP]: IN_TABLE_MODE, + [$.TBODY]: IN_TABLE_MODE, + [$.TFOOT]: IN_TABLE_MODE, + [$.THEAD]: IN_TABLE_MODE, + [$.COL]: IN_COLUMN_GROUP_MODE, + [$.TR]: IN_TABLE_BODY_MODE, + [$.TD]: IN_ROW_MODE, + [$.TH]: IN_ROW_MODE +}; + +//Token handlers map for insertion modes +const TOKEN_HANDLERS = { + [INITIAL_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: tokenInInitialMode, + [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInInitialMode, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: doctypeInInitialMode, + [Tokenizer.START_TAG_TOKEN]: tokenInInitialMode, + [Tokenizer.END_TAG_TOKEN]: tokenInInitialMode, + [Tokenizer.EOF_TOKEN]: tokenInInitialMode + }, + [BEFORE_HTML_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: tokenBeforeHtml, + [Tokenizer.NULL_CHARACTER_TOKEN]: tokenBeforeHtml, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagBeforeHtml, + [Tokenizer.END_TAG_TOKEN]: endTagBeforeHtml, + [Tokenizer.EOF_TOKEN]: tokenBeforeHtml + }, + [BEFORE_HEAD_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: tokenBeforeHead, + [Tokenizer.NULL_CHARACTER_TOKEN]: tokenBeforeHead, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype, + [Tokenizer.START_TAG_TOKEN]: startTagBeforeHead, + [Tokenizer.END_TAG_TOKEN]: endTagBeforeHead, + [Tokenizer.EOF_TOKEN]: tokenBeforeHead + }, + [IN_HEAD_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: tokenInHead, + [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInHead, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype, + [Tokenizer.START_TAG_TOKEN]: startTagInHead, + [Tokenizer.END_TAG_TOKEN]: endTagInHead, + [Tokenizer.EOF_TOKEN]: tokenInHead + }, + [IN_HEAD_NO_SCRIPT_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: tokenInHeadNoScript, + [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInHeadNoScript, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype, + [Tokenizer.START_TAG_TOKEN]: startTagInHeadNoScript, + [Tokenizer.END_TAG_TOKEN]: endTagInHeadNoScript, + [Tokenizer.EOF_TOKEN]: tokenInHeadNoScript + }, + [AFTER_HEAD_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: tokenAfterHead, + [Tokenizer.NULL_CHARACTER_TOKEN]: tokenAfterHead, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype, + [Tokenizer.START_TAG_TOKEN]: startTagAfterHead, + [Tokenizer.END_TAG_TOKEN]: endTagAfterHead, + [Tokenizer.EOF_TOKEN]: tokenAfterHead + }, + [IN_BODY_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: characterInBody, + [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagInBody, + [Tokenizer.END_TAG_TOKEN]: endTagInBody, + [Tokenizer.EOF_TOKEN]: eofInBody + }, + [TEXT_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: insertCharacters, + [Tokenizer.NULL_CHARACTER_TOKEN]: insertCharacters, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters, + [Tokenizer.COMMENT_TOKEN]: ignoreToken, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: ignoreToken, + [Tokenizer.END_TAG_TOKEN]: endTagInText, + [Tokenizer.EOF_TOKEN]: eofInText + }, + [IN_TABLE_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: characterInTable, + [Tokenizer.NULL_CHARACTER_TOKEN]: characterInTable, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: characterInTable, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagInTable, + [Tokenizer.END_TAG_TOKEN]: endTagInTable, + [Tokenizer.EOF_TOKEN]: eofInBody + }, + [IN_TABLE_TEXT_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: characterInTableText, + [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInTableText, + [Tokenizer.COMMENT_TOKEN]: tokenInTableText, + [Tokenizer.DOCTYPE_TOKEN]: tokenInTableText, + [Tokenizer.START_TAG_TOKEN]: tokenInTableText, + [Tokenizer.END_TAG_TOKEN]: tokenInTableText, + [Tokenizer.EOF_TOKEN]: tokenInTableText + }, + [IN_CAPTION_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: characterInBody, + [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagInCaption, + [Tokenizer.END_TAG_TOKEN]: endTagInCaption, + [Tokenizer.EOF_TOKEN]: eofInBody + }, + [IN_COLUMN_GROUP_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: tokenInColumnGroup, + [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInColumnGroup, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagInColumnGroup, + [Tokenizer.END_TAG_TOKEN]: endTagInColumnGroup, + [Tokenizer.EOF_TOKEN]: eofInBody + }, + [IN_TABLE_BODY_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: characterInTable, + [Tokenizer.NULL_CHARACTER_TOKEN]: characterInTable, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: characterInTable, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagInTableBody, + [Tokenizer.END_TAG_TOKEN]: endTagInTableBody, + [Tokenizer.EOF_TOKEN]: eofInBody + }, + [IN_ROW_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: characterInTable, + [Tokenizer.NULL_CHARACTER_TOKEN]: characterInTable, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: characterInTable, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagInRow, + [Tokenizer.END_TAG_TOKEN]: endTagInRow, + [Tokenizer.EOF_TOKEN]: eofInBody + }, + [IN_CELL_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: characterInBody, + [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagInCell, + [Tokenizer.END_TAG_TOKEN]: endTagInCell, + [Tokenizer.EOF_TOKEN]: eofInBody + }, + [IN_SELECT_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: insertCharacters, + [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagInSelect, + [Tokenizer.END_TAG_TOKEN]: endTagInSelect, + [Tokenizer.EOF_TOKEN]: eofInBody + }, + [IN_SELECT_IN_TABLE_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: insertCharacters, + [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagInSelectInTable, + [Tokenizer.END_TAG_TOKEN]: endTagInSelectInTable, + [Tokenizer.EOF_TOKEN]: eofInBody + }, + [IN_TEMPLATE_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: characterInBody, + [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagInTemplate, + [Tokenizer.END_TAG_TOKEN]: endTagInTemplate, + [Tokenizer.EOF_TOKEN]: eofInTemplate + }, + [AFTER_BODY_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: tokenAfterBody, + [Tokenizer.NULL_CHARACTER_TOKEN]: tokenAfterBody, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody, + [Tokenizer.COMMENT_TOKEN]: appendCommentToRootHtmlElement, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagAfterBody, + [Tokenizer.END_TAG_TOKEN]: endTagAfterBody, + [Tokenizer.EOF_TOKEN]: stopParsing + }, + [IN_FRAMESET_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagInFrameset, + [Tokenizer.END_TAG_TOKEN]: endTagInFrameset, + [Tokenizer.EOF_TOKEN]: stopParsing + }, + [AFTER_FRAMESET_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters, + [Tokenizer.COMMENT_TOKEN]: appendComment, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagAfterFrameset, + [Tokenizer.END_TAG_TOKEN]: endTagAfterFrameset, + [Tokenizer.EOF_TOKEN]: stopParsing + }, + [AFTER_AFTER_BODY_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: tokenAfterAfterBody, + [Tokenizer.NULL_CHARACTER_TOKEN]: tokenAfterAfterBody, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody, + [Tokenizer.COMMENT_TOKEN]: appendCommentToDocument, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagAfterAfterBody, + [Tokenizer.END_TAG_TOKEN]: tokenAfterAfterBody, + [Tokenizer.EOF_TOKEN]: stopParsing + }, + [AFTER_AFTER_FRAMESET_MODE]: { + [Tokenizer.CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken, + [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody, + [Tokenizer.COMMENT_TOKEN]: appendCommentToDocument, + [Tokenizer.DOCTYPE_TOKEN]: ignoreToken, + [Tokenizer.START_TAG_TOKEN]: startTagAfterAfterFrameset, + [Tokenizer.END_TAG_TOKEN]: ignoreToken, + [Tokenizer.EOF_TOKEN]: stopParsing + } +}; + +//Parser +class Parser { + constructor(options) { + this.options = mergeOptions(DEFAULT_OPTIONS, options); + + this.treeAdapter = this.options.treeAdapter; + this.pendingScript = null; + + if (this.options.sourceCodeLocationInfo) { + Mixin.install(this, LocationInfoParserMixin); + } + + if (this.options.onParseError) { + Mixin.install(this, ErrorReportingParserMixin, { onParseError: this.options.onParseError }); + } + } + + // API + parse(html) { + const document = this.treeAdapter.createDocument(); + + this._bootstrap(document, null); + this.tokenizer.write(html, true); + this._runParsingLoop(null); + + return document; + } + + parseFragment(html, fragmentContext) { + //NOTE: use