@openplayerjs/ads 3.4.2 → 3.4.3

package/dist/index.js

@@ -5720,6 +5720,11 @@ function requireGrammar () {
 		// eslint-disable-next-line es5/no-unicode-code-point-escape
 		Char = reg('[', chars(Char), '\\u{10000}-\\u{10FFFF}', ']');
 	}
+	// Negation of Char: matches any character that is NOT a valid XML 1.0 Char.
+	// Derived directly from the Char character class above (after the unicode-support extension).
+	// XML 1.0 Char production [2]: #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
+	// @see https://www.w3.org/TR/xml/#NT-Char
+	var InvalidChar = new RegExp('[^' + chars(Char) + ']', UNICODE_SUPPORT ? 'u' : '');
 
 	var _SChar = /[\x20\x09\x0D\x0A]/;
 	var SChar_s = chars(_SChar);
@@ -5981,6 +5986,12 @@ function requireGrammar () {
 			regg(PUBLIC, S, '(?<PubidLiteral>', PubidLiteral, ')', S, '(?<SystemLiteral>', SystemLiteral, ')')
 		)
 	);
+	// Full-string anchored matcher for requireWellFormed serializer checks
+	// https://w3c.github.io/DOM-Parsing/#xml-serializing-a-document-node
+	var PubidLiteral_match = reg('^', PubidLiteral, '$');
+	// Full-string anchored matcher for requireWellFormed serializer checks
+	// https://w3c.github.io/DOM-Parsing/#xml-serializing-a-document-node
+	var SystemLiteral_match = reg('^', SystemLiteral, '$');
 
 	// https://www.w3.org/TR/xml11/#NT-NDataDecl
 	// `[76] NDataDecl ::= S 'NDATA' S Name` [VC: Notation Declared]
