@wavemaker/angular-app 11.14.3-rc.6401 → 11.14.4-rc.647538

package/dependencies/transpilation-web.cjs.js

@@ -5867,14 +5867,14 @@ function createNgModuleType(meta) {
     if (meta.kind === R3NgModuleMetadataKind.Local) {
         return new ExpressionType$1(meta.type.value);
     }
-    const { type: moduleType, declarations, exports: exports$1, imports, includeImportTypes, publicDeclarationTypes, } = meta;
+    const { type: moduleType, declarations, exports, imports, includeImportTypes, publicDeclarationTypes, } = meta;
     return new ExpressionType$1(importExpr(Identifiers.NgModuleDeclaration, [
         new ExpressionType$1(moduleType.type),
         publicDeclarationTypes === null
             ? tupleTypeOf(declarations)
             : tupleOfTypes(publicDeclarationTypes),
         includeImportTypes ? tupleTypeOf(imports) : NONE_TYPE,
-        tupleTypeOf(exports$1),
+        tupleTypeOf(exports),
     ]));
 }
 /**
@@ -37811,14 +37811,14 @@ function requireDom () {
 	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);
+	var INVALID_CHARACTER_ERR       = 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);
 	//level2
-	ExceptionCode.INVALID_STATE_ERR        	= ((ExceptionMessage[11]="Invalid state"),11);
+	var INVALID_STATE_ERR        	= 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);
@@ -37868,9 +37868,10 @@ function requireDom () {
 		item: function(index) {
 			return index >= 0 && index < this.length ? this[index] : null;
 		},
-		toString:function(isHTML,nodeFilter){
+		toString:function(isHTML,nodeFilter,options){
+			var requireWellFormed = !!options && !!options.requireWellFormed;
 			for(var buf = [], i = 0;i<this.length;i++){
-				serializeToString(this[i],buf,isHTML,nodeFilter);
+				serializeToString(this[i],buf,isHTML,nodeFilter,null,requireWellFormed);
 			}
 			return buf.join('');
 		},
@@ -38115,13 +38116,28 @@ function requireDom () {
 		/**
 		 * Returns a doctype, with the given `qualifiedName`, `publicId`, and `systemId`.
 		 *
-		 * __This behavior is slightly different from the in the specs__:
+		 * __This implementation differs from the specification:__
 		 * - this implementation is not validating names or qualified names
 		 *   (when parsing XML strings, the SAX parser takes care of that)
 		 *
+		 * Note: `internalSubset` can only be introduced via a direct property write to `node.internalSubset` after creation.
+		 * Creation-time validation of `publicId`, `systemId` is not enforced.
+		 * The serializer-level check covers all mutation vectors, including direct property writes.
+		 * `internalSubset` is only serialized as `[ ... ]` when both `publicId` and `systemId` are
+		 * absent (empty or `'.'`) — if either external identifier is present, `internalSubset` is
+		 * silently omitted from the serialized output.
+		 *
 		 * @param {string} qualifiedName
 		 * @param {string} [publicId]
+		 * The external subset public identifier. Stored verbatim including surrounding quotes.
+		 * When serialized with `requireWellFormed: true` (via the 4th-parameter options object),
+		 * throws `DOMException` with code `INVALID_STATE_ERR` if the value is non-empty and does
+		 * not match the XML `PubidLiteral` production (W3C DOM Parsing §3.2.1.3; XML 1.0 [12]).
 		 * @param {string} [systemId]
+		 * The external subset system identifier. Stored verbatim including surrounding quotes.
+		 * When serialized with `requireWellFormed: true`, throws `DOMException` with code
+		 * `INVALID_STATE_ERR` if the value is non-empty and does not match the XML `SystemLiteral`
+		 * production (W3C DOM Parsing §3.2.1.3; XML 1.0 [11]).
 		 * @returns {DocumentType} which can either be used with `DOMImplementation.createDocument` upon document creation
 		 * 				  or can be put into the document via methods like `Node.insertBefore()` or `Node.replaceChild()`
 		 *
@@ -38187,18 +38203,44 @@ function requireDom () {
 			return cloneNode(this.ownerDocument||this,this,deep);
 		},
 		// Modified in DOM Level 2:
-		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;
-				}
-			}
+		/**
+		 * Puts the specified node and all of its subtree into a "normalized" form. In a normalized
+		 * subtree, no text nodes in the subtree are empty and there are no adjacent text nodes.
+		 *
+		 * Specifically, this method merges any adjacent text nodes (i.e., nodes for which `nodeType`
+		 * is `TEXT_NODE`) into a single node with the combined data. It also removes any empty text
+		 * nodes.
+		 *
+		 * This method iteratively traverses all child nodes to normalize all descendant nodes within
+		 * the subtree.
+		 *
+		 * @throws {DOMException}
+		 * May throw a DOMException if operations within removeChild or appendData (which are
+		 * potentially invoked in this method) do not meet their specific constraints.
+		 * @see {@link Node.removeChild}
+		 * @see {@link CharacterData.appendData}
+		 * @see ../docs/walk-dom.md.
+		 */
+		normalize: function () {
+			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
+				},
+			});
 		},
 	  	// Introduced in DOM Level 2:
 		isSupported:function(feature, version){
@@ -38274,21 +38316,103 @@ function requireDom () {
 	copy(NodeType,Node.prototype);
 
 	/**
-	 * @param callback return true for continue,false for break
-	 * @return boolean true: break visit;
+	 * @param {Node} node
+	 * Root of the subtree to visit.
+	 * @param {function(Node): boolean} callback
+	 * Called for each node in depth-first pre-order. Return a truthy value to stop traversal early.
+	 * @return {boolean} `true` if traversal was aborted by the callback, `false` otherwise.
 	 */
-	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 _visitNode(node, callback) {
+		return walkDOM(node, null, { enter: function (n) { return callback(n) ? walkDOM.STOP : true; } }) === walkDOM.STOP;
 	}
 
+	/**
+	 * 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);
+				}
+			}
+		}
+	}
 
+	/**
+	 * 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;
 
 	function Document(){
 		this.ownerDocument = this;
@@ -38892,12 +39016,44 @@ function requireDom () {
 			node.appendData(data);
 			return node;
 		},
+		/**
+		 * Returns a new CDATASection node whose data is `data`.
+		 *
+		 * __This implementation differs from the specification:__
+		 * - calling this method on an HTML document does not throw `NotSupportedError`.
+		 *
+		 * @param {string} data
+		 * @returns {CDATASection}
+		 * @throws DOMException with code `INVALID_CHARACTER_ERR` if `data` contains `"]]>"`.
+		 * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/createCDATASection
+		 * @see https://dom.spec.whatwg.org/#dom-document-createcdatasection
+		 */
 		createCDATASection :	function(data){
+			if (data.indexOf(']]>') !== -1) {
+				throw new DOMException(INVALID_CHARACTER_ERR, 'data contains "]]>"');
+			}
 			var node = new CDATASection();
 			node.ownerDocument = this;
 			node.appendData(data);
 			return node;
 		},
+		/**
+		 * Returns a ProcessingInstruction node whose target is target and data is data.
+		 *
+		 * __This implementation differs from the specification:__
+		 * - 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 with code `INVALID_STATE_ERR` if `.data` contains `?>` (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();
 			node.ownerDocument = this;
@@ -39123,6 +39279,19 @@ function requireDom () {
 	_extends(CDATASection,CharacterData);
 
 
+	/**
+	 * Represents a DocumentType node (the `<!DOCTYPE ...>` declaration).
+	 *
+	 * `publicId`, `systemId`, and `internalSubset` are plain own-property assignments.
+	 * xmldom does not enforce the `readonly` constraint declared by the WHATWG DOM spec —
+	 * direct property writes succeed silently. Values are serialized verbatim when
+	 * `requireWellFormed` is false (the default). When the serializer is invoked with
+	 * `requireWellFormed: true` (via the 4th-parameter options object), it validates each
+	 * field and throws `DOMException` with code `INVALID_STATE_ERR` on invalid values.
+	 *
+	 * @class
+	 * @see https://developer.mozilla.org/en-US/docs/Web/API/DocumentType MDN
+	 */
 	function DocumentType() {
 	}	DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
 	_extends(DocumentType,Node);
@@ -39150,11 +39319,48 @@ function requireDom () {
 	ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
 	_extends(ProcessingInstruction,Node);
 	function XMLSerializer(){}
-	XMLSerializer.prototype.serializeToString = function(node,isHtml,nodeFilter){
-		return nodeSerializeToString.call(node,isHtml,nodeFilter);
+	/**
+	 * Returns the result of serializing `node` to XML.
+	 *
+	 * When `options.requireWellFormed` is `true`, the serializer throws for content that would
+	 * produce ill-formed 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) unless `requireWellFormed` is `true`.
+	 * - when `requireWellFormed` is `true`, `DOMException` with code `INVALID_STATE_ERR`
+	 *   is only thrown to prevent injection vectors, not for all the spec mandated checks.
+	 *
+	 * @param {Node} node
+	 * @param {boolean} [isHtml]
+	 * @param {function} [nodeFilter]
+	 * @param {Object} [options]
+	 * @param {boolean} [options.requireWellFormed=false]
+	 * When `true`, throws for content that would produce ill-formed XML.
+	 * @returns {string}
+	 * @throws {DOMException}
+	 * With code `INVALID_STATE_ERR` when `requireWellFormed` is `true` and:
+	 * - a CDATASection node's data contains `"]]>"`,
+	 * - a Comment node's data contains `"-->"` (bare `"--"` does not throw on this branch),
+	 * - a ProcessingInstruction's data contains `"?>"`,
+	 * - a DocumentType's `publicId` is non-empty and does not match the XML `PubidLiteral`
+	 *   production,
+	 * - a DocumentType's `systemId` is non-empty and does not match the XML `SystemLiteral`
+	 *   production, or
+	 * - a DocumentType's `internalSubset` contains `"]>"`.
+	 * Note: xmldom does not enforce `readonly` on DocumentType fields — direct property
+	 * writes succeed and are covered by the serializer-level checks above.
+	 * @see https://html.spec.whatwg.org/#dom-xmlserializer-serializetostring
+	 * @see https://w3c.github.io/DOM-Parsing/#xml-serialization
+	 * @see https://github.com/w3c/DOM-Parsing/issues/84
+	 */
+	XMLSerializer.prototype.serializeToString = function(node,isHtml,nodeFilter,options){
+		return nodeSerializeToString.call(node,isHtml,nodeFilter,options);
 	};
 	Node.prototype.toString = nodeSerializeToString;
-	function nodeSerializeToString(isHtml,nodeFilter){
+	function nodeSerializeToString(isHtml,nodeFilter,options){
+		var requireWellFormed = !!options && !!options.requireWellFormed;
 		var buf = [];
 		var refNode = this.nodeType == 9 && this.documentElement || this;
 		var prefix = refNode.prefix;
@@ -39171,7 +39377,7 @@ function requireDom () {
 				];
 			}
 		}
-		serializeToString(this,buf,isHtml,nodeFilter,visibleNamespaces);
+		serializeToString(this,buf,isHtml,nodeFilter,visibleNamespaces,requireWellFormed);
 		//console.log('###',this.nodeType,uri,prefix,buf.join(''))
 		return buf.join('');
 	}
@@ -39220,271 +39426,323 @@ function requireDom () {
 		buf.push(' ', qualifiedName, '="', value.replace(/[<>&"\t\n\r]/g, _xmlEncoder), '"');
 	}
 
-	function serializeToString(node,buf,isHTML,nodeFilter,visibleNamespaces){
+	function serializeToString(node, buf, isHTML, nodeFilter, visibleNamespaces, requireWellFormed) {
 		if (!visibleNamespaces) {
 			visibleNamespaces = [];
 		}
-
-		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;
-
-			isHTML = NAMESPACE.isHTML(node.namespaceURI) || isHTML;
-
-			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, isHTML: isHTML }, {
+			enter: function (n, ctx) {
+				var ns = ctx.ns;
+				var html = ctx.isHTML;
+
+				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;
+
+						html = NAMESPACE.isHTML(n.namespaceURI) || html;
+
+						var prefixedNodeName = nodeName;
+						if (!html && !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 = ns.length - 1; nsi >= 0; nsi--) {
+									var nsEntry = ns[nsi];
+									if (nsEntry.prefix === '' && nsEntry.namespace === n.namespaceURI) {
+										defaultNS = nsEntry.namespace;
+										break;
+									}
+								}
+							}
+							if (defaultNS !== n.namespaceURI) {
+								for (var nsi = ns.length - 1; nsi >= 0; nsi--) {
+									var nsEntry = ns[nsi];
+									if (nsEntry.namespace === n.namespaceURI) {
+										if (nsEntry.prefix) {
+											prefixedNodeName = nsEntry.prefix + ':' + nodeName;
+										}
+										break;
+									}
+								}
 							}
-							break
 						}
-					}
-				}
-			}
 
-			buf.push('<', prefixedNodeName);
+						buf.push('<', prefixedNodeName);
+
+						// Build a fresh namespace snapshot for this element's children.
+						// The slice prevents sibling elements from inheriting each other's declarations.
+						var childNs = ns.slice();
+						for (var i = 0; i < len; i++) {
+							var attr = attrs.item(i);
+							if (attr.prefix == 'xmlns') {
+								childNs.push({ prefix: attr.localName, namespace: attr.value });
+							} else if (attr.nodeName == 'xmlns') {
+								childNs.push({ prefix: '', namespace: attr.value });
+							}
+						}
 
-			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 });
-				}
-			}
+						for (var i = 0; i < len; i++) {
+							var attr = attrs.item(i);
+							if (needNamespaceDefine(attr, html, childNs)) {
+								var attrPrefix = attr.prefix || '';
+								var uri = attr.namespaceURI;
+								addSerializedAttribute(buf, attrPrefix ? 'xmlns:' + attrPrefix : 'xmlns', uri);
+								childNs.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);
+								}
+							}
+						}
 
