@angular/core 13.0.0-next.8 → 13.0.0-rc.2

package/esm2020/src/view/provider.mjs

@@ -0,0 +1,490 @@
+/**
+ * @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 { ChangeDetectorRef, SimpleChange } from '../change_detection/change_detection';
+import { INJECTOR, Injector, resolveForwardRef } from '../di';
+import { ElementRef } from '../linker/element_ref';
+import { TemplateRef } from '../linker/template_ref';
+import { ViewContainerRef } from '../linker/view_container_ref';
+import { Renderer2 } from '../render/api';
+import { isObservable } from '../util/lang';
+import { stringify } from '../util/stringify';
+import { NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR } from './provider_flags';
+import { createChangeDetectorRef, createInjector } from './refs';
+import { asElementData, asProviderData, Services, shouldCallLifecycleInitHook } from './types';
+import { calcBindingFlags, checkBinding, dispatchEvent, isComponentView, splitDepsDsl, splitMatchedQueriesDsl, tokenKey, viewParentEl } from './util';
+const Renderer2TokenKey = tokenKey(Renderer2);
+const ElementRefTokenKey = tokenKey(ElementRef);
+const ViewContainerRefTokenKey = tokenKey(ViewContainerRef);
+const TemplateRefTokenKey = tokenKey(TemplateRef);
+const ChangeDetectorRefTokenKey = tokenKey(ChangeDetectorRef);
+const InjectorRefTokenKey = tokenKey(Injector);
+const INJECTORRefTokenKey = tokenKey(INJECTOR);
+export function directiveDef(checkIndex, flags, matchedQueries, childCount, ctor, deps, props, outputs) {
+    const bindings = [];
+    if (props) {
+        for (let prop in props) {
+            const [bindingIndex, nonMinifiedName] = props[prop];
+            bindings[bindingIndex] = {
+                flags: 8 /* TypeProperty */,
+                name: prop,
+                nonMinifiedName,
+                ns: null,
+                securityContext: null,
+                suffix: null
+            };
+        }
+    }
+    const outputDefs = [];
+    if (outputs) {
+        for (let propName in outputs) {
+            outputDefs.push({ type: 1 /* DirectiveOutput */, propName, target: null, eventName: outputs[propName] });
+        }
+    }
+    flags |= 16384 /* TypeDirective */;
+    return _def(checkIndex, flags, matchedQueries, childCount, ctor, ctor, deps, bindings, outputDefs);
+}
+export function pipeDef(flags, ctor, deps) {
+    flags |= 16 /* TypePipe */;
+    return _def(-1, flags, null, 0, ctor, ctor, deps);
+}
+export function providerDef(flags, matchedQueries, token, value, deps) {
+    return _def(-1, flags, matchedQueries, 0, token, value, deps);
+}
+export function _def(checkIndex, flags, matchedQueriesDsl, childCount, token, value, deps, bindings, outputs) {
+    const { matchedQueries, references, matchedQueryIds } = splitMatchedQueriesDsl(matchedQueriesDsl);
+    if (!outputs) {
+        outputs = [];
+    }
+    if (!bindings) {
+        bindings = [];
+    }
+    // Need to resolve forwardRefs as e.g. for `useValue` we
+    // lowered the expression and then stopped evaluating it,
+    // i.e. also didn't unwrap it.
+    value = resolveForwardRef(value);
+    const depDefs = splitDepsDsl(deps, stringify(token));
+    return {
+        // will bet set by the view definition
+        nodeIndex: -1,
+        parent: null,
+        renderParent: null,
+        bindingIndex: -1,
+        outputIndex: -1,
+        // regular values
+        checkIndex,
+        flags,
+        childFlags: 0,
+        directChildFlags: 0,
+        childMatchedQueries: 0,
+        matchedQueries,
+        matchedQueryIds,
+        references,
+        ngContentIndex: -1,
+        childCount,
+        bindings,
+        bindingFlags: calcBindingFlags(bindings),
+        outputs,
+        element: null,
+        provider: { token, value, deps: depDefs },
+        text: null,
+        query: null,
+        ngContent: null
+    };
+}
+export function createProviderInstance(view, def) {
+    return _createProviderInstance(view, def);
+}
+export function createPipeInstance(view, def) {
+    // deps are looked up from component.
+    let compView = view;
+    while (compView.parent && !isComponentView(compView)) {
+        compView = compView.parent;
+    }
+    // pipes can see the private services of the component
+    const allowPrivateServices = true;
+    // pipes are always eager and classes!
+    return createClass(compView.parent, viewParentEl(compView), allowPrivateServices, def.provider.value, def.provider.deps);
+}
+export function createDirectiveInstance(view, def) {
+    // components can see other private services, other directives can't.
+    const allowPrivateServices = (def.flags & 32768 /* Component */) > 0;
+    // directives are always eager and classes!
+    const instance = createClass(view, def.parent, allowPrivateServices, def.provider.value, def.provider.deps);
+    if (def.outputs.length) {
+        for (let i = 0; i < def.outputs.length; i++) {
+            const output = def.outputs[i];
+            const outputObservable = instance[output.propName];
+            if (isObservable(outputObservable)) {
+                const subscription = outputObservable.subscribe(eventHandlerClosure(view, def.parent.nodeIndex, output.eventName));
+                view.disposables[def.outputIndex + i] = subscription.unsubscribe.bind(subscription);
+            }
+            else {
+                throw new Error(`@Output ${output.propName} not initialized in '${instance.constructor.name}'.`);
+            }
+        }
+    }
+    return instance;
+}
+function eventHandlerClosure(view, index, eventName) {
+    return (event) => dispatchEvent(view, index, eventName, event);
+}
+export function checkAndUpdateDirectiveInline(view, def, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {
+    const providerData = asProviderData(view, def.nodeIndex);
+    const directive = providerData.instance;
+    let changed = false;
+    let changes = undefined;
+    const bindLen = def.bindings.length;
+    if (bindLen > 0 && checkBinding(view, def, 0, v0)) {
+        changed = true;
+        changes = updateProp(view, providerData, def, 0, v0, changes);
+    }
+    if (bindLen > 1 && checkBinding(view, def, 1, v1)) {
+        changed = true;
+        changes = updateProp(view, providerData, def, 1, v1, changes);
+    }
+    if (bindLen > 2 && checkBinding(view, def, 2, v2)) {
+        changed = true;
+        changes = updateProp(view, providerData, def, 2, v2, changes);
+    }
+    if (bindLen > 3 && checkBinding(view, def, 3, v3)) {
+        changed = true;
+        changes = updateProp(view, providerData, def, 3, v3, changes);
+    }
+    if (bindLen > 4 && checkBinding(view, def, 4, v4)) {
+        changed = true;
+        changes = updateProp(view, providerData, def, 4, v4, changes);
+    }
+    if (bindLen > 5 && checkBinding(view, def, 5, v5)) {
+        changed = true;
+        changes = updateProp(view, providerData, def, 5, v5, changes);
+    }
+    if (bindLen > 6 && checkBinding(view, def, 6, v6)) {
+        changed = true;
+        changes = updateProp(view, providerData, def, 6, v6, changes);
+    }
+    if (bindLen > 7 && checkBinding(view, def, 7, v7)) {
+        changed = true;
+        changes = updateProp(view, providerData, def, 7, v7, changes);
+    }
+    if (bindLen > 8 && checkBinding(view, def, 8, v8)) {
+        changed = true;
+        changes = updateProp(view, providerData, def, 8, v8, changes);
+    }
+    if (bindLen > 9 && checkBinding(view, def, 9, v9)) {
+        changed = true;
+        changes = updateProp(view, providerData, def, 9, v9, changes);
+    }
+    if (changes) {
+        directive.ngOnChanges(changes);
+    }
+    if ((def.flags & 65536 /* OnInit */) &&
+        shouldCallLifecycleInitHook(view, 256 /* InitState_CallingOnInit */, def.nodeIndex)) {
+        directive.ngOnInit();
+    }
+    if (def.flags & 262144 /* DoCheck */) {
+        directive.ngDoCheck();
+    }
+    return changed;
+}
+export function checkAndUpdateDirectiveDynamic(view, def, values) {
+    const providerData = asProviderData(view, def.nodeIndex);
+    const directive = providerData.instance;
+    let changed = false;
+    let changes = undefined;
+    for (let i = 0; i < values.length; i++) {
+        if (checkBinding(view, def, i, values[i])) {
+            changed = true;
+            changes = updateProp(view, providerData, def, i, values[i], changes);
+        }
+    }
+    if (changes) {
+        directive.ngOnChanges(changes);
+    }
+    if ((def.flags & 65536 /* OnInit */) &&
+        shouldCallLifecycleInitHook(view, 256 /* InitState_CallingOnInit */, def.nodeIndex)) {
+        directive.ngOnInit();
+    }
+    if (def.flags & 262144 /* DoCheck */) {
+        directive.ngDoCheck();
+    }
+    return changed;
+}
+function _createProviderInstance(view, def) {
+    // private services can see other private services
+    const allowPrivateServices = (def.flags & 8192 /* PrivateProvider */) > 0;
+    const providerDef = def.provider;
+    switch (def.flags & 201347067 /* Types */) {
+        case 512 /* TypeClassProvider */:
+            return createClass(view, def.parent, allowPrivateServices, providerDef.value, providerDef.deps);
+        case 1024 /* TypeFactoryProvider */:
+            return callFactory(view, def.parent, allowPrivateServices, providerDef.value, providerDef.deps);
+        case 2048 /* TypeUseExistingProvider */:
+            return resolveDep(view, def.parent, allowPrivateServices, providerDef.deps[0]);
+        case 256 /* TypeValueProvider */:
+            return providerDef.value;
+    }
+}
+function createClass(view, elDef, allowPrivateServices, ctor, deps) {
+    const len = deps.length;
+    switch (len) {
+        case 0:
+            return new ctor();
+        case 1:
+            return new ctor(resolveDep(view, elDef, allowPrivateServices, deps[0]));
+        case 2:
+            return new ctor(resolveDep(view, elDef, allowPrivateServices, deps[0]), resolveDep(view, elDef, allowPrivateServices, deps[1]));
+        case 3:
+            return new ctor(resolveDep(view, elDef, allowPrivateServices, deps[0]), resolveDep(view, elDef, allowPrivateServices, deps[1]), resolveDep(view, elDef, allowPrivateServices, deps[2]));
+        default:
+            const depValues = [];
+            for (let i = 0; i < len; i++) {
+                depValues.push(resolveDep(view, elDef, allowPrivateServices, deps[i]));
+            }
+            return new ctor(...depValues);
+    }
+}
+function callFactory(view, elDef, allowPrivateServices, factory, deps) {
+    const len = deps.length;
+    switch (len) {
+        case 0:
+            return factory();
+        case 1:
+            return factory(resolveDep(view, elDef, allowPrivateServices, deps[0]));
+        case 2:
+            return factory(resolveDep(view, elDef, allowPrivateServices, deps[0]), resolveDep(view, elDef, allowPrivateServices, deps[1]));
+        case 3:
+            return factory(resolveDep(view, elDef, allowPrivateServices, deps[0]), resolveDep(view, elDef, allowPrivateServices, deps[1]), resolveDep(view, elDef, allowPrivateServices, deps[2]));
+        default:
+            const depValues = [];
+            for (let i = 0; i < len; i++) {
+                depValues.push(resolveDep(view, elDef, allowPrivateServices, deps[i]));
+            }
+            return factory(...depValues);
+    }
+}
+export function resolveDep(view, elDef, allowPrivateServices, depDef, notFoundValue = Injector.THROW_IF_NOT_FOUND) {
+    if (depDef.flags & 8 /* Value */) {
+        return depDef.token;
+    }
+    const startView = view;
+    if (depDef.flags & 2 /* Optional */) {
+        notFoundValue = null;
+    }
+    const tokenKey = depDef.tokenKey;
+    if (tokenKey === ChangeDetectorRefTokenKey) {
+        // directives on the same element as a component should be able to control the change detector
+        // of that component as well.
+        allowPrivateServices = !!(elDef && elDef.element.componentView);
+    }
+    if (elDef && (depDef.flags & 1 /* SkipSelf */)) {
+        allowPrivateServices = false;
+        elDef = elDef.parent;
+    }
+    let searchView = view;
+    while (searchView) {
+        if (elDef) {
+            switch (tokenKey) {
+                case Renderer2TokenKey: {
+                    const compView = findCompView(searchView, elDef, allowPrivateServices);
+                    return compView.renderer;
+                }
+                case ElementRefTokenKey:
+                    return new ElementRef(asElementData(searchView, elDef.nodeIndex).renderElement);
+                case ViewContainerRefTokenKey:
+                    return asElementData(searchView, elDef.nodeIndex).viewContainer;
+                case TemplateRefTokenKey: {
+                    if (elDef.element.template) {
+                        return asElementData(searchView, elDef.nodeIndex).template;
+                    }
+                    break;
+                }
+                case ChangeDetectorRefTokenKey: {
+                    let cdView = findCompView(searchView, elDef, allowPrivateServices);
+                    return createChangeDetectorRef(cdView);
+                }
+                case InjectorRefTokenKey:
+                case INJECTORRefTokenKey:
+                    return createInjector(searchView, elDef);
+                default:
+                    const providerDef = (allowPrivateServices ? elDef.element.allProviders :
+                        elDef.element.publicProviders)[tokenKey];
+                    if (providerDef) {
+                        let providerData = asProviderData(searchView, providerDef.nodeIndex);
+                        if (!providerData) {
+                            providerData = { instance: _createProviderInstance(searchView, providerDef) };
+                            searchView.nodes[providerDef.nodeIndex] = providerData;
+                        }
+                        return providerData.instance;
+                    }
+            }
+        }
+        allowPrivateServices = isComponentView(searchView);
+        elDef = viewParentEl(searchView);
+        searchView = searchView.parent;
+        if (depDef.flags & 4 /* Self */) {
+            searchView = null;
+        }
+    }
+    const value = startView.root.injector.get(depDef.token, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR);
+    if (value !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR ||
+        notFoundValue === NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR) {
+        // Return the value from the root element injector when
+        // - it provides it
+        //   (value !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR)
+        // - the module injector should not be checked
+        //   (notFoundValue === NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR)
+        return value;
+    }
+    return startView.root.ngModule.injector.get(depDef.token, notFoundValue);
+}
+function findCompView(view, elDef, allowPrivateServices) {
+    let compView;
+    if (allowPrivateServices) {
+        compView = asElementData(view, elDef.nodeIndex).componentView;
+    }
+    else {
+        compView = view;
+        while (compView.parent && !isComponentView(compView)) {
+            compView = compView.parent;
+        }
+    }
+    return compView;
+}
+function updateProp(view, providerData, def, bindingIdx, value, changes) {
+    if (def.flags & 32768 /* Component */) {
+        const compView = asElementData(view, def.parent.nodeIndex).componentView;
+        if (compView.def.flags & 2 /* OnPush */) {
+            compView.state |= 8 /* ChecksEnabled */;
+        }
+    }
+    const binding = def.bindings[bindingIdx];
+    const propName = binding.name;
+    // Note: This is still safe with Closure Compiler as
+    // the user passed in the property name as an object has to `providerDef`,
+    // so Closure Compiler will have renamed the property correctly already.
+    providerData.instance[propName] = value;
+    if (def.flags & 524288 /* OnChanges */) {
+        changes = changes || {};
+        const oldValue = view.oldValues[def.bindingIndex + bindingIdx];
+        const binding = def.bindings[bindingIdx];
+        changes[binding.nonMinifiedName] =
+            new SimpleChange(oldValue, value, (view.state & 2 /* FirstCheck */) !== 0);
+    }
+    view.oldValues[def.bindingIndex + bindingIdx] = value;
+    return changes;
+}
+// This function calls the ngAfterContentCheck, ngAfterContentInit,
+// ngAfterViewCheck, and ngAfterViewInit lifecycle hooks (depending on the node
+// flags in lifecycle). Unlike ngDoCheck, ngOnChanges and ngOnInit, which are
+// called during a pre-order traversal of the view tree (that is calling the
+// parent hooks before the child hooks) these events are sent in using a
+// post-order traversal of the tree (children before parents). This changes the
+// meaning of initIndex in the view state. For ngOnInit, initIndex tracks the
+// expected nodeIndex which a ngOnInit should be called. When sending
+// ngAfterContentInit and ngAfterViewInit it is the expected count of
+// ngAfterContentInit or ngAfterViewInit methods that have been called. This
+// ensure that despite being called recursively or after picking up after an
+// exception, the ngAfterContentInit or ngAfterViewInit will be called on the
+// correct nodes. Consider for example, the following (where E is an element
+// and D is a directive)
+//  Tree:       pre-order index  post-order index
+//    E1        0                6
+//      E2      1                1
+//       D3     2                0
+//      E4      3                5
+//       E5     4                4
+//        E6    5                2
+//        E7    6                3
+// As can be seen, the post-order index has an unclear relationship to the
+// pre-order index (postOrderIndex === preOrderIndex - parentCount +
+// childCount). Since number of calls to ngAfterContentInit and ngAfterViewInit
+// are stable (will be the same for the same view regardless of exceptions or
+// recursion) we just need to count them which will roughly correspond to the
+// post-order index (it skips elements and directives that do not have
+// lifecycle hooks).
+//
+// For example, if an exception is raised in the E6.onAfterViewInit() the
+// initIndex is left at 3 (by shouldCallLifecycleInitHook() which set it to
+// initIndex + 1). When checkAndUpdateView() is called again D3, E2 and E6 will
+// not have their ngAfterViewInit() called but, starting with E7, the rest of
+// the view will begin getting ngAfterViewInit() called until a check and
+// pass is complete.
+//
+// This algorthim also handles recursion. Consider if E4's ngAfterViewInit()
+// indirectly calls E1's ChangeDetectorRef.detectChanges(). The expected
+// initIndex is set to 6, the recusive checkAndUpdateView() starts walk again.
+// D3, E2, E6, E7, E5 and E4 are skipped, ngAfterViewInit() is called on E1.
+// When the recursion returns the initIndex will be 7 so E1 is skipped as it
+// has already been called in the recursively called checkAnUpdateView().
+export function callLifecycleHooksChildrenFirst(view, lifecycles) {
+    if (!(view.def.nodeFlags & lifecycles)) {
+        return;
+    }
+    const nodes = view.def.nodes;
+    let initIndex = 0;
+    for (let i = 0; i < nodes.length; i++) {
+        const nodeDef = nodes[i];
+        let parent = nodeDef.parent;
+        if (!parent && nodeDef.flags & lifecycles) {
+            // matching root node (e.g. a pipe)
+            callProviderLifecycles(view, i, nodeDef.flags & lifecycles, initIndex++);
+        }
+        if ((nodeDef.childFlags & lifecycles) === 0) {
+            // no child matches one of the lifecycles
+            i += nodeDef.childCount;
+        }
+        while (parent && (parent.flags & 1 /* TypeElement */) &&
+            i === parent.nodeIndex + parent.childCount) {
+            // last child of an element
+            if (parent.directChildFlags & lifecycles) {
+                initIndex = callElementProvidersLifecycles(view, parent, lifecycles, initIndex);
+            }
+            parent = parent.parent;
+        }
+    }
+}
+function callElementProvidersLifecycles(view, elDef, lifecycles, initIndex) {
+    for (let i = elDef.nodeIndex + 1; i <= elDef.nodeIndex + elDef.childCount; i++) {
+        const nodeDef = view.def.nodes[i];
+        if (nodeDef.flags & lifecycles) {
+            callProviderLifecycles(view, i, nodeDef.flags & lifecycles, initIndex++);
+        }
+        // only visit direct children
+        i += nodeDef.childCount;
+    }
+    return initIndex;
+}
+function callProviderLifecycles(view, index, lifecycles, initIndex) {
+    const providerData = asProviderData(view, index);
+    if (!providerData) {
+        return;
+    }
+    const provider = providerData.instance;
+    if (!provider) {
+        return;
+    }
+    Services.setCurrentNode(view, index);
+    if (lifecycles & 1048576 /* AfterContentInit */ &&
+        shouldCallLifecycleInitHook(view, 512 /* InitState_CallingAfterContentInit */, initIndex)) {
+        provider.ngAfterContentInit();
+    }
+    if (lifecycles & 2097152 /* AfterContentChecked */) {
+        provider.ngAfterContentChecked();
+    }
+    if (lifecycles & 4194304 /* AfterViewInit */ &&
+        shouldCallLifecycleInitHook(view, 768 /* InitState_CallingAfterViewInit */, initIndex)) {
+        provider.ngAfterViewInit();
+    }
+    if (lifecycles & 8388608 /* AfterViewChecked */) {
+        provider.ngAfterViewChecked();
+    }
+    if (lifecycles & 131072 /* OnDestroy */) {
+        provider.ngOnDestroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/view/provider.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 {ChangeDetectorRef, SimpleChange, SimpleChanges} from '../change_detection/change_detection';\nimport {INJECTOR, Injector, resolveForwardRef} from '../di';\nimport {ElementRef} from '../linker/element_ref';\nimport {TemplateRef} from '../linker/template_ref';\nimport {ViewContainerRef} from '../linker/view_container_ref';\nimport {Renderer2} from '../render/api';\nimport {isObservable} from '../util/lang';\nimport {stringify} from '../util/stringify';\n\nimport {NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR} from './provider_flags';\nimport {createChangeDetectorRef, createInjector} from './refs';\nimport {asElementData, asProviderData, BindingDef, BindingFlags, DepDef, DepFlags, NodeDef, NodeFlags, OutputDef, OutputType, ProviderData, QueryValueType, Services, shouldCallLifecycleInitHook, ViewData, ViewFlags, ViewState} from './types';\nimport {calcBindingFlags, checkBinding, dispatchEvent, isComponentView, splitDepsDsl, splitMatchedQueriesDsl, tokenKey, viewParentEl} from './util';\n\nconst Renderer2TokenKey = tokenKey(Renderer2);\nconst ElementRefTokenKey = tokenKey(ElementRef);\nconst ViewContainerRefTokenKey = tokenKey(ViewContainerRef);\nconst TemplateRefTokenKey = tokenKey(TemplateRef);\nconst ChangeDetectorRefTokenKey = tokenKey(ChangeDetectorRef);\nconst InjectorRefTokenKey = tokenKey(Injector);\nconst INJECTORRefTokenKey = tokenKey(INJECTOR);\n\nexport function directiveDef(\n    checkIndex: number, flags: NodeFlags, matchedQueries: null|[string | number, QueryValueType][],\n    childCount: number, ctor: any, deps: ([DepFlags, any]|any)[],\n    props?: null|{[name: string]: [number, string]},\n    outputs?: null|{[name: string]: string}): NodeDef {\n  const bindings: BindingDef[] = [];\n  if (props) {\n    for (let prop in props) {\n      const [bindingIndex, nonMinifiedName] = props[prop];\n      bindings[bindingIndex] = {\n        flags: BindingFlags.TypeProperty,\n        name: prop,\n        nonMinifiedName,\n        ns: null,\n        securityContext: null,\n        suffix: null\n      };\n    }\n  }\n  const outputDefs: OutputDef[] = [];\n  if (outputs) {\n    for (let propName in outputs) {\n      outputDefs.push(\n          {type: OutputType.DirectiveOutput, propName, target: null, eventName: outputs[propName]});\n    }\n  }\n  flags |= NodeFlags.TypeDirective;\n  return _def(\n      checkIndex, flags, matchedQueries, childCount, ctor, ctor, deps, bindings, outputDefs);\n}\n\nexport function pipeDef(flags: NodeFlags, ctor: any, deps: ([DepFlags, any]|any)[]): NodeDef {\n  flags |= NodeFlags.TypePipe;\n  return _def(-1, flags, null, 0, ctor, ctor, deps);\n}\n\nexport function providerDef(\n    flags: NodeFlags, matchedQueries: null|[string | number, QueryValueType][], token: any,\n    value: any, deps: ([DepFlags, any]|any)[]): NodeDef {\n  return _def(-1, flags, matchedQueries, 0, token, value, deps);\n}\n\nexport function _def(\n    checkIndex: number, flags: NodeFlags, matchedQueriesDsl: [string|number, QueryValueType][]|null,\n    childCount: number, token: any, value: any, deps: ([DepFlags, any]|any)[],\n    bindings?: BindingDef[], outputs?: OutputDef[]): NodeDef {\n  const {matchedQueries, references, matchedQueryIds} = splitMatchedQueriesDsl(matchedQueriesDsl);\n  if (!outputs) {\n    outputs = [];\n  }\n  if (!bindings) {\n    bindings = [];\n  }\n  // Need to resolve forwardRefs as e.g. for `useValue` we\n  // lowered the expression and then stopped evaluating it,\n  // i.e. also didn't unwrap it.\n  value = resolveForwardRef(value);\n\n  const depDefs = splitDepsDsl(deps, stringify(token));\n\n  return {\n    // will bet set by the view definition\n    nodeIndex: -1,\n    parent: null,\n    renderParent: null,\n    bindingIndex: -1,\n    outputIndex: -1,\n    // regular values\n    checkIndex,\n    flags,\n    childFlags: 0,\n    directChildFlags: 0,\n    childMatchedQueries: 0,\n    matchedQueries,\n    matchedQueryIds,\n    references,\n    ngContentIndex: -1,\n    childCount,\n    bindings,\n    bindingFlags: calcBindingFlags(bindings),\n    outputs,\n    element: null,\n    provider: {token, value, deps: depDefs},\n    text: null,\n    query: null,\n    ngContent: null\n  };\n}\n\nexport function createProviderInstance(view: ViewData, def: NodeDef): any {\n  return _createProviderInstance(view, def);\n}\n\nexport function createPipeInstance(view: ViewData, def: NodeDef): any {\n  // deps are looked up from component.\n  let compView = view;\n  while (compView.parent && !isComponentView(compView)) {\n    compView = compView.parent;\n  }\n  // pipes can see the private services of the component\n  const allowPrivateServices = true;\n  // pipes are always eager and classes!\n  return createClass(\n      compView.parent!, viewParentEl(compView)!, allowPrivateServices, def.provider!.value,\n      def.provider!.deps);\n}\n\nexport function createDirectiveInstance(view: ViewData, def: NodeDef): any {\n  // components can see other private services, other directives can't.\n  const allowPrivateServices = (def.flags & NodeFlags.Component) > 0;\n  // directives are always eager and classes!\n  const instance =\n      createClass(view, def.parent!, allowPrivateServices, def.provider!.value, def.provider!.deps);\n  if (def.outputs.length) {\n    for (let i = 0; i < def.outputs.length; i++) {\n      const output = def.outputs[i];\n      const outputObservable = instance[output.propName!];\n      if (isObservable(outputObservable)) {\n        const subscription = outputObservable.subscribe(\n            eventHandlerClosure(view, def.parent!.nodeIndex, output.eventName));\n        view.disposables![def.outputIndex + i] = subscription.unsubscribe.bind(subscription);\n      } else {\n        throw new Error(\n            `@Output ${output.propName} not initialized in '${instance.constructor.name}'.`);\n      }\n    }\n  }\n  return instance;\n}\n\nfunction eventHandlerClosure(view: ViewData, index: number, eventName: string) {\n  return (event: any) => dispatchEvent(view, index, eventName, event);\n}\n\nexport function checkAndUpdateDirectiveInline(\n    view: ViewData, def: NodeDef, v0: any, v1: any, v2: any, v3: any, v4: any, v5: any, v6: any,\n    v7: any, v8: any, v9: any): boolean {\n  const providerData = asProviderData(view, def.nodeIndex);\n  const directive = providerData.instance;\n  let changed = false;\n  let changes: SimpleChanges = undefined!;\n  const bindLen = def.bindings.length;\n  if (bindLen > 0 && checkBinding(view, def, 0, v0)) {\n    changed = true;\n    changes = updateProp(view, providerData, def, 0, v0, changes);\n  }\n  if (bindLen > 1 && checkBinding(view, def, 1, v1)) {\n    changed = true;\n    changes = updateProp(view, providerData, def, 1, v1, changes);\n  }\n  if (bindLen > 2 && checkBinding(view, def, 2, v2)) {\n    changed = true;\n    changes = updateProp(view, providerData, def, 2, v2, changes);\n  }\n  if (bindLen > 3 && checkBinding(view, def, 3, v3)) {\n    changed = true;\n    changes = updateProp(view, providerData, def, 3, v3, changes);\n  }\n  if (bindLen > 4 && checkBinding(view, def, 4, v4)) {\n    changed = true;\n    changes = updateProp(view, providerData, def, 4, v4, changes);\n  }\n  if (bindLen > 5 && checkBinding(view, def, 5, v5)) {\n    changed = true;\n    changes = updateProp(view, providerData, def, 5, v5, changes);\n  }\n  if (bindLen > 6 && checkBinding(view, def, 6, v6)) {\n    changed = true;\n    changes = updateProp(view, providerData, def, 6, v6, changes);\n  }\n  if (bindLen > 7 && checkBinding(view, def, 7, v7)) {\n    changed = true;\n    changes = updateProp(view, providerData, def, 7, v7, changes);\n  }\n  if (bindLen > 8 && checkBinding(view, def, 8, v8)) {\n    changed = true;\n    changes = updateProp(view, providerData, def, 8, v8, changes);\n  }\n  if (bindLen > 9 && checkBinding(view, def, 9, v9)) {\n    changed = true;\n    changes = updateProp(view, providerData, def, 9, v9, changes);\n  }\n  if (changes) {\n    directive.ngOnChanges(changes);\n  }\n  if ((def.flags & NodeFlags.OnInit) &&\n      shouldCallLifecycleInitHook(view, ViewState.InitState_CallingOnInit, def.nodeIndex)) {\n    directive.ngOnInit();\n  }\n  if (def.flags & NodeFlags.DoCheck) {\n    directive.ngDoCheck();\n  }\n  return changed;\n}\n\nexport function checkAndUpdateDirectiveDynamic(\n    view: ViewData, def: NodeDef, values: any[]): boolean {\n  const providerData = asProviderData(view, def.nodeIndex);\n  const directive = providerData.instance;\n  let changed = false;\n  let changes: SimpleChanges = undefined!;\n  for (let i = 0; i < values.length; i++) {\n    if (checkBinding(view, def, i, values[i])) {\n      changed = true;\n      changes = updateProp(view, providerData, def, i, values[i], changes);\n    }\n  }\n  if (changes) {\n    directive.ngOnChanges(changes);\n  }\n  if ((def.flags & NodeFlags.OnInit) &&\n      shouldCallLifecycleInitHook(view, ViewState.InitState_CallingOnInit, def.nodeIndex)) {\n    directive.ngOnInit();\n  }\n  if (def.flags & NodeFlags.DoCheck) {\n    directive.ngDoCheck();\n  }\n  return changed;\n}\n\nfunction _createProviderInstance(view: ViewData, def: NodeDef): any {\n  // private services can see other private services\n  const allowPrivateServices = (def.flags & NodeFlags.PrivateProvider) > 0;\n  const providerDef = def.provider;\n  switch (def.flags & NodeFlags.Types) {\n    case NodeFlags.TypeClassProvider:\n      return createClass(\n          view, def.parent!, allowPrivateServices, providerDef!.value, providerDef!.deps);\n    case NodeFlags.TypeFactoryProvider:\n      return callFactory(\n          view, def.parent!, allowPrivateServices, providerDef!.value, providerDef!.deps);\n    case NodeFlags.TypeUseExistingProvider:\n      return resolveDep(view, def.parent!, allowPrivateServices, providerDef!.deps[0]);\n    case NodeFlags.TypeValueProvider:\n      return providerDef!.value;\n  }\n}\n\nfunction createClass(\n    view: ViewData, elDef: NodeDef, allowPrivateServices: boolean, ctor: any, deps: DepDef[]): any {\n  const len = deps.length;\n  switch (len) {\n    case 0:\n      return new ctor();\n    case 1:\n      return new ctor(resolveDep(view, elDef, allowPrivateServices, deps[0]));\n    case 2:\n      return new ctor(\n          resolveDep(view, elDef, allowPrivateServices, deps[0]),\n          resolveDep(view, elDef, allowPrivateServices, deps[1]));\n    case 3:\n      return new ctor(\n          resolveDep(view, elDef, allowPrivateServices, deps[0]),\n          resolveDep(view, elDef, allowPrivateServices, deps[1]),\n          resolveDep(view, elDef, allowPrivateServices, deps[2]));\n    default:\n      const depValues = [];\n      for (let i = 0; i < len; i++) {\n        depValues.push(resolveDep(view, elDef, allowPrivateServices, deps[i]));\n      }\n      return new ctor(...depValues);\n  }\n}\n\nfunction callFactory(\n    view: ViewData, elDef: NodeDef, allowPrivateServices: boolean, factory: any,\n    deps: DepDef[]): any {\n  const len = deps.length;\n  switch (len) {\n    case 0:\n      return factory();\n    case 1:\n      return factory(resolveDep(view, elDef, allowPrivateServices, deps[0]));\n    case 2:\n      return factory(\n          resolveDep(view, elDef, allowPrivateServices, deps[0]),\n          resolveDep(view, elDef, allowPrivateServices, deps[1]));\n    case 3:\n      return factory(\n          resolveDep(view, elDef, allowPrivateServices, deps[0]),\n          resolveDep(view, elDef, allowPrivateServices, deps[1]),\n          resolveDep(view, elDef, allowPrivateServices, deps[2]));\n    default:\n      const depValues = [];\n      for (let i = 0; i < len; i++) {\n        depValues.push(resolveDep(view, elDef, allowPrivateServices, deps[i]));\n      }\n      return factory(...depValues);\n  }\n}\n\nexport function resolveDep(\n    view: ViewData, elDef: NodeDef, allowPrivateServices: boolean, depDef: DepDef,\n    notFoundValue: any = Injector.THROW_IF_NOT_FOUND): any {\n  if (depDef.flags & DepFlags.Value) {\n    return depDef.token;\n  }\n  const startView = view;\n  if (depDef.flags & DepFlags.Optional) {\n    notFoundValue = null;\n  }\n  const tokenKey = depDef.tokenKey;\n\n  if (tokenKey === ChangeDetectorRefTokenKey) {\n    // directives on the same element as a component should be able to control the change detector\n    // of that component as well.\n    allowPrivateServices = !!(elDef && elDef.element!.componentView);\n  }\n\n  if (elDef && (depDef.flags & DepFlags.SkipSelf)) {\n    allowPrivateServices = false;\n    elDef = elDef.parent!;\n  }\n\n  let searchView: ViewData|null = view;\n  while (searchView) {\n    if (elDef) {\n      switch (tokenKey) {\n        case Renderer2TokenKey: {\n          const compView = findCompView(searchView, elDef, allowPrivateServices);\n          return compView.renderer;\n        }\n        case ElementRefTokenKey:\n          return new ElementRef(asElementData(searchView, elDef.nodeIndex).renderElement);\n        case ViewContainerRefTokenKey:\n          return asElementData(searchView, elDef.nodeIndex).viewContainer;\n        case TemplateRefTokenKey: {\n          if (elDef.element!.template) {\n            return asElementData(searchView, elDef.nodeIndex).template;\n          }\n          break;\n        }\n        case ChangeDetectorRefTokenKey: {\n          let cdView = findCompView(searchView, elDef, allowPrivateServices);\n          return createChangeDetectorRef(cdView);\n        }\n        case InjectorRefTokenKey:\n        case INJECTORRefTokenKey:\n          return createInjector(searchView, elDef);\n        default:\n          const providerDef =\n              (allowPrivateServices ? elDef.element!.allProviders :\n                                      elDef.element!.publicProviders)![tokenKey];\n          if (providerDef) {\n            let providerData = asProviderData(searchView, providerDef.nodeIndex);\n            if (!providerData) {\n              providerData = {instance: _createProviderInstance(searchView, providerDef)};\n              searchView.nodes[providerDef.nodeIndex] = providerData as any;\n            }\n            return providerData.instance;\n          }\n      }\n    }\n\n    allowPrivateServices = isComponentView(searchView);\n    elDef = viewParentEl(searchView)!;\n    searchView = searchView.parent!;\n\n    if (depDef.flags & DepFlags.Self) {\n      searchView = null;\n    }\n  }\n\n  const value = startView.root.injector.get(depDef.token, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR);\n\n  if (value !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR ||\n      notFoundValue === NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR) {\n    // Return the value from the root element injector when\n    // - it provides it\n    //   (value !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR)\n    // - the module injector should not be checked\n    //   (notFoundValue === NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR)\n    return value;\n  }\n\n  return startView.root.ngModule.injector.get(depDef.token, notFoundValue);\n}\n\nfunction findCompView(view: ViewData, elDef: NodeDef, allowPrivateServices: boolean) {\n  let compView: ViewData;\n  if (allowPrivateServices) {\n    compView = asElementData(view, elDef.nodeIndex).componentView;\n  } else {\n    compView = view;\n    while (compView.parent && !isComponentView(compView)) {\n      compView = compView.parent;\n    }\n  }\n  return compView;\n}\n\nfunction updateProp(\n    view: ViewData, providerData: ProviderData, def: NodeDef, bindingIdx: number, value: any,\n    changes: SimpleChanges): SimpleChanges {\n  if (def.flags & NodeFlags.Component) {\n    const compView = asElementData(view, def.parent!.nodeIndex).componentView;\n    if (compView.def.flags & ViewFlags.OnPush) {\n      compView.state |= ViewState.ChecksEnabled;\n    }\n  }\n  const binding = def.bindings[bindingIdx];\n  const propName = binding.name!;\n  // Note: This is still safe with Closure Compiler as\n  // the user passed in the property name as an object has to `providerDef`,\n  // so Closure Compiler will have renamed the property correctly already.\n  providerData.instance[propName] = value;\n  if (def.flags & NodeFlags.OnChanges) {\n    changes = changes || {};\n    const oldValue = view.oldValues[def.bindingIndex + bindingIdx];\n    const binding = def.bindings[bindingIdx];\n    changes[binding.nonMinifiedName!] =\n        new SimpleChange(oldValue, value, (view.state & ViewState.FirstCheck) !== 0);\n  }\n  view.oldValues[def.bindingIndex + bindingIdx] = value;\n  return changes;\n}\n\n// This function calls the ngAfterContentCheck, ngAfterContentInit,\n// ngAfterViewCheck, and ngAfterViewInit lifecycle hooks (depending on the node\n// flags in lifecycle). Unlike ngDoCheck, ngOnChanges and ngOnInit, which are\n// called during a pre-order traversal of the view tree (that is calling the\n// parent hooks before the child hooks) these events are sent in using a\n// post-order traversal of the tree (children before parents). This changes the\n// meaning of initIndex in the view state. For ngOnInit, initIndex tracks the\n// expected nodeIndex which a ngOnInit should be called. When sending\n// ngAfterContentInit and ngAfterViewInit it is the expected count of\n// ngAfterContentInit or ngAfterViewInit methods that have been called. This\n// ensure that despite being called recursively or after picking up after an\n// exception, the ngAfterContentInit or ngAfterViewInit will be called on the\n// correct nodes. Consider for example, the following (where E is an element\n// and D is a directive)\n//  Tree:       pre-order index  post-order index\n//    E1        0                6\n//      E2      1                1\n//       D3     2                0\n//      E4      3                5\n//       E5     4                4\n//        E6    5                2\n//        E7    6                3\n// As can be seen, the post-order index has an unclear relationship to the\n// pre-order index (postOrderIndex === preOrderIndex - parentCount +\n// childCount). Since number of calls to ngAfterContentInit and ngAfterViewInit\n// are stable (will be the same for the same view regardless of exceptions or\n// recursion) we just need to count them which will roughly correspond to the\n// post-order index (it skips elements and directives that do not have\n// lifecycle hooks).\n//\n// For example, if an exception is raised in the E6.onAfterViewInit() the\n// initIndex is left at 3 (by shouldCallLifecycleInitHook() which set it to\n// initIndex + 1). When checkAndUpdateView() is called again D3, E2 and E6 will\n// not have their ngAfterViewInit() called but, starting with E7, the rest of\n// the view will begin getting ngAfterViewInit() called until a check and\n// pass is complete.\n//\n// This algorthim also handles recursion. Consider if E4's ngAfterViewInit()\n// indirectly calls E1's ChangeDetectorRef.detectChanges(). The expected\n// initIndex is set to 6, the recusive checkAndUpdateView() starts walk again.\n// D3, E2, E6, E7, E5 and E4 are skipped, ngAfterViewInit() is called on E1.\n// When the recursion returns the initIndex will be 7 so E1 is skipped as it\n// has already been called in the recursively called checkAnUpdateView().\nexport function callLifecycleHooksChildrenFirst(view: ViewData, lifecycles: NodeFlags) {\n  if (!(view.def.nodeFlags & lifecycles)) {\n    return;\n  }\n  const nodes = view.def.nodes;\n  let initIndex = 0;\n  for (let i = 0; i < nodes.length; i++) {\n    const nodeDef = nodes[i];\n    let parent = nodeDef.parent;\n    if (!parent && nodeDef.flags & lifecycles) {\n      // matching root node (e.g. a pipe)\n      callProviderLifecycles(view, i, nodeDef.flags & lifecycles, initIndex++);\n    }\n    if ((nodeDef.childFlags & lifecycles) === 0) {\n      // no child matches one of the lifecycles\n      i += nodeDef.childCount;\n    }\n    while (parent && (parent.flags & NodeFlags.TypeElement) &&\n           i === parent.nodeIndex + parent.childCount) {\n      // last child of an element\n      if (parent.directChildFlags & lifecycles) {\n        initIndex = callElementProvidersLifecycles(view, parent, lifecycles, initIndex);\n      }\n      parent = parent.parent;\n    }\n  }\n}\n\nfunction callElementProvidersLifecycles(\n    view: ViewData, elDef: NodeDef, lifecycles: NodeFlags, initIndex: number): number {\n  for (let i = elDef.nodeIndex + 1; i <= elDef.nodeIndex + elDef.childCount; i++) {\n    const nodeDef = view.def.nodes[i];\n    if (nodeDef.flags & lifecycles) {\n      callProviderLifecycles(view, i, nodeDef.flags & lifecycles, initIndex++);\n    }\n    // only visit direct children\n    i += nodeDef.childCount;\n  }\n  return initIndex;\n}\n\nfunction callProviderLifecycles(\n    view: ViewData, index: number, lifecycles: NodeFlags, initIndex: number) {\n  const providerData = asProviderData(view, index);\n  if (!providerData) {\n    return;\n  }\n  const provider = providerData.instance;\n  if (!provider) {\n    return;\n  }\n  Services.setCurrentNode(view, index);\n  if (lifecycles & NodeFlags.AfterContentInit &&\n      shouldCallLifecycleInitHook(view, ViewState.InitState_CallingAfterContentInit, initIndex)) {\n    provider.ngAfterContentInit();\n  }\n  if (lifecycles & NodeFlags.AfterContentChecked) {\n    provider.ngAfterContentChecked();\n  }\n  if (lifecycles & NodeFlags.AfterViewInit &&\n      shouldCallLifecycleInitHook(view, ViewState.InitState_CallingAfterViewInit, initIndex)) {\n    provider.ngAfterViewInit();\n  }\n  if (lifecycles & NodeFlags.AfterViewChecked) {\n    provider.ngAfterViewChecked();\n  }\n  if (lifecycles & NodeFlags.OnDestroy) {\n    provider.ngOnDestroy();\n  }\n}\n"]}

package/esm2020/src/view/provider_flags.mjs

@@ -0,0 +1,26 @@
+/**
+ * @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
+ */
+// This default value is when checking the hierarchy for a token.
+//
+// It means both:
+// - the token is not provided by the current injector,
+// - only the element injectors should be checked (ie do not check module injectors
+//
+//          mod1
+//         /
+//       el1   mod2
+//         \  /
+//         el2
+//
+// When requesting el2.injector.get(token), we should check in the following order and return the
+// first found value:
+// - el2.injector.get(token, default)
+// - el1.injector.get(token, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR) -> do not check the module
+// - mod2.injector.get(token, default)
+export const NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvdmlkZXJfZmxhZ3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy92aWV3L3Byb3ZpZGVyX2ZsYWdzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILGlFQUFpRTtBQUNqRSxFQUFFO0FBQ0YsaUJBQWlCO0FBQ2pCLHVEQUF1RDtBQUN2RCxtRkFBbUY7QUFDbkYsRUFBRTtBQUNGLGdCQUFnQjtBQUNoQixZQUFZO0FBQ1osbUJBQW1CO0FBQ25CLGVBQWU7QUFDZixjQUFjO0FBQ2QsRUFBRTtBQUNGLGlHQUFpRztBQUNqRyxxQkFBcUI7QUFDckIscUNBQXFDO0FBQ3JDLDhGQUE4RjtBQUM5RixzQ0FBc0M7QUFDdEMsTUFBTSxDQUFDLE1BQU0scUNBQXFDLEdBQUcsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbi8vIFRoaXMgZGVmYXVsdCB2YWx1ZSBpcyB3aGVuIGNoZWNraW5nIHRoZSBoaWVyYXJjaHkgZm9yIGEgdG9rZW4uXG4vL1xuLy8gSXQgbWVhbnMgYm90aDpcbi8vIC0gdGhlIHRva2VuIGlzIG5vdCBwcm92aWRlZCBieSB0aGUgY3VycmVudCBpbmplY3Rvcixcbi8vIC0gb25seSB0aGUgZWxlbWVudCBpbmplY3RvcnMgc2hvdWxkIGJlIGNoZWNrZWQgKGllIGRvIG5vdCBjaGVjayBtb2R1bGUgaW5qZWN0b3JzXG4vL1xuLy8gICAgICAgICAgbW9kMVxuLy8gICAgICAgICAvXG4vLyAgICAgICBlbDEgICBtb2QyXG4vLyAgICAgICAgIFxcICAvXG4vLyAgICAgICAgIGVsMlxuLy9cbi8vIFdoZW4gcmVxdWVzdGluZyBlbDIuaW5qZWN0b3IuZ2V0KHRva2VuKSwgd2Ugc2hvdWxkIGNoZWNrIGluIHRoZSBmb2xsb3dpbmcgb3JkZXIgYW5kIHJldHVybiB0aGVcbi8vIGZpcnN0IGZvdW5kIHZhbHVlOlxuLy8gLSBlbDIuaW5qZWN0b3IuZ2V0KHRva2VuLCBkZWZhdWx0KVxuLy8gLSBlbDEuaW5qZWN0b3IuZ2V0KHRva2VuLCBOT1RfRk9VTkRfQ0hFQ0tfT05MWV9FTEVNRU5UX0lOSkVDVE9SKSAtPiBkbyBub3QgY2hlY2sgdGhlIG1vZHVsZVxuLy8gLSBtb2QyLmluamVjdG9yLmdldCh0b2tlbiwgZGVmYXVsdClcbmV4cG9ydCBjb25zdCBOT1RfRk9VTkRfQ0hFQ0tfT05MWV9FTEVNRU5UX0lOSkVDVE9SID0ge307XG4iXX0=