@@ -6104,6 +6115,7 @@ function requireGrammar () {
 	grammar.PI = PI;
 	grammar.PUBLIC = PUBLIC;
 	grammar.PubidLiteral = PubidLiteral;
+	grammar.PubidLiteral_match = PubidLiteral_match;
 	grammar.QName = QName;
 	grammar.QName_exact = QName_exact;
 	grammar.QName_group = QName_group;
@@ -6112,6 +6124,8 @@ function requireGrammar () {
 	grammar.S_OPT = S_OPT;
 	grammar.SYSTEM = SYSTEM;
 	grammar.SystemLiteral = SystemLiteral;
+	grammar.SystemLiteral_match = SystemLiteral_match;
+	grammar.InvalidChar = InvalidChar;
 	grammar.UNICODE_REPLACEMENT_CHARACTER = UNICODE_REPLACEMENT_CHARACTER;
 	grammar.UNICODE_SUPPORT = UNICODE_SUPPORT;
 	grammar.XMLDecl = XMLDecl;
@@ -6454,14 +6468,31 @@ function requireDom () {
 		/**
 		 * Returns a string representation of the NodeList.
 		 *
-		 * @param {unknown} nodeFilter
-		 * __A filter function? Not implemented according to the spec?__.
+		 * Accepts the same `options` object as `XMLSerializer.prototype.serializeToString`
+		 * (`requireWellFormed`, `splitCDATASections`, `nodeFilter`). Passing a function is treated as
+		 * a legacy `nodeFilter` for backward compatibility.
+		 *
+		 * @param {Object | function} [options]
+		 * @param {boolean} [options.requireWellFormed=false]
+		 * @param {boolean} [options.splitCDATASections=true]
+		 * @param {function} [options.nodeFilter]
 		 * @returns {string}
-		 * A string representation of the NodeList.
 		 */
-		toString: function (nodeFilter) {
+		toString: function (options) {
+			var opts;
+			if (typeof options === 'function') {
+				opts = { requireWellFormed: false, splitCDATASections: true, nodeFilter: options };
+			} else if (!!options) {
+				opts = {
+					requireWellFormed: !!options.requireWellFormed,
+					splitCDATASections: options.splitCDATASections !== false,
+					nodeFilter: options.nodeFilter || null,
+				};
+			} else {
+				opts = { requireWellFormed: false, splitCDATASections: true, nodeFilter: null };
+			}
 			for (var buf = [], i = 0; i < this.length; i++) {
-				serializeToString(this[i], buf, nodeFilter);
+				serializeToString(this[i], buf, null, opts);
 			}
 			return buf.join('');
 		},
@@ -6990,11 +7021,21 @@ function requireDom () {
 		 * The {@link https://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-qualifiedname qualified
 		 * name} of the document type to be created.
 		 * @param {string} [publicId]
-		 * The external subset public identifier.
+		 * The external subset public identifier. Stored verbatim including surrounding quotes.
+		 * When serialized with `requireWellFormed: true`, the serializer throws `InvalidStateError`
+		 * if the value is non-empty and does not match the XML `PubidLiteral` production
+		 * (W3C DOM Parsing §3.2.1.3; XML 1.0 production [12]). Creation-time validation is not
+		 * enforced — deferred to a future breaking release.
 		 * @param {string} [systemId]
-		 * The external subset system identifier.
+		 * The external subset system identifier. Stored verbatim including surrounding quotes.
+		 * When serialized with `requireWellFormed: true`, the serializer throws `InvalidStateError`
+		 * if the value is non-empty and does not match the XML `SystemLiteral` production
+		 * (W3C DOM Parsing §3.2.1.3; XML 1.0 production [11]). Creation-time validation is not
+		 * enforced — deferred to a future breaking release.
 		 * @param {string} [internalSubset]
-		 * the internal subset or an empty string if it is not present
+		 * The internal subset or an empty string if it is not present. Stored verbatim.
+		 * When serialized with `requireWellFormed: true`, the serializer throws `InvalidStateError`
+		 * if the value contains `"]>"`. Creation-time validation is not enforced.
 		 * @returns {DocumentType}
 		 * A new {@link DocumentType} node with {@link Node#ownerDocument} set to null.
 		 * @throws {DOMException}
@@ -7238,56 +7279,68 @@ function requireDom () {
 		/**
 		 * Checks whether the given node is equal to this node.
 		 *
+		 * Two nodes are equal when they have the same type, defining characteristics (for the type),
+		 * and the same childNodes. The comparison is iterative to avoid stack overflows on
+		 * deeply-nested trees. Attribute nodes of each Element pair are also pushed onto the stack
+		 * and compared the same way.
+		 *
 		 * @param {Node} [otherNode]
+		 * @returns {boolean}
 		 * @see https://dom.spec.whatwg.org/#concept-node-equals
+		 * @see ../docs/walk-dom.md.
 		 */
 		isEqualNode: function (otherNode) {
 			if (!otherNode) return false;
 
-			if (this.nodeType !== otherNode.nodeType) return false;
+			// Use an explicit {node, other} pair stack to avoid call-stack overflow on deep trees.
+			// walkDOM cannot be used here — parallel two-tree traversal requires pairing
+			// corresponding nodes at each step across both trees simultaneously.
+			var stack = [{ node: this, other: otherNode }];
+			while (stack.length > 0) {
+				var pair = stack.pop();
+				var node = pair.node;
+				var other = pair.other;
 
-			switch (this.nodeType) {
-				case this.DOCUMENT_TYPE_NODE:
-					if (this.name !== otherNode.name) return false;
-					if (this.publicId !== otherNode.publicId) return false;
-					if (this.systemId !== otherNode.systemId) return false;
-					break;
-				case this.ELEMENT_NODE:
-					if (this.namespaceURI !== otherNode.namespaceURI) return false;
-					if (this.prefix !== otherNode.prefix) return false;
-					if (this.localName !== otherNode.localName) return false;
-					if (this.attributes.length !== otherNode.attributes.length) return false;
-					for (var i = 0; i < this.attributes.length; i++) {
-						var attr = this.attributes.item(i);
-						if (!attr.isEqualNode(otherNode.getAttributeNodeNS(attr.namespaceURI, attr.localName))) {
-							return false;
-						}
-					}
-					break;
-				case this.ATTRIBUTE_NODE:
-					if (this.namespaceURI !== otherNode.namespaceURI) return false;
-					if (this.localName !== otherNode.localName) return false;
-					if (this.value !== otherNode.value) return false;
+				if (node.nodeType !== other.nodeType) return false;
 
-					break;
-				case this.PROCESSING_INSTRUCTION_NODE:
-					if (this.target !== otherNode.target || this.data !== otherNode.data) {
-						return false;
-					}
-					break;
-				case this.TEXT_NODE:
-				case this.COMMENT_NODE:
-					if (this.data !== otherNode.data) return false;
-					break;
-			}
+				switch (node.nodeType) {
+					case node.DOCUMENT_TYPE_NODE:
+						if (node.name !== other.name) return false;
+						if (node.publicId !== other.publicId) return false;
+						if (node.systemId !== other.systemId) return false;
+						break;
+					case node.ELEMENT_NODE:
+						if (node.namespaceURI !== other.namespaceURI) return false;
+						if (node.prefix !== other.prefix) return false;
+						if (node.localName !== other.localName) return false;
+						if (node.attributes.length !== other.attributes.length) return false;
+						for (var i = 0; i < node.attributes.length; i++) {
+							var attr = node.attributes.item(i);
+							var otherAttr = other.getAttributeNodeNS(attr.namespaceURI, attr.localName);
+							if (!otherAttr) return false;
+							stack.push({ node: attr, other: otherAttr });
+						}
+						break;
+					case node.ATTRIBUTE_NODE:
+						if (node.namespaceURI !== other.namespaceURI) return false;
+						if (node.localName !== other.localName) return false;
+						if (node.value !== other.value) return false;
+						break;
+					case node.PROCESSING_INSTRUCTION_NODE:
+						if (node.target !== other.target || node.data !== other.data) return false;
+						break;
+					case node.TEXT_NODE:
+					case node.CDATA_SECTION_NODE:
+					case node.COMMENT_NODE:
+						if (node.data !== other.data) return false;
+						break;
+				}
 
-			if (this.childNodes.length !== otherNode.childNodes.length) {
-				return false;
-			}
+				if (node.childNodes.length !== other.childNodes.length) return false;
 
-			for (var i = 0; i < this.childNodes.length; i++) {
-				if (!this.childNodes[i].isEqualNode(otherNode.childNodes[i])) {
-					return false;
+				// Push children in reverse order so index 0 is processed first (LIFO).
+				for (var i = node.childNodes.length - 1; i >= 0; i--) {
+					stack.push({ node: node.childNodes[i], other: other.childNodes[i] });
 				}
 			}
 
@@ -7407,7 +7460,7 @@ function requireDom () {
 		 * is `TEXT_NODE`) into a single node with the combined data. It also removes any empty text
 		 * nodes.
 		 *
-		 * This method operates recursively, so it also normalizes any and all descendent nodes within
+		 * This method iterativly traverses all child nodes to normalize all descendent nodes within
 		 * the subtree.
 		 *
 		 * @throws {DOMException}
@@ -7416,19 +7469,28 @@ function requireDom () {
 		 * @since Modified in DOM Level 2
 		 * @see {@link Node.removeChild}
 		 * @see {@link CharacterData.appendData}
+		 * @see ../docs/walk-dom.md.
 		 */
 		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;
-				}
-			}
+			walkDOM(this, null, {
+				enter: function (node) {
+					// Merge adjacent text children of node before walkDOM schedules them.
+					// walkDOM reads lastChild/previousSibling after enter returns, so the
+					// surviving post-merge children are what it descends into.
+					var child = node.firstChild;
+					while (child) {
+						var next = child.nextSibling;
+						if (next !== null && next.nodeType === TEXT_NODE && child.nodeType === TEXT_NODE) {
+							node.removeChild(next);
+							child.appendData(next.data);
+							// Do not advance child: re-check new nextSibling for another text run
+						} else {
+							child = next;
+						}
+					}
+					return true; // descend into surviving children
+				},
+			});
 		},
 		/**
 		 * Checks whether the DOM implementation implements a specific feature and its version.
@@ -7645,24 +7707,112 @@ function requireDom () {
 	copy(DocumentPosition, Node.prototype);
 
 	/**
-	 * @param callback
-	 * Return true for continue,false for break.
-	 * @returns
-	 * boolean true: break visit;
+	 * Visits every node in the subtree rooted at `node` in depth-first pre-order.
+	 *
+	 * Delegates to {@link walkDOM} for traversal. The `callback` is called on each node;
+	 * if it returns a truthy value, traversal stops immediately.
+	 *
+	 * @param {Node} node
+	 * Root of the subtree to visit.
+	 * @param {function(Node): *} callback
+	 * Called for each node. A truthy return value stops traversal early.
 	 */
 	function _visitNode(node, callback) {
-		if (callback(node)) {
-			return true;
-		}
-		if ((node = node.firstChild)) {
-			do {
-				if (_visitNode(node, callback)) {
-					return true;
+		walkDOM(node, null, {
+			enter: function (n) {
+				return callback(n) ? walkDOM.STOP : true;
+			},
+		});
+	}
+
+	/**
+	 * Depth-first pre/post-order DOM tree walker.
+	 *
+	 * Visits every node in the subtree rooted at `node`. For each node:
+	 *
+	 * 1. Calls `callbacks.enter(node, context)` before descending into the node's children. The
+	 * return value becomes the `context` passed to each child's `enter` call and to the matching
+	 * `exit` call.
+	 * 2. If `enter` returns `null` or `undefined`, the node's children are skipped;
+	 * sibling traversal continues normally.
+	 * 3. If `enter` returns `walkDOM.STOP`, the entire traversal is aborted immediately — no
+	 * further `enter` or `exit` calls are made.
+	 * 4. `lastChild` and `previousSibling` are read **after** `enter` returns, so `enter` may
+	 * safely modify the node's own child list before the walker descends. Modifying siblings of
+	 * the current node or any other part of the tree produces unpredictable results: nodes already
+	 * queued on the stack are visited regardless of DOM changes, and newly inserted nodes outside
+	 * the current child list are never visited.
+	 * 5. Calls `callbacks.exit(node, context)` (if provided) after all of a node's children have
+	 * been visited, passing the same `context` that `enter`
+	 * returned for that node.
+	 *
+	 * This implementation uses an explicit stack and does not recurse — it is safe on arbitrarily
+	 * deep trees.
+	 *
+	 * @param {Node} node
+	 * Root of the subtree to walk.
+	 * @param {*} context
+	 * Initial context value passed to the root node's `enter`.
+	 * @param {{ enter: function(Node, *): *, exit?: function(Node, *): void }} callbacks
+	 * @returns {void | walkDOM.STOP}
+	 * @see ../docs/walk-dom.md.
+	 */
+	function walkDOM(node, context, callbacks) {
+		// Each stack frame is {node, context, phase}:
+		//   walkDOM.ENTER — call enter, then push children
+		//   walkDOM.EXIT  — call exit
+		var stack = [{ node: node, context: context, phase: walkDOM.ENTER }];
+		while (stack.length > 0) {
+			var frame = stack.pop();
+			if (frame.phase === walkDOM.ENTER) {
+				var childContext = callbacks.enter(frame.node, frame.context);
+				if (childContext === walkDOM.STOP) {
+					return walkDOM.STOP;
+				}
+				// Push exit frame before children so it fires after all children are processed (Last In First Out)
+				stack.push({ node: frame.node, context: childContext, phase: walkDOM.EXIT });
+				if (childContext === null || childContext === undefined) {
+					continue; // skip children
+				}
+				// lastChild is read after enter returns, so enter may modify the child list.
+				var child = frame.node.lastChild;
+				// Traverse from lastChild backwards so that pushing onto the stack
+				// naturally yields firstChild on top (processed first).
+				while (child) {
+					stack.push({ node: child, context: childContext, phase: walkDOM.ENTER });
+					child = child.previousSibling;
+				}
+			} else {
+				// frame.phase === walkDOM.EXIT
+				if (callbacks.exit) {
+					callbacks.exit(frame.node, frame.context);
 				}
-			} while ((node = node.nextSibling));
+			}
 		}
 	}
 
+	/**
+	 * Sentinel value returned from a `walkDOM` `enter` callback to abort the entire traversal
+	 * immediately.
+	 *
+	 * @type {symbol}
+	 */
+	walkDOM.STOP = Symbol('walkDOM.STOP');
+	/**
+	 * Phase constant for a stack frame that has not yet been visited.
+	 * The `enter` callback is called and children are scheduled.
+	 *
+	 * @type {number}
+	 */
+	walkDOM.ENTER = 0;
+	/**
+	 * Phase constant for a stack frame whose subtree has been fully visited.
+	 * The `exit` callback is called.
+	 *
+	 * @type {number}
+	 */
+	walkDOM.EXIT = 1;
+
 	/**
 	 * @typedef DocumentOptions
 	 * @property {string} [contentType=MIME_TYPE.XML_APPLICATION]
@@ -8249,7 +8399,20 @@ function requireDom () {
 				this.documentElement = newChild;
 			}
 		},
-		// Introduced in DOM Level 2:
+		/**
+		 * Imports a node from another document into this document, creating a new copy owned by this
+		 * document. The source node and its subtree are not modified.
+		 *
+		 * @param {Node} importedNode
+		 * The node to import.
+		 * @param {boolean} deep
+		 * If true, the contents of the node are recursively imported.
+		 * If false, only the node itself (and its attributes, if it is an element) are imported.
+		 * @returns {Node}
+		 * Returns the newly created import of the node.
+		 * @see {@link importNode}
+		 * @see {@link https://dom.spec.whatwg.org/#dom-document-importnode}
+		 */
 		importNode: function (importedNode, deep) {
 			return importNode(this, importedNode, deep);
 		},
@@ -8325,6 +8488,15 @@ function requireDom () {
 		/**
 		 * @param {string} data
 		 * @returns {Comment}
+		 * @see https://dom.spec.whatwg.org/#dom-document-createcomment
+		 * @see https://www.w3.org/TR/xml/#NT-Comment XML 1.0 production [15]
+		 * @see https://www.w3.org/TR/DOM-Parsing/#dfn-concept-serialize-xml §3.2.1.3
+		 *
+		 *      Note: no validation is performed at creation time. When the resulting document is
+		 *      serialized with `requireWellFormed: true`, the serializer throws `InvalidStateError`
+		 *      if the comment data contains `--` anywhere, ends with `-`, or contains characters
+		 *      outside the XML Char production (W3C DOM Parsing §3.2.1.3). Without that option the
+		 *      data is emitted verbatim.
 		 */
 		createComment: function (data) {
 			var node = new Comment(PDC);
@@ -8357,9 +8529,24 @@ function requireDom () {
 			return node;
 		},
 		/**
+		 * Returns a ProcessingInstruction node whose target is target and data is data.
+		 *
+		 * __This behavior is slightly different from the in the specs__:
+		 * - it does not do any input validation on the arguments and doesn't throw
+		 * "InvalidCharacterError".
+		 *
+		 * Note: When the resulting document is serialized with `requireWellFormed: true`, the
+		 * serializer throws `InvalidStateError` if `.target` contains `:` or is an ASCII
+		 * case-insensitive match for `"xml"`, or if `.data` contains `?>` or characters outside the
+		 * XML Char production (W3C DOM Parsing §3.2.1.7). Without that option the data is emitted
+		 * verbatim.
+		 *
 		 * @param {string} target
 		 * @param {string} data
 		 * @returns {ProcessingInstruction}
+		 * @see https://developer.mozilla.org/docs/Web/API/Document/createProcessingInstruction
+		 * @see https://dom.spec.whatwg.org/#dom-document-createprocessinginstruction
+		 * @see https://www.w3.org/TR/DOM-Parsing/#dfn-concept-serialize-xml §3.2.1.7
 		 */
 		createProcessingInstruction: function (target, data) {
 			var node = new ProcessingInstruction(PDC);
@@ -8792,6 +8979,31 @@ function requireDom () {
 	};
 	_extends(CDATASection, Text);
 
+	/**
+	 * @class DocumentType
+	 * @augments Node
+	 * @property {string} publicId
+	 * The external subset public identifier, stored verbatim (including surrounding quotes).
+	 * Declared `readonly` by the WHATWG DOM spec; xmldom does not enforce this constraint —
+	 * direct property writes succeed and the written value is serialized verbatim.
+	 * When serialized with `requireWellFormed: true`, the serializer validates the value against
+	 * the XML `PubidLiteral` production and throws `InvalidStateError` if it does not match.
+	 * @property {string} systemId
+	 * The external subset system identifier, stored verbatim (including surrounding quotes).
+	 * Declared `readonly` by the WHATWG DOM spec; xmldom does not enforce this constraint —
+	 * direct property writes succeed and the written value is serialized verbatim.
+	 * When serialized with `requireWellFormed: true`, the serializer validates the value against
+	 * the XML `SystemLiteral` production and throws `InvalidStateError` if it does not match.
+	 * @property {string} internalSubset
+	 * The internal subset string (the raw content between `[` and `]`), or an empty string.
+	 * Declared `readonly` by the WHATWG DOM spec; xmldom does not enforce this constraint —
+	 * direct property writes succeed and the written value is serialized verbatim.
+	 * When serialized with `requireWellFormed: true`, the serializer throws `InvalidStateError`
+	 * if the value contains `"]>"`.
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DocumentType MDN
+	 * @see https://dom.spec.whatwg.org/#interface-documenttype WHATWG DOM
+	 * @prettierignore
+	 */
 	function DocumentType(symbol) {
 		checkSymbol(symbol);
 	}
@@ -8832,21 +9044,79 @@ function requireDom () {
 	/**
 	 * Returns the result of serializing `node` to XML.
 	 *
-	 * __This implementation differs from the specification:__ - CDATASection nodes whose data
-	 * contains `]]>` are serialized by splitting the section at each `]]>` occurrence (following
-	 * W3C DOM Level 3 Core `split-cdata-sections`
-	 * default behaviour). A configurable option is not yet implemented.
+	 * When `options.requireWellFormed` is `true`, the serializer throws `InvalidStateError` for
+	 * content that would produce ill-formed XML (e.g. CDATASection data containing `"]]>"`, Text
+	 * data containing characters outside the XML Char production, or a Document with no
+	 * `documentElement`).
+	 *
+	 * When `options.splitCDATASections` is `false`, CDATASection data is emitted verbatim even
+	 * when it contains `"]]>"`. When `true` (the default), `"]]>"` sequences are split across
+	 * concatenated CDATA sections — this behavior is **deprecated** and will be removed in the
+	 * next breaking release. Callers should migrate to `{ requireWellFormed: true }`, which throws
+	 * `InvalidStateError` instead of transforming.
+	 *
+	 * __This implementation differs from the specification:__ - CDATASection serialization is not
+	 * specified by W3C DOM Parsing or WHATWG DOM Parsing (see
+	 * {@link https://github.com/w3c/DOM-Parsing/issues/38 w3c/DOM-Parsing#38}).
+	 * When `splitCDATASections` is `true` (the default), `"]]>"` sequences in CDATASection data
+	 * are split across concatenated CDATA sections — this mechanism is derived from DOM Level 3
+	 * Core and is **deprecated**. The split mechanics will be removed in the next breaking
+	 * release. Callers that rely on this behavior should migrate to `{ requireWellFormed: true }`.
+	 * - W3C DOM Parsing §3.2.1.1 requires well-formedness checks on Element `localName`s,
+	 * prefixes,
+	 * and attribute serialization (duplicate attributes, namespace declarations, attribute value
+	 * characters) when `requireWellFormed` is `true`. These checks are **not implemented** in this
+	 * release — see the tracking issue filed against the next breaking milestone.
 	 *
 	 * @param {Node} node
-	 * @param {function} [nodeFilter]
+	 * @param {Object | function} [options]
+	 * Options object, or a legacy nodeFilter function (backward compatible).
+	 * @param {boolean} [options.requireWellFormed=false]
+	 * When `true`, throws `InvalidStateError` for content that would produce ill-formed XML.
+	 * @param {boolean} [options.splitCDATASections=true]
+	 * When `true` (default), splits `"]]>"` sequences in CDATASection data across concatenated
+	 * CDATA sections. **Deprecated** — will be removed in the next breaking release.
+	 * @param {function} [options.nodeFilter]
+	 * A filter function applied to each node before serialization.
 	 * @returns {string}
+	 * @throws {DOMException}
+	 * With name `InvalidStateError` when `requireWellFormed` is `true` and any of the following
+	 * conditions hold:
+	 * - CDATASection data contains `"]]>"`
+	 * - Text data contains characters outside the XML Char production
+	 * - a Comment node's data contains `--` anywhere or ends with `-`
+	 * - a ProcessingInstruction's target contains `:` or is an ASCII case-insensitive match for
+	 * `"xml"`, or its data contains `?>` or characters outside the XML Char production
+	 * - a DocumentType's `publicId` is non-empty and does not match the XML `PubidLiteral`
+	 * production (W3C DOM Parsing §3.2.1.3; XML 1.0 production [12])
+	 * - a DocumentType's `systemId` is non-empty and does not match the XML `SystemLiteral`
+	 * production (W3C DOM Parsing §3.2.1.3; XML 1.0 production [11])
+	 * - a DocumentType's `internalSubset` contains `"]>"`
+	 * - the Document has no `documentElement`
+	 * @see https://developer.mozilla.org/docs/Web/API/XMLSerializer/serializeToString
 	 * @see https://html.spec.whatwg.org/#dom-xmlserializer-serializetostring
+	 * @see https://github.com/w3c/DOM-Parsing/issues/84
+	 * @prettierignore
 	 */
-	XMLSerializer.prototype.serializeToString = function (node, nodeFilter) {
-		return nodeSerializeToString.call(node, nodeFilter);
+	XMLSerializer.prototype.serializeToString = function (node, options) {
+		return nodeSerializeToString.call(node, options);
 	};
 	Node.prototype.toString = nodeSerializeToString;
-	function nodeSerializeToString(nodeFilter) {
+	function nodeSerializeToString(options) {
+		// Normalize the user-supplied options into a single internal opts object so that the
+		// internal serializer always works with a consistent shape rather than positional flags.
+		var opts;
+		if (typeof options === 'function') {
+			opts = { requireWellFormed: false, splitCDATASections: true, nodeFilter: options };
+		} else if (options != null) {
+			opts = {
+				requireWellFormed: !!options.requireWellFormed,
+				splitCDATASections: options.splitCDATASections !== false,
+				nodeFilter: options.nodeFilter || null,
+			};
+		} else {
+			opts = { requireWellFormed: false, splitCDATASections: true, nodeFilter: null };
+		}
 		var buf = [];
 		var refNode = (this.nodeType === DOCUMENT_NODE && this.documentElement) || this;
 		var prefix = refNode.prefix;
@@ -8861,7 +9131,7 @@ function requireDom () {
 				];
 			}
 		}
-		serializeToString(this, buf, nodeFilter, visibleNamespaces);
+		serializeToString(this, buf, visibleNamespaces, opts);
 		return buf.join('');
 	}
 
@@ -8911,235 +9181,317 @@ function requireDom () {
 		buf.push(' ', qualifiedName, '="', value.replace(/[<>&"\t\n\r]/g, _xmlEncoder), '"');
 	}
 
-	function serializeToString(node, buf, nodeFilter, visibleNamespaces) {
+	function serializeToString(node, buf, visibleNamespaces, opts) {
 		if (!visibleNamespaces) {
 			visibleNamespaces = [];
 		}
+		var nodeFilter = opts.nodeFilter;
+		var requireWellFormed = opts.requireWellFormed;
+		var splitCDATASections = opts.splitCDATASections;
 		var doc = node.nodeType === DOCUMENT_NODE ? node : node.ownerDocument;
 		var isHTML = doc.type === 'html';
 
-		if (nodeFilter) {
-			node = nodeFilter(node);
-			if (node) {
-				if (typeof node == 'string') {
-					buf.push(node);
-					return;
-				}
-			} else {
-				return;
-			}
-			//buf.sort.apply(attrs, attributeSorter);
-		}
-
-		switch (node.nodeType) {
-			case ELEMENT_NODE:
-				var attrs = node.attributes;
-				var len = attrs.length;
-				var child = node.firstChild;
-				var nodeName = node.tagName;
-
-				var prefixedNodeName = nodeName;
-				if (!isHTML && !node.prefix && node.namespaceURI) {
-					var defaultNS;
-					// lookup current default ns from `xmlns` attribute
-					for (var ai = 0; ai < attrs.length; ai++) {
-						if (attrs.item(ai).name === 'xmlns') {
-							defaultNS = attrs.item(ai).value;
-							break;
-						}
-					}
-					if (!defaultNS) {
-						// lookup current default ns in visibleNamespaces
-						for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {
-							var namespace = visibleNamespaces[nsi];
-							if (namespace.prefix === '' && namespace.namespace === node.namespaceURI) {
-								defaultNS = namespace.namespace;
-								break;
+		walkDOM(
+			node,
+			{ ns: visibleNamespaces },
+			{
+				enter: function (n, ctx) {
+					var namespaces = ctx.ns;
+
+					if (nodeFilter) {
+						n = nodeFilter(n);
+						if (n) {
+							if (typeof n == 'string') {
+								buf.push(n);
+								return null;
 							}
+						} else {
+							return null;
 						}
 					}
-					if (defaultNS !== node.namespaceURI) {
-						for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {
-							var namespace = visibleNamespaces[nsi];
-							if (namespace.namespace === node.namespaceURI) {
-								if (namespace.prefix) {
-									prefixedNodeName = namespace.prefix + ':' + nodeName;
+
+					switch (n.nodeType) {
+						case ELEMENT_NODE:
+							var attrs = n.attributes;
+							var len = attrs.length;
+							var nodeName = n.tagName;
+
+							var prefixedNodeName = nodeName;
+							if (!isHTML && !n.prefix && n.namespaceURI) {
+								var defaultNS;
+								// lookup current default ns from `xmlns` attribute
+								for (var ai = 0; ai < attrs.length; ai++) {
+									if (attrs.item(ai).name === 'xmlns') {
+										defaultNS = attrs.item(ai).value;
+										break;
+									}
+								}
+								if (!defaultNS) {
+									// lookup current default ns in visibleNamespaces
+									for (var nsi = namespaces.length - 1; nsi >= 0; nsi--) {
+										var nsEntry = namespaces[nsi];
+										if (nsEntry.prefix === '' && nsEntry.namespace === n.namespaceURI) {
+											defaultNS = nsEntry.namespace;
+											break;
+										}
+									}
+								}
+								if (defaultNS !== n.namespaceURI) {
+									for (var nsi = namespaces.length - 1; nsi >= 0; nsi--) {
+										var nsEntry = namespaces[nsi];
+										if (nsEntry.namespace === n.namespaceURI) {
+											if (nsEntry.prefix) {
+												prefixedNodeName = nsEntry.prefix + ':' + nodeName;
+											}
+											break;
+										}
+									}
 								}
-								break;
 							}
-						}
-					}
-				}
 
-				buf.push('<', prefixedNodeName);
+							buf.push('<', prefixedNodeName);
 
-				for (var i = 0; i < len; i++) {
-					// add namespaces for attributes
-					var attr = attrs.item(i);
-					if (attr.prefix == 'xmlns') {
-						visibleNamespaces.push({
-							prefix: attr.localName,
-							namespace: attr.value,
-						});
-					} else if (attr.nodeName == 'xmlns') {
-						visibleNamespaces.push({ prefix: '', namespace: attr.value });
-					}
-				}
+							// Build a fresh namespace snapshot for this element's children.
+							// The slice prevents sibling elements from inheriting each other's declarations.
+							var childNamespaces = namespaces.slice();
 
-				for (var i = 0; i < len; i++) {
-					var attr = attrs.item(i);
-					if (needNamespaceDefine(attr, isHTML, visibleNamespaces)) {
-						var prefix = attr.prefix || '';
-						var uri = attr.namespaceURI;
-						addSerializedAttribute(buf, prefix ? 'xmlns:' + prefix : 'xmlns', uri);
-						visibleNamespaces.push({ prefix: prefix, namespace: uri });
-					}
-					serializeToString(attr, buf, nodeFilter, visibleNamespaces);
-				}
+							for (var i = 0; i < len; i++) {
+								// add namespaces for attributes
+								var attr = attrs.item(i);
+								if (attr.prefix == 'xmlns') {
+									childNamespaces.push({
+										prefix: attr.localName,
+										namespace: attr.value,
+									});
+								} else if (attr.nodeName == 'xmlns') {
+									childNamespaces.push({ prefix: '', namespace: attr.value });
+								}
+							}
 
-				// add namespace for current node
-				if (nodeName === prefixedNodeName && needNamespaceDefine(node, isHTML, visibleNamespaces)) {
-					var prefix = node.prefix || '';
-					var uri = node.namespaceURI;
-					addSerializedAttribute(buf, prefix ? 'xmlns:' + prefix : 'xmlns', uri);
-					visibleNamespaces.push({ prefix: prefix, namespace: uri });
-				}
-				// in XML elements can be closed when they have no children
-				var canCloseTag = !child;
-				if (canCloseTag && (isHTML || node.namespaceURI === NAMESPACE.HTML)) {
-					// in HTML (doc or ns) only void elements can be closed right away
-					canCloseTag = isHTMLVoidElement(nodeName);
-				}
-				if (canCloseTag) {
-					buf.push('/>');
-				} else {
-					buf.push('>');
-					//if is cdata child node
-					if (isHTML && isHTMLRawTextElement(nodeName)) {
-						while (child) {
-							if (child.data) {
-								buf.push(child.data);
+							for (var i = 0; i < len; i++) {
+								var attr = attrs.item(i);
+								if (needNamespaceDefine(attr, isHTML, childNamespaces)) {
+									var attrPrefix = attr.prefix || '';
+									var uri = attr.namespaceURI;
+									addSerializedAttribute(buf, attrPrefix ? 'xmlns:' + attrPrefix : 'xmlns', uri);
+									childNamespaces.push({ prefix: attrPrefix, namespace: uri });
+								}
+								// Apply nodeFilter and serialize the attribute.
+								var filteredAttr = nodeFilter ? nodeFilter(attr) : attr;
+								if (filteredAttr) {
+									if (typeof filteredAttr === 'string') {
+										buf.push(filteredAttr);
+									} else {
+										addSerializedAttribute(buf, filteredAttr.name, filteredAttr.value);
+									}
+								}
+							}
+
+							// add namespace for current node
+							if (nodeName === prefixedNodeName && needNamespaceDefine(n, isHTML, childNamespaces)) {
+								var nodePrefix = n.prefix || '';
+								var uri = n.namespaceURI;
+								addSerializedAttribute(buf, nodePrefix ? 'xmlns:' + nodePrefix : 'xmlns', uri);
+								childNamespaces.push({ prefix: nodePrefix, namespace: uri });
+							}
+
+							// in XML elements can be closed when they have no children
+							var canCloseTag = !n.firstChild;
+							if (canCloseTag && (isHTML || n.namespaceURI === NAMESPACE.HTML)) {
+								// in HTML (doc or ns) only void elements can be closed right away
+								canCloseTag = isHTMLVoidElement(nodeName);
+							}
+							if (canCloseTag) {
+								buf.push('/>');
+								// Self-closing: no children and no closing tag needed from exit.
+								return null;
+							}
+
+							buf.push('>');
+
+							// HTML raw text elements: serialize children as raw data without further descent.
+							if (isHTML && isHTMLRawTextElement(nodeName)) {
+								var child = n.firstChild;
+								while (child) {
+									if (child.data) {
+										buf.push(child.data);
+									} else {
+										serializeToString(child, buf, childNamespaces.slice(), opts);
+									}
+									child = child.nextSibling;
+								}
+								buf.push('</', prefixedNodeName, '>');
+								// Children handled manually above; prevent walkDOM from also traversing them.
+								return null;
+							}
+
+							// Return child context so walkDOM descends; exit will emit the closing tag.
+							return { ns: childNamespaces, tag: prefixedNodeName };
+						case DOCUMENT_NODE:
+						case DOCUMENT_FRAGMENT_NODE:
+							if (requireWellFormed && n.nodeType === DOCUMENT_NODE && n.documentElement == null) {
+								throw new DOMException('The Document has no documentElement', DOMExceptionName.InvalidStateError);
+							}
+							// Pass namespaces through; each child element will slice independently.
+							return { ns: namespaces };
+						case ATTRIBUTE_NODE:
+							addSerializedAttribute(buf, n.name, n.value);
+							return null;
+						case TEXT_NODE:
+							/*
+							 * The ampersand character (&) and the left angle bracket (<) must not appear in their literal form,
+							 * except when used as markup delimiters, or within a comment, a processing instruction,
+							 * or a CDATA section.
+							 * If they are needed elsewhere, they must be escaped using either numeric character
+							 * references or the strings `&amp;` and `&lt;` respectively.
+							 * The right angle bracket (>) may be represented using the string " &gt; ",
+							 * and must, for compatibility, be escaped using either `&gt;`,
+							 * or a character reference when it appears in the string `]]>` in content,
+							 * when that string is not marking the end of a CDATA section.
+							 *
+							 * In the content of elements, character data is any string of characters which does not
+							 * contain the start-delimiter of any markup and does not include the CDATA-section-close
+							 * delimiter, `]]>`.
+							 *
+							 * @see https://www.w3.org/TR/xml/#NT-CharData
+							 * @see https://w3c.github.io/DOM-Parsing/#xml-serializing-a-text-node
+							 */
+							if (requireWellFormed && g.InvalidChar.test(n.data)) {
+								throw new DOMException(
+									'The Text node data contains characters outside the XML Char production',
+									DOMExceptionName.InvalidStateError
+								);
+							}
+							buf.push(n.data.replace(/[<&>]/g, _xmlEncoder));
+							return null;
+						case CDATA_SECTION_NODE:
+							if (requireWellFormed && n.data.indexOf(']]>') !== -1) {
+								throw new DOMException('The CDATASection data contains "]]>"', DOMExceptionName.InvalidStateError);
+							}
+							if (splitCDATASections) {
+								buf.push(g.CDATA_START, n.data.replace(/]]>/g, ']]]]><![CDATA[>'), g.CDATA_END);
 							} else {
-								serializeToString(child, buf, nodeFilter, visibleNamespaces.slice());
+								buf.push(g.CDATA_START, n.data, g.CDATA_END);
 							}
-							child = child.nextSibling;
-						}
-					} else {
-						while (child) {
-							serializeToString(child, buf, nodeFilter, visibleNamespaces.slice());
-							child = child.nextSibling;
-						}
+							return null;
+						case COMMENT_NODE:
+							if (requireWellFormed) {
+								if (g.InvalidChar.test(n.data)) {
+									throw new DOMException(
+										'The comment node data contains characters outside the XML Char production',
+										DOMExceptionName.InvalidStateError
+									);
+								}
+								if (n.data.indexOf('--') !== -1 || n.data[n.data.length - 1] === '-') {
+									throw new DOMException(
+										'The comment node data contains "--" or ends with "-"',
+										DOMExceptionName.InvalidStateError
+									);
+								}
+							}
+							buf.push(g.COMMENT_START, n.data, g.COMMENT_END);
+							return null;
+						case DOCUMENT_TYPE_NODE:
+							var pubid = n.publicId;
+							var sysid = n.systemId;
+							if (requireWellFormed) {
+								if (pubid && !g.PubidLiteral_match.test(pubid)) {
+									throw new DOMException('DocumentType publicId is not a valid PubidLiteral', DOMExceptionName.InvalidStateError);
+								}
+								if (sysid && sysid !== '.' && !g.SystemLiteral_match.test(sysid)) {
+									throw new DOMException('DocumentType systemId is not a valid SystemLiteral', DOMExceptionName.InvalidStateError);
+								}
+								if (n.internalSubset && n.internalSubset.indexOf(']>') !== -1) {
+									throw new DOMException('DocumentType internalSubset contains "]>"', DOMExceptionName.InvalidStateError);
+								}
+							}
+							buf.push(g.DOCTYPE_DECL_START, ' ', n.name);
+							if (pubid) {
+								buf.push(' ', g.PUBLIC, ' ', pubid);
+								if (sysid && sysid !== '.') {
+									buf.push(' ', sysid);
+								}
+							} else if (sysid && sysid !== '.') {
+								buf.push(' ', g.SYSTEM, ' ', sysid);
+							}
+							if (n.internalSubset) {
+								buf.push(' [', n.internalSubset, ']');
+							}
+							buf.push('>');
+							return null;
+						case PROCESSING_INSTRUCTION_NODE:
+							if (requireWellFormed) {
+								if (n.target.indexOf(':') !== -1 || n.target.toLowerCase() === 'xml') {
+									throw new DOMException('The ProcessingInstruction target is not well-formed', DOMExceptionName.InvalidStateError);
+								}
+								if (g.InvalidChar.test(n.data)) {
+									throw new DOMException(
+										'The ProcessingInstruction data contains characters outside the XML Char production',
+										DOMExceptionName.InvalidStateError
+									);
+								}
+								if (n.data.indexOf('?>') !== -1) {
+									throw new DOMException('The ProcessingInstruction data contains "?>"', DOMExceptionName.InvalidStateError);
+								}
+							}
+							buf.push('<?', n.target, ' ', n.data, '?>');
+							return null;
+						case ENTITY_REFERENCE_NODE:
+							buf.push('&', n.nodeName, ';');
+							return null;
+						//case ENTITY_NODE:
+						//case NOTATION_NODE:
+						default:
+							buf.push('??', n.nodeName);
+							return null;
 					}
-					buf.push('</', prefixedNodeName, '>');
-				}
-				// remove added visible namespaces
-				//visibleNamespaces.length = startVisibleNamespaces;
-				return;
-			case DOCUMENT_NODE:
-			case DOCUMENT_FRAGMENT_NODE:
-				var child = node.firstChild;
-				while (child) {
-					serializeToString(child, buf, nodeFilter, visibleNamespaces.slice());
-					child = child.nextSibling;
-				}
-				return;
-			case ATTRIBUTE_NODE:
-				return addSerializedAttribute(buf, node.name, node.value);
-			case TEXT_NODE:
-				/*
-				 * The ampersand character (&) and the left angle bracket (<) must not appear in their literal form,
-				 * except when used as markup delimiters, or within a comment, a processing instruction,
-				 * or a CDATA section.
-				 * If they are needed elsewhere, they must be escaped using either numeric character
-				 * references or the strings `&amp;` and `&lt;` respectively.
-				 * The right angle bracket (>) may be represented using the string " &gt; ",
-				 * and must, for compatibility, be escaped using either `&gt;`,
-				 * or a character reference when it appears in the string `]]>` in content,
-				 * when that string is not marking the end of a CDATA section.
-				 *
-				 * In the content of elements, character data is any string of characters which does not
-				 * contain the start-delimiter of any markup and does not include the CDATA-section-close
-				 * delimiter, `]]>`.
-				 *
-				 * @see https://www.w3.org/TR/xml/#NT-CharData
-				 * @see https://w3c.github.io/DOM-Parsing/#xml-serializing-a-text-node
-				 */
-				return buf.push(node.data.replace(/[<&>]/g, _xmlEncoder));
-			case CDATA_SECTION_NODE:
-				return buf.push(g.CDATA_START, node.data.replace(/]]>/g, ']]]]><![CDATA[>'), g.CDATA_END);
-			case COMMENT_NODE:
-				return buf.push(g.COMMENT_START, node.data, g.COMMENT_END);
-			case DOCUMENT_TYPE_NODE:
-				var pubid = node.publicId;
-				var sysid = node.systemId;
-				buf.push(g.DOCTYPE_DECL_START, ' ', node.name);
-				if (pubid) {
-					buf.push(' ', g.PUBLIC, ' ', pubid);
-					if (sysid && sysid !== '.') {
-						buf.push(' ', sysid);
+				},
+				exit: function (n, childCtx) {
+					// Emit the closing tag for elements that were opened (not self-closed, not raw text).
+					if (childCtx && childCtx.tag) {
+						buf.push('</', childCtx.tag, '>');
 					}
-				} else if (sysid && sysid !== '.') {
-					buf.push(' ', g.SYSTEM, ' ', sysid);
-				}
-				if (node.internalSubset) {
-					buf.push(' [', node.internalSubset, ']');
-				}
-				buf.push('>');
-				return;
-			case PROCESSING_INSTRUCTION_NODE:
-				return buf.push('<?', node.target, ' ', node.data, '?>');
-			case ENTITY_REFERENCE_NODE:
-				return buf.push('&', node.nodeName, ';');
-			//case ENTITY_NODE:
-			//case NOTATION_NODE:
-			default:
-				buf.push('??', node.nodeName);
-		}
+				},
+			}
+		);
 	}
+	/**
+	 * Imports a node from a different document into `doc`, creating a new copy.
+	 * Delegates to {@link walkDOM} for traversal. Each node in the subtree is shallow-cloned,
+	 * stamped with `doc` as its `ownerDocument`, and detached (`parentNode` set to `null`).
+	 * Children are imported recursively when `deep` is `true`; for {@link Attr} nodes `deep` is
+	 * always forced to `true`
+	 * because an attribute's value lives in a child text node.
+	 *
+	 * @param {Document} doc
+	 * The document that will own the imported node.
+	 * @param {Node} node
+	 * The node to import.
+	 * @param {boolean} deep
+	 * If `true`, descendants are imported recursively.
+	 * @returns {Node}
+	 * The newly imported node, now owned by `doc`.
+	 */
 	function importNode(doc, node, deep) {
-		var node2;
-		switch (node.nodeType) {
-			case ELEMENT_NODE:
-				node2 = node.cloneNode(false);
-				node2.ownerDocument = doc;
-			//var attrs = node2.attributes;
-			//var len = attrs.length;
-			//for(var i=0;i<len;i++){
-			//node2.setAttributeNodeNS(importNode(doc,attrs.item(i),deep));
-			//}
-			case DOCUMENT_FRAGMENT_NODE:
-				break;
-			case ATTRIBUTE_NODE:
-				deep = true;
-				break;
-			//case ENTITY_REFERENCE_NODE:
-			//case PROCESSING_INSTRUCTION_NODE:
-			////case TEXT_NODE:
-			//case CDATA_SECTION_NODE:
-			//case COMMENT_NODE:
-			//	deep = false;
-			//	break;
-			//case DOCUMENT_NODE:
-			//case DOCUMENT_TYPE_NODE:
-			//cannot be imported.
-			//case ENTITY_NODE:
-			//case NOTATION_NODE：
-			//can not hit in level3
-			//default:throw e;
-		}
-		if (!node2) {
-			node2 = node.cloneNode(false); //false
-		}
-		node2.ownerDocument = doc;
-		node2.parentNode = null;
-		if (deep) {
-			var child = node.firstChild;
-			while (child) {
-				node2.appendChild(importNode(doc, child, deep));
-				child = child.nextSibling;
-			}
-		}
-		return node2;
+		var destRoot;
+		walkDOM(node, null, {
+			enter: function (srcNode, destParent) {
+				// Shallow-clone the node and stamp it into the target document.
+				var destNode = srcNode.cloneNode(false);
+				destNode.ownerDocument = doc;
+				destNode.parentNode = null;
+				// capture as the root of the imported subtree or attach to parent.
+				if (destParent === null) {
+					destRoot = destNode;
+				} else {
+					destParent.appendChild(destNode);
+				}
+				// ATTRIBUTE_NODE must always be imported deeply: its value lives in a child text node.
+				var shouldDeep = srcNode.nodeType === ATTRIBUTE_NODE || deep;
+				return shouldDeep ? destNode : null;
+			},
+		});
+		return destRoot;
 	}
 
 	/**
@@ -9159,42 +9511,55 @@ function requireDom () {
 	 * potentially invoked in this function) do not meet their specific constraints.
 	 */
 	function cloneNode(doc, node, deep) {
-		var node2 = new node.constructor(PDC);
-		for (var n in node) {
-			if (hasOwn(node, n)) {
-				var v = node[n];
-				if (typeof v != 'object') {
-					if (v != node2[n]) {
-						node2[n] = v;
+		var destRoot;
+		walkDOM(node, null, {
+			enter: function (srcNode, destParent) {
+				// 1. Create a blank node of the same type and copy all scalar own properties.
+				var destNode = new srcNode.constructor(PDC);
+				for (var n in srcNode) {
+					if (hasOwn(srcNode, n)) {
+						var v = srcNode[n];
+						if (typeof v != 'object') {
+							if (v != destNode[n]) {
+								destNode[n] = v;
+							}
+						}
 					}
 				}
-			}
-		}
-		if (node.childNodes) {
-			node2.childNodes = new NodeList();
-		}
-		node2.ownerDocument = doc;
-		switch (node2.nodeType) {
-			case ELEMENT_NODE:
-				var attrs = node.attributes;
-				var attrs2 = (node2.attributes = new NamedNodeMap());
-				var len = attrs.length;
-				attrs2._ownerElement = node2;
-				for (var i = 0; i < len; i++) {
-					node2.setAttributeNode(cloneNode(doc, attrs.item(i), true));
+				if (srcNode.childNodes) {
+					destNode.childNodes = new NodeList();
 				}
-				break;
-			case ATTRIBUTE_NODE:
-				deep = true;
-		}
-		if (deep) {
-			var child = node.firstChild;
-			while (child) {
-				node2.appendChild(cloneNode(doc, child, deep));
-				child = child.nextSibling;
-			}
-		}
-		return node2;
+				destNode.ownerDocument = doc;
+				// 2. Handle node-type-specific setup.
+				//    Attributes are not DOM children, so they are cloned inline here
+				//    rather than by walkDOM descent.
+				//    ATTRIBUTE_NODE forces deep=true so its own children are walked.
+				var shouldDeep = deep;
+				switch (destNode.nodeType) {
+					case ELEMENT_NODE:
+						var attrs = srcNode.attributes;
+						var attrs2 = (destNode.attributes = new NamedNodeMap());
+						var len = attrs.length;
+						attrs2._ownerElement = destNode;
+						for (var i = 0; i < len; i++) {
+							destNode.setAttributeNode(cloneNode(doc, attrs.item(i), true));
+						}
+						break;
+					case ATTRIBUTE_NODE:
+						shouldDeep = true;
+				}
+				// 3. Attach to parent, or capture as the root of the cloned subtree.
+				if (destParent !== null) {
+					destParent.appendChild(destNode);
+				} else {
+					destRoot = destNode;
+				}
+				// 4. Return destNode as the context for children (causes walkDOM to descend),
+				//    or null to skip children (shallow clone).
+				return shouldDeep ? destNode : null;
+			},
+		});
+		return destRoot;
 	}
 
 	function __set__(object, key, value) {
@@ -9226,9 +9591,37 @@ function requireDom () {
 				},
 			});
 
+			/**
+			 * The text content of this node and its descendants.
+			 *
+			 * For {@link Element} and {@link DocumentFragment} nodes, returns the concatenation of the
+			 * `nodeValue` of every descendant text node, excluding processing instruction and comment
+			 * nodes. For all other node types, returns `nodeValue`.
+			 *
+			 * Setting `textContent` on an element or document fragment replaces all child nodes with a
+			 * single text node; on other nodes it sets `data`, `value`, and `nodeValue` directly.
+			 *
+			 * @type {string | null}
+			 * @see {@link https://dom.spec.whatwg.org/#dom-node-textcontent}
+			 */
 			Object.defineProperty(Node.prototype, 'textContent', {
 				get: function () {
-					return getTextContent(this);
+					if (this.nodeType === ELEMENT_NODE || this.nodeType === DOCUMENT_FRAGMENT_NODE) {
+						var buf = [];
+						walkDOM(this, null, {
+							enter: function (n) {
+								if (n.nodeType === ELEMENT_NODE || n.nodeType === DOCUMENT_FRAGMENT_NODE) {
+									return true; // enter children
+								}
+								if (n.nodeType === PROCESSING_INSTRUCTION_NODE || n.nodeType === COMMENT_NODE) {
+									return null; // excluded from text content
+								}
+								buf.push(n.nodeValue);
+							},
+						});
+						return buf.join('');
+					}
+					return this.nodeValue;
 				},
 
 				set: function (data) {
@@ -9251,24 +9644,6 @@ function requireDom () {
 				},
 			});
 
-			function getTextContent(node) {
-				switch (node.nodeType) {
-					case ELEMENT_NODE:
-					case DOCUMENT_FRAGMENT_NODE:
-						var buf = [];
-						node = node.firstChild;
-						while (node) {
-							if (node.nodeType !== 7 && node.nodeType !== 8) {
-								buf.push(getTextContent(node));
-							}
-							node = node.nextSibling;
-						}
-						return buf.join('');
-					default:
-						return node.nodeValue;
-				}
-			}
-
 			Object.defineProperty(Element.prototype, 'children', {
 				get: function () {
 					return new LiveNodeList(this, childrenRefresh);
@@ -9313,6 +9688,7 @@ function requireDom () {
 	dom.Notation = Notation;
 	dom.Text = Text;
 	dom.ProcessingInstruction = ProcessingInstruction;
+	dom.walkDOM = walkDOM;
 	dom.XMLSerializer = XMLSerializer;
 	return dom;
 }
@@ -9326,7 +9702,7 @@ var hasRequiredEntities;
 function requireEntities () {
 	if (hasRequiredEntities) return entities;
 	hasRequiredEntities = 1;
-	(function (exports$1) {
+	(function (exports) {
 
 		var freeze = /*@__PURE__*/ requireConventions().freeze;
 
@@ -9338,7 +9714,7 @@ function requireEntities () {
 		 * @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Predefined_entities_in_XML
 		 *      Wikipedia
 		 */
-		exports$1.XML_ENTITIES = freeze({
+		exports.XML_ENTITIES = freeze({
 			amp: '&',
 			apos: "'",
 			gt: '>',
@@ -9363,7 +9739,7 @@ function requireEntities () {
 		 * @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Entities_representing_special_characters_in_XHTML
 		 *      Wikpedia (XHTML)
 		 */
-		exports$1.HTML_ENTITIES = freeze({
+		exports.HTML_ENTITIES = freeze({
 			Aacute: '\u00C1',
 			aacute: '\u00E1',
 			Abreve: '\u0102',
@@ -11496,7 +11872,7 @@ function requireEntities () {
 		 * Use `HTML_ENTITIES` instead.
 		 * @see {@link HTML_ENTITIES}
 		 */
-		exports$1.entityMap = exports$1.HTML_ENTITIES; 
+		exports.entityMap = exports.HTML_ENTITIES; 
 	} (entities));
 	return entities;
 }