-			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,isHTML,nodeFilter,visibleNamespaces);
-			}
+						// add namespace for current node
+						if (nodeName === prefixedNodeName && needNamespaceDefine(n, html, childNs)) {
+							var nodePrefix = n.prefix || '';
+							var uri = n.namespaceURI;
+							addSerializedAttribute(buf, nodePrefix ? 'xmlns:' + nodePrefix : 'xmlns', uri);
+							childNs.push({ prefix: nodePrefix, namespace: uri });
+						}
 
-			// 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 });
-			}
+						var child = n.firstChild;
+						if (child || html && !/^(?:meta|link|img|br|hr|input)$/i.test(nodeName)) {
+							buf.push('>');
+							if (html && /^script$/i.test(nodeName)) {
+								// Inline serialization for <script> children; return null to skip walkDOM descent.
+								while (child) {
+									if (child.data) {
+										buf.push(child.data);
+									} else {
+										serializeToString(child, buf, html, nodeFilter, childNs.slice(), requireWellFormed);
+									}
+									child = child.nextSibling;
+								}
+								buf.push('</', nodeName, '>');
+								return null;
+							}
+							// Return child context; walkDOM descends and exit emits the closing tag.
+							return { ns: childNs, isHTML: html, tag: prefixedNodeName };
+						} else {
+							buf.push('/>');
+							return null;
+						}
 
