hot-updater
Version:
React Native OTA solution for self-hosted
1,045 lines (1,044 loc) • 905 kB
JavaScript
#!/usr/bin/env node
const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
return 'undefined' == typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
}();
var __webpack_modules__ = {
"../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/conventions.js": function(__unused_webpack_module, exports1) {
"use strict";
function find(list, predicate, ac) {
if (void 0 === ac) ac = Array.prototype;
if (list && 'function' == typeof ac.find) return ac.find.call(list, predicate);
for(var i = 0; i < list.length; i++)if (Object.prototype.hasOwnProperty.call(list, i)) {
var item = list[i];
if (predicate.call(void 0, item, i, list)) return item;
}
}
function freeze(object, oc) {
if (void 0 === oc) oc = Object;
return oc && 'function' == typeof oc.freeze ? oc.freeze(object) : object;
}
function assign(target, source) {
if (null === target || 'object' != typeof target) throw new TypeError('target is not an object');
for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
return target;
}
var MIME_TYPE = freeze({
HTML: 'text/html',
isHTML: function(value) {
return value === MIME_TYPE.HTML;
},
XML_APPLICATION: 'application/xml',
XML_TEXT: 'text/xml',
XML_XHTML_APPLICATION: 'application/xhtml+xml',
XML_SVG_IMAGE: 'image/svg+xml'
});
var NAMESPACE = freeze({
HTML: 'http://www.w3.org/1999/xhtml',
isHTML: function(uri) {
return uri === NAMESPACE.HTML;
},
SVG: 'http://www.w3.org/2000/svg',
XML: 'http://www.w3.org/XML/1998/namespace',
XMLNS: 'http://www.w3.org/2000/xmlns/'
});
exports1.assign = assign;
exports1.find = find;
exports1.freeze = freeze;
exports1.MIME_TYPE = MIME_TYPE;
exports1.NAMESPACE = NAMESPACE;
},
"../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/dom-parser.js": function(__unused_webpack_module, exports1, __webpack_require__) {
var conventions = __webpack_require__("../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/conventions.js");
var dom = __webpack_require__("../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/dom.js");
var entities = __webpack_require__("../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/entities.js");
var sax = __webpack_require__("../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/sax.js");
var DOMImplementation = dom.DOMImplementation;
var NAMESPACE = conventions.NAMESPACE;
var ParseError = sax.ParseError;
var XMLReader = sax.XMLReader;
function normalizeLineEndings(input) {
return input.replace(/\r[\n\u0085]/g, '\n').replace(/[\r\u0085\u2028]/g, '\n');
}
function DOMParser(options) {
this.options = options || {
locator: {}
};
}
DOMParser.prototype.parseFromString = function(source, mimeType) {
var options = this.options;
var sax = new XMLReader();
var domBuilder = options.domBuilder || new DOMHandler();
var errorHandler = options.errorHandler;
var locator = options.locator;
var defaultNSMap = options.xmlns || {};
var isHTML = /\/x?html?$/.test(mimeType);
var entityMap = isHTML ? entities.HTML_ENTITIES : entities.XML_ENTITIES;
if (locator) domBuilder.setDocumentLocator(locator);
sax.errorHandler = buildErrorHandler(errorHandler, domBuilder, locator);
sax.domBuilder = options.domBuilder || domBuilder;
if (isHTML) defaultNSMap[''] = NAMESPACE.HTML;
defaultNSMap.xml = defaultNSMap.xml || NAMESPACE.XML;
var normalize = options.normalizeLineEndings || normalizeLineEndings;
if (source && 'string' == typeof source) sax.parse(normalize(source), defaultNSMap, entityMap);
else sax.errorHandler.error('invalid doc source');
return domBuilder.doc;
};
function buildErrorHandler(errorImpl, domBuilder, locator) {
if (!errorImpl) {
if (domBuilder instanceof DOMHandler) return domBuilder;
errorImpl = domBuilder;
}
var errorHandler = {};
var isCallback = errorImpl instanceof Function;
locator = locator || {};
function build(key) {
var fn = errorImpl[key];
if (!fn && isCallback) fn = 2 == errorImpl.length ? function(msg) {
errorImpl(key, msg);
} : errorImpl;
errorHandler[key] = fn && function(msg) {
fn('[xmldom ' + key + ']\t' + msg + _locator(locator));
} || function() {};
}
build('warning');
build('error');
build('fatalError');
return errorHandler;
}
function DOMHandler() {
this.cdata = false;
}
function position(locator, node) {
node.lineNumber = locator.lineNumber;
node.columnNumber = locator.columnNumber;
}
DOMHandler.prototype = {
startDocument: function() {
this.doc = new DOMImplementation().createDocument(null, null, null);
if (this.locator) this.doc.documentURI = this.locator.systemId;
},
startElement: function(namespaceURI, localName, qName, attrs) {
var doc = this.doc;
var el = doc.createElementNS(namespaceURI, qName || localName);
var len = attrs.length;
appendElement(this, el);
this.currentElement = el;
this.locator && position(this.locator, el);
for(var i = 0; i < len; i++){
var namespaceURI = attrs.getURI(i);
var value = attrs.getValue(i);
var qName = attrs.getQName(i);
var attr = doc.createAttributeNS(namespaceURI, qName);
this.locator && position(attrs.getLocator(i), attr);
attr.value = attr.nodeValue = value;
el.setAttributeNode(attr);
}
},
endElement: function(namespaceURI, localName, qName) {
var current = this.currentElement;
current.tagName;
this.currentElement = current.parentNode;
},
startPrefixMapping: function(prefix, uri) {},
endPrefixMapping: function(prefix) {},
processingInstruction: function(target, data) {
var ins = this.doc.createProcessingInstruction(target, data);
this.locator && position(this.locator, ins);
appendElement(this, ins);
},
ignorableWhitespace: function(ch, start, length) {},
characters: function(chars, start, length) {
chars = _toString.apply(this, arguments);
if (chars) {
if (this.cdata) var charNode = this.doc.createCDATASection(chars);
else var charNode = this.doc.createTextNode(chars);
if (this.currentElement) this.currentElement.appendChild(charNode);
else if (/^\s*$/.test(chars)) this.doc.appendChild(charNode);
this.locator && position(this.locator, charNode);
}
},
skippedEntity: function(name) {},
endDocument: function() {
this.doc.normalize();
},
setDocumentLocator: function(locator) {
if (this.locator = locator) locator.lineNumber = 0;
},
comment: function(chars, start, length) {
chars = _toString.apply(this, arguments);
var comm = this.doc.createComment(chars);
this.locator && position(this.locator, comm);
appendElement(this, comm);
},
startCDATA: function() {
this.cdata = true;
},
endCDATA: function() {
this.cdata = false;
},
startDTD: function(name, publicId, systemId) {
var impl = this.doc.implementation;
if (impl && impl.createDocumentType) {
var dt = impl.createDocumentType(name, publicId, systemId);
this.locator && position(this.locator, dt);
appendElement(this, dt);
this.doc.doctype = dt;
}
},
warning: function(error) {
console.warn('[xmldom warning]\t' + error, _locator(this.locator));
},
error: function(error) {
console.error('[xmldom error]\t' + error, _locator(this.locator));
},
fatalError: function(error) {
throw new ParseError(error, this.locator);
}
};
function _locator(l) {
if (l) return '\n@' + (l.systemId || '') + '#[line:' + l.lineNumber + ',col:' + l.columnNumber + ']';
}
function _toString(chars, start, length) {
if ('string' == typeof chars) return chars.substr(start, length);
if (chars.length >= start + length || start) return new java.lang.String(chars, start, length) + '';
return chars;
}
"endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g, function(key) {
DOMHandler.prototype[key] = function() {
return null;
};
});
function appendElement(hander, node) {
if (hander.currentElement) hander.currentElement.appendChild(node);
else hander.doc.appendChild(node);
}
exports1.DOMParser = DOMParser;
},
"../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/dom.js": function(__unused_webpack_module, exports1, __webpack_require__) {
var conventions = __webpack_require__("../../node_modules/.pnpm/@xmldom+xmldom@0.8.10/node_modules/@xmldom/xmldom/lib/conventions.js");
var find = conventions.find;
var NAMESPACE = conventions.NAMESPACE;
function notEmptyString(input) {
return '' !== input;
}
function splitOnASCIIWhitespace(input) {
return input ? input.split(/[\t\n\f\r ]+/).filter(notEmptyString) : [];
}
function orderedSetReducer(current, element) {
if (!current.hasOwnProperty(element)) current[element] = true;
return current;
}
function toOrderedSet(input) {
if (!input) return [];
var list = splitOnASCIIWhitespace(input);
return Object.keys(list.reduce(orderedSetReducer, {}));
}
function arrayIncludes(list) {
return function(element) {
return list && -1 !== list.indexOf(element);
};
}
function copy(src, dest) {
for(var p in src)if (Object.prototype.hasOwnProperty.call(src, p)) dest[p] = src[p];
}
function _extends(Class, Super) {
var pt = Class.prototype;
if (!(pt instanceof Super)) {
function t() {}
t.prototype = Super.prototype;
t = new t();
copy(pt, t);
Class.prototype = pt = t;
}
if (pt.constructor != Class) {
if ('function' != typeof Class) console.error("unknown Class:" + Class);
pt.constructor = Class;
}
}
var NodeType = {};
var ELEMENT_NODE = NodeType.ELEMENT_NODE = 1;
var ATTRIBUTE_NODE = NodeType.ATTRIBUTE_NODE = 2;
var TEXT_NODE = NodeType.TEXT_NODE = 3;
var CDATA_SECTION_NODE = NodeType.CDATA_SECTION_NODE = 4;
var ENTITY_REFERENCE_NODE = NodeType.ENTITY_REFERENCE_NODE = 5;
var ENTITY_NODE = NodeType.ENTITY_NODE = 6;
var PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE = 7;
var COMMENT_NODE = NodeType.COMMENT_NODE = 8;
var DOCUMENT_NODE = NodeType.DOCUMENT_NODE = 9;
var DOCUMENT_TYPE_NODE = NodeType.DOCUMENT_TYPE_NODE = 10;
var DOCUMENT_FRAGMENT_NODE = NodeType.DOCUMENT_FRAGMENT_NODE = 11;
var NOTATION_NODE = NodeType.NOTATION_NODE = 12;
var ExceptionCode = {};
var ExceptionMessage = {};
ExceptionCode.INDEX_SIZE_ERR = (ExceptionMessage[1] = "Index size error", 1);
ExceptionCode.DOMSTRING_SIZE_ERR = (ExceptionMessage[2] = "DOMString size error", 2);
var HIERARCHY_REQUEST_ERR = ExceptionCode.HIERARCHY_REQUEST_ERR = (ExceptionMessage[3] = "Hierarchy request error", 3);
ExceptionCode.WRONG_DOCUMENT_ERR = (ExceptionMessage[4] = "Wrong document", 4);
ExceptionCode.INVALID_CHARACTER_ERR = (ExceptionMessage[5] = "Invalid character", 5);
ExceptionCode.NO_DATA_ALLOWED_ERR = (ExceptionMessage[6] = "No data allowed", 6);
ExceptionCode.NO_MODIFICATION_ALLOWED_ERR = (ExceptionMessage[7] = "No modification allowed", 7);
var NOT_FOUND_ERR = ExceptionCode.NOT_FOUND_ERR = (ExceptionMessage[8] = "Not found", 8);
ExceptionCode.NOT_SUPPORTED_ERR = (ExceptionMessage[9] = "Not supported", 9);
var INUSE_ATTRIBUTE_ERR = ExceptionCode.INUSE_ATTRIBUTE_ERR = (ExceptionMessage[10] = "Attribute in use", 10);
ExceptionCode.INVALID_STATE_ERR = (ExceptionMessage[11] = "Invalid state", 11);
ExceptionCode.SYNTAX_ERR = (ExceptionMessage[12] = "Syntax error", 12);
ExceptionCode.INVALID_MODIFICATION_ERR = (ExceptionMessage[13] = "Invalid modification", 13);
ExceptionCode.NAMESPACE_ERR = (ExceptionMessage[14] = "Invalid namespace", 14);
ExceptionCode.INVALID_ACCESS_ERR = (ExceptionMessage[15] = "Invalid access", 15);
function DOMException1(code, message) {
if (message instanceof Error) var error = message;
else {
error = this;
Error.call(this, ExceptionMessage[code]);
this.message = ExceptionMessage[code];
if (Error.captureStackTrace) Error.captureStackTrace(this, DOMException1);
}
error.code = code;
if (message) this.message = this.message + ": " + message;
return error;
}
DOMException1.prototype = Error.prototype;
copy(ExceptionCode, DOMException1);
function NodeList() {}
NodeList.prototype = {
length: 0,
item: function(index) {
return index >= 0 && index < this.length ? this[index] : null;
},
toString: function(isHTML, nodeFilter) {
for(var buf = [], i = 0; i < this.length; i++)serializeToString(this[i], buf, isHTML, nodeFilter);
return buf.join('');
},
filter: function(predicate) {
return Array.prototype.filter.call(this, predicate);
},
indexOf: function(item) {
return Array.prototype.indexOf.call(this, item);
}
};
function LiveNodeList(node, refresh) {
this._node = node;
this._refresh = refresh;
_updateLiveList(this);
}
function _updateLiveList(list) {
var inc = list._node._inc || list._node.ownerDocument._inc;
if (list._inc !== inc) {
var ls = list._refresh(list._node);
__set__(list, 'length', ls.length);
if (!list.$$length || ls.length < list.$$length) {
for(var i = ls.length; i in list; i++)if (Object.prototype.hasOwnProperty.call(list, i)) delete list[i];
}
copy(ls, list);
list._inc = inc;
}
}
LiveNodeList.prototype.item = function(i) {
_updateLiveList(this);
return this[i] || null;
};
_extends(LiveNodeList, NodeList);
function NamedNodeMap() {}
function _findNodeIndex(list, node) {
var i = list.length;
while(i--)if (list[i] === node) return i;
}
function _addNamedNode(el, list, newAttr, oldAttr) {
if (oldAttr) list[_findNodeIndex(list, oldAttr)] = newAttr;
else list[list.length++] = newAttr;
if (el) {
newAttr.ownerElement = el;
var doc = el.ownerDocument;
if (doc) {
oldAttr && _onRemoveAttribute(doc, el, oldAttr);
_onAddAttribute(doc, el, newAttr);
}
}
}
function _removeNamedNode(el, list, attr) {
var i = _findNodeIndex(list, attr);
if (i >= 0) {
var lastIndex = list.length - 1;
while(i < lastIndex)list[i] = list[++i];
list.length = lastIndex;
if (el) {
var doc = el.ownerDocument;
if (doc) {
_onRemoveAttribute(doc, el, attr);
attr.ownerElement = null;
}
}
} else throw new DOMException1(NOT_FOUND_ERR, new Error(el.tagName + '@' + attr));
}
NamedNodeMap.prototype = {
length: 0,
item: NodeList.prototype.item,
getNamedItem: function(key) {
var i = this.length;
while(i--){
var attr = this[i];
if (attr.nodeName == key) return attr;
}
},
setNamedItem: function(attr) {
var el = attr.ownerElement;
if (el && el != this._ownerElement) throw new DOMException1(INUSE_ATTRIBUTE_ERR);
var oldAttr = this.getNamedItem(attr.nodeName);
_addNamedNode(this._ownerElement, this, attr, oldAttr);
return oldAttr;
},
setNamedItemNS: function(attr) {
var el = attr.ownerElement, oldAttr;
if (el && el != this._ownerElement) throw new DOMException1(INUSE_ATTRIBUTE_ERR);
oldAttr = this.getNamedItemNS(attr.namespaceURI, attr.localName);
_addNamedNode(this._ownerElement, this, attr, oldAttr);
return oldAttr;
},
removeNamedItem: function(key) {
var attr = this.getNamedItem(key);
_removeNamedNode(this._ownerElement, this, attr);
return attr;
},
removeNamedItemNS: function(namespaceURI, localName) {
var attr = this.getNamedItemNS(namespaceURI, localName);
_removeNamedNode(this._ownerElement, this, attr);
return attr;
},
getNamedItemNS: function(namespaceURI, localName) {
var i = this.length;
while(i--){
var node = this[i];
if (node.localName == localName && node.namespaceURI == namespaceURI) return node;
}
return null;
}
};
function DOMImplementation() {}
DOMImplementation.prototype = {
hasFeature: function(feature, version) {
return true;
},
createDocument: function(namespaceURI, qualifiedName, doctype) {
var doc = new Document();
doc.implementation = this;
doc.childNodes = new NodeList();
doc.doctype = doctype || null;
if (doctype) doc.appendChild(doctype);
if (qualifiedName) {
var root = doc.createElementNS(namespaceURI, qualifiedName);
doc.appendChild(root);
}
return doc;
},
createDocumentType: function(qualifiedName, publicId, systemId) {
var node = new DocumentType();
node.name = qualifiedName;
node.nodeName = qualifiedName;
node.publicId = publicId || '';
node.systemId = systemId || '';
return node;
}
};
function Node() {}
Node.prototype = {
firstChild: null,
lastChild: null,
previousSibling: null,
nextSibling: null,
attributes: null,
parentNode: null,
childNodes: null,
ownerDocument: null,
nodeValue: null,
namespaceURI: null,
prefix: null,
localName: null,
insertBefore: function(newChild, refChild) {
return _insertBefore(this, newChild, refChild);
},
replaceChild: function(newChild, oldChild) {
_insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);
if (oldChild) this.removeChild(oldChild);
},
removeChild: function(oldChild) {
return _removeChild(this, oldChild);
},
appendChild: function(newChild) {
return this.insertBefore(newChild, null);
},
hasChildNodes: function() {
return null != this.firstChild;
},
cloneNode: function(deep) {
return cloneNode(this.ownerDocument || this, this, deep);
},
normalize: function() {
var child = this.firstChild;
while(child){
var next = child.nextSibling;
if (next && next.nodeType == TEXT_NODE && child.nodeType == TEXT_NODE) {
this.removeChild(next);
child.appendData(next.data);
} else {
child.normalize();
child = next;
}
}
},
isSupported: function(feature, version) {
return this.ownerDocument.implementation.hasFeature(feature, version);
},
hasAttributes: function() {
return this.attributes.length > 0;
},
lookupPrefix: function(namespaceURI) {
var el = this;
while(el){
var map = el._nsMap;
if (map) {
for(var n in map)if (Object.prototype.hasOwnProperty.call(map, n) && map[n] === namespaceURI) return n;
}
el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;
}
return null;
},
lookupNamespaceURI: function(prefix) {
var el = this;
while(el){
var map = el._nsMap;
if (map) {
if (Object.prototype.hasOwnProperty.call(map, prefix)) return map[prefix];
}
el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;
}
return null;
},
isDefaultNamespace: function(namespaceURI) {
var prefix = this.lookupPrefix(namespaceURI);
return null == prefix;
}
};
function _xmlEncoder(c) {
return '<' == c && '<' || '>' == c && '>' || '&' == c && '&' || '"' == c && '"' || '&#' + c.charCodeAt() + ';';
}
copy(NodeType, Node);
copy(NodeType, Node.prototype);
function _visitNode(node, callback) {
if (callback(node)) return true;
if (node = node.firstChild) do if (_visitNode(node, callback)) return true;
while (node = node.nextSibling);
}
function Document() {
this.ownerDocument = this;
}
function _onAddAttribute(doc, el, newAttr) {
doc && doc._inc++;
var ns = newAttr.namespaceURI;
if (ns === NAMESPACE.XMLNS) el._nsMap[newAttr.prefix ? newAttr.localName : ''] = newAttr.value;
}
function _onRemoveAttribute(doc, el, newAttr, remove) {
doc && doc._inc++;
var ns = newAttr.namespaceURI;
if (ns === NAMESPACE.XMLNS) delete el._nsMap[newAttr.prefix ? newAttr.localName : ''];
}
function _onUpdateChild(doc, el, newChild) {
if (doc && doc._inc) {
doc._inc++;
var cs = el.childNodes;
if (newChild) cs[cs.length++] = newChild;
else {
var child = el.firstChild;
var i = 0;
while(child){
cs[i++] = child;
child = child.nextSibling;
}
cs.length = i;
delete cs[cs.length];
}
}
}
function _removeChild(parentNode, child) {
var previous = child.previousSibling;
var next = child.nextSibling;
if (previous) previous.nextSibling = next;
else parentNode.firstChild = next;
if (next) next.previousSibling = previous;
else parentNode.lastChild = previous;
child.parentNode = null;
child.previousSibling = null;
child.nextSibling = null;
_onUpdateChild(parentNode.ownerDocument, parentNode);
return child;
}
function hasValidParentNodeType(node) {
return node && (node.nodeType === Node.DOCUMENT_NODE || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node.ELEMENT_NODE);
}
function hasInsertableNodeType(node) {
return node && (isElementNode(node) || isTextNode(node) || isDocTypeNode(node) || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node.COMMENT_NODE || node.nodeType === Node.PROCESSING_INSTRUCTION_NODE);
}
function isDocTypeNode(node) {
return node && node.nodeType === Node.DOCUMENT_TYPE_NODE;
}
function isElementNode(node) {
return node && node.nodeType === Node.ELEMENT_NODE;
}
function isTextNode(node) {
return node && node.nodeType === Node.TEXT_NODE;
}
function isElementInsertionPossible(doc, child) {
var parentChildNodes = doc.childNodes || [];
if (find(parentChildNodes, isElementNode) || isDocTypeNode(child)) return false;
var docTypeNode = find(parentChildNodes, isDocTypeNode);
return !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child));
}
function isElementReplacementPossible(doc, child) {
var parentChildNodes = doc.childNodes || [];
function hasElementChildThatIsNotChild(node) {
return isElementNode(node) && node !== child;
}
if (find(parentChildNodes, hasElementChildThatIsNotChild)) return false;
var docTypeNode = find(parentChildNodes, isDocTypeNode);
return !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child));
}
function assertPreInsertionValidity1to5(parent, node, child) {
if (!hasValidParentNodeType(parent)) throw new DOMException1(HIERARCHY_REQUEST_ERR, 'Unexpected parent node type ' + parent.nodeType);
if (child && child.parentNode !== parent) throw new DOMException1(NOT_FOUND_ERR, 'child not in parent');
if (!hasInsertableNodeType(node) || isDocTypeNode(node) && parent.nodeType !== Node.DOCUMENT_NODE) throw new DOMException1(HIERARCHY_REQUEST_ERR, 'Unexpected node type ' + node.nodeType + ' for parent node type ' + parent.nodeType);
}
function assertPreInsertionValidityInDocument(parent, node, child) {
var parentChildNodes = parent.childNodes || [];
var nodeChildNodes = node.childNodes || [];
if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
var nodeChildElements = nodeChildNodes.filter(isElementNode);
if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) throw new DOMException1(HIERARCHY_REQUEST_ERR, 'More than one element or text in fragment');
if (1 === nodeChildElements.length && !isElementInsertionPossible(parent, child)) throw new DOMException1(HIERARCHY_REQUEST_ERR, 'Element in fragment can not be inserted before doctype');
}
if (isElementNode(node)) {
if (!isElementInsertionPossible(parent, child)) throw new DOMException1(HIERARCHY_REQUEST_ERR, 'Only one element can be added and only after doctype');
}
if (isDocTypeNode(node)) {
if (find(parentChildNodes, isDocTypeNode)) throw new DOMException1(HIERARCHY_REQUEST_ERR, 'Only one doctype is allowed');
var parentElementChild = find(parentChildNodes, isElementNode);
if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) throw new DOMException1(HIERARCHY_REQUEST_ERR, 'Doctype can only be inserted before an element');
if (!child && parentElementChild) throw new DOMException1(HIERARCHY_REQUEST_ERR, 'Doctype can not be appended since element is present');
}
}
function assertPreReplacementValidityInDocument(parent, node, child) {
var parentChildNodes = parent.childNodes || [];
var nodeChildNodes = node.childNodes || [];
if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
var nodeChildElements = nodeChildNodes.filter(isElementNode);
if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) throw new DOMException1(HIERARCHY_REQUEST_ERR, 'More than one element or text in fragment');
if (1 === nodeChildElements.length && !isElementReplacementPossible(parent, child)) throw new DOMException1(HIERARCHY_REQUEST_ERR, 'Element in fragment can not be inserted before doctype');
}
if (isElementNode(node)) {
if (!isElementReplacementPossible(parent, child)) throw new DOMException1(HIERARCHY_REQUEST_ERR, 'Only one element can be added and only after doctype');
}
if (isDocTypeNode(node)) {
function hasDoctypeChildThatIsNotChild(node) {
return isDocTypeNode(node) && node !== child;
}
if (find(parentChildNodes, hasDoctypeChildThatIsNotChild)) throw new DOMException1(HIERARCHY_REQUEST_ERR, 'Only one doctype is allowed');
var parentElementChild = find(parentChildNodes, isElementNode);
if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) throw new DOMException1(HIERARCHY_REQUEST_ERR, 'Doctype can only be inserted before an element');
}
}
function _insertBefore(parent, node, child, _inDocumentAssertion) {
assertPreInsertionValidity1to5(parent, node, child);
if (parent.nodeType === Node.DOCUMENT_NODE) (_inDocumentAssertion || assertPreInsertionValidityInDocument)(parent, node, child);
var cp = node.parentNode;
if (cp) cp.removeChild(node);
if (node.nodeType === DOCUMENT_FRAGMENT_NODE) {
var newFirst = node.firstChild;
if (null == newFirst) return node;
var newLast = node.lastChild;
} else newFirst = newLast = node;
var pre = child ? child.previousSibling : parent.lastChild;
newFirst.previousSibling = pre;
newLast.nextSibling = child;
if (pre) pre.nextSibling = newFirst;
else parent.firstChild = newFirst;
if (null == child) parent.lastChild = newLast;
else child.previousSibling = newLast;
do newFirst.parentNode = parent;
while (newFirst !== newLast && (newFirst = newFirst.nextSibling));
_onUpdateChild(parent.ownerDocument || parent, parent);
if (node.nodeType == DOCUMENT_FRAGMENT_NODE) node.firstChild = node.lastChild = null;
return node;
}
function _appendSingleChild(parentNode, newChild) {
if (newChild.parentNode) newChild.parentNode.removeChild(newChild);
newChild.parentNode = parentNode;
newChild.previousSibling = parentNode.lastChild;
newChild.nextSibling = null;
if (newChild.previousSibling) newChild.previousSibling.nextSibling = newChild;
else parentNode.firstChild = newChild;
parentNode.lastChild = newChild;
_onUpdateChild(parentNode.ownerDocument, parentNode, newChild);
return newChild;
}
Document.prototype = {
nodeName: '#document',
nodeType: DOCUMENT_NODE,
doctype: null,
documentElement: null,
_inc: 1,
insertBefore: function(newChild, refChild) {
if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {
var child = newChild.firstChild;
while(child){
var next = child.nextSibling;
this.insertBefore(child, refChild);
child = next;
}
return newChild;
}
_insertBefore(this, newChild, refChild);
newChild.ownerDocument = this;
if (null === this.documentElement && newChild.nodeType === ELEMENT_NODE) this.documentElement = newChild;
return newChild;
},
removeChild: function(oldChild) {
if (this.documentElement == oldChild) this.documentElement = null;
return _removeChild(this, oldChild);
},
replaceChild: function(newChild, oldChild) {
_insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);
newChild.ownerDocument = this;
if (oldChild) this.removeChild(oldChild);
if (isElementNode(newChild)) this.documentElement = newChild;
},
importNode: function(importedNode, deep) {
return importNode(this, importedNode, deep);
},
getElementById: function(id) {
var rtv = null;
_visitNode(this.documentElement, function(node) {
if (node.nodeType == ELEMENT_NODE) {
if (node.getAttribute('id') == id) {
rtv = node;
return true;
}
}
});
return rtv;
},
getElementsByClassName: function(classNames) {
var classNamesSet = toOrderedSet(classNames);
return new LiveNodeList(this, function(base) {
var ls = [];
if (classNamesSet.length > 0) _visitNode(base.documentElement, function(node) {
if (node !== base && node.nodeType === ELEMENT_NODE) {
var nodeClassNames = node.getAttribute('class');
if (nodeClassNames) {
var matches = classNames === nodeClassNames;
if (!matches) {
var nodeClassNamesSet = toOrderedSet(nodeClassNames);
matches = classNamesSet.every(arrayIncludes(nodeClassNamesSet));
}
if (matches) ls.push(node);
}
}
});
return ls;
});
},
createElement: function(tagName) {
var node = new Element();
node.ownerDocument = this;
node.nodeName = tagName;
node.tagName = tagName;
node.localName = tagName;
node.childNodes = new NodeList();
var attrs = node.attributes = new NamedNodeMap();
attrs._ownerElement = node;
return node;
},
createDocumentFragment: function() {
var node = new DocumentFragment();
node.ownerDocument = this;
node.childNodes = new NodeList();
return node;
},
createTextNode: function(data) {
var node = new Text();
node.ownerDocument = this;
node.appendData(data);
return node;
},
createComment: function(data) {
var node = new Comment();
node.ownerDocument = this;
node.appendData(data);
return node;
},
createCDATASection: function(data) {
var node = new CDATASection();
node.ownerDocument = this;
node.appendData(data);
return node;
},
createProcessingInstruction: function(target, data) {
var node = new ProcessingInstruction();
node.ownerDocument = this;
node.tagName = node.nodeName = node.target = target;
node.nodeValue = node.data = data;
return node;
},
createAttribute: function(name) {
var node = new Attr();
node.ownerDocument = this;
node.name = name;
node.nodeName = name;
node.localName = name;
node.specified = true;
return node;
},
createEntityReference: function(name) {
var node = new EntityReference();
node.ownerDocument = this;
node.nodeName = name;
return node;
},
createElementNS: function(namespaceURI, qualifiedName) {
var node = new Element();
var pl = qualifiedName.split(':');
var attrs = node.attributes = new NamedNodeMap();
node.childNodes = new NodeList();
node.ownerDocument = this;
node.nodeName = qualifiedName;
node.tagName = qualifiedName;
node.namespaceURI = namespaceURI;
if (2 == pl.length) {
node.prefix = pl[0];
node.localName = pl[1];
} else node.localName = qualifiedName;
attrs._ownerElement = node;
return node;
},
createAttributeNS: function(namespaceURI, qualifiedName) {
var node = new Attr();
var pl = qualifiedName.split(':');
node.ownerDocument = this;
node.nodeName = qualifiedName;
node.name = qualifiedName;
node.namespaceURI = namespaceURI;
node.specified = true;
if (2 == pl.length) {
node.prefix = pl[0];
node.localName = pl[1];
} else node.localName = qualifiedName;
return node;
}
};
_extends(Document, Node);
function Element() {
this._nsMap = {};
}
Element.prototype = {
nodeType: ELEMENT_NODE,
hasAttribute: function(name) {
return null != this.getAttributeNode(name);
},
getAttribute: function(name) {
var attr = this.getAttributeNode(name);
return attr && attr.value || '';
},
getAttributeNode: function(name) {
return this.attributes.getNamedItem(name);
},
setAttribute: function(name, value) {
var attr = this.ownerDocument.createAttribute(name);
attr.value = attr.nodeValue = "" + value;
this.setAttributeNode(attr);
},
removeAttribute: function(name) {
var attr = this.getAttributeNode(name);
attr && this.removeAttributeNode(attr);
},
appendChild: function(newChild) {
if (newChild.nodeType === DOCUMENT_FRAGMENT_NODE) return this.insertBefore(newChild, null);
return _appendSingleChild(this, newChild);
},
setAttributeNode: function(newAttr) {
return this.attributes.setNamedItem(newAttr);
},
setAttributeNodeNS: function(newAttr) {
return this.attributes.setNamedItemNS(newAttr);
},
removeAttributeNode: function(oldAttr) {
return this.attributes.removeNamedItem(oldAttr.nodeName);
},
removeAttributeNS: function(namespaceURI, localName) {
var old = this.getAttributeNodeNS(namespaceURI, localName);
old && this.removeAttributeNode(old);
},
hasAttributeNS: function(namespaceURI, localName) {
return null != this.getAttributeNodeNS(namespaceURI, localName);
},
getAttributeNS: function(namespaceURI, localName) {
var attr = this.getAttributeNodeNS(namespaceURI, localName);
return attr && attr.value || '';
},
setAttributeNS: function(namespaceURI, qualifiedName, value) {
var attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);
attr.value = attr.nodeValue = "" + value;
this.setAttributeNode(attr);
},
getAttributeNodeNS: function(namespaceURI, localName) {
return this.attributes.getNamedItemNS(namespaceURI, localName);
},
getElementsByTagName: function(tagName) {
return new LiveNodeList(this, function(base) {
var ls = [];
_visitNode(base, function(node) {
if (node !== base && node.nodeType == ELEMENT_NODE && ('*' === tagName || node.tagName == tagName)) ls.push(node);
});
return ls;
});
},
getElementsByTagNameNS: function(namespaceURI, localName) {
return new LiveNodeList(this, function(base) {
var ls = [];
_visitNode(base, function(node) {
if (node !== base && node.nodeType === ELEMENT_NODE && ('*' === namespaceURI || node.namespaceURI === namespaceURI) && ('*' === localName || node.localName == localName)) ls.push(node);
});
return ls;
});
}
};
Document.prototype.getElementsByTagName = Element.prototype.getElementsByTagName;
Document.prototype.getElementsByTagNameNS = Element.prototype.getElementsByTagNameNS;
_extends(Element, Node);
function Attr() {}
Attr.prototype.nodeType = ATTRIBUTE_NODE;
_extends(Attr, Node);
function CharacterData() {}
CharacterData.prototype = {
data: '',
substringData: function(offset, count) {
return this.data.substring(offset, offset + count);
},
appendData: function(text) {
text = this.data + text;
this.nodeValue = this.data = text;
this.length = text.length;
},
insertData: function(offset, text) {
this.replaceData(offset, 0, text);
},
appendChild: function(newChild) {
throw new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR]);
},
deleteData: function(offset, count) {
this.replaceData(offset, count, "");
},
replaceData: function(offset, count, text) {
var start = this.data.substring(0, offset);
var end = this.data.substring(offset + count);
text = start + text + end;
this.nodeValue = this.data = text;
this.length = text.length;
}
};
_extends(CharacterData, Node);
function Text() {}
Text.prototype = {
nodeName: "#text",
nodeType: TEXT_NODE,
splitText: function(offset) {
var text = this.data;
var newText = text.substring(offset);
text = text.substring(0, offset);
this.data = this.nodeValue = text;
this.length = text.length;
var newNode = this.ownerDocument.createTextNode(newText);
if (this.parentNode) this.parentNode.insertBefore(newNode, this.nextSibling);
return newNode;
}
};
_extends(Text, CharacterData);
function Comment() {}
Comment.prototype = {
nodeName: "#comment",
nodeType: COMMENT_NODE
};
_extends(Comment, CharacterData);
function CDATASection() {}
CDATASection.prototype = {
nodeName: "#cdata-section",
nodeType: CDATA_SECTION_NODE
};
_extends(CDATASection, CharacterData);
function DocumentType() {}
DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
_extends(DocumentType, Node);
function Notation() {}
Notation.prototype.nodeType = NOTATION_NODE;
_extends(Notation, Node);
function Entity() {}
Entity.prototype.nodeType = ENTITY_NODE;
_extends(Entity, Node);
function EntityReference() {}
EntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;
_extends(EntityReference, Node);
function DocumentFragment() {}
DocumentFragment.prototype.nodeName = "#document-fragment";
DocumentFragment.prototype.nodeType = DOCUMENT_FRAGMENT_NODE;
_extends(DocumentFragment, Node);
function ProcessingInstruction() {}
ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
_extends(ProcessingInstruction, Node);
function XMLSerializer() {}
XMLSerializer.prototype.serializeToString = function(node, isHtml, nodeFilter) {
return nodeSerializeToString.call(node, isHtml, nodeFilter);
};
Node.prototype.toString = nodeSerializeToString;
function nodeSerializeToString(isHtml, nodeFilter) {
var buf = [];
var refNode = 9 == this.nodeType && this.documentElement || this;
var prefix = refNode.prefix;
var uri = refNode.namespaceURI;
if (uri && null == prefix) {
var prefix = refNode.lookupPrefix(uri);
if (null == prefix) var visibleNamespaces = [
{
namespace: uri,
prefix: null
}
];
}
serializeToString(this, buf, isHtml, nodeFilter, visibleNamespaces);
return buf.join('');
}
function needNamespaceDefine(node, isHTML, visibleNamespaces) {
var prefix = node.prefix || '';
var uri = node.namespaceURI;
if (!uri) return false;
if ("xml" === prefix && uri === NAMESPACE.XML || uri === NAMESPACE.XMLNS) return false;
var i = visibleNamespaces.length;
while(i--){
var ns = visibleNamespaces[i];
if (ns.prefix === prefix) return ns.namespace !== uri;
}
return true;
}
function addSerializedAttribute(buf, qualifiedName, value) {
buf.push(' ', qualifiedName, '="', value.replace(/[<>&"\t\n\r]/g, _xmlEncoder), '"');
}
function serializeToString(node, buf, isHTML, nodeFilter, visibleNamespaces) {
if (!visibleNamespaces) visibleNamespaces = [];
if (nodeFilter) {
node = nodeFilter(node);
if (!node) return;
if ('string' == typeof node) {
buf.push(node);
return;
}
}
switch(node.nodeType){
case ELEMENT_NODE:
var attrs = node.attributes;
var len = attrs.length;
var child = node.firstChild;