@angular/core 16.0.0-next.3 → 16.0.0-next.5

package/esm2022/src/render3/node_selector_matcher.mjs

@@ -0,0 +1,426 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import '../util/ng_dev_mode';
+import { assertDefined, assertEqual, assertNotEqual } from '../util/assert';
+import { classIndexOf } from './styling/class_differ';
+import { isNameOnlyAttributeMarker } from './util/attrs_utils';
+const NG_TEMPLATE_SELECTOR = 'ng-template';
+/**
+ * Search the `TAttributes` to see if it contains `cssClassToMatch` (case insensitive)
+ *
+ * @param attrs `TAttributes` to search through.
+ * @param cssClassToMatch class to match (lowercase)
+ * @param isProjectionMode Whether or not class matching should look into the attribute `class` in
+ *    addition to the `AttributeMarker.Classes`.
+ */
+function isCssClassMatching(attrs, cssClassToMatch, isProjectionMode) {
+    // TODO(misko): The fact that this function needs to know about `isProjectionMode` seems suspect.
+    // It is strange to me that sometimes the class information comes in form of `class` attribute
+    // and sometimes in form of `AttributeMarker.Classes`. Some investigation is needed to determine
+    // if that is the right behavior.
+    ngDevMode &&
+        assertEqual(cssClassToMatch, cssClassToMatch.toLowerCase(), 'Class name expected to be lowercase.');
+    let i = 0;
+    // Indicates whether we are processing value from the implicit
+    // attribute section (i.e. before the first marker in the array).
+    let isImplicitAttrsSection = true;
+    while (i < attrs.length) {
+        let item = attrs[i++];
+        if (typeof item === 'string' && isImplicitAttrsSection) {
+            const value = attrs[i++];
+            if (isProjectionMode && item === 'class') {
+                // We found a `class` attribute in the implicit attribute section,
+                // check if it matches the value of the `cssClassToMatch` argument.
+                if (classIndexOf(value.toLowerCase(), cssClassToMatch, 0) !== -1) {
+                    return true;
+                }
+            }
+        }
+        else if (item === 1 /* AttributeMarker.Classes */) {
+            // We found the classes section. Start searching for the class.
+            while (i < attrs.length && typeof (item = attrs[i++]) == 'string') {
+                // while we have strings
+                if (item.toLowerCase() === cssClassToMatch)
+                    return true;
+            }
+            return false;
+        }
+        else if (typeof item === 'number') {
+            // We've came across a first marker, which indicates
+            // that the implicit attribute section is over.
+            isImplicitAttrsSection = false;
+        }
+    }
+    return false;
+}
+/**
+ * Checks whether the `tNode` represents an inline template (e.g. `*ngFor`).
+ *
+ * @param tNode current TNode
+ */
+export function isInlineTemplate(tNode) {
+    return tNode.type === 4 /* TNodeType.Container */ && tNode.value !== NG_TEMPLATE_SELECTOR;
+}
+/**
+ * Function that checks whether a given tNode matches tag-based selector and has a valid type.
+ *
+ * Matching can be performed in 2 modes: projection mode (when we project nodes) and regular
+ * directive matching mode:
+ * - in the "directive matching" mode we do _not_ take TContainer's tagName into account if it is
+ * different from NG_TEMPLATE_SELECTOR (value different from NG_TEMPLATE_SELECTOR indicates that a
+ * tag name was extracted from * syntax so we would match the same directive twice);
+ * - in the "projection" mode, we use a tag name potentially extracted from the * syntax processing
+ * (applicable to TNodeType.Container only).
+ */
+function hasTagAndTypeMatch(tNode, currentSelector, isProjectionMode) {
+    const tagNameToCompare = tNode.type === 4 /* TNodeType.Container */ && !isProjectionMode ? NG_TEMPLATE_SELECTOR : tNode.value;
+    return currentSelector === tagNameToCompare;
+}
+/**
+ * A utility function to match an Ivy node static data against a simple CSS selector
+ *
+ * @param node static data of the node to match
+ * @param selector The selector to try matching against the node.
+ * @param isProjectionMode if `true` we are matching for content projection, otherwise we are doing
+ * directive matching.
+ * @returns true if node matches the selector.
+ */
+export function isNodeMatchingSelector(tNode, selector, isProjectionMode) {
+    ngDevMode && assertDefined(selector[0], 'Selector should have a tag name');
+    let mode = 4 /* SelectorFlags.ELEMENT */;
+    const nodeAttrs = tNode.attrs || [];
+    // Find the index of first attribute that has no value, only a name.
+    const nameOnlyMarkerIdx = getNameOnlyMarkerIndex(nodeAttrs);
+    // When processing ":not" selectors, we skip to the next ":not" if the
+    // current one doesn't match
+    let skipToNextSelector = false;
+    for (let i = 0; i < selector.length; i++) {
+        const current = selector[i];
+        if (typeof current === 'number') {
+            // If we finish processing a :not selector and it hasn't failed, return false
+            if (!skipToNextSelector && !isPositive(mode) && !isPositive(current)) {
+                return false;
+            }
+            // If we are skipping to the next :not() and this mode flag is positive,
+            // it's a part of the current :not() selector, and we should keep skipping
+            if (skipToNextSelector && isPositive(current))
+                continue;
+            skipToNextSelector = false;
+            mode = current | (mode & 1 /* SelectorFlags.NOT */);
+            continue;
+        }
+        if (skipToNextSelector)
+            continue;
+        if (mode & 4 /* SelectorFlags.ELEMENT */) {
+            mode = 2 /* SelectorFlags.ATTRIBUTE */ | mode & 1 /* SelectorFlags.NOT */;
+            if (current !== '' && !hasTagAndTypeMatch(tNode, current, isProjectionMode) ||
+                current === '' && selector.length === 1) {
+                if (isPositive(mode))
+                    return false;
+                skipToNextSelector = true;
+            }
+        }
+        else {
+            const selectorAttrValue = mode & 8 /* SelectorFlags.CLASS */ ? current : selector[++i];
+            // special case for matching against classes when a tNode has been instantiated with
+            // class and style values as separate attribute values (e.g. ['title', CLASS, 'foo'])
+            if ((mode & 8 /* SelectorFlags.CLASS */) && tNode.attrs !== null) {
+                if (!isCssClassMatching(tNode.attrs, selectorAttrValue, isProjectionMode)) {
+                    if (isPositive(mode))
+                        return false;
+                    skipToNextSelector = true;
+                }
+                continue;
+            }
+            const attrName = (mode & 8 /* SelectorFlags.CLASS */) ? 'class' : current;
+            const attrIndexInNode = findAttrIndexInNode(attrName, nodeAttrs, isInlineTemplate(tNode), isProjectionMode);
+            if (attrIndexInNode === -1) {
+                if (isPositive(mode))
+                    return false;
+                skipToNextSelector = true;
+                continue;
+            }
+            if (selectorAttrValue !== '') {
+                let nodeAttrValue;
+                if (attrIndexInNode > nameOnlyMarkerIdx) {
+                    nodeAttrValue = '';
+                }
+                else {
+                    ngDevMode &&
+                        assertNotEqual(nodeAttrs[attrIndexInNode], 0 /* AttributeMarker.NamespaceURI */, 'We do not match directives on namespaced attributes');
+                    // we lowercase the attribute value to be able to match
+                    // selectors without case-sensitivity
+                    // (selectors are already in lowercase when generated)
+                    nodeAttrValue = nodeAttrs[attrIndexInNode + 1].toLowerCase();
+                }
+                const compareAgainstClassName = mode & 8 /* SelectorFlags.CLASS */ ? nodeAttrValue : null;
+                if (compareAgainstClassName &&
+                    classIndexOf(compareAgainstClassName, selectorAttrValue, 0) !== -1 ||
+                    mode & 2 /* SelectorFlags.ATTRIBUTE */ && selectorAttrValue !== nodeAttrValue) {
+                    if (isPositive(mode))
+                        return false;
+                    skipToNextSelector = true;
+                }
+            }
+        }
+    }
+    return isPositive(mode) || skipToNextSelector;
+}
+function isPositive(mode) {
+    return (mode & 1 /* SelectorFlags.NOT */) === 0;
+}
+/**
+ * Examines the attribute's definition array for a node to find the index of the
+ * attribute that matches the given `name`.
+ *
+ * NOTE: This will not match namespaced attributes.
+ *
+ * Attribute matching depends upon `isInlineTemplate` and `isProjectionMode`.
+ * The following table summarizes which types of attributes we attempt to match:
+ *
+ * ===========================================================================================================
+ * Modes                   | Normal Attributes | Bindings Attributes | Template Attributes | I18n
+ * Attributes
+ * ===========================================================================================================
+ * Inline + Projection     | YES               | YES                 | NO                  | YES
+ * -----------------------------------------------------------------------------------------------------------
+ * Inline + Directive      | NO                | NO                  | YES                 | NO
+ * -----------------------------------------------------------------------------------------------------------
+ * Non-inline + Projection | YES               | YES                 | NO                  | YES
+ * -----------------------------------------------------------------------------------------------------------
+ * Non-inline + Directive  | YES               | YES                 | NO                  | YES
+ * ===========================================================================================================
+ *
+ * @param name the name of the attribute to find
+ * @param attrs the attribute array to examine
+ * @param isInlineTemplate true if the node being matched is an inline template (e.g. `*ngFor`)
+ * rather than a manually expanded template node (e.g `<ng-template>`).
+ * @param isProjectionMode true if we are matching against content projection otherwise we are
+ * matching against directives.
+ */
+function findAttrIndexInNode(name, attrs, isInlineTemplate, isProjectionMode) {
+    if (attrs === null)
+        return -1;
+    let i = 0;
+    if (isProjectionMode || !isInlineTemplate) {
+        let bindingsMode = false;
+        while (i < attrs.length) {
+            const maybeAttrName = attrs[i];
+            if (maybeAttrName === name) {
+                return i;
+            }
+            else if (maybeAttrName === 3 /* AttributeMarker.Bindings */ || maybeAttrName === 6 /* AttributeMarker.I18n */) {
+                bindingsMode = true;
+            }
+            else if (maybeAttrName === 1 /* AttributeMarker.Classes */ || maybeAttrName === 2 /* AttributeMarker.Styles */) {
+                let value = attrs[++i];
+                // We should skip classes here because we have a separate mechanism for
+                // matching classes in projection mode.
+                while (typeof value === 'string') {
+                    value = attrs[++i];
+                }
+                continue;
+            }
+            else if (maybeAttrName === 4 /* AttributeMarker.Template */) {
+                // We do not care about Template attributes in this scenario.
+                break;
+            }
+            else if (maybeAttrName === 0 /* AttributeMarker.NamespaceURI */) {
+                // Skip the whole namespaced attribute and value. This is by design.
+                i += 4;
+                continue;
+            }
+            // In binding mode there are only names, rather than name-value pairs.
+            i += bindingsMode ? 1 : 2;
+        }
+        // We did not match the attribute
+        return -1;
+    }
+    else {
+        return matchTemplateAttribute(attrs, name);
+    }
+}
+export function isNodeMatchingSelectorList(tNode, selector, isProjectionMode = false) {
+    for (let i = 0; i < selector.length; i++) {
+        if (isNodeMatchingSelector(tNode, selector[i], isProjectionMode)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function getProjectAsAttrValue(tNode) {
+    const nodeAttrs = tNode.attrs;
+    if (nodeAttrs != null) {
+        const ngProjectAsAttrIdx = nodeAttrs.indexOf(5 /* AttributeMarker.ProjectAs */);
+        // only check for ngProjectAs in attribute names, don't accidentally match attribute's value
+        // (attribute names are stored at even indexes)
+        if ((ngProjectAsAttrIdx & 1) === 0) {
+            return nodeAttrs[ngProjectAsAttrIdx + 1];
+        }
+    }
+    return null;
+}
+function getNameOnlyMarkerIndex(nodeAttrs) {
+    for (let i = 0; i < nodeAttrs.length; i++) {
+        const nodeAttr = nodeAttrs[i];
+        if (isNameOnlyAttributeMarker(nodeAttr)) {
+            return i;
+        }
+    }
+    return nodeAttrs.length;
+}
+function matchTemplateAttribute(attrs, name) {
+    let i = attrs.indexOf(4 /* AttributeMarker.Template */);
+    if (i > -1) {
+        i++;
+        while (i < attrs.length) {
+            const attr = attrs[i];
+            // Return in case we checked all template attrs and are switching to the next section in the
+            // attrs array (that starts with a number that represents an attribute marker).
+            if (typeof attr === 'number')
+                return -1;
+            if (attr === name)
+                return i;
+            i++;
+        }
+    }
+    return -1;
+}
+/**
+ * Checks whether a selector is inside a CssSelectorList
+ * @param selector Selector to be checked.
+ * @param list List in which to look for the selector.
+ */
+export function isSelectorInSelectorList(selector, list) {
+    selectorListLoop: for (let i = 0; i < list.length; i++) {
+        const currentSelectorInList = list[i];
+        if (selector.length !== currentSelectorInList.length) {
+            continue;
+        }
+        for (let j = 0; j < selector.length; j++) {
+            if (selector[j] !== currentSelectorInList[j]) {
+                continue selectorListLoop;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+function maybeWrapInNotSelector(isNegativeMode, chunk) {
+    return isNegativeMode ? ':not(' + chunk.trim() + ')' : chunk;
+}
+function stringifyCSSSelector(selector) {
+    let result = selector[0];
+    let i = 1;
+    let mode = 2 /* SelectorFlags.ATTRIBUTE */;
+    let currentChunk = '';
+    let isNegativeMode = false;
+    while (i < selector.length) {
+        let valueOrMarker = selector[i];
+        if (typeof valueOrMarker === 'string') {
+            if (mode & 2 /* SelectorFlags.ATTRIBUTE */) {
+                const attrValue = selector[++i];
+                currentChunk +=
+                    '[' + valueOrMarker + (attrValue.length > 0 ? '="' + attrValue + '"' : '') + ']';
+            }
+            else if (mode & 8 /* SelectorFlags.CLASS */) {
+                currentChunk += '.' + valueOrMarker;
+            }
+            else if (mode & 4 /* SelectorFlags.ELEMENT */) {
+                currentChunk += ' ' + valueOrMarker;
+            }
+        }
+        else {
+            //
+            // Append current chunk to the final result in case we come across SelectorFlag, which
+            // indicates that the previous section of a selector is over. We need to accumulate content
+            // between flags to make sure we wrap the chunk later in :not() selector if needed, e.g.
+            // ```
+            //  ['', Flags.CLASS, '.classA', Flags.CLASS | Flags.NOT, '.classB', '.classC']
+            // ```
+            // should be transformed to `.classA :not(.classB .classC)`.
+            //
+            // Note: for negative selector part, we accumulate content between flags until we find the
+            // next negative flag. This is needed to support a case where `:not()` rule contains more than
+            // one chunk, e.g. the following selector:
+            // ```
+            //  ['', Flags.ELEMENT | Flags.NOT, 'p', Flags.CLASS, 'foo', Flags.CLASS | Flags.NOT, 'bar']
+            // ```
+            // should be stringified to `:not(p.foo) :not(.bar)`
+            //
+            if (currentChunk !== '' && !isPositive(valueOrMarker)) {
+                result += maybeWrapInNotSelector(isNegativeMode, currentChunk);
+                currentChunk = '';
+            }
+            mode = valueOrMarker;
+            // According to CssSelector spec, once we come across `SelectorFlags.NOT` flag, the negative
+            // mode is maintained for remaining chunks of a selector.
+            isNegativeMode = isNegativeMode || !isPositive(mode);
+        }
+        i++;
+    }
+    if (currentChunk !== '') {
+        result += maybeWrapInNotSelector(isNegativeMode, currentChunk);
+    }
+    return result;
+}
+/**
+ * Generates string representation of CSS selector in parsed form.
+ *
+ * ComponentDef and DirectiveDef are generated with the selector in parsed form to avoid doing
+ * additional parsing at runtime (for example, for directive matching). However in some cases (for
+ * example, while bootstrapping a component), a string version of the selector is required to query
+ * for the host element on the page. This function takes the parsed form of a selector and returns
+ * its string representation.
+ *
+ * @param selectorList selector in parsed form
+ * @returns string representation of a given selector
+ */
+export function stringifyCSSSelectorList(selectorList) {
+    return selectorList.map(stringifyCSSSelector).join(',');
+}
+/**
+ * Extracts attributes and classes information from a given CSS selector.
+ *
+ * This function is used while creating a component dynamically. In this case, the host element
+ * (that is created dynamically) should contain attributes and classes specified in component's CSS
+ * selector.
+ *
+ * @param selector CSS selector in parsed form (in a form of array)
+ * @returns object with `attrs` and `classes` fields that contain extracted information
+ */
+export function extractAttrsAndClassesFromSelector(selector) {
+    const attrs = [];
+    const classes = [];
+    let i = 1;
+    let mode = 2 /* SelectorFlags.ATTRIBUTE */;
+    while (i < selector.length) {
+        let valueOrMarker = selector[i];
+        if (typeof valueOrMarker === 'string') {
+            if (mode === 2 /* SelectorFlags.ATTRIBUTE */) {
+                if (valueOrMarker !== '') {
+                    attrs.push(valueOrMarker, selector[++i]);
+                }
+            }
+            else if (mode === 8 /* SelectorFlags.CLASS */) {
+                classes.push(valueOrMarker);
+            }
+        }
+        else {
+            // According to CssSelector spec, once we come across `SelectorFlags.NOT` flag, the negative
+            // mode is maintained for remaining chunks of a selector. Since attributes and classes are
+            // extracted only for "positive" part of the selector, we can stop here.
+            if (!isPositive(mode))
+                break;
+            mode = valueOrMarker;
+        }
+        i++;
+    }
+    return { attrs, classes };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node_selector_matcher.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/node_selector_matcher.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 '../util/ng_dev_mode';\n\nimport {assertDefined, assertEqual, assertNotEqual} from '../util/assert';\n\nimport {AttributeMarker, TAttributes, TNode, TNodeType} from './interfaces/node';\nimport {CssSelector, CssSelectorList, SelectorFlags} from './interfaces/projection';\nimport {classIndexOf} from './styling/class_differ';\nimport {isNameOnlyAttributeMarker} from './util/attrs_utils';\n\nconst NG_TEMPLATE_SELECTOR = 'ng-template';\n\n/**\n * Search the `TAttributes` to see if it contains `cssClassToMatch` (case insensitive)\n *\n * @param attrs `TAttributes` to search through.\n * @param cssClassToMatch class to match (lowercase)\n * @param isProjectionMode Whether or not class matching should look into the attribute `class` in\n *    addition to the `AttributeMarker.Classes`.\n */\nfunction isCssClassMatching(\n    attrs: TAttributes, cssClassToMatch: string, isProjectionMode: boolean): boolean {\n  // TODO(misko): The fact that this function needs to know about `isProjectionMode` seems suspect.\n  // It is strange to me that sometimes the class information comes in form of `class` attribute\n  // and sometimes in form of `AttributeMarker.Classes`. Some investigation is needed to determine\n  // if that is the right behavior.\n  ngDevMode &&\n      assertEqual(\n          cssClassToMatch, cssClassToMatch.toLowerCase(), 'Class name expected to be lowercase.');\n  let i = 0;\n  // Indicates whether we are processing value from the implicit\n  // attribute section (i.e. before the first marker in the array).\n  let isImplicitAttrsSection = true;\n  while (i < attrs.length) {\n    let item = attrs[i++];\n    if (typeof item === 'string' && isImplicitAttrsSection) {\n      const value = attrs[i++] as string;\n      if (isProjectionMode && item === 'class') {\n        // We found a `class` attribute in the implicit attribute section,\n        // check if it matches the value of the `cssClassToMatch` argument.\n        if (classIndexOf(value.toLowerCase(), cssClassToMatch, 0) !== -1) {\n          return true;\n        }\n      }\n    } else if (item === AttributeMarker.Classes) {\n      // We found the classes section. Start searching for the class.\n      while (i < attrs.length && typeof (item = attrs[i++]) == 'string') {\n        // while we have strings\n        if (item.toLowerCase() === cssClassToMatch) return true;\n      }\n      return false;\n    } else if (typeof item === 'number') {\n      // We've came across a first marker, which indicates\n      // that the implicit attribute section is over.\n      isImplicitAttrsSection = false;\n    }\n  }\n  return false;\n}\n\n/**\n * Checks whether the `tNode` represents an inline template (e.g. `*ngFor`).\n *\n * @param tNode current TNode\n */\nexport function isInlineTemplate(tNode: TNode): boolean {\n  return tNode.type === TNodeType.Container && tNode.value !== NG_TEMPLATE_SELECTOR;\n}\n\n/**\n * Function that checks whether a given tNode matches tag-based selector and has a valid type.\n *\n * Matching can be performed in 2 modes: projection mode (when we project nodes) and regular\n * directive matching mode:\n * - in the \"directive matching\" mode we do _not_ take TContainer's tagName into account if it is\n * different from NG_TEMPLATE_SELECTOR (value different from NG_TEMPLATE_SELECTOR indicates that a\n * tag name was extracted from * syntax so we would match the same directive twice);\n * - in the \"projection\" mode, we use a tag name potentially extracted from the * syntax processing\n * (applicable to TNodeType.Container only).\n */\nfunction hasTagAndTypeMatch(\n    tNode: TNode, currentSelector: string, isProjectionMode: boolean): boolean {\n  const tagNameToCompare =\n      tNode.type === TNodeType.Container && !isProjectionMode ? NG_TEMPLATE_SELECTOR : tNode.value;\n  return currentSelector === tagNameToCompare;\n}\n\n/**\n * A utility function to match an Ivy node static data against a simple CSS selector\n *\n * @param node static data of the node to match\n * @param selector The selector to try matching against the node.\n * @param isProjectionMode if `true` we are matching for content projection, otherwise we are doing\n * directive matching.\n * @returns true if node matches the selector.\n */\nexport function isNodeMatchingSelector(\n    tNode: TNode, selector: CssSelector, isProjectionMode: boolean): boolean {\n  ngDevMode && assertDefined(selector[0], 'Selector should have a tag name');\n  let mode: SelectorFlags = SelectorFlags.ELEMENT;\n  const nodeAttrs = tNode.attrs || [];\n\n  // Find the index of first attribute that has no value, only a name.\n  const nameOnlyMarkerIdx = getNameOnlyMarkerIndex(nodeAttrs);\n\n  // When processing \":not\" selectors, we skip to the next \":not\" if the\n  // current one doesn't match\n  let skipToNextSelector = false;\n\n  for (let i = 0; i < selector.length; i++) {\n    const current = selector[i];\n    if (typeof current === 'number') {\n      // If we finish processing a :not selector and it hasn't failed, return false\n      if (!skipToNextSelector && !isPositive(mode) && !isPositive(current)) {\n        return false;\n      }\n      // If we are skipping to the next :not() and this mode flag is positive,\n      // it's a part of the current :not() selector, and we should keep skipping\n      if (skipToNextSelector && isPositive(current)) continue;\n      skipToNextSelector = false;\n      mode = (current as number) | (mode & SelectorFlags.NOT);\n      continue;\n    }\n\n    if (skipToNextSelector) continue;\n\n    if (mode & SelectorFlags.ELEMENT) {\n      mode = SelectorFlags.ATTRIBUTE | mode & SelectorFlags.NOT;\n      if (current !== '' && !hasTagAndTypeMatch(tNode, current, isProjectionMode) ||\n          current === '' && selector.length === 1) {\n        if (isPositive(mode)) return false;\n        skipToNextSelector = true;\n      }\n    } else {\n      const selectorAttrValue = mode & SelectorFlags.CLASS ? current : selector[++i];\n\n      // special case for matching against classes when a tNode has been instantiated with\n      // class and style values as separate attribute values (e.g. ['title', CLASS, 'foo'])\n      if ((mode & SelectorFlags.CLASS) && tNode.attrs !== null) {\n        if (!isCssClassMatching(tNode.attrs, selectorAttrValue as string, isProjectionMode)) {\n          if (isPositive(mode)) return false;\n          skipToNextSelector = true;\n        }\n        continue;\n      }\n\n      const attrName = (mode & SelectorFlags.CLASS) ? 'class' : current;\n      const attrIndexInNode =\n          findAttrIndexInNode(attrName, nodeAttrs, isInlineTemplate(tNode), isProjectionMode);\n\n      if (attrIndexInNode === -1) {\n        if (isPositive(mode)) return false;\n        skipToNextSelector = true;\n        continue;\n      }\n\n      if (selectorAttrValue !== '') {\n        let nodeAttrValue: string;\n        if (attrIndexInNode > nameOnlyMarkerIdx) {\n          nodeAttrValue = '';\n        } else {\n          ngDevMode &&\n              assertNotEqual(\n                  nodeAttrs[attrIndexInNode], AttributeMarker.NamespaceURI,\n                  'We do not match directives on namespaced attributes');\n          // we lowercase the attribute value to be able to match\n          // selectors without case-sensitivity\n          // (selectors are already in lowercase when generated)\n          nodeAttrValue = (nodeAttrs[attrIndexInNode + 1] as string).toLowerCase();\n        }\n\n        const compareAgainstClassName = mode & SelectorFlags.CLASS ? nodeAttrValue : null;\n        if (compareAgainstClassName &&\n                classIndexOf(compareAgainstClassName, selectorAttrValue as string, 0) !== -1 ||\n            mode & SelectorFlags.ATTRIBUTE && selectorAttrValue !== nodeAttrValue) {\n          if (isPositive(mode)) return false;\n          skipToNextSelector = true;\n        }\n      }\n    }\n  }\n\n  return isPositive(mode) || skipToNextSelector;\n}\n\nfunction isPositive(mode: SelectorFlags): boolean {\n  return (mode & SelectorFlags.NOT) === 0;\n}\n\n/**\n * Examines the attribute's definition array for a node to find the index of the\n * attribute that matches the given `name`.\n *\n * NOTE: This will not match namespaced attributes.\n *\n * Attribute matching depends upon `isInlineTemplate` and `isProjectionMode`.\n * The following table summarizes which types of attributes we attempt to match:\n *\n * ===========================================================================================================\n * Modes                   | Normal Attributes | Bindings Attributes | Template Attributes | I18n\n * Attributes\n * ===========================================================================================================\n * Inline + Projection     | YES               | YES                 | NO                  | YES\n * -----------------------------------------------------------------------------------------------------------\n * Inline + Directive      | NO                | NO                  | YES                 | NO\n * -----------------------------------------------------------------------------------------------------------\n * Non-inline + Projection | YES               | YES                 | NO                  | YES\n * -----------------------------------------------------------------------------------------------------------\n * Non-inline + Directive  | YES               | YES                 | NO                  | YES\n * ===========================================================================================================\n *\n * @param name the name of the attribute to find\n * @param attrs the attribute array to examine\n * @param isInlineTemplate true if the node being matched is an inline template (e.g. `*ngFor`)\n * rather than a manually expanded template node (e.g `<ng-template>`).\n * @param isProjectionMode true if we are matching against content projection otherwise we are\n * matching against directives.\n */\nfunction findAttrIndexInNode(\n    name: string, attrs: TAttributes|null, isInlineTemplate: boolean,\n    isProjectionMode: boolean): number {\n  if (attrs === null) return -1;\n\n  let i = 0;\n\n  if (isProjectionMode || !isInlineTemplate) {\n    let bindingsMode = false;\n    while (i < attrs.length) {\n      const maybeAttrName = attrs[i];\n      if (maybeAttrName === name) {\n        return i;\n      } else if (\n          maybeAttrName === AttributeMarker.Bindings || maybeAttrName === AttributeMarker.I18n) {\n        bindingsMode = true;\n      } else if (\n          maybeAttrName === AttributeMarker.Classes || maybeAttrName === AttributeMarker.Styles) {\n        let value = attrs[++i];\n        // We should skip classes here because we have a separate mechanism for\n        // matching classes in projection mode.\n        while (typeof value === 'string') {\n          value = attrs[++i];\n        }\n        continue;\n      } else if (maybeAttrName === AttributeMarker.Template) {\n        // We do not care about Template attributes in this scenario.\n        break;\n      } else if (maybeAttrName === AttributeMarker.NamespaceURI) {\n        // Skip the whole namespaced attribute and value. This is by design.\n        i += 4;\n        continue;\n      }\n      // In binding mode there are only names, rather than name-value pairs.\n      i += bindingsMode ? 1 : 2;\n    }\n    // We did not match the attribute\n    return -1;\n  } else {\n    return matchTemplateAttribute(attrs, name);\n  }\n}\n\nexport function isNodeMatchingSelectorList(\n    tNode: TNode, selector: CssSelectorList, isProjectionMode: boolean = false): boolean {\n  for (let i = 0; i < selector.length; i++) {\n    if (isNodeMatchingSelector(tNode, selector[i], isProjectionMode)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nexport function getProjectAsAttrValue(tNode: TNode): CssSelector|null {\n  const nodeAttrs = tNode.attrs;\n  if (nodeAttrs != null) {\n    const ngProjectAsAttrIdx = nodeAttrs.indexOf(AttributeMarker.ProjectAs);\n    // only check for ngProjectAs in attribute names, don't accidentally match attribute's value\n    // (attribute names are stored at even indexes)\n    if ((ngProjectAsAttrIdx & 1) === 0) {\n      return nodeAttrs[ngProjectAsAttrIdx + 1] as CssSelector;\n    }\n  }\n  return null;\n}\n\nfunction getNameOnlyMarkerIndex(nodeAttrs: TAttributes) {\n  for (let i = 0; i < nodeAttrs.length; i++) {\n    const nodeAttr = nodeAttrs[i];\n    if (isNameOnlyAttributeMarker(nodeAttr)) {\n      return i;\n    }\n  }\n  return nodeAttrs.length;\n}\n\nfunction matchTemplateAttribute(attrs: TAttributes, name: string): number {\n  let i = attrs.indexOf(AttributeMarker.Template);\n  if (i > -1) {\n    i++;\n    while (i < attrs.length) {\n      const attr = attrs[i];\n      // Return in case we checked all template attrs and are switching to the next section in the\n      // attrs array (that starts with a number that represents an attribute marker).\n      if (typeof attr === 'number') return -1;\n      if (attr === name) return i;\n      i++;\n    }\n  }\n  return -1;\n}\n\n/**\n * Checks whether a selector is inside a CssSelectorList\n * @param selector Selector to be checked.\n * @param list List in which to look for the selector.\n */\nexport function isSelectorInSelectorList(selector: CssSelector, list: CssSelectorList): boolean {\n  selectorListLoop: for (let i = 0; i < list.length; i++) {\n    const currentSelectorInList = list[i];\n    if (selector.length !== currentSelectorInList.length) {\n      continue;\n    }\n    for (let j = 0; j < selector.length; j++) {\n      if (selector[j] !== currentSelectorInList[j]) {\n        continue selectorListLoop;\n      }\n    }\n    return true;\n  }\n  return false;\n}\n\nfunction maybeWrapInNotSelector(isNegativeMode: boolean, chunk: string): string {\n  return isNegativeMode ? ':not(' + chunk.trim() + ')' : chunk;\n}\n\nfunction stringifyCSSSelector(selector: CssSelector): string {\n  let result = selector[0] as string;\n  let i = 1;\n  let mode = SelectorFlags.ATTRIBUTE;\n  let currentChunk = '';\n  let isNegativeMode = false;\n  while (i < selector.length) {\n    let valueOrMarker = selector[i];\n    if (typeof valueOrMarker === 'string') {\n      if (mode & SelectorFlags.ATTRIBUTE) {\n        const attrValue = selector[++i] as string;\n        currentChunk +=\n            '[' + valueOrMarker + (attrValue.length > 0 ? '=\"' + attrValue + '\"' : '') + ']';\n      } else if (mode & SelectorFlags.CLASS) {\n        currentChunk += '.' + valueOrMarker;\n      } else if (mode & SelectorFlags.ELEMENT) {\n        currentChunk += ' ' + valueOrMarker;\n      }\n    } else {\n      //\n      // Append current chunk to the final result in case we come across SelectorFlag, which\n      // indicates that the previous section of a selector is over. We need to accumulate content\n      // between flags to make sure we wrap the chunk later in :not() selector if needed, e.g.\n      // ```\n      //  ['', Flags.CLASS, '.classA', Flags.CLASS | Flags.NOT, '.classB', '.classC']\n      // ```\n      // should be transformed to `.classA :not(.classB .classC)`.\n      //\n      // Note: for negative selector part, we accumulate content between flags until we find the\n      // next negative flag. This is needed to support a case where `:not()` rule contains more than\n      // one chunk, e.g. the following selector:\n      // ```\n      //  ['', Flags.ELEMENT | Flags.NOT, 'p', Flags.CLASS, 'foo', Flags.CLASS | Flags.NOT, 'bar']\n      // ```\n      // should be stringified to `:not(p.foo) :not(.bar)`\n      //\n      if (currentChunk !== '' && !isPositive(valueOrMarker)) {\n        result += maybeWrapInNotSelector(isNegativeMode, currentChunk);\n        currentChunk = '';\n      }\n      mode = valueOrMarker;\n      // According to CssSelector spec, once we come across `SelectorFlags.NOT` flag, the negative\n      // mode is maintained for remaining chunks of a selector.\n      isNegativeMode = isNegativeMode || !isPositive(mode);\n    }\n    i++;\n  }\n  if (currentChunk !== '') {\n    result += maybeWrapInNotSelector(isNegativeMode, currentChunk);\n  }\n  return result;\n}\n\n/**\n * Generates string representation of CSS selector in parsed form.\n *\n * ComponentDef and DirectiveDef are generated with the selector in parsed form to avoid doing\n * additional parsing at runtime (for example, for directive matching). However in some cases (for\n * example, while bootstrapping a component), a string version of the selector is required to query\n * for the host element on the page. This function takes the parsed form of a selector and returns\n * its string representation.\n *\n * @param selectorList selector in parsed form\n * @returns string representation of a given selector\n */\nexport function stringifyCSSSelectorList(selectorList: CssSelectorList): string {\n  return selectorList.map(stringifyCSSSelector).join(',');\n}\n\n/**\n * Extracts attributes and classes information from a given CSS selector.\n *\n * This function is used while creating a component dynamically. In this case, the host element\n * (that is created dynamically) should contain attributes and classes specified in component's CSS\n * selector.\n *\n * @param selector CSS selector in parsed form (in a form of array)\n * @returns object with `attrs` and `classes` fields that contain extracted information\n */\nexport function extractAttrsAndClassesFromSelector(selector: CssSelector):\n    {attrs: string[], classes: string[]} {\n  const attrs: string[] = [];\n  const classes: string[] = [];\n  let i = 1;\n  let mode = SelectorFlags.ATTRIBUTE;\n  while (i < selector.length) {\n    let valueOrMarker = selector[i];\n    if (typeof valueOrMarker === 'string') {\n      if (mode === SelectorFlags.ATTRIBUTE) {\n        if (valueOrMarker !== '') {\n          attrs.push(valueOrMarker, selector[++i] as string);\n        }\n      } else if (mode === SelectorFlags.CLASS) {\n        classes.push(valueOrMarker);\n      }\n    } else {\n      // According to CssSelector spec, once we come across `SelectorFlags.NOT` flag, the negative\n      // mode is maintained for remaining chunks of a selector. Since attributes and classes are\n      // extracted only for \"positive\" part of the selector, we can stop here.\n      if (!isPositive(mode)) break;\n      mode = valueOrMarker;\n    }\n    i++;\n  }\n  return {attrs, classes};\n}\n"]}

package/esm2022/src/render3/reactive_lview_consumer.mjs

@@ -0,0 +1,80 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ReactiveNode, setActiveConsumer } from '../signals/src/graph';
+import { assertDefined, assertEqual } from '../util/assert';
+import { markViewDirty } from './instructions/mark_view_dirty';
+const NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;
+export class ReactiveLViewConsumer extends ReactiveNode {
+    constructor() {
+        super(...arguments);
+        this._lView = null;
+    }
+    set lView(lView) {
+        NG_DEV_MODE && assertEqual(this._lView, null, 'Consumer already associated with a view.');
+        this._lView = lView;
+    }
+    onConsumerDependencyMayHaveChanged() {
+        NG_DEV_MODE &&
+            assertDefined(this._lView, 'Updating a signal during template or host binding execution is not allowed.');
+        markViewDirty(this._lView);
+    }
+    onProducerUpdateValueVersion() {
+        // This type doesn't implement the producer side of a `ReactiveNode`.
+    }
+    get hasReadASignal() {
+        return this.hasProducers;
+    }
+    runInContext(fn, rf, ctx) {
+        const prevConsumer = setActiveConsumer(this);
+        this.trackingVersion++;
+        try {
+            fn(rf, ctx);
+        }
+        finally {
+            setActiveConsumer(prevConsumer);
+        }
+    }
+    destroy() {
+        // Incrementing the version means that every producer which tries to update this consumer will
+        // consider its record stale, and not notify.
+        this.trackingVersion++;
+    }
+}
+let currentConsumer = null;
+function getOrCreateCurrentLViewConsumer() {
+    currentConsumer ??= new ReactiveLViewConsumer();
+    return currentConsumer;
+}
+/**
+ * Create a new template consumer pointing at the specified LView.
+ * Sometimes, a previously created consumer may be reused, in order to save on allocations. In that
+ * case, the LView will be updated.
+ */
+export function getReactiveLViewConsumer(lView, slot) {
+    return lView[slot] ?? getOrCreateCurrentLViewConsumer();
+}
+/**
+ * Assigns the `currentTemplateContext` to its LView's `REACTIVE_CONSUMER` slot if there are tracked
+ * producers.
+ *
+ * The presence of producers means that a signal was read while the consumer was the active
+ * consumer.
+ *
+ * If no producers are present, we do not assign the current template context. This also means we
+ * can just reuse the template context for the next LView.
+ */
+export function commitLViewConsumerIfHasProducers(lView, slot) {
+    const consumer = getOrCreateCurrentLViewConsumer();
+    if (!consumer.hasReadASignal) {
+        return;
+    }
+    lView[slot] = currentConsumer;
+    consumer.lView = lView;
+    currentConsumer = new ReactiveLViewConsumer();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVhY3RpdmVfbHZpZXdfY29uc3VtZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9yZW5kZXIzL3JlYWN0aXZlX2x2aWV3X2NvbnN1bWVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyxZQUFZLEVBQUUsaUJBQWlCLEVBQUMsTUFBTSxzQkFBc0IsQ0FBQztBQUNyRSxPQUFPLEVBQUMsYUFBYSxFQUFFLFdBQVcsRUFBQyxNQUFNLGdCQUFnQixDQUFDO0FBRTFELE9BQU8sRUFBQyxhQUFhLEVBQUMsTUFBTSxnQ0FBZ0MsQ0FBQztBQUk3RCxNQUFNLFdBQVcsR0FBRyxPQUFPLFNBQVMsS0FBSyxXQUFXLElBQUksU0FBUyxDQUFDO0FBRWxFLE1BQU0sT0FBTyxxQkFBc0IsU0FBUSxZQUFZO0lBQXZEOztRQUNVLFdBQU0sR0FBZSxJQUFJLENBQUM7SUF3Q3BDLENBQUM7SUF0Q0MsSUFBSSxLQUFLLENBQUMsS0FBWTtRQUNwQixXQUFXLElBQUksV0FBVyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsSUFBSSxFQUFFLDBDQUEwQyxDQUFDLENBQUM7UUFDMUYsSUFBSSxDQUFDLE1BQU0sR0FBRyxLQUFLLENBQUM7SUFDdEIsQ0FBQztJQUVrQixrQ0FBa0M7UUFDbkQsV0FBVztZQUNQLGFBQWEsQ0FDVCxJQUFJLENBQUMsTUFBTSxFQUNYLDZFQUE2RSxDQUFDLENBQUM7UUFDdkYsYUFBYSxDQUFDLElBQUksQ0FBQyxNQUFPLENBQUMsQ0FBQztJQUM5QixDQUFDO0lBRWtCLDRCQUE0QjtRQUM3QyxxRUFBcUU7SUFDdkUsQ0FBQztJQUVELElBQUksY0FBYztRQUNoQixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUM7SUFDM0IsQ0FBQztJQUVELFlBQVksQ0FDUixFQUE0RCxFQUFFLEVBQWUsRUFDN0UsR0FBWTtRQUNkLE1BQU0sWUFBWSxHQUFHLGlCQUFpQixDQUFDLElBQUksQ0FBQyxDQUFDO1FBQzdDLElBQUksQ0FBQyxlQUFlLEVBQUUsQ0FBQztRQUN2QixJQUFJO1lBQ0YsRUFBRSxDQUFDLEVBQUUsRUFBRSxHQUFHLENBQUMsQ0FBQztTQUNiO2dCQUFTO1lBQ1IsaUJBQWlCLENBQUMsWUFBWSxDQUFDLENBQUM7U0FDakM7SUFDSCxDQUFDO0lBRUQsT0FBTztRQUNMLDhGQUE4RjtRQUM5Riw2Q0FBNkM7UUFDN0MsSUFBSSxDQUFDLGVBQWUsRUFBRSxDQUFDO0lBQ3pCLENBQUM7Q0FDRjtBQUVELElBQUksZUFBZSxHQUErQixJQUFJLENBQUM7QUFFdkQsU0FBUywrQkFBK0I7SUFDdEMsZUFBZSxLQUFLLElBQUkscUJBQXFCLEVBQUUsQ0FBQztJQUNoRCxPQUFPLGVBQWUsQ0FBQztBQUN6QixDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSx3QkFBd0IsQ0FDcEMsS0FBWSxFQUFFLElBQTZFO0lBRTdGLE9BQU8sS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLCtCQUErQixFQUFFLENBQUM7QUFDMUQsQ0FBQztBQUVEOzs7Ozs7Ozs7R0FTRztBQUNILE1BQU0sVUFBVSxpQ0FBaUMsQ0FDN0MsS0FBWSxFQUNaLElBQTZFO0lBQy9FLE1BQU0sUUFBUSxHQUFHLCtCQUErQixFQUFFLENBQUM7SUFDbkQsSUFBSSxDQUFDLFFBQVEsQ0FBQyxjQUFjLEVBQUU7UUFDNUIsT0FBTztLQUNSO0lBRUQsS0FBSyxDQUFDLElBQUksQ0FBQyxHQUFHLGVBQWUsQ0FBQztJQUM5QixRQUFRLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztJQUN2QixlQUFlLEdBQUcsSUFBSSxxQkFBcUIsRUFBRSxDQUFDO0FBQ2hELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtSZWFjdGl2ZU5vZGUsIHNldEFjdGl2ZUNvbnN1bWVyfSBmcm9tICcuLi9zaWduYWxzL3NyYy9ncmFwaCc7XG5pbXBvcnQge2Fzc2VydERlZmluZWQsIGFzc2VydEVxdWFsfSBmcm9tICcuLi91dGlsL2Fzc2VydCc7XG5cbmltcG9ydCB7bWFya1ZpZXdEaXJ0eX0gZnJvbSAnLi9pbnN0cnVjdGlvbnMvbWFya192aWV3X2RpcnR5JztcbmltcG9ydCB7Q29tcG9uZW50VGVtcGxhdGUsIEhvc3RCaW5kaW5nc0Z1bmN0aW9uLCBSZW5kZXJGbGFnc30gZnJvbSAnLi9pbnRlcmZhY2VzL2RlZmluaXRpb24nO1xuaW1wb3J0IHtMVmlldywgUkVBQ1RJVkVfSE9TVF9CSU5ESU5HX0NPTlNVTUVSLCBSRUFDVElWRV9URU1QTEFURV9DT05TVU1FUn0gZnJvbSAnLi9pbnRlcmZhY2VzL3ZpZXcnO1xuXG5jb25zdCBOR19ERVZfTU9ERSA9IHR5cGVvZiBuZ0Rldk1vZGUgPT09ICd1bmRlZmluZWQnIHx8IG5nRGV2TW9kZTtcblxuZXhwb3J0IGNsYXNzIFJlYWN0aXZlTFZpZXdDb25zdW1lciBleHRlbmRzIFJlYWN0aXZlTm9kZSB7XG4gIHByaXZhdGUgX2xWaWV3OiBMVmlld3xudWxsID0gbnVsbDtcblxuICBzZXQgbFZpZXcobFZpZXc6IExWaWV3KSB7XG4gICAgTkdfREVWX01PREUgJiYgYXNzZXJ0RXF1YWwodGhpcy5fbFZpZXcsIG51bGwsICdDb25zdW1lciBhbHJlYWR5IGFzc29jaWF0ZWQgd2l0aCBhIHZpZXcuJyk7XG4gICAgdGhpcy5fbFZpZXcgPSBsVmlldztcbiAgfVxuXG4gIHByb3RlY3RlZCBvdmVycmlkZSBvbkNvbnN1bWVyRGVwZW5kZW5jeU1heUhhdmVDaGFuZ2VkKCkge1xuICAgIE5HX0RFVl9NT0RFICYmXG4gICAgICAgIGFzc2VydERlZmluZWQoXG4gICAgICAgICAgICB0aGlzLl9sVmlldyxcbiAgICAgICAgICAgICdVcGRhdGluZyBhIHNpZ25hbCBkdXJpbmcgdGVtcGxhdGUgb3IgaG9zdCBiaW5kaW5nIGV4ZWN1dGlvbiBpcyBub3QgYWxsb3dlZC4nKTtcbiAgICBtYXJrVmlld0RpcnR5KHRoaXMuX2xWaWV3ISk7XG4gIH1cblxuICBwcm90ZWN0ZWQgb3ZlcnJpZGUgb25Qcm9kdWNlclVwZGF0ZVZhbHVlVmVyc2lvbigpOiB2b2lkIHtcbiAgICAvLyBUaGlzIHR5cGUgZG9lc24ndCBpbXBsZW1lbnQgdGhlIHByb2R1Y2VyIHNpZGUgb2YgYSBgUmVhY3RpdmVOb2RlYC5cbiAgfVxuXG4gIGdldCBoYXNSZWFkQVNpZ25hbCgpOiBib29sZWFuIHtcbiAgICByZXR1cm4gdGhpcy5oYXNQcm9kdWNlcnM7XG4gIH1cblxuICBydW5JbkNvbnRleHQoXG4gICAgICBmbjogSG9zdEJpbmRpbmdzRnVuY3Rpb248dW5rbm93bj58Q29tcG9uZW50VGVtcGxhdGU8dW5rbm93bj4sIHJmOiBSZW5kZXJGbGFncyxcbiAgICAgIGN0eDogdW5rbm93bik6IHZvaWQge1xuICAgIGNvbnN0IHByZXZDb25zdW1lciA9IHNldEFjdGl2ZUNvbnN1bWVyKHRoaXMpO1xuICAgIHRoaXMudHJhY2tpbmdWZXJzaW9uKys7XG4gICAgdHJ5IHtcbiAgICAgIGZuKHJmLCBjdHgpO1xuICAgIH0gZmluYWxseSB7XG4gICAgICBzZXRBY3RpdmVDb25zdW1lcihwcmV2Q29uc3VtZXIpO1xuICAgIH1cbiAgfVxuXG4gIGRlc3Ryb3koKTogdm9pZCB7XG4gICAgLy8gSW5jcmVtZW50aW5nIHRoZSB2ZXJzaW9uIG1lYW5zIHRoYXQgZXZlcnkgcHJvZHVjZXIgd2hpY2ggdHJpZXMgdG8gdXBkYXRlIHRoaXMgY29uc3VtZXIgd2lsbFxuICAgIC8vIGNvbnNpZGVyIGl0cyByZWNvcmQgc3RhbGUsIGFuZCBub3Qgbm90aWZ5LlxuICAgIHRoaXMudHJhY2tpbmdWZXJzaW9uKys7XG4gIH1cbn1cblxubGV0IGN1cnJlbnRDb25zdW1lcjogUmVhY3RpdmVMVmlld0NvbnN1bWVyfG51bGwgPSBudWxsO1xuXG5mdW5jdGlvbiBnZXRPckNyZWF0ZUN1cnJlbnRMVmlld0NvbnN1bWVyKCkge1xuICBjdXJyZW50Q29uc3VtZXIgPz89IG5ldyBSZWFjdGl2ZUxWaWV3Q29uc3VtZXIoKTtcbiAgcmV0dXJuIGN1cnJlbnRDb25zdW1lcjtcbn1cblxuLyoqXG4gKiBDcmVhdGUgYSBuZXcgdGVtcGxhdGUgY29uc3VtZXIgcG9pbnRpbmcgYXQgdGhlIHNwZWNpZmllZCBMVmlldy5cbiAqIFNvbWV0aW1lcywgYSBwcmV2aW91c2x5IGNyZWF0ZWQgY29uc3VtZXIgbWF5IGJlIHJldXNlZCwgaW4gb3JkZXIgdG8gc2F2ZSBvbiBhbGxvY2F0aW9ucy4gSW4gdGhhdFxuICogY2FzZSwgdGhlIExWaWV3IHdpbGwgYmUgdXBkYXRlZC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldFJlYWN0aXZlTFZpZXdDb25zdW1lcihcbiAgICBsVmlldzogTFZpZXcsIHNsb3Q6IHR5cGVvZiBSRUFDVElWRV9URU1QTEFURV9DT05TVU1FUnx0eXBlb2YgUkVBQ1RJVkVfSE9TVF9CSU5ESU5HX0NPTlNVTUVSKTpcbiAgICBSZWFjdGl2ZUxWaWV3Q29uc3VtZXIge1xuICByZXR1cm4gbFZpZXdbc2xvdF0gPz8gZ2V0T3JDcmVhdGVDdXJyZW50TFZpZXdDb25zdW1lcigpO1xufVxuXG4vKipcbiAqIEFzc2lnbnMgdGhlIGBjdXJyZW50VGVtcGxhdGVDb250ZXh0YCB0byBpdHMgTFZpZXcncyBgUkVBQ1RJVkVfQ09OU1VNRVJgIHNsb3QgaWYgdGhlcmUgYXJlIHRyYWNrZWRcbiAqIHByb2R1Y2Vycy5cbiAqXG4gKiBUaGUgcHJlc2VuY2Ugb2YgcHJvZHVjZXJzIG1lYW5zIHRoYXQgYSBzaWduYWwgd2FzIHJlYWQgd2hpbGUgdGhlIGNvbnN1bWVyIHdhcyB0aGUgYWN0aXZlXG4gKiBjb25zdW1lci5cbiAqXG4gKiBJZiBubyBwcm9kdWNlcnMgYXJlIHByZXNlbnQsIHdlIGRvIG5vdCBhc3NpZ24gdGhlIGN1cnJlbnQgdGVtcGxhdGUgY29udGV4dC4gVGhpcyBhbHNvIG1lYW5zIHdlXG4gKiBjYW4ganVzdCByZXVzZSB0aGUgdGVtcGxhdGUgY29udGV4dCBmb3IgdGhlIG5leHQgTFZpZXcuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjb21taXRMVmlld0NvbnN1bWVySWZIYXNQcm9kdWNlcnMoXG4gICAgbFZpZXc6IExWaWV3LFxuICAgIHNsb3Q6IHR5cGVvZiBSRUFDVElWRV9URU1QTEFURV9DT05TVU1FUnx0eXBlb2YgUkVBQ1RJVkVfSE9TVF9CSU5ESU5HX0NPTlNVTUVSKTogdm9pZCB7XG4gIGNvbnN0IGNvbnN1bWVyID0gZ2V0T3JDcmVhdGVDdXJyZW50TFZpZXdDb25zdW1lcigpO1xuICBpZiAoIWNvbnN1bWVyLmhhc1JlYWRBU2lnbmFsKSB7XG4gICAgcmV0dXJuO1xuICB9XG5cbiAgbFZpZXdbc2xvdF0gPSBjdXJyZW50Q29uc3VtZXI7XG4gIGNvbnN1bWVyLmxWaWV3ID0gbFZpZXc7XG4gIGN1cnJlbnRDb25zdW1lciA9IG5ldyBSZWFjdGl2ZUxWaWV3Q29uc3VtZXIoKTtcbn1cbiJdfQ==