-			if(child || isHTML && !/^(?:meta|link|img|br|hr|input)$/i.test(nodeName)){
-				buf.push('>');
-				//if is cdata child node
-				if(isHTML && /^script$/i.test(nodeName)){
-					while(child){
-						if(child.data){
-							buf.push(child.data);
-						}else {
-							serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
+					case DOCUMENT_NODE:
+					case DOCUMENT_FRAGMENT_NODE:
+						// Descend into children; exit is a no-op (tag is null).
+						return { ns: ns.slice(), isHTML: html, tag: null };
+
+					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
+						 */
+						buf.push(n.data.replace(/[<&>]/g, _xmlEncoder));
+						return null;
+
+					case CDATA_SECTION_NODE:
+						if (requireWellFormed && n.data.indexOf(']]>') !== -1) {
+							throw new DOMException(INVALID_STATE_ERR, 'The CDATASection data contains "]]>"');
 						}
-						child = child.nextSibling;
-					}
-				}else
-				{
-					while(child){
-						serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
-						child = child.nextSibling;
-					}
-				}
-				buf.push('</',prefixedNodeName,'>');
-			}else {
-				buf.push('/>');
-			}
-			// remove added visible namespaces
-			//visibleNamespaces.length = startVisibleNamespaces;
-			return;
-		case DOCUMENT_NODE:
-		case DOCUMENT_FRAGMENT_NODE:
-			var child = node.firstChild;
-			while(child){
-				serializeToString(child, buf, isHTML, 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( '<![CDATA[',node.data,']]>');
-		case COMMENT_NODE:
-			return buf.push( "<!--",node.data,"-->");
-		case DOCUMENT_TYPE_NODE:
-			var pubid = node.publicId;
-			var sysid = node.systemId;
-			buf.push('<!DOCTYPE ',node.name);
-			if(pubid){
-				buf.push(' PUBLIC ', pubid);
-				if (sysid && sysid!='.') {
-					buf.push(' ', sysid);
+						buf.push('<![CDATA[', n.data.replace(/]]>/g, ']]]]><![CDATA[>'), ']]>');
+						return null;
+
+					case COMMENT_NODE:
+						if (requireWellFormed && n.data.indexOf('-->') !== -1) {
+							throw new DOMException(INVALID_STATE_ERR, 'The comment node data contains "-->"');
+						}
+						buf.push('<!--', n.data, '-->');
+						return null;
+
+					case DOCUMENT_TYPE_NODE:
+						if (requireWellFormed) {
+							if (n.publicId && !/^("[\x20\r\na-zA-Z0-9\-()+,.\/:=?;!*#@$_%']*"|'[\x20\r\na-zA-Z0-9\-()+,.\/:=?;!*#@$_%'"]*')$/.test(n.publicId)) {
+								throw new DOMException(INVALID_STATE_ERR, 'DocumentType publicId is not a valid PubidLiteral');
+							}
+							if (n.systemId && !/^("[^"]*"|'[^']*')$/.test(n.systemId)) {
+								throw new DOMException(INVALID_STATE_ERR, 'DocumentType systemId is not a valid SystemLiteral');
+							}
+							if (n.internalSubset && n.internalSubset.indexOf(']>') !== -1) {
+								throw new DOMException(INVALID_STATE_ERR, 'DocumentType internalSubset contains "]>"');
+							}
+						}
+						var pubid = n.publicId;
+						var sysid = n.systemId;
+						buf.push('<!DOCTYPE ', n.name);
+						if (pubid) {
+							buf.push(' PUBLIC ', pubid);
+							if (sysid && sysid != '.') {
+								buf.push(' ', sysid);
+							}
+							buf.push('>');
+						} else if (sysid && sysid != '.') {
+							buf.push(' SYSTEM ', sysid, '>');
+						} else {
+							var sub = n.internalSubset;
+							if (sub) {
+								buf.push(' [', sub, ']');
+							}
+							buf.push('>');
+						}
+						return null;
+
+					case PROCESSING_INSTRUCTION_NODE:
+						if (requireWellFormed && n.data.indexOf('?>') !== -1) {
+							throw new DOMException(INVALID_STATE_ERR, 'The ProcessingInstruction data contains "?>"');
+						}
+						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('>');
-			}else if(sysid && sysid!='.'){
-				buf.push(' SYSTEM ', sysid, '>');
-			}else {
-				var sub = node.internalSubset;
-				if(sub){
-					buf.push(" [",sub,"]");
+			},
+			exit: function (n, childCtx) {
+				if (childCtx && childCtx.tag) {
+					buf.push('</', childCtx.tag, '>');
 				}
-				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);
-		}
+			},
+		});
 	}
