@angular/core 13.0.0-next.7 → 13.0.0-rc.1

package/esm2020/src/debug/debug_node.mjs

@@ -0,0 +1,625 @@
+import { assertTNodeForLView } from '../render3/assert';
+import { getLContext } from '../render3/context_discovery';
+import { CONTAINER_HEADER_OFFSET, NATIVE } from '../render3/interfaces/container';
+import { isComponentHost, isLContainer } from '../render3/interfaces/type_checks';
+import { DECLARATION_COMPONENT_VIEW, PARENT, T_HOST, TVIEW } from '../render3/interfaces/view';
+import { getComponent, getContext, getInjectionTokens, getInjector, getListeners, getLocalRefs, getOwningComponent } from '../render3/util/discovery_utils';
+import { INTERPOLATION_DELIMITER } from '../render3/util/misc_utils';
+import { renderStringify } from '../render3/util/stringify_utils';
+import { getComponentLViewByIndex, getNativeByTNodeOrNull } from '../render3/util/view_utils';
+import { assertDomNode } from '../util/assert';
+/**
+ * @publicApi
+ */
+export class DebugEventListener {
+    constructor(name, callback) {
+        this.name = name;
+        this.callback = callback;
+    }
+}
+export class DebugNode__PRE_R3__ {
+    constructor(nativeNode, parent, _debugContext) {
+        this.listeners = [];
+        this.parent = null;
+        this._debugContext = _debugContext;
+        this.nativeNode = nativeNode;
+        if (parent && parent instanceof DebugElement__PRE_R3__) {
+            parent.addChild(this);
+        }
+    }
+    get injector() {
+        return this._debugContext.injector;
+    }
+    get componentInstance() {
+        return this._debugContext.component;
+    }
+    get context() {
+        return this._debugContext.context;
+    }
+    get references() {
+        return this._debugContext.references;
+    }
+    get providerTokens() {
+        return this._debugContext.providerTokens;
+    }
+}
+export class DebugElement__PRE_R3__ extends DebugNode__PRE_R3__ {
+    constructor(nativeNode, parent, _debugContext) {
+        super(nativeNode, parent, _debugContext);
+        this.properties = {};
+        this.attributes = {};
+        this.classes = {};
+        this.styles = {};
+        this.childNodes = [];
+        this.nativeElement = nativeNode;
+    }
+    addChild(child) {
+        if (child) {
+            this.childNodes.push(child);
+            child.parent = this;
+        }
+    }
+    removeChild(child) {
+        const childIndex = this.childNodes.indexOf(child);
+        if (childIndex !== -1) {
+            child.parent = null;
+            this.childNodes.splice(childIndex, 1);
+        }
+    }
+    insertChildrenAfter(child, newChildren) {
+        const siblingIndex = this.childNodes.indexOf(child);
+        if (siblingIndex !== -1) {
+            this.childNodes.splice(siblingIndex + 1, 0, ...newChildren);
+            newChildren.forEach(c => {
+                if (c.parent) {
+                    c.parent.removeChild(c);
+                }
+                child.parent = this;
+            });
+        }
+    }
+    insertBefore(refChild, newChild) {
+        const refIndex = this.childNodes.indexOf(refChild);
+        if (refIndex === -1) {
+            this.addChild(newChild);
+        }
+        else {
+            if (newChild.parent) {
+                newChild.parent.removeChild(newChild);
+            }
+            newChild.parent = this;
+            this.childNodes.splice(refIndex, 0, newChild);
+        }
+    }
+    query(predicate) {
+        const results = this.queryAll(predicate);
+        return results[0] || null;
+    }
+    queryAll(predicate) {
+        const matches = [];
+        _queryElementChildren(this, predicate, matches);
+        return matches;
+    }
+    queryAllNodes(predicate) {
+        const matches = [];
+        _queryNodeChildren(this, predicate, matches);
+        return matches;
+    }
+    get children() {
+        return this.childNodes //
+            .filter((node) => node instanceof DebugElement__PRE_R3__);
+    }
+    triggerEventHandler(eventName, eventObj) {
+        this.listeners.forEach((listener) => {
+            if (listener.name == eventName) {
+                listener.callback(eventObj);
+            }
+        });
+    }
+}
+/**
+ * @publicApi
+ */
+export function asNativeElements(debugEls) {
+    return debugEls.map((el) => el.nativeElement);
+}
+function _queryElementChildren(element, predicate, matches) {
+    element.childNodes.forEach(node => {
+        if (node instanceof DebugElement__PRE_R3__) {
+            if (predicate(node)) {
+                matches.push(node);
+            }
+            _queryElementChildren(node, predicate, matches);
+        }
+    });
+}
+function _queryNodeChildren(parentNode, predicate, matches) {
+    if (parentNode instanceof DebugElement__PRE_R3__) {
+        parentNode.childNodes.forEach(node => {
+            if (predicate(node)) {
+                matches.push(node);
+            }
+            if (node instanceof DebugElement__PRE_R3__) {
+                _queryNodeChildren(node, predicate, matches);
+            }
+        });
+    }
+}
+class DebugNode__POST_R3__ {
+    constructor(nativeNode) {
+        this.nativeNode = nativeNode;
+    }
+    get parent() {
+        const parent = this.nativeNode.parentNode;
+        return parent ? new DebugElement__POST_R3__(parent) : null;
+    }
+    get injector() {
+        return getInjector(this.nativeNode);
+    }
+    get componentInstance() {
+        const nativeElement = this.nativeNode;
+        return nativeElement &&
+            (getComponent(nativeElement) || getOwningComponent(nativeElement));
+    }
+    get context() {
+        return getComponent(this.nativeNode) || getContext(this.nativeNode);
+    }
+    get listeners() {
+        return getListeners(this.nativeNode).filter(listener => listener.type === 'dom');
+    }
+    get references() {
+        return getLocalRefs(this.nativeNode);
+    }
+    get providerTokens() {
+        return getInjectionTokens(this.nativeNode);
+    }
+}
+class DebugElement__POST_R3__ extends DebugNode__POST_R3__ {
+    constructor(nativeNode) {
+        ngDevMode && assertDomNode(nativeNode);
+        super(nativeNode);
+    }
+    get nativeElement() {
+        return this.nativeNode.nodeType == Node.ELEMENT_NODE ? this.nativeNode : null;
+    }
+    get name() {
+        const context = getLContext(this.nativeNode);
+        if (context !== null) {
+            const lView = context.lView;
+            const tData = lView[TVIEW].data;
+            const tNode = tData[context.nodeIndex];
+            return tNode.value;
+        }
+        else {
+            return this.nativeNode.nodeName;
+        }
+    }
+    /**
+     *  Gets a map of property names to property values for an element.
+     *
+     *  This map includes:
+     *  - Regular property bindings (e.g. `[id]="id"`)
+     *  - Host property bindings (e.g. `host: { '[id]': "id" }`)
+     *  - Interpolated property bindings (e.g. `id="{{ value }}")
+     *
+     *  It does not include:
+     *  - input property bindings (e.g. `[myCustomInput]="value"`)
+     *  - attribute bindings (e.g. `[attr.role]="menu"`)
+     */
+    get properties() {
+        const context = getLContext(this.nativeNode);
+        if (context === null) {
+            return {};
+        }
+        const lView = context.lView;
+        const tData = lView[TVIEW].data;
+        const tNode = tData[context.nodeIndex];
+        const properties = {};
+        // Collect properties from the DOM.
+        copyDomProperties(this.nativeElement, properties);
+        // Collect properties from the bindings. This is needed for animation renderer which has
+        // synthetic properties which don't get reflected into the DOM.
+        collectPropertyBindings(properties, tNode, lView, tData);
+        return properties;
+    }
+    get attributes() {
+        const attributes = {};
+        const element = this.nativeElement;
+        if (!element) {
+            return attributes;
+        }
+        const context = getLContext(element);
+        if (context === null) {
+            return {};
+        }
+        const lView = context.lView;
+        const tNodeAttrs = lView[TVIEW].data[context.nodeIndex].attrs;
+        const lowercaseTNodeAttrs = [];
+        // For debug nodes we take the element's attribute directly from the DOM since it allows us
+        // to account for ones that weren't set via bindings (e.g. ViewEngine keeps track of the ones
+        // that are set through `Renderer2`). The problem is that the browser will lowercase all names,
+        // however since we have the attributes already on the TNode, we can preserve the case by going
+        // through them once, adding them to the `attributes` map and putting their lower-cased name
+        // into an array. Afterwards when we're going through the native DOM attributes, we can check
+        // whether we haven't run into an attribute already through the TNode.
+        if (tNodeAttrs) {
+            let i = 0;
+            while (i < tNodeAttrs.length) {
+                const attrName = tNodeAttrs[i];
+                // Stop as soon as we hit a marker. We only care about the regular attributes. Everything
+                // else will be handled below when we read the final attributes off the DOM.
+                if (typeof attrName !== 'string')
+                    break;
+                const attrValue = tNodeAttrs[i + 1];
+                attributes[attrName] = attrValue;
+                lowercaseTNodeAttrs.push(attrName.toLowerCase());
+                i += 2;
+            }
+        }
+        const eAttrs = element.attributes;
+        for (let i = 0; i < eAttrs.length; i++) {
+            const attr = eAttrs[i];
+            const lowercaseName = attr.name.toLowerCase();
+            // Make sure that we don't assign the same attribute both in its
+            // case-sensitive form and the lower-cased one from the browser.
+            if (lowercaseTNodeAttrs.indexOf(lowercaseName) === -1) {
+                // Save the lowercase name to align the behavior between browsers.
+                // IE preserves the case, while all other browser convert it to lower case.
+                attributes[lowercaseName] = attr.value;
+            }
+        }
+        return attributes;
+    }
+    get styles() {
+        if (this.nativeElement && this.nativeElement.style) {
+            return this.nativeElement.style;
+        }
+        return {};
+    }
+    get classes() {
+        const result = {};
+        const element = this.nativeElement;
+        // SVG elements return an `SVGAnimatedString` instead of a plain string for the `className`.
+        const className = element.className;
+        const classes = className && typeof className !== 'string' ? className.baseVal.split(' ') :
+            className.split(' ');
+        classes.forEach((value) => result[value] = true);
+        return result;
+    }
+    get childNodes() {
+        const childNodes = this.nativeNode.childNodes;
+        const children = [];
+        for (let i = 0; i < childNodes.length; i++) {
+            const element = childNodes[i];
+            children.push(getDebugNode__POST_R3__(element));
+        }
+        return children;
+    }
+    get children() {
+        const nativeElement = this.nativeElement;
+        if (!nativeElement)
+            return [];
+        const childNodes = nativeElement.children;
+        const children = [];
+        for (let i = 0; i < childNodes.length; i++) {
+            const element = childNodes[i];
+            children.push(getDebugNode__POST_R3__(element));
+        }
+        return children;
+    }
+    query(predicate) {
+        const results = this.queryAll(predicate);
+        return results[0] || null;
+    }
+    queryAll(predicate) {
+        const matches = [];
+        _queryAllR3(this, predicate, matches, true);
+        return matches;
+    }
+    queryAllNodes(predicate) {
+        const matches = [];
+        _queryAllR3(this, predicate, matches, false);
+        return matches;
+    }
+    triggerEventHandler(eventName, eventObj) {
+        const node = this.nativeNode;
+        const invokedListeners = [];
+        this.listeners.forEach(listener => {
+            if (listener.name === eventName) {
+                const callback = listener.callback;
+                callback.call(node, eventObj);
+                invokedListeners.push(callback);
+            }
+        });
+        // We need to check whether `eventListeners` exists, because it's something
+        // that Zone.js only adds to `EventTarget` in browser environments.
+        if (typeof node.eventListeners === 'function') {
+            // Note that in Ivy we wrap event listeners with a call to `event.preventDefault` in some
+            // cases. We use '__ngUnwrap__' as a special token that gives us access to the actual event
+            // listener.
+            node.eventListeners(eventName).forEach((listener) => {
+                // In order to ensure that we can detect the special __ngUnwrap__ token described above, we
+                // use `toString` on the listener and see if it contains the token. We use this approach to
+                // ensure that it still worked with compiled code since it cannot remove or rename string
+                // literals. We also considered using a special function name (i.e. if(listener.name ===
+                // special)) but that was more cumbersome and we were also concerned the compiled code could
+                // strip the name, turning the condition in to ("" === "") and always returning true.
+                if (listener.toString().indexOf('__ngUnwrap__') !== -1) {
+                    const unwrappedListener = listener('__ngUnwrap__');
+                    return invokedListeners.indexOf(unwrappedListener) === -1 &&
+                        unwrappedListener.call(node, eventObj);
+                }
+            });
+        }
+    }
+}
+function copyDomProperties(element, properties) {
+    if (element) {
+        // Skip own properties (as those are patched)
+        let obj = Object.getPrototypeOf(element);
+        const NodePrototype = Node.prototype;
+        while (obj !== null && obj !== NodePrototype) {
+            const descriptors = Object.getOwnPropertyDescriptors(obj);
+            for (let key in descriptors) {
+                if (!key.startsWith('__') && !key.startsWith('on')) {
+                    // don't include properties starting with `__` and `on`.
+                    // `__` are patched values which should not be included.
+                    // `on` are listeners which also should not be included.
+                    const value = element[key];
+                    if (isPrimitiveValue(value)) {
+                        properties[key] = value;
+                    }
+                }
+            }
+            obj = Object.getPrototypeOf(obj);
+        }
+    }
+}
+function isPrimitiveValue(value) {
+    return typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number' ||
+        value === null;
+}
+function _queryAllR3(parentElement, predicate, matches, elementsOnly) {
+    const context = getLContext(parentElement.nativeNode);
+    if (context !== null) {
+        const parentTNode = context.lView[TVIEW].data[context.nodeIndex];
+        _queryNodeChildrenR3(parentTNode, context.lView, predicate, matches, elementsOnly, parentElement.nativeNode);
+    }
+    else {
+        // If the context is null, then `parentElement` was either created with Renderer2 or native DOM
+        // APIs.
+        _queryNativeNodeDescendants(parentElement.nativeNode, predicate, matches, elementsOnly);
+    }
+}
+/**
+ * Recursively match the current TNode against the predicate, and goes on with the next ones.
+ *
+ * @param tNode the current TNode
+ * @param lView the LView of this TNode
+ * @param predicate the predicate to match
+ * @param matches the list of positive matches
+ * @param elementsOnly whether only elements should be searched
+ * @param rootNativeNode the root native node on which predicate should not be matched
+ */
+function _queryNodeChildrenR3(tNode, lView, predicate, matches, elementsOnly, rootNativeNode) {
+    ngDevMode && assertTNodeForLView(tNode, lView);
+    const nativeNode = getNativeByTNodeOrNull(tNode, lView);
+    // For each type of TNode, specific logic is executed.
+    if (tNode.type & (3 /* AnyRNode */ | 8 /* ElementContainer */)) {
+        // Case 1: the TNode is an element
+        // The native node has to be checked.
+        _addQueryMatchR3(nativeNode, predicate, matches, elementsOnly, rootNativeNode);
+        if (isComponentHost(tNode)) {
+            // If the element is the host of a component, then all nodes in its view have to be processed.
+            // Note: the component's content (tNode.child) will be processed from the insertion points.
+            const componentView = getComponentLViewByIndex(tNode.index, lView);
+            if (componentView && componentView[TVIEW].firstChild) {
+                _queryNodeChildrenR3(componentView[TVIEW].firstChild, componentView, predicate, matches, elementsOnly, rootNativeNode);
+            }
+        }
+        else {
+            if (tNode.child) {
+                // Otherwise, its children have to be processed.
+                _queryNodeChildrenR3(tNode.child, lView, predicate, matches, elementsOnly, rootNativeNode);
+            }
+            // We also have to query the DOM directly in order to catch elements inserted through
+            // Renderer2. Note that this is __not__ optimal, because we're walking similar trees multiple
+            // times. ViewEngine could do it more efficiently, because all the insertions go through
+            // Renderer2, however that's not the case in Ivy. This approach is being used because:
+            // 1. Matching the ViewEngine behavior would mean potentially introducing a depedency
+            //    from `Renderer2` to Ivy which could bring Ivy code into ViewEngine.
+            // 2. We would have to make `Renderer3` "know" about debug nodes.
+            // 3. It allows us to capture nodes that were inserted directly via the DOM.
+            nativeNode && _queryNativeNodeDescendants(nativeNode, predicate, matches, elementsOnly);
+        }
+        // In all cases, if a dynamic container exists for this node, each view inside it has to be
+        // processed.
+        const nodeOrContainer = lView[tNode.index];
+        if (isLContainer(nodeOrContainer)) {
+            _queryNodeChildrenInContainerR3(nodeOrContainer, predicate, matches, elementsOnly, rootNativeNode);
+        }
+    }
+    else if (tNode.type & 4 /* Container */) {
+        // Case 2: the TNode is a container
+        // The native node has to be checked.
+        const lContainer = lView[tNode.index];
+        _addQueryMatchR3(lContainer[NATIVE], predicate, matches, elementsOnly, rootNativeNode);
+        // Each view inside the container has to be processed.
+        _queryNodeChildrenInContainerR3(lContainer, predicate, matches, elementsOnly, rootNativeNode);
+    }
+    else if (tNode.type & 16 /* Projection */) {
+        // Case 3: the TNode is a projection insertion point (i.e. a <ng-content>).
+        // The nodes projected at this location all need to be processed.
+        const componentView = lView[DECLARATION_COMPONENT_VIEW];
+        const componentHost = componentView[T_HOST];
+        const head = componentHost.projection[tNode.projection];
+        if (Array.isArray(head)) {
+            for (let nativeNode of head) {
+                _addQueryMatchR3(nativeNode, predicate, matches, elementsOnly, rootNativeNode);
+            }
+        }
+        else if (head) {
+            const nextLView = componentView[PARENT];
+            const nextTNode = nextLView[TVIEW].data[head.index];
+            _queryNodeChildrenR3(nextTNode, nextLView, predicate, matches, elementsOnly, rootNativeNode);
+        }
+    }
+    else if (tNode.child) {
+        // Case 4: the TNode is a view.
+        _queryNodeChildrenR3(tNode.child, lView, predicate, matches, elementsOnly, rootNativeNode);
+    }
+    // We don't want to go to the next sibling of the root node.
+    if (rootNativeNode !== nativeNode) {
+        // To determine the next node to be processed, we need to use the next or the projectionNext
+        // link, depending on whether the current node has been projected.
+        const nextTNode = (tNode.flags & 4 /* isProjected */) ? tNode.projectionNext : tNode.next;
+        if (nextTNode) {
+            _queryNodeChildrenR3(nextTNode, lView, predicate, matches, elementsOnly, rootNativeNode);
+        }
+    }
+}
+/**
+ * Process all TNodes in a given container.
+ *
+ * @param lContainer the container to be processed
+ * @param predicate the predicate to match
+ * @param matches the list of positive matches
+ * @param elementsOnly whether only elements should be searched
+ * @param rootNativeNode the root native node on which predicate should not be matched
+ */
+function _queryNodeChildrenInContainerR3(lContainer, predicate, matches, elementsOnly, rootNativeNode) {
+    for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+        const childView = lContainer[i];
+        const firstChild = childView[TVIEW].firstChild;
+        if (firstChild) {
+            _queryNodeChildrenR3(firstChild, childView, predicate, matches, elementsOnly, rootNativeNode);
+        }
+    }
+}
+/**
+ * Match the current native node against the predicate.
+ *
+ * @param nativeNode the current native node
+ * @param predicate the predicate to match
+ * @param matches the list of positive matches
+ * @param elementsOnly whether only elements should be searched
+ * @param rootNativeNode the root native node on which predicate should not be matched
+ */
+function _addQueryMatchR3(nativeNode, predicate, matches, elementsOnly, rootNativeNode) {
+    if (rootNativeNode !== nativeNode) {
+        const debugNode = getDebugNode(nativeNode);
+        if (!debugNode) {
+            return;
+        }
+        // Type of the "predicate and "matches" array are set based on the value of
+        // the "elementsOnly" parameter. TypeScript is not able to properly infer these
+        // types with generics, so we manually cast the parameters accordingly.
+        if (elementsOnly && debugNode instanceof DebugElement__POST_R3__ && predicate(debugNode) &&
+            matches.indexOf(debugNode) === -1) {
+            matches.push(debugNode);
+        }
+        else if (!elementsOnly && predicate(debugNode) &&
+            matches.indexOf(debugNode) === -1) {
+            matches.push(debugNode);
+        }
+    }
+}
+/**
+ * Match all the descendants of a DOM node against a predicate.
+ *
+ * @param nativeNode the current native node
+ * @param predicate the predicate to match
+ * @param matches the list where matches are stored
+ * @param elementsOnly whether only elements should be searched
+ */
+function _queryNativeNodeDescendants(parentNode, predicate, matches, elementsOnly) {
+    const nodes = parentNode.childNodes;
+    const length = nodes.length;
+    for (let i = 0; i < length; i++) {
+        const node = nodes[i];
+        const debugNode = getDebugNode(node);
+        if (debugNode) {
+            if (elementsOnly && debugNode instanceof DebugElement__POST_R3__ && predicate(debugNode) &&
+                matches.indexOf(debugNode) === -1) {
+                matches.push(debugNode);
+            }
+            else if (!elementsOnly && predicate(debugNode) &&
+                matches.indexOf(debugNode) === -1) {
+                matches.push(debugNode);
+            }
+            _queryNativeNodeDescendants(node, predicate, matches, elementsOnly);
+        }
+    }
+}
+/**
+ * Iterates through the property bindings for a given node and generates
+ * a map of property names to values. This map only contains property bindings
+ * defined in templates, not in host bindings.
+ */
+function collectPropertyBindings(properties, tNode, lView, tData) {
+    let bindingIndexes = tNode.propertyBindings;
+    if (bindingIndexes !== null) {
+        for (let i = 0; i < bindingIndexes.length; i++) {
+            const bindingIndex = bindingIndexes[i];
+            const propMetadata = tData[bindingIndex];
+            const metadataParts = propMetadata.split(INTERPOLATION_DELIMITER);
+            const propertyName = metadataParts[0];
+            if (metadataParts.length > 1) {
+                let value = metadataParts[1];
+                for (let j = 1; j < metadataParts.length - 1; j++) {
+                    value += renderStringify(lView[bindingIndex + j - 1]) + metadataParts[j + 1];
+                }
+                properties[propertyName] = value;
+            }
+            else {
+                properties[propertyName] = lView[bindingIndex];
+            }
+        }
+    }
+}
+// Need to keep the nodes in a global Map so that multiple angular apps are supported.
+const _nativeNodeToDebugNode = new Map();
+function getDebugNode__PRE_R3__(nativeNode) {
+    return _nativeNodeToDebugNode.get(nativeNode) || null;
+}
+const NG_DEBUG_PROPERTY = '__ng_debug__';
+export function getDebugNode__POST_R3__(nativeNode) {
+    if (nativeNode instanceof Node) {
+        if (!(nativeNode.hasOwnProperty(NG_DEBUG_PROPERTY))) {
+            nativeNode[NG_DEBUG_PROPERTY] = nativeNode.nodeType == Node.ELEMENT_NODE ?
+                new DebugElement__POST_R3__(nativeNode) :
+                new DebugNode__POST_R3__(nativeNode);
+        }
+        return nativeNode[NG_DEBUG_PROPERTY];
+    }
+    return null;
+}
+/**
+ * @publicApi
+ */
+export const getDebugNode = getDebugNode__POST_R3__;
+export function getDebugNodeR2__PRE_R3__(nativeNode) {
+    return getDebugNode__PRE_R3__(nativeNode);
+}
+export function getDebugNodeR2__POST_R3__(_nativeNode) {
+    return null;
+}
+export const getDebugNodeR2 = getDebugNodeR2__POST_R3__;
+export function getAllDebugNodes() {
+    return Array.from(_nativeNodeToDebugNode.values());
+}
+export function indexDebugNode(node) {
+    _nativeNodeToDebugNode.set(node.nativeNode, node);
+}
+export function removeDebugNodeFromIndex(node) {
+    _nativeNodeToDebugNode.delete(node.nativeNode);
+}
+/**
+ * @publicApi
+ */
+export const DebugNode = DebugNode__POST_R3__;
+/**
+ * @publicApi
+ */
+export const DebugElement = DebugElement__POST_R3__;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"debug_node.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/debug/debug_node.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Injector} from '../di/injector';\nimport {assertTNodeForLView} from '../render3/assert';\nimport {getLContext} from '../render3/context_discovery';\nimport {CONTAINER_HEADER_OFFSET, LContainer, NATIVE} from '../render3/interfaces/container';\nimport {TElementNode, TNode, TNodeFlags, TNodeType} from '../render3/interfaces/node';\nimport {isComponentHost, isLContainer} from '../render3/interfaces/type_checks';\nimport {DECLARATION_COMPONENT_VIEW, LView, PARENT, T_HOST, TData, TVIEW} from '../render3/interfaces/view';\nimport {getComponent, getContext, getInjectionTokens, getInjector, getListeners, getLocalRefs, getOwningComponent} from '../render3/util/discovery_utils';\nimport {INTERPOLATION_DELIMITER} from '../render3/util/misc_utils';\nimport {renderStringify} from '../render3/util/stringify_utils';\nimport {getComponentLViewByIndex, getNativeByTNodeOrNull} from '../render3/util/view_utils';\nimport {assertDomNode} from '../util/assert';\nimport {DebugContext} from '../view/types';\n\n\n/**\n * @publicApi\n */\nexport class DebugEventListener {\n  constructor(public name: string, public callback: Function) {}\n}\n\n/**\n * @publicApi\n */\nexport interface DebugNode {\n  /**\n   * The callbacks attached to the component's @Output properties and/or the element's event\n   * properties.\n   */\n  readonly listeners: DebugEventListener[];\n\n  /**\n   * The `DebugElement` parent. Will be `null` if this is the root element.\n   */\n  readonly parent: DebugElement|null;\n\n  /**\n   * The underlying DOM node.\n   */\n  readonly nativeNode: any;\n\n  /**\n   * The host dependency injector. For example, the root element's component instance injector.\n   */\n  readonly injector: Injector;\n\n  /**\n   * The element's own component instance, if it has one.\n   */\n  readonly componentInstance: any;\n\n  /**\n   * An object that provides parent context for this element. Often an ancestor component instance\n   * that governs this element.\n   *\n   * When an element is repeated within *ngFor, the context is an `NgForOf` whose `$implicit`\n   * property is the value of the row instance value. For example, the `hero` in `*ngFor=\"let hero\n   * of heroes\"`.\n   */\n  readonly context: any;\n\n  /**\n   * Dictionary of objects associated with template local variables (e.g. #foo), keyed by the local\n   * variable name.\n   */\n  readonly references: {[key: string]: any};\n\n  /**\n   * This component's injector lookup tokens. Includes the component itself plus the tokens that the\n   * component lists in its providers metadata.\n   */\n  readonly providerTokens: any[];\n}\nexport class DebugNode__PRE_R3__ {\n  readonly listeners: DebugEventListener[] = [];\n  readonly parent: DebugElement|null = null;\n  readonly nativeNode: any;\n  private readonly _debugContext: DebugContext;\n\n  constructor(nativeNode: any, parent: DebugNode|null, _debugContext: DebugContext) {\n    this._debugContext = _debugContext;\n    this.nativeNode = nativeNode;\n    if (parent && parent instanceof DebugElement__PRE_R3__) {\n      parent.addChild(this);\n    }\n  }\n\n  get injector(): Injector {\n    return this._debugContext.injector;\n  }\n\n  get componentInstance(): any {\n    return this._debugContext.component;\n  }\n\n  get context(): any {\n    return this._debugContext.context;\n  }\n\n  get references(): {[key: string]: any} {\n    return this._debugContext.references;\n  }\n\n  get providerTokens(): any[] {\n    return this._debugContext.providerTokens;\n  }\n}\n\n/**\n * @publicApi\n *\n * @see [Component testing scenarios](guide/testing-components-scenarios)\n * @see [Basics of testing components](guide/testing-components-basics)\n * @see [Testing utility APIs](guide/testing-utility-apis)\n */\nexport interface DebugElement extends DebugNode {\n  /**\n   * The element tag name, if it is an element.\n   */\n  readonly name: string;\n\n  /**\n   *  A map of property names to property values for an element.\n   *\n   *  This map includes:\n   *  - Regular property bindings (e.g. `[id]=\"id\"`)\n   *  - Host property bindings (e.g. `host: { '[id]': \"id\" }`)\n   *  - Interpolated property bindings (e.g. `id=\"{{ value }}\")\n   *\n   *  It does not include:\n   *  - input property bindings (e.g. `[myCustomInput]=\"value\"`)\n   *  - attribute bindings (e.g. `[attr.role]=\"menu\"`)\n   */\n  readonly properties: {[key: string]: any};\n\n  /**\n   *  A map of attribute names to attribute values for an element.\n   */\n  readonly attributes: {[key: string]: string|null};\n\n  /**\n   * A map containing the class names on the element as keys.\n   *\n   * This map is derived from the `className` property of the DOM element.\n   *\n   * Note: The values of this object will always be `true`. The class key will not appear in the KV\n   * object if it does not exist on the element.\n   *\n   * @see [Element.className](https://developer.mozilla.org/en-US/docs/Web/API/Element/className)\n   */\n  readonly classes: {[key: string]: boolean};\n\n  /**\n   * The inline styles of the DOM element.\n   *\n   * Will be `null` if there is no `style` property on the underlying DOM element.\n   *\n   * @see [ElementCSSInlineStyle](https://developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style)\n   */\n  readonly styles: {[key: string]: string|null};\n\n  /**\n   * The `childNodes` of the DOM element as a `DebugNode` array.\n   *\n   * @see [Node.childNodes](https://developer.mozilla.org/en-US/docs/Web/API/Node/childNodes)\n   */\n  readonly childNodes: DebugNode[];\n\n  /**\n   * The underlying DOM element at the root of the component.\n   */\n  readonly nativeElement: any;\n\n  /**\n   * The immediate `DebugElement` children. Walk the tree by descending through `children`.\n   */\n  readonly children: DebugElement[];\n\n  /**\n   * @returns the first `DebugElement` that matches the predicate at any depth in the subtree.\n   */\n  query(predicate: Predicate<DebugElement>): DebugElement;\n\n  /**\n   * @returns All `DebugElement` matches for the predicate at any depth in the subtree.\n   */\n  queryAll(predicate: Predicate<DebugElement>): DebugElement[];\n\n  /**\n   * @returns All `DebugNode` matches for the predicate at any depth in the subtree.\n   */\n  queryAllNodes(predicate: Predicate<DebugNode>): DebugNode[];\n\n  /**\n   * Triggers the event by its name if there is a corresponding listener in the element's\n   * `listeners` collection.\n   *\n   * If the event lacks a listener or there's some other problem, consider\n   * calling `nativeElement.dispatchEvent(eventObject)`.\n   *\n   * @param eventName The name of the event to trigger\n   * @param eventObj The _event object_ expected by the handler\n   *\n   * @see [Testing components scenarios](guide/testing-components-scenarios#trigger-event-handler)\n   */\n  triggerEventHandler(eventName: string, eventObj: any): void;\n}\nexport class DebugElement__PRE_R3__ extends DebugNode__PRE_R3__ implements DebugElement {\n  readonly name!: string;\n  readonly properties: {[key: string]: any} = {};\n  readonly attributes: {[key: string]: string|null} = {};\n  readonly classes: {[key: string]: boolean} = {};\n  readonly styles: {[key: string]: string|null} = {};\n  readonly childNodes: DebugNode[] = [];\n  readonly nativeElement: any;\n\n  constructor(nativeNode: any, parent: any, _debugContext: DebugContext) {\n    super(nativeNode, parent, _debugContext);\n    this.nativeElement = nativeNode;\n  }\n\n  addChild(child: DebugNode) {\n    if (child) {\n      this.childNodes.push(child);\n      (child as {parent: DebugNode}).parent = this;\n    }\n  }\n\n  removeChild(child: DebugNode) {\n    const childIndex = this.childNodes.indexOf(child);\n    if (childIndex !== -1) {\n      (child as {parent: DebugNode | null}).parent = null;\n      this.childNodes.splice(childIndex, 1);\n    }\n  }\n\n  insertChildrenAfter(child: DebugNode, newChildren: DebugNode[]) {\n    const siblingIndex = this.childNodes.indexOf(child);\n    if (siblingIndex !== -1) {\n      this.childNodes.splice(siblingIndex + 1, 0, ...newChildren);\n      newChildren.forEach(c => {\n        if (c.parent) {\n          (c.parent as DebugElement__PRE_R3__).removeChild(c);\n        }\n        (child as {parent: DebugNode}).parent = this;\n      });\n    }\n  }\n\n  insertBefore(refChild: DebugNode, newChild: DebugNode): void {\n    const refIndex = this.childNodes.indexOf(refChild);\n    if (refIndex === -1) {\n      this.addChild(newChild);\n    } else {\n      if (newChild.parent) {\n        (newChild.parent as DebugElement__PRE_R3__).removeChild(newChild);\n      }\n      (newChild as {parent: DebugNode}).parent = this;\n      this.childNodes.splice(refIndex, 0, newChild);\n    }\n  }\n\n  query(predicate: Predicate<DebugElement>): DebugElement {\n    const results = this.queryAll(predicate);\n    return results[0] || null;\n  }\n\n  queryAll(predicate: Predicate<DebugElement>): DebugElement[] {\n    const matches: DebugElement[] = [];\n    _queryElementChildren(this, predicate, matches);\n    return matches;\n  }\n\n  queryAllNodes(predicate: Predicate<DebugNode>): DebugNode[] {\n    const matches: DebugNode[] = [];\n    _queryNodeChildren(this, predicate, matches);\n    return matches;\n  }\n\n  get children(): DebugElement[] {\n    return this.childNodes  //\n               .filter((node) => node instanceof DebugElement__PRE_R3__) as DebugElement[];\n  }\n\n  triggerEventHandler(eventName: string, eventObj: any) {\n    this.listeners.forEach((listener) => {\n      if (listener.name == eventName) {\n        listener.callback(eventObj);\n      }\n    });\n  }\n}\n\n/**\n * @publicApi\n */\nexport function asNativeElements(debugEls: DebugElement[]): any {\n  return debugEls.map((el) => el.nativeElement);\n}\n\nfunction _queryElementChildren(\n    element: DebugElement, predicate: Predicate<DebugElement>, matches: DebugElement[]) {\n  element.childNodes.forEach(node => {\n    if (node instanceof DebugElement__PRE_R3__) {\n      if (predicate(node)) {\n        matches.push(node);\n      }\n      _queryElementChildren(node, predicate, matches);\n    }\n  });\n}\n\nfunction _queryNodeChildren(\n    parentNode: DebugNode, predicate: Predicate<DebugNode>, matches: DebugNode[]) {\n  if (parentNode instanceof DebugElement__PRE_R3__) {\n    parentNode.childNodes.forEach(node => {\n      if (predicate(node)) {\n        matches.push(node);\n      }\n      if (node instanceof DebugElement__PRE_R3__) {\n        _queryNodeChildren(node, predicate, matches);\n      }\n    });\n  }\n}\n\nclass DebugNode__POST_R3__ implements DebugNode {\n  readonly nativeNode: Node;\n\n  constructor(nativeNode: Node) {\n    this.nativeNode = nativeNode;\n  }\n\n  get parent(): DebugElement|null {\n    const parent = this.nativeNode.parentNode as Element;\n    return parent ? new DebugElement__POST_R3__(parent) : null;\n  }\n\n  get injector(): Injector {\n    return getInjector(this.nativeNode);\n  }\n\n  get componentInstance(): any {\n    const nativeElement = this.nativeNode;\n    return nativeElement &&\n        (getComponent(nativeElement as Element) || getOwningComponent(nativeElement));\n  }\n  get context(): any {\n    return getComponent(this.nativeNode as Element) || getContext(this.nativeNode as Element);\n  }\n\n  get listeners(): DebugEventListener[] {\n    return getListeners(this.nativeNode as Element).filter(listener => listener.type === 'dom');\n  }\n\n  get references(): {[key: string]: any;} {\n    return getLocalRefs(this.nativeNode);\n  }\n\n  get providerTokens(): any[] {\n    return getInjectionTokens(this.nativeNode as Element);\n  }\n}\n\nclass DebugElement__POST_R3__ extends DebugNode__POST_R3__ implements DebugElement {\n  constructor(nativeNode: Element) {\n    ngDevMode && assertDomNode(nativeNode);\n    super(nativeNode);\n  }\n\n  get nativeElement(): Element|null {\n    return this.nativeNode.nodeType == Node.ELEMENT_NODE ? this.nativeNode as Element : null;\n  }\n\n  get name(): string {\n    const context = getLContext(this.nativeNode);\n    if (context !== null) {\n      const lView = context.lView;\n      const tData = lView[TVIEW].data;\n      const tNode = tData[context.nodeIndex] as TNode;\n      return tNode.value!;\n    } else {\n      return this.nativeNode.nodeName;\n    }\n  }\n\n  /**\n   *  Gets a map of property names to property values for an element.\n   *\n   *  This map includes:\n   *  - Regular property bindings (e.g. `[id]=\"id\"`)\n   *  - Host property bindings (e.g. `host: { '[id]': \"id\" }`)\n   *  - Interpolated property bindings (e.g. `id=\"{{ value }}\")\n   *\n   *  It does not include:\n   *  - input property bindings (e.g. `[myCustomInput]=\"value\"`)\n   *  - attribute bindings (e.g. `[attr.role]=\"menu\"`)\n   */\n  get properties(): {[key: string]: any;} {\n    const context = getLContext(this.nativeNode);\n    if (context === null) {\n      return {};\n    }\n\n    const lView = context.lView;\n    const tData = lView[TVIEW].data;\n    const tNode = tData[context.nodeIndex] as TNode;\n\n    const properties: {[key: string]: string} = {};\n    // Collect properties from the DOM.\n    copyDomProperties(this.nativeElement, properties);\n    // Collect properties from the bindings. This is needed for animation renderer which has\n    // synthetic properties which don't get reflected into the DOM.\n    collectPropertyBindings(properties, tNode, lView, tData);\n    return properties;\n  }\n\n  get attributes(): {[key: string]: string|null;} {\n    const attributes: {[key: string]: string|null;} = {};\n    const element = this.nativeElement;\n\n    if (!element) {\n      return attributes;\n    }\n\n    const context = getLContext(element);\n    if (context === null) {\n      return {};\n    }\n\n    const lView = context.lView;\n    const tNodeAttrs = (lView[TVIEW].data[context.nodeIndex] as TNode).attrs;\n    const lowercaseTNodeAttrs: string[] = [];\n\n    // For debug nodes we take the element's attribute directly from the DOM since it allows us\n    // to account for ones that weren't set via bindings (e.g. ViewEngine keeps track of the ones\n    // that are set through `Renderer2`). The problem is that the browser will lowercase all names,\n    // however since we have the attributes already on the TNode, we can preserve the case by going\n    // through them once, adding them to the `attributes` map and putting their lower-cased name\n    // into an array. Afterwards when we're going through the native DOM attributes, we can check\n    // whether we haven't run into an attribute already through the TNode.\n    if (tNodeAttrs) {\n      let i = 0;\n      while (i < tNodeAttrs.length) {\n        const attrName = tNodeAttrs[i];\n\n        // Stop as soon as we hit a marker. We only care about the regular attributes. Everything\n        // else will be handled below when we read the final attributes off the DOM.\n        if (typeof attrName !== 'string') break;\n\n        const attrValue = tNodeAttrs[i + 1];\n        attributes[attrName] = attrValue as string;\n        lowercaseTNodeAttrs.push(attrName.toLowerCase());\n\n        i += 2;\n      }\n    }\n\n    const eAttrs = element.attributes;\n    for (let i = 0; i < eAttrs.length; i++) {\n      const attr = eAttrs[i];\n      const lowercaseName = attr.name.toLowerCase();\n\n      // Make sure that we don't assign the same attribute both in its\n      // case-sensitive form and the lower-cased one from the browser.\n      if (lowercaseTNodeAttrs.indexOf(lowercaseName) === -1) {\n        // Save the lowercase name to align the behavior between browsers.\n        // IE preserves the case, while all other browser convert it to lower case.\n        attributes[lowercaseName] = attr.value;\n      }\n    }\n\n    return attributes;\n  }\n\n  get styles(): {[key: string]: string|null} {\n    if (this.nativeElement && (this.nativeElement as HTMLElement).style) {\n      return (this.nativeElement as HTMLElement).style as {[key: string]: any};\n    }\n    return {};\n  }\n\n  get classes(): {[key: string]: boolean;} {\n    const result: {[key: string]: boolean;} = {};\n    const element = this.nativeElement as HTMLElement | SVGElement;\n\n    // SVG elements return an `SVGAnimatedString` instead of a plain string for the `className`.\n    const className = element.className as string | SVGAnimatedString;\n    const classes = className && typeof className !== 'string' ? className.baseVal.split(' ') :\n                                                                 className.split(' ');\n\n    classes.forEach((value: string) => result[value] = true);\n\n    return result;\n  }\n\n  get childNodes(): DebugNode[] {\n    const childNodes = this.nativeNode.childNodes;\n    const children: DebugNode[] = [];\n    for (let i = 0; i < childNodes.length; i++) {\n      const element = childNodes[i];\n      children.push(getDebugNode__POST_R3__(element));\n    }\n    return children;\n  }\n\n  get children(): DebugElement[] {\n    const nativeElement = this.nativeElement;\n    if (!nativeElement) return [];\n    const childNodes = nativeElement.children;\n    const children: DebugElement[] = [];\n    for (let i = 0; i < childNodes.length; i++) {\n      const element = childNodes[i];\n      children.push(getDebugNode__POST_R3__(element));\n    }\n    return children;\n  }\n\n  query(predicate: Predicate<DebugElement>): DebugElement {\n    const results = this.queryAll(predicate);\n    return results[0] || null;\n  }\n\n  queryAll(predicate: Predicate<DebugElement>): DebugElement[] {\n    const matches: DebugElement[] = [];\n    _queryAllR3(this, predicate, matches, true);\n    return matches;\n  }\n\n  queryAllNodes(predicate: Predicate<DebugNode>): DebugNode[] {\n    const matches: DebugNode[] = [];\n    _queryAllR3(this, predicate, matches, false);\n    return matches;\n  }\n\n  triggerEventHandler(eventName: string, eventObj: any): void {\n    const node = this.nativeNode as any;\n    const invokedListeners: Function[] = [];\n\n    this.listeners.forEach(listener => {\n      if (listener.name === eventName) {\n        const callback = listener.callback;\n        callback.call(node, eventObj);\n        invokedListeners.push(callback);\n      }\n    });\n\n    // We need to check whether `eventListeners` exists, because it's something\n    // that Zone.js only adds to `EventTarget` in browser environments.\n    if (typeof node.eventListeners === 'function') {\n      // Note that in Ivy we wrap event listeners with a call to `event.preventDefault` in some\n      // cases. We use '__ngUnwrap__' as a special token that gives us access to the actual event\n      // listener.\n      node.eventListeners(eventName).forEach((listener: Function) => {\n        // In order to ensure that we can detect the special __ngUnwrap__ token described above, we\n        // use `toString` on the listener and see if it contains the token. We use this approach to\n        // ensure that it still worked with compiled code since it cannot remove or rename string\n        // literals. We also considered using a special function name (i.e. if(listener.name ===\n        // special)) but that was more cumbersome and we were also concerned the compiled code could\n        // strip the name, turning the condition in to (\"\" === \"\") and always returning true.\n        if (listener.toString().indexOf('__ngUnwrap__') !== -1) {\n          const unwrappedListener = listener('__ngUnwrap__');\n          return invokedListeners.indexOf(unwrappedListener) === -1 &&\n              unwrappedListener.call(node, eventObj);\n        }\n      });\n    }\n  }\n}\n\nfunction copyDomProperties(element: Element|null, properties: {[name: string]: string}): void {\n  if (element) {\n    // Skip own properties (as those are patched)\n    let obj = Object.getPrototypeOf(element);\n    const NodePrototype: any = Node.prototype;\n    while (obj !== null && obj !== NodePrototype) {\n      const descriptors = Object.getOwnPropertyDescriptors(obj);\n      for (let key in descriptors) {\n        if (!key.startsWith('__') && !key.startsWith('on')) {\n          // don't include properties starting with `__` and `on`.\n          // `__` are patched values which should not be included.\n          // `on` are listeners which also should not be included.\n          const value = (element as any)[key];\n          if (isPrimitiveValue(value)) {\n            properties[key] = value;\n          }\n        }\n      }\n      obj = Object.getPrototypeOf(obj);\n    }\n  }\n}\n\nfunction isPrimitiveValue(value: any): boolean {\n  return typeof value === 'string' || typeof value === 'boolean' || typeof value === 'number' ||\n      value === null;\n}\n\n/**\n * Walk the TNode tree to find matches for the predicate.\n *\n * @param parentElement the element from which the walk is started\n * @param predicate the predicate to match\n * @param matches the list of positive matches\n * @param elementsOnly whether only elements should be searched\n */\nfunction _queryAllR3(\n    parentElement: DebugElement, predicate: Predicate<DebugElement>, matches: DebugElement[],\n    elementsOnly: true): void;\nfunction _queryAllR3(\n    parentElement: DebugElement, predicate: Predicate<DebugNode>, matches: DebugNode[],\n    elementsOnly: false): void;\nfunction _queryAllR3(\n    parentElement: DebugElement, predicate: Predicate<DebugElement>|Predicate<DebugNode>,\n    matches: DebugElement[]|DebugNode[], elementsOnly: boolean) {\n  const context = getLContext(parentElement.nativeNode);\n  if (context !== null) {\n    const parentTNode = context.lView[TVIEW].data[context.nodeIndex] as TNode;\n    _queryNodeChildrenR3(\n        parentTNode, context.lView, predicate, matches, elementsOnly, parentElement.nativeNode);\n  } else {\n    // If the context is null, then `parentElement` was either created with Renderer2 or native DOM\n    // APIs.\n    _queryNativeNodeDescendants(parentElement.nativeNode, predicate, matches, elementsOnly);\n  }\n}\n\n/**\n * Recursively match the current TNode against the predicate, and goes on with the next ones.\n *\n * @param tNode the current TNode\n * @param lView the LView of this TNode\n * @param predicate the predicate to match\n * @param matches the list of positive matches\n * @param elementsOnly whether only elements should be searched\n * @param rootNativeNode the root native node on which predicate should not be matched\n */\nfunction _queryNodeChildrenR3(\n    tNode: TNode, lView: LView, predicate: Predicate<DebugElement>|Predicate<DebugNode>,\n    matches: DebugElement[]|DebugNode[], elementsOnly: boolean, rootNativeNode: any) {\n  ngDevMode && assertTNodeForLView(tNode, lView);\n  const nativeNode = getNativeByTNodeOrNull(tNode, lView);\n  // For each type of TNode, specific logic is executed.\n  if (tNode.type & (TNodeType.AnyRNode | TNodeType.ElementContainer)) {\n    // Case 1: the TNode is an element\n    // The native node has to be checked.\n    _addQueryMatchR3(nativeNode, predicate, matches, elementsOnly, rootNativeNode);\n    if (isComponentHost(tNode)) {\n      // If the element is the host of a component, then all nodes in its view have to be processed.\n      // Note: the component's content (tNode.child) will be processed from the insertion points.\n      const componentView = getComponentLViewByIndex(tNode.index, lView);\n      if (componentView && componentView[TVIEW].firstChild) {\n        _queryNodeChildrenR3(\n            componentView[TVIEW].firstChild!, componentView, predicate, matches, elementsOnly,\n            rootNativeNode);\n      }\n    } else {\n      if (tNode.child) {\n        // Otherwise, its children have to be processed.\n        _queryNodeChildrenR3(tNode.child, lView, predicate, matches, elementsOnly, rootNativeNode);\n      }\n\n      // We also have to query the DOM directly in order to catch elements inserted through\n      // Renderer2. Note that this is __not__ optimal, because we're walking similar trees multiple\n      // times. ViewEngine could do it more efficiently, because all the insertions go through\n      // Renderer2, however that's not the case in Ivy. This approach is being used because:\n      // 1. Matching the ViewEngine behavior would mean potentially introducing a depedency\n      //    from `Renderer2` to Ivy which could bring Ivy code into ViewEngine.\n      // 2. We would have to make `Renderer3` \"know\" about debug nodes.\n      // 3. It allows us to capture nodes that were inserted directly via the DOM.\n      nativeNode && _queryNativeNodeDescendants(nativeNode, predicate, matches, elementsOnly);\n    }\n    // In all cases, if a dynamic container exists for this node, each view inside it has to be\n    // processed.\n    const nodeOrContainer = lView[tNode.index];\n    if (isLContainer(nodeOrContainer)) {\n      _queryNodeChildrenInContainerR3(\n          nodeOrContainer, predicate, matches, elementsOnly, rootNativeNode);\n    }\n  } else if (tNode.type & TNodeType.Container) {\n    // Case 2: the TNode is a container\n    // The native node has to be checked.\n    const lContainer = lView[tNode.index];\n    _addQueryMatchR3(lContainer[NATIVE], predicate, matches, elementsOnly, rootNativeNode);\n    // Each view inside the container has to be processed.\n    _queryNodeChildrenInContainerR3(lContainer, predicate, matches, elementsOnly, rootNativeNode);\n  } else if (tNode.type & TNodeType.Projection) {\n    // Case 3: the TNode is a projection insertion point (i.e. a <ng-content>).\n    // The nodes projected at this location all need to be processed.\n    const componentView = lView![DECLARATION_COMPONENT_VIEW];\n    const componentHost = componentView[T_HOST] as TElementNode;\n    const head: TNode|null =\n        (componentHost.projection as (TNode | null)[])[tNode.projection as number];\n\n    if (Array.isArray(head)) {\n      for (let nativeNode of head) {\n        _addQueryMatchR3(nativeNode, predicate, matches, elementsOnly, rootNativeNode);\n      }\n    } else if (head) {\n      const nextLView = componentView[PARENT]! as LView;\n      const nextTNode = nextLView[TVIEW].data[head.index] as TNode;\n      _queryNodeChildrenR3(nextTNode, nextLView, predicate, matches, elementsOnly, rootNativeNode);\n    }\n  } else if (tNode.child) {\n    // Case 4: the TNode is a view.\n    _queryNodeChildrenR3(tNode.child, lView, predicate, matches, elementsOnly, rootNativeNode);\n  }\n\n  // We don't want to go to the next sibling of the root node.\n  if (rootNativeNode !== nativeNode) {\n    // To determine the next node to be processed, we need to use the next or the projectionNext\n    // link, depending on whether the current node has been projected.\n    const nextTNode = (tNode.flags & TNodeFlags.isProjected) ? tNode.projectionNext : tNode.next;\n    if (nextTNode) {\n      _queryNodeChildrenR3(nextTNode, lView, predicate, matches, elementsOnly, rootNativeNode);\n    }\n  }\n}\n\n/**\n * Process all TNodes in a given container.\n *\n * @param lContainer the container to be processed\n * @param predicate the predicate to match\n * @param matches the list of positive matches\n * @param elementsOnly whether only elements should be searched\n * @param rootNativeNode the root native node on which predicate should not be matched\n */\nfunction _queryNodeChildrenInContainerR3(\n    lContainer: LContainer, predicate: Predicate<DebugElement>|Predicate<DebugNode>,\n    matches: DebugElement[]|DebugNode[], elementsOnly: boolean, rootNativeNode: any) {\n  for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {\n    const childView = lContainer[i] as LView;\n    const firstChild = childView[TVIEW].firstChild;\n    if (firstChild) {\n      _queryNodeChildrenR3(firstChild, childView, predicate, matches, elementsOnly, rootNativeNode);\n    }\n  }\n}\n\n/**\n * Match the current native node against the predicate.\n *\n * @param nativeNode the current native node\n * @param predicate the predicate to match\n * @param matches the list of positive matches\n * @param elementsOnly whether only elements should be searched\n * @param rootNativeNode the root native node on which predicate should not be matched\n */\nfunction _addQueryMatchR3(\n    nativeNode: any, predicate: Predicate<DebugElement>|Predicate<DebugNode>,\n    matches: DebugElement[]|DebugNode[], elementsOnly: boolean, rootNativeNode: any) {\n  if (rootNativeNode !== nativeNode) {\n    const debugNode = getDebugNode(nativeNode);\n    if (!debugNode) {\n      return;\n    }\n    // Type of the \"predicate and \"matches\" array are set based on the value of\n    // the \"elementsOnly\" parameter. TypeScript is not able to properly infer these\n    // types with generics, so we manually cast the parameters accordingly.\n    if (elementsOnly && debugNode instanceof DebugElement__POST_R3__ && predicate(debugNode) &&\n        matches.indexOf(debugNode) === -1) {\n      matches.push(debugNode);\n    } else if (\n        !elementsOnly && (predicate as Predicate<DebugNode>)(debugNode) &&\n        (matches as DebugNode[]).indexOf(debugNode) === -1) {\n      (matches as DebugNode[]).push(debugNode);\n    }\n  }\n}\n\n/**\n * Match all the descendants of a DOM node against a predicate.\n *\n * @param nativeNode the current native node\n * @param predicate the predicate to match\n * @param matches the list where matches are stored\n * @param elementsOnly whether only elements should be searched\n */\nfunction _queryNativeNodeDescendants(\n    parentNode: any, predicate: Predicate<DebugElement>|Predicate<DebugNode>,\n    matches: DebugElement[]|DebugNode[], elementsOnly: boolean) {\n  const nodes = parentNode.childNodes;\n  const length = nodes.length;\n\n  for (let i = 0; i < length; i++) {\n    const node = nodes[i];\n    const debugNode = getDebugNode(node);\n\n    if (debugNode) {\n      if (elementsOnly && debugNode instanceof DebugElement__POST_R3__ && predicate(debugNode) &&\n          matches.indexOf(debugNode) === -1) {\n        matches.push(debugNode);\n      } else if (\n          !elementsOnly && (predicate as Predicate<DebugNode>)(debugNode) &&\n          (matches as DebugNode[]).indexOf(debugNode) === -1) {\n        (matches as DebugNode[]).push(debugNode);\n      }\n\n      _queryNativeNodeDescendants(node, predicate, matches, elementsOnly);\n    }\n  }\n}\n\n/**\n * Iterates through the property bindings for a given node and generates\n * a map of property names to values. This map only contains property bindings\n * defined in templates, not in host bindings.\n */\nfunction collectPropertyBindings(\n    properties: {[key: string]: string}, tNode: TNode, lView: LView, tData: TData): void {\n  let bindingIndexes = tNode.propertyBindings;\n\n  if (bindingIndexes !== null) {\n    for (let i = 0; i < bindingIndexes.length; i++) {\n      const bindingIndex = bindingIndexes[i];\n      const propMetadata = tData[bindingIndex] as string;\n      const metadataParts = propMetadata.split(INTERPOLATION_DELIMITER);\n      const propertyName = metadataParts[0];\n      if (metadataParts.length > 1) {\n        let value = metadataParts[1];\n        for (let j = 1; j < metadataParts.length - 1; j++) {\n          value += renderStringify(lView[bindingIndex + j - 1]) + metadataParts[j + 1];\n        }\n        properties[propertyName] = value;\n      } else {\n        properties[propertyName] = lView[bindingIndex];\n      }\n    }\n  }\n}\n\n\n// Need to keep the nodes in a global Map so that multiple angular apps are supported.\nconst _nativeNodeToDebugNode = new Map<any, DebugNode>();\n\nfunction getDebugNode__PRE_R3__(nativeNode: any): DebugNode|null {\n  return _nativeNodeToDebugNode.get(nativeNode) || null;\n}\n\nconst NG_DEBUG_PROPERTY = '__ng_debug__';\n\nexport function getDebugNode__POST_R3__(nativeNode: Element): DebugElement__POST_R3__;\nexport function getDebugNode__POST_R3__(nativeNode: Node): DebugNode__POST_R3__;\nexport function getDebugNode__POST_R3__(nativeNode: null): null;\nexport function getDebugNode__POST_R3__(nativeNode: any): DebugNode|null {\n  if (nativeNode instanceof Node) {\n    if (!(nativeNode.hasOwnProperty(NG_DEBUG_PROPERTY))) {\n      (nativeNode as any)[NG_DEBUG_PROPERTY] = nativeNode.nodeType == Node.ELEMENT_NODE ?\n          new DebugElement__POST_R3__(nativeNode as Element) :\n          new DebugNode__POST_R3__(nativeNode);\n    }\n    return (nativeNode as any)[NG_DEBUG_PROPERTY];\n  }\n  return null;\n}\n\n/**\n * @publicApi\n */\nexport const getDebugNode: (nativeNode: any) => DebugNode | null = getDebugNode__PRE_R3__;\n\n\nexport function getDebugNodeR2__PRE_R3__(nativeNode: any): DebugNode|null {\n  return getDebugNode__PRE_R3__(nativeNode);\n}\n\nexport function getDebugNodeR2__POST_R3__(_nativeNode: any): DebugNode|null {\n  return null;\n}\n\nexport const getDebugNodeR2: (nativeNode: any) => DebugNode | null = getDebugNodeR2__PRE_R3__;\n\n\nexport function getAllDebugNodes(): DebugNode[] {\n  return Array.from(_nativeNodeToDebugNode.values());\n}\n\nexport function indexDebugNode(node: DebugNode) {\n  _nativeNodeToDebugNode.set(node.nativeNode, node);\n}\n\nexport function removeDebugNodeFromIndex(node: DebugNode) {\n  _nativeNodeToDebugNode.delete(node.nativeNode);\n}\n\n/**\n * A boolean-valued function over a value, possibly including context information\n * regarding that value's position in an array.\n *\n * @publicApi\n */\nexport interface Predicate<T> {\n  (value: T): boolean;\n}\n\n/**\n * @publicApi\n */\nexport const DebugNode: {new (...args: any[]): DebugNode} = DebugNode__PRE_R3__;\n\n/**\n * @publicApi\n */\nexport const DebugElement: {new (...args: any[]): DebugElement} = DebugElement__PRE_R3__;\n"]}