@builder.io/qwik
Version:
An Open-Source sub-framework designed with a focus on server-side-rendering, lazy-loading, and styling/animation.
1,377 lines (1,367 loc) • 836 kB
JavaScript
/**
* @license
* @builder.io/qwik/testing 1.16.0
* Copyright Builder.io, Inc. 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://github.com/QwikDev/qwik/blob/main/LICENSE
*/
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
// packages/qwik-dom/lib/Event.js
var require_Event = __commonJS({
"packages/qwik-dom/lib/Event.js"(exports, module) {
"use strict";
module.exports = Event;
Event.CAPTURING_PHASE = 1;
Event.AT_TARGET = 2;
Event.BUBBLING_PHASE = 3;
function Event(type, dictionary) {
this.type = "";
this.target = null;
this.currentTarget = null;
this.eventPhase = Event.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 (type) this.type = type;
if (dictionary) {
for (var p in dictionary) {
this[p] = dictionary[p];
}
}
}
Event.prototype = Object.create(Object.prototype, {
constructor: { value: Event },
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(type, 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 = type;
this.bubbles = bubbles;
this.cancelable = cancelable;
}
}
});
}
});
// packages/qwik-dom/lib/UIEvent.js
var require_UIEvent = __commonJS({
"packages/qwik-dom/lib/UIEvent.js"(exports, module) {
"use strict";
var Event = require_Event();
module.exports = UIEvent;
function UIEvent() {
Event.call(this);
this.view = null;
this.detail = 0;
}
UIEvent.prototype = Object.create(Event.prototype, {
constructor: { value: UIEvent },
initUIEvent: {
value: function(type, bubbles, cancelable, view, detail) {
this.initEvent(type, bubbles, cancelable);
this.view = view;
this.detail = detail;
}
}
});
}
});
// packages/qwik-dom/lib/MouseEvent.js
var require_MouseEvent = __commonJS({
"packages/qwik-dom/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(type, bubbles, cancelable, view, detail, screenX, screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey, button, relatedTarget) {
this.initEvent(type, 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;
}
}
}
});
}
});
// packages/qwik-dom/lib/DOMException.js
var require_DOMException = __commonJS({
"packages/qwik-dom/lib/DOMException.js"(exports, module) {
"use strict";
module.exports = DOMException;
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 DOMException(code2) {
Error.call(this);
Error.captureStackTrace(this, this.constructor);
this.code = code2;
this.message = messages[code2];
this.name = names[code2];
}
DOMException.prototype.__proto__ = Error.prototype;
for (c in constants) {
v = { value: constants[c] };
Object.defineProperty(DOMException, c, v);
Object.defineProperty(DOMException.prototype, c, v);
}
var v;
var c;
}
});
// packages/qwik-dom/lib/config.js
var require_config = __commonJS({
"packages/qwik-dom/lib/config.js"(exports) {
"use strict";
exports.isApiWritable = !global.__domino_frozen__;
}
});
// packages/qwik-dom/lib/utils.js
var require_utils = __commonJS({
"packages/qwik-dom/lib/utils.js"(exports) {
"use strict";
var DOMException = require_DOMException();
var ERR = DOMException;
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 DOMException(ERR.INDEX_SIZE_ERR);
};
exports.HierarchyRequestError = function() {
throw new DOMException(ERR.HIERARCHY_REQUEST_ERR);
};
exports.WrongDocumentError = function() {
throw new DOMException(ERR.WRONG_DOCUMENT_ERR);
};
exports.InvalidCharacterError = function() {
throw new DOMException(ERR.INVALID_CHARACTER_ERR);
};
exports.NoModificationAllowedError = function() {
throw new DOMException(ERR.NO_MODIFICATION_ALLOWED_ERR);
};
exports.NotFoundError = function() {
throw new DOMException(ERR.NOT_FOUND_ERR);
};
exports.NotSupportedError = function() {
throw new DOMException(ERR.NOT_SUPPORTED_ERR);
};
exports.InvalidStateError = function() {
throw new DOMException(ERR.INVALID_STATE_ERR);
};
exports.SyntaxError = function() {
throw new DOMException(ERR.SYNTAX_ERR);
};
exports.InvalidModificationError = function() {
throw new DOMException(ERR.INVALID_MODIFICATION_ERR);
};
exports.NamespaceError = function() {
throw new DOMException(ERR.NAMESPACE_ERR);
};
exports.InvalidAccessError = function() {
throw new DOMException(ERR.INVALID_ACCESS_ERR);
};
exports.TypeMismatchError = function() {
throw new DOMException(ERR.TYPE_MISMATCH_ERR);
};
exports.SecurityError = function() {
throw new DOMException(ERR.SECURITY_ERR);
};
exports.NetworkError = function() {
throw new DOMException(ERR.NETWORK_ERR);
};
exports.AbortError = function() {
throw new DOMException(ERR.ABORT_ERR);
};
exports.UrlMismatchError = function() {
throw new DOMException(ERR.URL_MISMATCH_ERR);
};
exports.QuotaExceededError = function() {
throw new DOMException(ERR.QUOTA_EXCEEDED_ERR);
};
exports.TimeoutError = function() {
throw new DOMException(ERR.TIMEOUT_ERR);
};
exports.InvalidNodeTypeError = function() {
throw new DOMException(ERR.INVALID_NODE_TYPE_ERR);
};
exports.DataCloneError = function() {
throw new DOMException(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.escapeText = function(str) {
return str;
};
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();
});
};
}
});
// packages/qwik-dom/lib/EventTarget.js
var require_EventTarget = __commonJS({
"packages/qwik-dom/lib/EventTarget.js"(exports, module) {
"use strict";
var Event = require_Event();
var MouseEvent = require_MouseEvent();
var utils = require_utils();
module.exports = EventTarget;
function EventTarget() {
}
EventTarget.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(type, listener, capture) {
if (!listener) return;
if (capture === void 0) capture = false;
if (!this._listeners) this._listeners = /* @__PURE__ */ Object.create(null);
if (!this._listeners[type]) this._listeners[type] = [];
var list = this._listeners[type];
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(type, listener, capture) {
if (capture === void 0) capture = false;
if (this._listeners) {
var list = this._listeners[type];
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[type] = 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 invoke2(target, event2) {
var type = event2.type, phase = event2.eventPhase;
event2.currentTarget = target;
if (phase !== Event.CAPTURING_PHASE && target._handlers && target._handlers[type]) {
var handler = target._handlers[type];
var rv;
if (typeof handler === "function") {
rv = handler.call(event2.currentTarget, event2);
} else {
var f = handler.handleEvent;
if (typeof f !== "function")
throw new TypeError(
"handleEvent property of event handler object isnot a function."
);
rv = f.call(handler, 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[type];
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 === Event.CAPTURING_PHASE && !l.capture || phase === Event.BUBBLING_PHASE && l.capture)
continue;
if (l.f) {
l.f.call(event2.currentTarget, event2);
} else {
var fn = l.listener.handleEvent;
if (typeof fn !== "function")
throw new TypeError("handleEvent property of event listener object is not a function.");
fn.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 = Event.CAPTURING_PHASE;
for (var i = ancestors.length - 1; i >= 0; i--) {
invoke2(ancestors[i], event);
if (event._propagationStopped) break;
}
if (!event._propagationStopped) {
event.eventPhase = Event.AT_TARGET;
invoke2(this, event);
}
if (event.bubbles && !event._propagationStopped) {
event.eventPhase = Event.BUBBLING_PHASE;
for (var ii = 0, nn = ancestors.length; ii < nn; ii++) {
invoke2(ancestors[ii], event);
if (event._propagationStopped) break;
}
}
event._dispatching = false;
event.eventPhase = Event.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(type, handler) {
if (!this._handlers) this._handlers = /* @__PURE__ */ Object.create(null);
this._handlers[type] = handler;
},
_getEventHandler: function _getEventHandler(type) {
return this._handlers && this._handlers[type] || null;
}
};
}
});
// packages/qwik-dom/lib/LinkedList.js
var require_LinkedList = __commonJS({
"packages/qwik-dom/lib/LinkedList.js"(exports, module) {
"use strict";
var utils = require_utils();
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 next = a._nextSibling;
prev._nextSibling = next;
next._previousSibling = prev;
a._previousSibling = a._nextSibling = a;
utils.assert(LinkedList.valid(a));
}
};
}
});
// packages/qwik-dom/lib/NodeUtils.js
var require_NodeUtils = __commonJS({
"packages/qwik-dom/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
};
var utils = require_utils();
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
*/
};
function escape2(s) {
return s.replace(/[&<>\u00A0]/g, function(c) {
switch (c) {
case "&":
return "&";
case "<":
return "<";
case ">":
return ">";
case "\xA0":
return " ";
}
});
}
function escapeAttr(s) {
var toEscape = /[&"\u00A0]/g;
if (!toEscape.test(s)) {
return s;
} else {
return s.replace(toEscape, function(c) {
switch (c) {
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 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 (html && extraNewLine[tagname] && ss.charAt(0) === "\n") s += "\n";
s += ss;
s += "</" + tagname + ">";
}
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 += "<!--" + kid.data + "-->";
break;
case 7:
s += "<?" + kid.target + " " + kid.data + "?>";
break;
case 10:
s += "<!DOCTYPE " + kid.name;
if (false) {
if (kid.publicID) {
s += ' PUBLIC "' + kid.publicId + '"';
}
if (kid.systemId) {
s += ' "' + kid.systemId + '"';
}
}
s += ">";
break;
default:
utils.InvalidStateError();
}
return s;
}
}
});
// packages/qwik-dom/lib/Node.js
var require_Node = __commonJS({
"packages/qwik-dom/lib/Node.js"(exports, module) {
"use strict";
module.exports = Node;
var EventTarget = require_EventTarget();
var LinkedList = require_LinkedList();
var NodeUtils = require_NodeUtils();
var utils = require_utils();
function Node() {
EventTarget.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(EventTarget.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 node = this;
while (node != null) {
if (node.nodeType === Node.DOCUMENT_NODE) {
return true;
}
node = node.parentNode;
if (node != null && node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
node = node.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, next = this._nextSibling;
if (!parent) return null;
if (next === parent.firstChild) return null;
return next;
}
},
textContent: {
// Should override for DocumentFragment/Element/Attr/Text/PI/Comment
get: function() {
return null;
},
set: function(v) {
}
},
_countChildrenOfType: {
value: function(type) {
var sum = 0;
for (var kid = this.firstChild; kid !== null; kid = kid.nextSibling) {
if (kid.nodeType === type) sum++;
}
return sum;
}
},
_ensureInsertValid: {
value: function _ensureInsertValid(node, child, isPreinsert) {
var parent = this, i, kid;
if (!node.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 (node.isAncestor(parent)) utils.HierarchyRequestError();
if (child !== null || !isPreinsert) {
if (child.parentNode !== parent) utils.NotFoundError();
}
switch (node.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 (node.nodeType) {
case TEXT_NODE:
utils.HierarchyRequestError();
break;
case DOCUMENT_FRAGMENT_NODE:
if (node._countChildrenOfType(TEXT_NODE) > 0) utils.HierarchyRequestError();
switch (node._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 (node.nodeType === DOCUMENT_TYPE_NODE) utils.HierarchyRequestError();
}
}
},
insertBefore: {
value: function insertBefore2(node, child) {
var parent = this;
parent._ensureInsertValid(node, child, true);
var refChild = child;
if (refChild === node) {
refChild = node.nextSibling;
}
parent.doc.adoptNode(node);
node._insertOrReplace(parent, refChild, false);
return node;
}
},
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(node, child) {
var parent = this;
parent._ensureInsertValid(node, child, false);
if (node.doc !== parent.doc) {
parent.doc.adoptNode(node);
}
node._insertOrReplace(parent, child, true);
return child;
}
},
// See: http://ejohn.org/blog/comparing-document-position/
contains: {
value: function contains(node) {
if (node === null) {
return false;
}
if (this === node) {
return true;
}
return (this.compareDocumentPosition(node) & 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(node) {
return this === node;
}
},
// 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(node) {
if (!node) return false;
if (node.nodeType !== this.nodeType) return false;
if (!this.isEqual(node)) return false;
for (var c1 = this.firstChild, c2 = node.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 clone = this.clone();
if (deep) {
for (var kid = this.firstChild; kid !== null; kid = kid.nextSibling) {
clone._appendChild(kid.cloneNode(true));
}
}
return clone;
}
},
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], next;
for (var kid = child.firstChild; kid !== null; kid = next) {
next = 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) {
chi