-	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;
+	/**
+	 * 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 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;
 	}
 	//
 	//var _relationMap = {firstChild:1,lastChild:1,previousSibling:1,nextSibling:1,
 	//					attributes:1,childNodes:1,parentNode:1,documentElement:1,doctype,};
-	function cloneNode(doc,node,deep){
-		var node2 = new node.constructor();
-		for (var n in node) {
-			if (Object.prototype.hasOwnProperty.call(node, n)) {
-				var v = node[n];
-				if (typeof v != "object") {
-					if (v != node2[n]) {
-						node2[n] = v;
+	function cloneNode(doc, node, deep) {
+		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();
+				for (var n in srcNode) {
+					if (Object.prototype.hasOwnProperty.call(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));
-			}
-			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;
+				if (srcNode.childNodes) {
+					destNode.childNodes = new NodeList();
+				}
+				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){
@@ -39500,49 +39758,55 @@ function requireDom () {
 				}
 			});
 
-			Object.defineProperty(Node.prototype,'textContent',{
-				get:function(){
-					return getTextContent(this);
+			/**
+			 * The text content of this node and its descendants.
+			 *
+			 * 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 () {
+					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){
-					switch(this.nodeType){
-					case ELEMENT_NODE:
-					case DOCUMENT_FRAGMENT_NODE:
-						while(this.firstChild){
-							this.removeChild(this.firstChild);
-						}
-						if(data || String(data)){
-							this.appendChild(this.ownerDocument.createTextNode(data));
-						}
-						break;
+				set: function (data) {
+					switch (this.nodeType) {
+						case ELEMENT_NODE:
+						case DOCUMENT_FRAGMENT_NODE:
+							while (this.firstChild) {
+								this.removeChild(this.firstChild);
+							}
+							if (data || String(data)) {
+								this.appendChild(this.ownerDocument.createTextNode(data));
+							}
+							break;
 
-					default:
-						this.data = data;
-						this.value = data;
-						this.nodeValue = data;
+						default:
+							this.data = data;
+							this.value = data;
+							this.nodeValue = data;
 					}
-				}
+				},
 			});
 
-			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;
-				}
-			}
-
 			__set__ = function(object,key,value){
 				//console.log(value)
 				object['$$'+key] = value;
@@ -39558,6 +39822,7 @@ function requireDom () {
 		dom.Element = Element;
 		dom.Node = Node;
 		dom.NodeList = NodeList;
+		dom.walkDOM = walkDOM;
 		dom.XMLSerializer = XMLSerializer;
 	//}
 	return dom;
@@ -39572,7 +39837,7 @@ var hasRequiredEntities;
 function requireEntities () {
 	if (hasRequiredEntities) return entities;
 	hasRequiredEntities = 1;
-	(function (exports$1) {
+	(function (exports) {
 
 		var freeze = requireConventions().freeze;
 
@@ -39583,7 +39848,7 @@ function requireEntities () {
 		 * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-predefined-ent W3C XML 1.0
 		 * @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: '>',
@@ -39605,7 +39870,7 @@ function requireEntities () {
 		 * @see https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references#Character_entity_references_in_HTML Wikipedia (HTML)
 		 * @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',
@@ -41737,7 +42002,7 @@ function requireEntities () {
 		 * @deprecated use `HTML_ENTITIES` instead
 		 * @see HTML_ENTITIES
 		 */
-		exports$1.entityMap = exports$1.HTML_ENTITIES; 
+		exports.entityMap = exports.HTML_ENTITIES; 
 	} (entities));
 	return entities;
 }
@@ -42348,7 +42613,7 @@ function requireSax () {
 	function parseInstruction(source,start,domBuilder){
 		var end = source.indexOf('?>',start);
 		if(end){
-			var match = source.substring(start,end).match(/^<\?(\S*)\s*([\s\S]*?)\s*$/);
+			var match = source.substring(start,end).match(/^<\?(\S*)\s*([\s\S]*?)$/);
 			if(match){
 				match[0].length;
 				domBuilder.processingInstruction(match[1], match[2]) ;
@@ -43545,7 +43810,7 @@ var hasRequiredMoment;
 function requireMoment () {
 	if (hasRequiredMoment) return moment$1.exports;
 	hasRequiredMoment = 1;
-	(function (module, exports$1) {
+	(function (module, exports) {
 (function (global, factory) {
 		    module.exports = factory() ;
 		}(this, (function () {
@@ -49235,7 +49500,7 @@ function requireMomentTimezone () {
 	hasRequiredMomentTimezone = 1;
 	(function (module) {
 		//! moment-timezone.js
-		//! version : 0.6.0
+		//! version : 0.6.2
 		//! Copyright (c) JS Foundation and other contributors
 		//! license : MIT
 		//! github.com/moment/moment-timezone
@@ -49261,7 +49526,7 @@ function requireMomentTimezone () {
 			// 	return moment;
 			// }
 
-			var VERSION = "0.6.0",
+			var VERSION = "0.6.2",
 				zones = {},
 				links = {},
 				countries = {},
@@ -81680,7 +81945,7 @@ function verifySemanticsOfNgModuleDef(moduleType, allowDuplicateDeclarationsInRo
         verifySemanticsOfNgModuleImport(modOrStandaloneCmpt, moduleType);
         verifySemanticsOfNgModuleDef(modOrStandaloneCmpt, false, moduleType);
     });
-    const exports$1 = maybeUnwrapFn(ngModuleDef.exports);
+    const exports = maybeUnwrapFn(ngModuleDef.exports);
     declarations.forEach(verifyDeclarationsHaveDefinitions);
     declarations.forEach(verifyDirectivesHaveSelector);
     declarations.forEach((declarationType) => verifyNotStandalone(declarationType, moduleType));
@@ -81688,7 +81953,7 @@ function verifySemanticsOfNgModuleDef(moduleType, allowDuplicateDeclarationsInRo
         ...declarations.map(resolveForwardRef),
         ...flatten(imports.map(computeCombinedExports)).map(resolveForwardRef),
     ];
-    exports$1.forEach(verifyExportsAreDeclaredOrReExported);
+    exports.forEach(verifyExportsAreDeclaredOrReExported);
     declarations.forEach((decl) => verifyDeclarationIsUnique(decl, allowDuplicateDeclarationsInRoot));
     const ngModule = getAnnotation(moduleType, 'NgModule');
     if (ngModule) {
@@ -99707,11 +99972,11 @@ const getRowActionAttrs = attrs => {
     return tmpl;
 };
 
-const $RAF = window.requestAnimationFrame;
+const $RAF$1 = window.requestAnimationFrame;
 const $RAFQueue = [];
 const invokeLater = fn => {
     if (!$RAFQueue.length) {
-        $RAF(() => {
+        $RAF$1(() => {
             $RAFQueue.forEach(f => f());
             $RAFQueue.length = 0;
         });
@@ -99719,23 +99984,7 @@ const invokeLater = fn => {
     $RAFQueue.push(fn);
 };
 const setAttr = (node, attrName, val, sync) => {
-    const task = () => {
-        if (node instanceof Element) {
-            // Handle tabindex specifically - ensure it's a valid string representation
-            if (attrName === 'tabindex') {
-                // Convert to string, handling 0, null, undefined, and NaN
-                if (val === null || val === undefined || (typeof val === 'number' && isNaN(val))) {
-                    node.removeAttribute(attrName);
-                }
-                else {
-                    node.setAttribute(attrName, String(val));
-                }
-            }
-            else {
-                node.setAttribute(attrName, val);
-            }
-        }
-    };
+    const task = () => node instanceof Element && node.setAttribute(attrName, val);
     invokeLater(task);
 };
 
@@ -100269,220 +100518,70 @@ const getFnForEventExpr = (expr) => {
     return fnExecutor(expr, ExpressionType.Action);
 };
 
-// Constants
-const WIDGET_ID_REGEX = /^(widget-[^_]+)/;
-const WIDGET_PROPERTY_REGEX = /^widget-[^_]+_(.+)$/;
-const ARRAY_INDEX_PLACEHOLDER = '[$i]';
-const ARRAY_INDEX_ZERO = '[0]';
 const registry = new Map();
 const watchIdGenerator = new IDGenerator('watch-id-');
-const FIRST_TIME_WATCH = Object.freeze({});
-/**
- * Extracts widget ID from identifier (e.g., "widget-id23_eventsource" -> "widget-id23")
- */
-const getWidgetId = (identifier) => {
-    if (!identifier || typeof identifier !== 'string') {
-        return null;
-    }
-    const match = identifier.match(WIDGET_ID_REGEX);
-    return match ? match[1] : null;
-};
-/**
- * Extracts property name from identifier (e.g., "widget-id23_eventsource" -> "eventsource")
- */
-const getPropertyName = (identifier) => {
-    if (!identifier || typeof identifier !== 'string') {
-        return identifier;
-    }
-    const match = identifier.match(WIDGET_PROPERTY_REGEX);
-    return match ? match[1] : identifier;
-};
-/**
- * Array consumer wrapper for array-based expressions
- */
+const FIRST_TIME_WATCH = {};
+Object.freeze(FIRST_TIME_WATCH);
 const arrayConsumer = (listenerFn, restExpr, newVal, oldVal) => {
-    if (!isArray(newVal)) {
-        return;
-    }
-    let formattedData = newVal.map(datum => findValueOf(datum, restExpr));
-    // Flatten if result is array of arrays
-    if (isArray(formattedData[0])) {
-        formattedData = flatten$1(formattedData);
+    let data = newVal, formattedData;
+    if (isArray(data)) {
+        formattedData = data.map(function (datum) {
+            return findValueOf(datum, restExpr);
+        });
+        // If resulting structure is an array of array, flatten it
+        if (isArray(formattedData[0])) {
+            formattedData = flatten$1(formattedData);
+        }
+        listenerFn(formattedData, oldVal);
     }
-    listenerFn(formattedData, oldVal);
 };
-/**
- * Updates watch info for array expressions
- */
-const getUpdatedWatchInfo = (expr, acceptsArray, listener) => {
-    const regex = /\[\$i\]/g;
+const getUpdatedWatcInfo = (expr, acceptsArray, listener) => {
+    // listener doesn't accept array
+    // replace all `[$i]` with `[0]` and return the expression
+    let regex = /\[\$i\]/g, $I = '[$i]', $0 = '[0]';
     if (!acceptsArray) {
         return {
-            expr: expr.replace(regex, ARRAY_INDEX_ZERO),
-            listener
+            'expr': expr.replace(regex, $0),
+            'listener': listener
         };
     }
-    const lastIndex = expr.lastIndexOf(ARRAY_INDEX_PLACEHOLDER);
-    const baseExpr = expr.substring(0, lastIndex).replace(ARRAY_INDEX_PLACEHOLDER, ARRAY_INDEX_ZERO);
-    const restExpr = expr.substring(lastIndex + 5);
-    const arrayConsumerFn = restExpr
-        ? arrayConsumer.bind(undefined, listener, restExpr)
-        : listener;
+    // listener accepts array
+    // replace all except the last `[$i]` with `[0]` and return the expression.
+    var index = expr.lastIndexOf($I), _expr = expr.substr(0, index).replace($I, $0), restExpr = expr.substr(index + 5), arrayConsumerFn = listener;
+    if (restExpr) {
+        arrayConsumerFn = arrayConsumer.bind(undefined, listener, restExpr);
+    }
     return {
-        expr: baseExpr,
-        listener: arrayConsumerFn
+        'expr': _expr,
+        'listener': arrayConsumerFn
     };
 };
-/**
- * Determines if an expression is static (doesn't need to be watched)
- */
-const STATIC_EXPRESSION_NAMES = [
-    "row.getProperty('investment')",
-    "row.getProperty('factsheetLink')",
-    "row.getProperty('isRebalanceEligible')"
-];
-const isStaticExpression = (expr) => {
-    if (typeof expr !== 'string') {
-        return false;
-    }
-    const trimmedExpr = expr.trim();
-    // Expressions that always evaluate to localization strings
-    // if (trimmedExpr.includes('appLocale')) {
-    //     return true;
-    // }
-    // Hard-coded static expression names
-    if (STATIC_EXPRESSION_NAMES.includes(trimmedExpr)) {
-        return true;
-    }
-    return false;
-};
-/**
- * Gets the scope type from the scope object
- */
-const getScopeType = ($scope) => {
-    if (!$scope) {
-        return null;
-    }
-    if ($scope.pageName)
-        return 'Page';
-    if ($scope.prefabName)
-        return 'Prefab';
-    if ($scope.partialName)
-        return 'Partial';
-    // Check for App scope
-    if ($scope.Variables !== undefined &&
-        $scope.Actions !== undefined &&
-        !$scope.pageName &&
-        !$scope.prefabName &&
-        !$scope.partialName) {
-        return 'App';
-    }
-    if ($scope.constructor?.name === 'AppRef') {
-        return 'App';
-    }
-    return null;
-};
-/**
- * Gets scope name based on scope type
- */
-const getScopeName = ($scope, scopeType) => {
-    if (!scopeType || !$scope) {
-        return null;
-    }
-    switch (scopeType) {
-        case 'Prefab': return $scope.prefabName || null;
-        case 'Partial': return $scope.partialName || null;
-        case 'Page': return $scope.pageName || null;
-        default: return null;
-    }
-};
-/**
- * Main watch function
- */
 const $watch = (expr, $scope, $locals, listener, identifier = watchIdGenerator.nextUid(), doNotClone = false, config = {}, isMuted) => {
-    // Handle array expressions
-    if (expr.includes(ARRAY_INDEX_PLACEHOLDER)) {
-        const watchInfo = getUpdatedWatchInfo(expr, config.arrayType || config.isList || false, listener);
+    if (expr.indexOf('[$i]') !== -1) {
+        let watchInfo = getUpdatedWatcInfo(expr, config && (config.arrayType || config.isList), listener);
         expr = watchInfo.expr;
         listener = watchInfo.listener;
     }
-    // Handle static expressions
-    if (isStaticExpression(expr)) {
-        try {
-            const fn = $parseExpr(expr);
-            const staticValue = fn($scope, $locals);
-            listener(staticValue, FIRST_TIME_WATCH);
-        }
-        catch (e) {
-            console.warn(`Error evaluating static expression '${expr}':`, e);
-            listener(undefined, FIRST_TIME_WATCH);
-        }
-        return () => { }; // No-op unsubscribe
-    }
     const fn = $parseExpr();
-    const scopeType = getScopeType($scope);
-    const scopeName = getScopeName($scope, scopeType);
-    const watchInfo = {
-        fn: fn.bind(null, $scope, $locals),
+    registry.set(identifier, {
+        fn: fn.bind(expr, $scope, $locals),
         listener,
         expr,
         last: FIRST_TIME_WATCH,
         doNotClone,
-        isMuted,
-        scopeType,
-        scopeName
-    };
-    // Store in registry
-    const widgetId = getWidgetId(identifier);
-    if (widgetId) {
-        const propertyName = getPropertyName(identifier);
-        if (!registry.has(widgetId)) {
-            registry.set(widgetId, {});
-        }
-        const widgetGroup = registry.get(widgetId);
-        widgetGroup[propertyName] = watchInfo;
-    }
-    else {
-        registry.set(identifier, watchInfo);
-    }
+        isMuted: isMuted
+    });
     return () => $unwatch(identifier);
 };
-/**
- * Unwatches a single identifier
- */
-const $unwatch = (identifier) => {
-    const widgetId = getWidgetId(identifier);
-    if (widgetId) {
-        const propertyName = getPropertyName(identifier);
-        const widgetGroup = registry.get(widgetId);
-        if (widgetGroup && typeof widgetGroup === 'object' && !widgetGroup.fn) {
-            const watchInfo = widgetGroup[propertyName];
-            if (watchInfo) {
-                delete widgetGroup[propertyName];
-                // Clean up empty widget groups
-                if (Object.keys(widgetGroup).length === 0) {
-                    registry.delete(widgetId);
-                }
-                return true;
-            }
-        }
-    }
-    // Fallback to direct lookup
-    if (registry.has(identifier)) {
-        registry.delete(identifier);
-        return true;
-    }
-    return false;
-};
+const $unwatch = identifier => registry.delete(identifier);
+window.watchRegistry = registry;
 const $appDigest = (() => {
-    return (force = false) => {
+    return (force) => {
         {
             return;
         }
     };
 })();
-// Export registry for debugging
-window.watchRegistry = registry;
 
 var ComponentType;
 (function (ComponentType) {
@@ -100553,7 +100652,6 @@ const REGEX = {
     SUPPORTED_AUDIO_FORMAT: /\.(mp3|ogg|webm|wma|3gp|wav|m4a)$/i,
     SUPPORTED_VIDEO_FORMAT: /\.(mp4|ogg|webm|wmv|mpeg|mpg|avi|mov)$/i,
     VALID_WEB_URL: /^(http[s]?:\/\/)(www\.){0,1}[a-zA-Z0-9=:?\/\.\-]+(\.[a-zA-Z]{2,5}[\.]{0,1})?/,
-    VALID_IMAGE_URL: /^(https?|blob|data|file|ftp):/i,
     REPLACE_PATTERN: /\$\{([^\}]+)\}/g,
     DATA_URL: /^\s*data:([a-z]+\/[a-z0-9-+.]+(;[a-z-]+=[a-z0-9-]+)?)?(;base64)?,([a-z0-9!$&',()*+;=\-._~:@\/?%\s]*)\s*$/i,
     ISO_DATE_FORMAT: /(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2})(\.\d+)?([+-]\d{2}:?\d{2}|Z)$/
@@ -100776,9 +100874,6 @@ const isVideoFile = (fileName) => {
 const isValidWebURL = (url) => {
     return (REGEX.VALID_WEB_URL).test(url);
 };
-const isValidImageUrl = (url) => {
-    return (REGEX.VALID_IMAGE_URL).test(url?.trim());
-};
 /*This function returns the url to the resource after checking the validity of url*/
 const getResourceURL = (urlString) => {
     return urlString;
@@ -102032,7 +102127,6 @@ var Utils = /*#__PURE__*/Object.freeze({
     isPageable: isPageable,
     isSafari: isSafari,
     isTablet: isTablet,
-    isValidImageUrl: isValidImageUrl,
     isValidWebURL: isValidWebURL,
     isVideoFile: isVideoFile,
     loadScript: loadScript,
@@ -102126,10 +102220,7 @@ class EventNotifier {
         return noop;
     }
     destroy() {
-        this._subject.next(null); // optional
-        this._subject.complete(); // clears all observers
-        this._isInitialized = false;
-        this._eventsBeforeInit = [];
+        this._subject.complete();
     }
 }
 let MINIMUM_TAB_WIDTH = 768;
@@ -102144,11 +102235,9 @@ class Viewport {
         this.isTabletType = false;
         this._eventNotifier = new EventNotifier(true);
         this.setScreenType();
-        // MEMORY LEAK FIX: Store bound function reference for proper removal
-        this.boundResizeFn = this.resizeFn.bind(this);
-        window.addEventListener("resize" /* ViewportEvent.RESIZE */, this.boundResizeFn);
-        this.mediaQuery = window.matchMedia('(orientation: portrait)');
-        if (this.mediaQuery.matches) {
+        window.addEventListener("resize" /* ViewportEvent.RESIZE */, this.resizeFn.bind(this));
+        const query = window.matchMedia('(orientation: portrait)');
+        if (query.matches) {
             this.orientation.isPortrait = true;
         }
         else {
@@ -102156,10 +102245,8 @@ class Viewport {
         }
         // Add a media query change listener
         // addEventListener is not supported ios browser
-        if (this.mediaQuery.addEventListener) {
-            // MEMORY LEAK FIX: Store bound function reference for proper removal
-            this.boundOrientationChange = ($event) => this.orientationChange($event, !$event.matches);
-            this.mediaQuery.addEventListener('change', this.boundOrientationChange);
+        if (query.addEventListener) {
+            query.addEventListener('change', $event => this.orientationChange($event, !$event.matches));
         }
     }
     update(selectedViewPort) {
@@ -102186,14 +102273,14 @@ class Viewport {
         return this._eventNotifier.subscribe(eventName, callback);
     }
     notify(eventName, ...data) {
-        this._eventNotifier.notify(eventName, ...data);
+        this._eventNotifier.notify.apply(this._eventNotifier, arguments);
     }
     setScreenType() {
         const $el = document.querySelector('.wm-app');
         this.screenWidth = $el.clientWidth;
         this.screenHeight = $el.clientHeight;
-        // const minValue = this.screenWidth < this.screenHeight ? this.screenWidth : this.screenHeight;
-        // const maxValue = this.screenWidth > this.screenHeight ? this.screenWidth : this.screenHeight;
+        this.screenWidth < this.screenHeight ? this.screenWidth : this.screenHeight;
+        this.screenWidth > this.screenHeight ? this.screenWidth : this.screenHeight;
         this.isTabletType = false;
         this.isMobileType = false;
         if (get$1(this.selectedViewPort, 'deviceCategory')) {
@@ -102225,17 +102312,7 @@ class Viewport {
     }
     ngOnDestroy() {
         this._eventNotifier.destroy();
-        // MEMORY LEAK FIX: Remove resize event listener using stored bound function reference
-        if (this.boundResizeFn) {
-            window.removeEventListener('resize', this.boundResizeFn);
-            this.boundResizeFn = null;
-        }
-        // MEMORY LEAK FIX: Remove media query orientation change listener
-        if (this.mediaQuery && this.boundOrientationChange && this.mediaQuery.removeEventListener) {
-            this.mediaQuery.removeEventListener('change', this.boundOrientationChange);
-            this.boundOrientationChange = null;
-        }
-        this.mediaQuery = null;
+        window.removeEventListener('resize', this.resizeFn);
     }
     static { this.ɵfac = ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: Viewport, deps: [], target: FactoryTarget.Injectable }); }
     static { this.ɵprov = ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: Viewport, providedIn: 'root' }); }